Pinsave/counterstrike
1
1/**2 * The `node:url` module provides utilities for URL resolution and parsing. It can3 * be accessed using:4 *5 * ```js6 * import url from 'node:url';7 * ```8 * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/url.js)9 */10declare module "url" {11 import { Blob as NodeBlob } from "node:buffer";12 import { ClientRequestArgs } from "node:http";13 import { ParsedUrlQuery, ParsedUrlQueryInput } from "node:querystring";14 // Input to `url.format`15 interface UrlObject {16 auth?: string | null | undefined;17 hash?: string | null | undefined;18 host?: string | null | undefined;19 hostname?: string | null | undefined;20 href?: string | null | undefined;21 pathname?: string | null | undefined;22 protocol?: string | null | undefined;23 search?: string | null | undefined;24 slashes?: boolean | null | undefined;25 port?: string | number | null | undefined;26 query?: string | null | ParsedUrlQueryInput | undefined;27 }28 // Output of `url.parse`29 interface Url {30 auth: string | null;31 hash: string | null;32 host: string | null;33 hostname: string | null;34 href: string;35 path: string | null;36 pathname: string | null;37 protocol: string | null;38 search: string | null;39 slashes: boolean | null;40 port: string | null;41 query: string | null | ParsedUrlQuery;42 }43 interface UrlWithParsedQuery extends Url {44 query: ParsedUrlQuery;45 }46 interface UrlWithStringQuery extends Url {47 query: string | null;48 }49 interface FileUrlToPathOptions {50 /**51 * `true` if the `path` should be return as a windows filepath, `false` for posix, and `undefined` for the system default.52 * @default undefined53 * @since v22.1.054 */55 windows?: boolean | undefined;56 }57 interface PathToFileUrlOptions {58 /**59 * `true` if the `path` should be return as a windows filepath, `false` for posix, and `undefined` for the system default.60 * @default undefined61 * @since v22.1.062 */63 windows?: boolean | undefined;64 }65 /**66 * The `url.parse()` method takes a URL string, parses it, and returns a URL67 * object.68 *69 * A `TypeError` is thrown if `urlString` is not a string.70 *71 * A `URIError` is thrown if the `auth` property is present but cannot be decoded.72 *73 * `url.parse()` uses a lenient, non-standard algorithm for parsing URL74 * strings. It is prone to security issues such as [host name spoofing](https://hackerone.com/reports/678487) and incorrect handling of usernames and passwords. Do not use with untrusted75 * input. CVEs are not issued for `url.parse()` vulnerabilities. Use the `WHATWG URL` API instead.76 * @since v0.1.2577 * @deprecated Use the WHATWG URL API instead.78 * @param urlString The URL string to parse.79 * @param [parseQueryString=false] If `true`, the `query` property will always be set to an object returned by the {@link querystring} module's `parse()` method. If `false`, the `query` property80 * on the returned URL object will be an unparsed, undecoded string.81 * @param [slashesDenoteHost=false] If `true`, the first token after the literal string `//` and preceding the next `/` will be interpreted as the `host`. For instance, given `//foo/bar`, the82 * result would be `{host: 'foo', pathname: '/bar'}` rather than `{pathname: '//foo/bar'}`.83 */84 function parse(urlString: string): UrlWithStringQuery;85 function parse(86 urlString: string,87 parseQueryString: false | undefined,88 slashesDenoteHost?: boolean,89 ): UrlWithStringQuery;90 function parse(urlString: string, parseQueryString: true, slashesDenoteHost?: boolean): UrlWithParsedQuery;91 function parse(urlString: string, parseQueryString: boolean, slashesDenoteHost?: boolean): Url;92 /**93 * The `url.format()` method returns a formatted URL string derived from `urlObject`.94 *95 * ```js96 * import url from 'node:url';97 * url.format({98 * protocol: 'https',99 * hostname: 'example.com',100 * pathname: '/some/path',101 * query: {102 * page: 1,103 * format: 'json',104 * },105 * });106 *107 * // => 'https://example.com/some/path?page=1&format=json'108 * ```109 *110 * If `urlObject` is not an object or a string, `url.format()` will throw a `TypeError`.111 *112 * The formatting process operates as follows:113 *114 * * A new empty string `result` is created.115 * * If `urlObject.protocol` is a string, it is appended as-is to `result`.116 * * Otherwise, if `urlObject.protocol` is not `undefined` and is not a string, an `Error` is thrown.117 * * For all string values of `urlObject.protocol` that _do not end_ with an ASCII118 * colon (`:`) character, the literal string `:` will be appended to `result`.119 * * If either of the following conditions is true, then the literal string `//` will be appended to `result`:120 * * `urlObject.slashes` property is true;121 * * `urlObject.protocol` begins with `http`, `https`, `ftp`, `gopher`, or `file`;122 * * If the value of the `urlObject.auth` property is truthy, and either `urlObject.host` or `urlObject.hostname` are not `undefined`, the value of `urlObject.auth` will be coerced into a string123 * and appended to `result` followed by the literal string `@`.124 * * If the `urlObject.host` property is `undefined` then:125 * * If the `urlObject.hostname` is a string, it is appended to `result`.126 * * Otherwise, if `urlObject.hostname` is not `undefined` and is not a string,127 * an `Error` is thrown.128 * * If the `urlObject.port` property value is truthy, and `urlObject.hostname` is not `undefined`:129 * * The literal string `:` is appended to `result`, and130 * * The value of `urlObject.port` is coerced to a string and appended to `result`.131 * * Otherwise, if the `urlObject.host` property value is truthy, the value of `urlObject.host` is coerced to a string and appended to `result`.132 * * If the `urlObject.pathname` property is a string that is not an empty string:133 * * If the `urlObject.pathname` _does not start_ with an ASCII forward slash134 * (`/`), then the literal string `'/'` is appended to `result`.135 * * The value of `urlObject.pathname` is appended to `result`.136 * * Otherwise, if `urlObject.pathname` is not `undefined` and is not a string, an `Error` is thrown.137 * * If the `urlObject.search` property is `undefined` and if the `urlObject.query`property is an `Object`, the literal string `?` is appended to `result` followed by the output of calling the138 * `querystring` module's `stringify()` method passing the value of `urlObject.query`.139 * * Otherwise, if `urlObject.search` is a string:140 * * If the value of `urlObject.search` _does not start_ with the ASCII question141 * mark (`?`) character, the literal string `?` is appended to `result`.142 * * The value of `urlObject.search` is appended to `result`.143 * * Otherwise, if `urlObject.search` is not `undefined` and is not a string, an `Error` is thrown.144 * * If the `urlObject.hash` property is a string:145 * * If the value of `urlObject.hash` _does not start_ with the ASCII hash (`#`)146 * character, the literal string `#` is appended to `result`.147 * * The value of `urlObject.hash` is appended to `result`.148 * * Otherwise, if the `urlObject.hash` property is not `undefined` and is not a149 * string, an `Error` is thrown.150 * * `result` is returned.151 * @since v0.1.25152 * @legacy Use the WHATWG URL API instead.153 * @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise). If a string, it is converted to an object by passing it to `url.parse()`.154 */155 function format(urlObject: URL, options?: URLFormatOptions): string;156 /**157 * The `url.format()` method returns a formatted URL string derived from `urlObject`.158 *159 * ```js160 * import url from 'node:url';161 * url.format({162 * protocol: 'https',163 * hostname: 'example.com',164 * pathname: '/some/path',165 * query: {166 * page: 1,167 * format: 'json',168 * },169 * });170 *171 * // => 'https://example.com/some/path?page=1&format=json'172 * ```173 *174 * If `urlObject` is not an object or a string, `url.format()` will throw a `TypeError`.175 *176 * The formatting process operates as follows:177 *178 * * A new empty string `result` is created.179 * * If `urlObject.protocol` is a string, it is appended as-is to `result`.180 * * Otherwise, if `urlObject.protocol` is not `undefined` and is not a string, an `Error` is thrown.181 * * For all string values of `urlObject.protocol` that _do not end_ with an ASCII182 * colon (`:`) character, the literal string `:` will be appended to `result`.183 * * If either of the following conditions is true, then the literal string `//` will be appended to `result`:184 * * `urlObject.slashes` property is true;185 * * `urlObject.protocol` begins with `http`, `https`, `ftp`, `gopher`, or `file`;186 * * If the value of the `urlObject.auth` property is truthy, and either `urlObject.host` or `urlObject.hostname` are not `undefined`, the value of `urlObject.auth` will be coerced into a string187 * and appended to `result` followed by the literal string `@`.188 * * If the `urlObject.host` property is `undefined` then:189 * * If the `urlObject.hostname` is a string, it is appended to `result`.190 * * Otherwise, if `urlObject.hostname` is not `undefined` and is not a string,191 * an `Error` is thrown.192 * * If the `urlObject.port` property value is truthy, and `urlObject.hostname` is not `undefined`:193 * * The literal string `:` is appended to `result`, and194 * * The value of `urlObject.port` is coerced to a string and appended to `result`.195 * * Otherwise, if the `urlObject.host` property value is truthy, the value of `urlObject.host` is coerced to a string and appended to `result`.196 * * If the `urlObject.pathname` property is a string that is not an empty string:197 * * If the `urlObject.pathname` _does not start_ with an ASCII forward slash198 * (`/`), then the literal string `'/'` is appended to `result`.199 * * The value of `urlObject.pathname` is appended to `result`.200 * * Otherwise, if `urlObject.pathname` is not `undefined` and is not a string, an `Error` is thrown.201 * * If the `urlObject.search` property is `undefined` and if the `urlObject.query`property is an `Object`, the literal string `?` is appended to `result` followed by the output of calling the202 * `querystring` module's `stringify()` method passing the value of `urlObject.query`.203 * * Otherwise, if `urlObject.search` is a string:204 * * If the value of `urlObject.search` _does not start_ with the ASCII question205 * mark (`?`) character, the literal string `?` is appended to `result`.206 * * The value of `urlObject.search` is appended to `result`.207 * * Otherwise, if `urlObject.search` is not `undefined` and is not a string, an `Error` is thrown.208 * * If the `urlObject.hash` property is a string:209 * * If the value of `urlObject.hash` _does not start_ with the ASCII hash (`#`)210 * character, the literal string `#` is appended to `result`.211 * * The value of `urlObject.hash` is appended to `result`.212 * * Otherwise, if the `urlObject.hash` property is not `undefined` and is not a213 * string, an `Error` is thrown.214 * * `result` is returned.215 * @since v0.1.25216 * @legacy Use the WHATWG URL API instead.217 * @param urlObject A URL object (as returned by `url.parse()` or constructed otherwise). If a string, it is converted to an object by passing it to `url.parse()`.218 */219 function format(urlObject: UrlObject | string): string;220 /**221 * The `url.resolve()` method resolves a target URL relative to a base URL in a222 * manner similar to that of a web browser resolving an anchor tag.223 *224 * ```js225 * import url from 'node:url';226 * url.resolve('/one/two/three', 'four'); // '/one/two/four'227 * url.resolve('http://example.com/', '/one'); // 'http://example.com/one'228 * url.resolve('http://example.com/one', '/two'); // 'http://example.com/two'229 * ```230 *231 * To achieve the same result using the WHATWG URL API:232 *233 * ```js234 * function resolve(from, to) {235 * const resolvedUrl = new URL(to, new URL(from, 'resolve://'));236 * if (resolvedUrl.protocol === 'resolve:') {237 * // `from` is a relative URL.238 * const { pathname, search, hash } = resolvedUrl;239 * return pathname + search + hash;240 * }241 * return resolvedUrl.toString();242 * }243 *244 * resolve('/one/two/three', 'four'); // '/one/two/four'245 * resolve('http://example.com/', '/one'); // 'http://example.com/one'246 * resolve('http://example.com/one', '/two'); // 'http://example.com/two'247 * ```248 * @since v0.1.25249 * @legacy Use the WHATWG URL API instead.250 * @param from The base URL to use if `to` is a relative URL.251 * @param to The target URL to resolve.252 */253 function resolve(from: string, to: string): string;254 /**255 * Returns the [Punycode](https://tools.ietf.org/html/rfc5891#section-4.4) ASCII serialization of the `domain`. If `domain` is an256 * invalid domain, the empty string is returned.257 *258 * It performs the inverse operation to {@link domainToUnicode}.259 *260 * ```js261 * import url from 'node:url';262 *263 * console.log(url.domainToASCII('español.com'));264 * // Prints xn--espaol-zwa.com265 * console.log(url.domainToASCII('中文.com'));266 * // Prints xn--fiq228c.com267 * console.log(url.domainToASCII('xn--iñvalid.com'));268 * // Prints an empty string269 * ```270 * @since v7.4.0, v6.13.0271 */272 function domainToASCII(domain: string): string;273 /**274 * Returns the Unicode serialization of the `domain`. If `domain` is an invalid275 * domain, the empty string is returned.276 *277 * It performs the inverse operation to {@link domainToASCII}.278 *279 * ```js280 * import url from 'node:url';281 *282 * console.log(url.domainToUnicode('xn--espaol-zwa.com'));283 * // Prints español.com284 * console.log(url.domainToUnicode('xn--fiq228c.com'));285 * // Prints 中文.com286 * console.log(url.domainToUnicode('xn--iñvalid.com'));287 * // Prints an empty string288 * ```289 * @since v7.4.0, v6.13.0290 */291 function domainToUnicode(domain: string): string;292 /**293 * This function ensures the correct decodings of percent-encoded characters as294 * well as ensuring a cross-platform valid absolute path string.295 *296 * ```js297 * import { fileURLToPath } from 'node:url';298 *299 * const __filename = fileURLToPath(import.meta.url);300 *301 * new URL('file:///C:/path/').pathname; // Incorrect: /C:/path/302 * fileURLToPath('file:///C:/path/'); // Correct: C:\path\ (Windows)303 *304 * new URL('file://nas/foo.txt').pathname; // Incorrect: /foo.txt305 * fileURLToPath('file://nas/foo.txt'); // Correct: \\nas\foo.txt (Windows)306 *307 * new URL('file:///你好.txt').pathname; // Incorrect: /%E4%BD%A0%E5%A5%BD.txt308 * fileURLToPath('file:///你好.txt'); // Correct: /你好.txt (POSIX)309 *310 * new URL('file:///hello world').pathname; // Incorrect: /hello%20world311 * fileURLToPath('file:///hello world'); // Correct: /hello world (POSIX)312 * ```313 * @since v10.12.0314 * @param url The file URL string or URL object to convert to a path.315 * @return The fully-resolved platform-specific Node.js file path.316 */317 function fileURLToPath(url: string | URL, options?: FileUrlToPathOptions): string;318 /**319 * This function ensures that `path` is resolved absolutely, and that the URL320 * control characters are correctly encoded when converting into a File URL.321 *322 * ```js323 * import { pathToFileURL } from 'node:url';324 *325 * new URL('/foo#1', 'file:'); // Incorrect: file:///foo#1326 * pathToFileURL('/foo#1'); // Correct: file:///foo%231 (POSIX)327 *328 * new URL('/some/path%.c', 'file:'); // Incorrect: file:///some/path%.c329 * pathToFileURL('/some/path%.c'); // Correct: file:///some/path%25.c (POSIX)330 * ```331 * @since v10.12.0332 * @param path The path to convert to a File URL.333 * @return The file URL object.334 */335 function pathToFileURL(path: string, options?: PathToFileUrlOptions): URL;336 /**337 * This utility function converts a URL object into an ordinary options object as338 * expected by the `http.request()` and `https.request()` APIs.339 *340 * ```js341 * import { urlToHttpOptions } from 'node:url';342 * const myURL = new URL('https://a:b@測試?abc#foo');343 *344 * console.log(urlToHttpOptions(myURL));345 * /*346 * {347 * protocol: 'https:',348 * hostname: 'xn--g6w251d',349 * hash: '#foo',350 * search: '?abc',351 * pathname: '/',352 * path: '/?abc',353 * href: 'https://a:b@xn--g6w251d/?abc#foo',354 * auth: 'a:b'355 * }356 *357 * ```358 * @since v15.7.0, v14.18.0359 * @param url The `WHATWG URL` object to convert to an options object.360 * @return Options object361 */362 function urlToHttpOptions(url: URL): ClientRequestArgs;363 interface URLFormatOptions {364 /**365 * `true` if the serialized URL string should include the username and password, `false` otherwise.366 * @default true367 */368 auth?: boolean | undefined;369 /**370 * `true` if the serialized URL string should include the fragment, `false` otherwise.371 * @default true372 */373 fragment?: boolean | undefined;374 /**375 * `true` if the serialized URL string should include the search query, `false` otherwise.376 * @default true377 */378 search?: boolean | undefined;379 /**380 * `true` if Unicode characters appearing in the host component of the URL string should be encoded directly as opposed to381 * being Punycode encoded.382 * @default false383 */384 unicode?: boolean | undefined;385 }386 /**387 * Browser-compatible `URL` class, implemented by following the WHATWG URL388 * Standard. [Examples of parsed URLs](https://url.spec.whatwg.org/#example-url-parsing) may be found in the Standard itself.389 * The `URL` class is also available on the global object.390 *391 * In accordance with browser conventions, all properties of `URL` objects392 * are implemented as getters and setters on the class prototype, rather than as393 * data properties on the object itself. Thus, unlike `legacy urlObject`s,394 * using the `delete` keyword on any properties of `URL` objects (e.g. `delete myURL.protocol`, `delete myURL.pathname`, etc) has no effect but will still395 * return `true`.396 * @since v7.0.0, v6.13.0397 */398 class URL {399 /**400 * Creates a `'blob:nodedata:...'` URL string that represents the given `Blob` object and can be used to retrieve the `Blob` later.401 *402 * ```js403 * import {404 * Blob,405 * resolveObjectURL,406 * } from 'node:buffer';407 *408 * const blob = new Blob(['hello']);409 * const id = URL.createObjectURL(blob);410 *411 * // later...412 *413 * const otherBlob = resolveObjectURL(id);414 * console.log(otherBlob.size);415 * ```416 *417 * The data stored by the registered `Blob` will be retained in memory until `URL.revokeObjectURL()` is called to remove it.418 *419 * `Blob` objects are registered within the current thread. If using Worker420 * Threads, `Blob` objects registered within one Worker will not be available421 * to other workers or the main thread.422 * @since v16.7.0423 */424 static createObjectURL(blob: NodeBlob): string;425 /**426 * Removes the stored `Blob` identified by the given ID. Attempting to revoke a427 * ID that isn't registered will silently fail.428 * @since v16.7.0429 * @param id A `'blob:nodedata:...` URL string returned by a prior call to `URL.createObjectURL()`.430 */431 static revokeObjectURL(id: string): void;432 /**433 * Checks if an `input` relative to the `base` can be parsed to a `URL`.434 *435 * ```js436 * const isValid = URL.canParse('/foo', 'https://example.org/'); // true437 *438 * const isNotValid = URL.canParse('/foo'); // false439 * ```440 * @since v19.9.0441 * @param input The absolute or relative input URL to parse. If `input` is relative, then `base` is required. If `input` is absolute, the `base` is ignored. If `input` is not a string, it is442 * `converted to a string` first.443 * @param base The base URL to resolve against if the `input` is not absolute. If `base` is not a string, it is `converted to a string` first.444 */445 static canParse(input: string, base?: string): boolean;446 /**447 * Parses a string as a URL. If `base` is provided, it will be used as the base URL for the purpose of resolving non-absolute `input` URLs.448 * Returns `null` if `input` is not a valid.449 * @param input The absolute or relative input URL to parse. If `input` is relative, then `base` is required. If `input` is absolute, the `base` is ignored. If `input` is not a string, it is450 * `converted to a string` first.451 * @param base The base URL to resolve against if the `input` is not absolute. If `base` is not a string, it is `converted to a string` first.452 * @since v22.1.0453 */454 static parse(input: string, base?: string): URL | null;455 constructor(input: string | { toString: () => string }, base?: string | URL);456 /**457 * Gets and sets the fragment portion of the URL.458 *459 * ```js460 * const myURL = new URL('https://example.org/foo#bar');461 * console.log(myURL.hash);462 * // Prints #bar463 *464 * myURL.hash = 'baz';465 * console.log(myURL.href);466 * // Prints https://example.org/foo#baz467 * ```468 *469 * Invalid URL characters included in the value assigned to the `hash` property470 * are `percent-encoded`. The selection of which characters to471 * percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.472 */473 hash: string;474 /**475 * Gets and sets the host portion of the URL.476 *477 * ```js478 * const myURL = new URL('https://example.org:81/foo');479 * console.log(myURL.host);480 * // Prints example.org:81481 *482 * myURL.host = 'example.com:82';483 * console.log(myURL.href);484 * // Prints https://example.com:82/foo485 * ```486 *487 * Invalid host values assigned to the `host` property are ignored.488 */489 host: string;490 /**491 * Gets and sets the host name portion of the URL. The key difference between`url.host` and `url.hostname` is that `url.hostname` does _not_ include the492 * port.493 *494 * ```js495 * const myURL = new URL('https://example.org:81/foo');496 * console.log(myURL.hostname);497 * // Prints example.org498 *499 * // Setting the hostname does not change the port500 * myURL.hostname = 'example.com';501 * console.log(myURL.href);502 * // Prints https://example.com:81/foo503 *504 * // Use myURL.host to change the hostname and port505 * myURL.host = 'example.org:82';506 * console.log(myURL.href);507 * // Prints https://example.org:82/foo508 * ```509 *510 * Invalid host name values assigned to the `hostname` property are ignored.511 */512 hostname: string;513 /**514 * Gets and sets the serialized URL.515 *516 * ```js517 * const myURL = new URL('https://example.org/foo');518 * console.log(myURL.href);519 * // Prints https://example.org/foo520 *521 * myURL.href = 'https://example.com/bar';522 * console.log(myURL.href);523 * // Prints https://example.com/bar524 * ```525 *526 * Getting the value of the `href` property is equivalent to calling {@link toString}.527 *528 * Setting the value of this property to a new value is equivalent to creating a529 * new `URL` object using `new URL(value)`. Each of the `URL` object's properties will be modified.530 *531 * If the value assigned to the `href` property is not a valid URL, a `TypeError` will be thrown.532 */533 href: string;534 /**535 * Gets the read-only serialization of the URL's origin.536 *537 * ```js538 * const myURL = new URL('https://example.org/foo/bar?baz');539 * console.log(myURL.origin);540 * // Prints https://example.org541 * ```542 *543 * ```js544 * const idnURL = new URL('https://測試');545 * console.log(idnURL.origin);546 * // Prints https://xn--g6w251d547 *548 * console.log(idnURL.hostname);549 * // Prints xn--g6w251d550 * ```551 */552 readonly origin: string;553 /**554 * Gets and sets the password portion of the URL.555 *556 * ```js557 * const myURL = new URL('https://abc:xyz@example.com');558 * console.log(myURL.password);559 * // Prints xyz560 *561 * myURL.password = '123';562 * console.log(myURL.href);563 * // Prints https://abc:123@example.com/564 * ```565 *566 * Invalid URL characters included in the value assigned to the `password` property567 * are `percent-encoded`. The selection of which characters to568 * percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.569 */570 password: string;571 /**572 * Gets and sets the path portion of the URL.573 *574 * ```js575 * const myURL = new URL('https://example.org/abc/xyz?123');576 * console.log(myURL.pathname);577 * // Prints /abc/xyz578 *579 * myURL.pathname = '/abcdef';580 * console.log(myURL.href);581 * // Prints https://example.org/abcdef?123582 * ```583 *584 * Invalid URL characters included in the value assigned to the `pathname` property are `percent-encoded`. The selection of which characters585 * to percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.586 */587 pathname: string;588 /**589 * Gets and sets the port portion of the URL.590 *591 * The port value may be a number or a string containing a number in the range `0` to `65535` (inclusive). Setting the value to the default port of the `URL` objects given `protocol` will592 * result in the `port` value becoming593 * the empty string (`''`).594 *595 * The port value can be an empty string in which case the port depends on596 * the protocol/scheme:597 *598 * <omitted>599 *600 * Upon assigning a value to the port, the value will first be converted to a601 * string using `.toString()`.602 *603 * If that string is invalid but it begins with a number, the leading number is604 * assigned to `port`.605 * If the number lies outside the range denoted above, it is ignored.606 *607 * ```js608 * const myURL = new URL('https://example.org:8888');609 * console.log(myURL.port);610 * // Prints 8888611 *612 * // Default ports are automatically transformed to the empty string613 * // (HTTPS protocol's default port is 443)614 * myURL.port = '443';615 * console.log(myURL.port);616 * // Prints the empty string617 * console.log(myURL.href);618 * // Prints https://example.org/619 *620 * myURL.port = 1234;621 * console.log(myURL.port);622 * // Prints 1234623 * console.log(myURL.href);624 * // Prints https://example.org:1234/625 *626 * // Completely invalid port strings are ignored627 * myURL.port = 'abcd';628 * console.log(myURL.port);629 * // Prints 1234630 *631 * // Leading numbers are treated as a port number632 * myURL.port = '5678abcd';633 * console.log(myURL.port);634 * // Prints 5678635 *636 * // Non-integers are truncated637 * myURL.port = 1234.5678;638 * console.log(myURL.port);639 * // Prints 1234640 *641 * // Out-of-range numbers which are not represented in scientific notation642 * // will be ignored.643 * myURL.port = 1e10; // 10000000000, will be range-checked as described below644 * console.log(myURL.port);645 * // Prints 1234646 * ```647 *648 * Numbers which contain a decimal point,649 * such as floating-point numbers or numbers in scientific notation,650 * are not an exception to this rule.651 * Leading numbers up to the decimal point will be set as the URL's port,652 * assuming they are valid:653 *654 * ```js655 * myURL.port = 4.567e21;656 * console.log(myURL.port);657 * // Prints 4 (because it is the leading number in the string '4.567e21')658 * ```659 */660 port: string;661 /**662 * Gets and sets the protocol portion of the URL.663 *664 * ```js665 * const myURL = new URL('https://example.org');666 * console.log(myURL.protocol);667 * // Prints https:668 *669 * myURL.protocol = 'ftp';670 * console.log(myURL.href);671 * // Prints ftp://example.org/672 * ```673 *674 * Invalid URL protocol values assigned to the `protocol` property are ignored.675 */676 protocol: string;677 /**678 * Gets and sets the serialized query portion of the URL.679 *680 * ```js681 * const myURL = new URL('https://example.org/abc?123');682 * console.log(myURL.search);683 * // Prints ?123684 *685 * myURL.search = 'abc=xyz';686 * console.log(myURL.href);687 * // Prints https://example.org/abc?abc=xyz688 * ```689 *690 * Any invalid URL characters appearing in the value assigned the `search` property will be `percent-encoded`. The selection of which691 * characters to percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.692 */693 search: string;694 /**695 * Gets the `URLSearchParams` object representing the query parameters of the696 * URL. This property is read-only but the `URLSearchParams` object it provides697 * can be used to mutate the URL instance; to replace the entirety of query698 * parameters of the URL, use the {@link search} setter. See `URLSearchParams` documentation for details.699 *700 * Use care when using `.searchParams` to modify the `URL` because,701 * per the WHATWG specification, the `URLSearchParams` object uses702 * different rules to determine which characters to percent-encode. For703 * instance, the `URL` object will not percent encode the ASCII tilde (`~`)704 * character, while `URLSearchParams` will always encode it:705 *706 * ```js707 * const myURL = new URL('https://example.org/abc?foo=~bar');708 *709 * console.log(myURL.search); // prints ?foo=~bar710 *711 * // Modify the URL via searchParams...712 * myURL.searchParams.sort();713 *714 * console.log(myURL.search); // prints ?foo=%7Ebar715 * ```716 */717 readonly searchParams: URLSearchParams;718 /**719 * Gets and sets the username portion of the URL.720 *721 * ```js722 * const myURL = new URL('https://abc:xyz@example.com');723 * console.log(myURL.username);724 * // Prints abc725 *726 * myURL.username = '123';727 * console.log(myURL.href);728 * // Prints https://123:xyz@example.com/729 * ```730 *731 * Any invalid URL characters appearing in the value assigned the `username` property will be `percent-encoded`. The selection of which732 * characters to percent-encode may vary somewhat from what the {@link parse} and {@link format} methods would produce.733 */734 username: string;735 /**736 * The `toString()` method on the `URL` object returns the serialized URL. The737 * value returned is equivalent to that of {@link href} and {@link toJSON}.738 */739 toString(): string;740 /**741 * The `toJSON()` method on the `URL` object returns the serialized URL. The742 * value returned is equivalent to that of {@link href} and {@link toString}.743 *744 * This method is automatically called when an `URL` object is serialized745 * with [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify).746 *747 * ```js748 * const myURLs = [749 * new URL('https://www.example.com'),750 * new URL('https://test.example.org'),751 * ];752 * console.log(JSON.stringify(myURLs));753 * // Prints ["https://www.example.com/","https://test.example.org/"]754 * ```755 */756 toJSON(): string;757 }758 interface URLPatternComponentResult {759 input: string;760 groups: Record<string, string | undefined>;761 }762 interface URLPatternInit {763 protocol?: string;764 username?: string;765 password?: string;766 hostname?: string;767 port?: string;768 pathname?: string;769 search?: string;770 hash?: string;771 baseURL?: string;772 }773 interface URLPatternOptions {774 ignoreCase?: boolean;775 }776 interface URLPatternResult {777 inputs: (string | URLPatternInit)[];778 protocol: URLPatternComponentResult;779 username: URLPatternComponentResult;780 password: URLPatternComponentResult;781 hostname: URLPatternComponentResult;782 port: URLPatternComponentResult;783 pathname: URLPatternComponentResult;784 search: URLPatternComponentResult;785 hash: URLPatternComponentResult;786 }787 /**788 * @since v23.8.0789 * @experimental790 */791 class URLPattern {792 constructor(input: string | URLPatternInit, baseURL: string, options?: URLPatternOptions);793 constructor(input?: string | URLPatternInit, options?: URLPatternOptions);794 exec(input?: string | URLPatternInit, baseURL?: string): URLPatternResult | null;795 readonly hasRegExpGroups: boolean;796 readonly hash: string;797 readonly hostname: string;798 readonly password: string;799 readonly pathname: string;800 readonly port: string;801 readonly protocol: string;802 readonly search: string;803 test(input?: string | URLPatternInit, baseURL?: string): boolean;804 readonly username: string;805 }806 interface URLSearchParamsIterator<T> extends NodeJS.Iterator<T, NodeJS.BuiltinIteratorReturn, unknown> {807 [Symbol.iterator](): URLSearchParamsIterator<T>;808 }809 /**810 * The `URLSearchParams` API provides read and write access to the query of a `URL`. The `URLSearchParams` class can also be used standalone with one of the811 * four following constructors.812 * The `URLSearchParams` class is also available on the global object.813 *814 * The WHATWG `URLSearchParams` interface and the `querystring` module have815 * similar purpose, but the purpose of the `querystring` module is more816 * general, as it allows the customization of delimiter characters (`&` and `=`).817 * On the other hand, this API is designed purely for URL query strings.818 *819 * ```js820 * const myURL = new URL('https://example.org/?abc=123');821 * console.log(myURL.searchParams.get('abc'));822 * // Prints 123823 *824 * myURL.searchParams.append('abc', 'xyz');825 * console.log(myURL.href);826 * // Prints https://example.org/?abc=123&abc=xyz827 *828 * myURL.searchParams.delete('abc');829 * myURL.searchParams.set('a', 'b');830 * console.log(myURL.href);831 * // Prints https://example.org/?a=b832 *833 * const newSearchParams = new URLSearchParams(myURL.searchParams);834 * // The above is equivalent to835 * // const newSearchParams = new URLSearchParams(myURL.search);836 *837 * newSearchParams.append('a', 'c');838 * console.log(myURL.href);839 * // Prints https://example.org/?a=b840 * console.log(newSearchParams.toString());841 * // Prints a=b&a=c842 *843 * // newSearchParams.toString() is implicitly called844 * myURL.search = newSearchParams;845 * console.log(myURL.href);846 * // Prints https://example.org/?a=b&a=c847 * newSearchParams.delete('a');848 * console.log(myURL.href);849 * // Prints https://example.org/?a=b&a=c850 * ```851 * @since v7.5.0, v6.13.0852 */853 class URLSearchParams implements Iterable<[string, string]> {854 constructor(855 init?:856 | URLSearchParams857 | string858 | Record<string, string | readonly string[]>859 | Iterable<[string, string]>860 | ReadonlyArray<[string, string]>,861 );862 /**863 * Append a new name-value pair to the query string.864 */865 append(name: string, value: string): void;866 /**867 * If `value` is provided, removes all name-value pairs868 * where name is `name` and value is `value`.869 *870 * If `value` is not provided, removes all name-value pairs whose name is `name`.871 */872 delete(name: string, value?: string): void;873 /**874 * Returns an ES6 `Iterator` over each of the name-value pairs in the query.875 * Each item of the iterator is a JavaScript `Array`. The first item of the `Array` is the `name`, the second item of the `Array` is the `value`.876 *877 * Alias for `urlSearchParams[@@iterator]()`.878 */879 entries(): URLSearchParamsIterator<[string, string]>;880 /**881 * Iterates over each name-value pair in the query and invokes the given function.882 *883 * ```js884 * const myURL = new URL('https://example.org/?a=b&c=d');885 * myURL.searchParams.forEach((value, name, searchParams) => {886 * console.log(name, value, myURL.searchParams === searchParams);887 * });888 * // Prints:889 * // a b true890 * // c d true891 * ```892 * @param fn Invoked for each name-value pair in the query893 * @param thisArg To be used as `this` value for when `fn` is called894 */895 forEach<TThis = this>(896 fn: (this: TThis, value: string, name: string, searchParams: URLSearchParams) => void,897 thisArg?: TThis,898 ): void;899 /**900 * Returns the value of the first name-value pair whose name is `name`. If there901 * are no such pairs, `null` is returned.902 * @return or `null` if there is no name-value pair with the given `name`.903 */904 get(name: string): string | null;905 /**906 * Returns the values of all name-value pairs whose name is `name`. If there are907 * no such pairs, an empty array is returned.908 */909 getAll(name: string): string[];910 /**911 * Checks if the `URLSearchParams` object contains key-value pair(s) based on `name` and an optional `value` argument.912 *913 * If `value` is provided, returns `true` when name-value pair with914 * same `name` and `value` exists.915 *916 * If `value` is not provided, returns `true` if there is at least one name-value917 * pair whose name is `name`.918 */919 has(name: string, value?: string): boolean;920 /**921 * Returns an ES6 `Iterator` over the names of each name-value pair.922 *923 * ```js924 * const params = new URLSearchParams('foo=bar&foo=baz');925 * for (const name of params.keys()) {926 * console.log(name);927 * }928 * // Prints:929 * // foo930 * // foo931 * ```932 */933 keys(): URLSearchParamsIterator<string>;934 /**935 * Sets the value in the `URLSearchParams` object associated with `name` to `value`. If there are any pre-existing name-value pairs whose names are `name`,936 * set the first such pair's value to `value` and remove all others. If not,937 * append the name-value pair to the query string.938 *939 * ```js940 * const params = new URLSearchParams();941 * params.append('foo', 'bar');942 * params.append('foo', 'baz');943 * params.append('abc', 'def');944 * console.log(params.toString());945 * // Prints foo=bar&foo=baz&abc=def946 *947 * params.set('foo', 'def');948 * params.set('xyz', 'opq');949 * console.log(params.toString());950 * // Prints foo=def&abc=def&xyz=opq951 * ```952 */953 set(name: string, value: string): void;954 /**955 * The total number of parameter entries.956 * @since v19.8.0957 */958 readonly size: number;959 /**960 * Sort all existing name-value pairs in-place by their names. Sorting is done961 * with a [stable sorting algorithm](https://en.wikipedia.org/wiki/Sorting_algorithm#Stability), so relative order between name-value pairs962 * with the same name is preserved.963 *964 * This method can be used, in particular, to increase cache hits.965 *966 * ```js967 * const params = new URLSearchParams('query[]=abc&type=search&query[]=123');968 * params.sort();969 * console.log(params.toString());970 * // Prints query%5B%5D=abc&query%5B%5D=123&type=search971 * ```972 * @since v7.7.0, v6.13.0973 */974 sort(): void;975 /**976 * Returns the search parameters serialized as a string, with characters977 * percent-encoded where necessary.978 */979 toString(): string;980 /**981 * Returns an ES6 `Iterator` over the values of each name-value pair.982 */983 values(): URLSearchParamsIterator<string>;984 [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;985 }986 import {987 URL as _URL,988 URLPattern as _URLPattern,989 URLPatternInit as _URLPatternInit,990 URLPatternResult as _URLPatternResult,991 URLSearchParams as _URLSearchParams,992 } from "url";993 global {994 interface URL extends _URL {}995 var URL: typeof globalThis extends {996 onmessage: any;997 URL: infer T;998 } ? T999 : typeof _URL;1000 interface URLSearchParams extends _URLSearchParams {}1001 var URLSearchParams: typeof globalThis extends {1002 onmessage: any;1003 URLSearchParams: infer T;1004 } ? T1005 : typeof _URLSearchParams;1006 interface URLPatternInit extends _URLPatternInit {}1007 interface URLPatternResult extends _URLPatternResult {}1008 interface URLPattern extends _URLPattern {}1009 var URLPattern: typeof _URLPattern;1010 }1011}1012declare module "node:url" {1013 export * from "url";1014}1015