exacturi 1.0.0

package/dist/lib/reuri.js

@@ -0,0 +1,457 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReUri = exports.DEBUG = void 0;
+const errors_js_1 = require("./errors.js");
+const utils_js_1 = require("./utils.js");
+const types_1 = require("@reflectiz/types");
+const payload_1 = require("./payload");
+exports.DEBUG = Symbol("debug");
+/**
+ * Represents a URI and allows performing operations and inspecting it.
+ *
+ * This class is immutable.
+ */
+class ReUri {
+    // Lots of params needed here
+    // eslint-disable-next-line max-params
+    constructor(_protocol, _hostname, _path, _query, _hash, _payload, _trace, _parsed, _port) {
+        this._protocol = _protocol;
+        this._hostname = _hostname;
+        this._path = _path;
+        this._query = _query;
+        this._hash = _hash;
+        this._payload = _payload;
+        this._trace = _trace;
+        this._parsed = _parsed;
+        this._port = _port;
+        if (_hostname) {
+            this._hostname = _hostname.replace("_", ".");
+            if (this._hostname.includes("_")) {
+                console.warn(`The hostname contains multiple underscores, which might not be intended. Current hostname: ${this._hostname}`);
+            }
+        }
+        this[0] = this._print(false);
+    }
+    static isReuri(other) {
+        return !!(other &&
+            typeof other === "object" &&
+            other.constructor &&
+            "__isReuri" in other.constructor);
+    }
+    segments(overwrite) {
+        if (arguments.length === 0) {
+            return this._path.split("/");
+        }
+        const clone = this._noCopyClone();
+        clone._path = overwrite.join("/");
+        return clone;
+    }
+    merge(other) {
+        if (typeof other === "string") {
+            return this.merge(ReUri.parse(other));
+        }
+        const mergedParts = {
+            hash: other._hash || this._hash,
+            hostname: other._hostname || this._hostname,
+            path: other._path || this._path,
+            port: other._port || this._port,
+            protocol: other._protocol || this._protocol,
+            query: other._query || this._query,
+            trace: other._trace || this._trace
+        };
+        return this.parts(mergedParts).payloadMerge(other.payload()).trace(other.trace());
+    }
+    pick(...keys) {
+        let result = ReUri.empty();
+        for (const key of keys) {
+            result = result.part(key, this.part(key));
+        }
+        return result;
+    }
+    parts(overwrite) {
+        if (arguments.length === 0) {
+            return {
+                protocol: this._protocol,
+                hostname: this._hostname,
+                port: this._port,
+                path: this._path,
+                query: this._query,
+                hash: this._hash,
+                payload: this._payload,
+                trace: this._trace
+            };
+        }
+        if (!overwrite) {
+            return this;
+        }
+        const clone = this._noCopyClone();
+        clone._protocol = "protocol" in overwrite ? overwrite.protocol : clone._protocol;
+        clone._hostname = "hostname" in overwrite ? overwrite.hostname : clone._hostname;
+        clone._port = "port" in overwrite ? overwrite.port : clone._port;
+        clone._path = "path" in overwrite ? overwrite.path : clone._path;
+        clone._query = "query" in overwrite ? overwrite.query : clone._query;
+        clone._hash = "hash" in overwrite ? overwrite.hash : clone._hash;
+        clone._payload = "payload" in overwrite ? overwrite.payload : clone._payload;
+        clone._trace = "trace" in overwrite ? overwrite.trace : clone._trace;
+        return clone;
+    }
+    part(key, value) {
+        if (arguments.length === 1) {
+            const result = this[key]();
+            return typeof result === "object" ? result : (0, types_1.str)(result);
+        }
+        return this[key](value);
+    }
+    address(address) {
+        if (arguments.length === 1) {
+            const parsed = ReUri.parse(address);
+            return parsed.parts({
+                protocol: this._protocol
+            });
+        }
+        return this.parts({
+            protocol: undefined
+        }).href;
+    }
+    resource(resource) {
+        if (arguments.length === 1) {
+            const parsed = ReUri.parse(resource);
+            return parsed.parts({
+                protocol: this._protocol,
+                hostname: this._hostname,
+                port: this._port
+            });
+        }
+        return this.parts({
+            protocol: undefined,
+            hostname: undefined,
+            port: undefined
+        }).href;
+    }
+    origin(origin) {
+        if (arguments.length === 1) {
+            const parsed = ReUri.parse(origin);
+            return this.parts({
+                protocol: parsed._protocol,
+                hostname: parsed._hostname,
+                port: parsed._port
+            });
+        }
+        const parts = this.parts();
+        return (ReUri.empty().parts({
+            protocol: parts.protocol,
+            hostname: parts.hostname,
+            port: parts.port
+        }).href || undefined);
+    }
+    segment(index, value) {
+        if (arguments.length === 0) {
+            throw new errors_js_1.ReUriError(`You must provide an index.`);
+        }
+        if (arguments.length === 1) {
+            return this._path.split("/")[index];
+        }
+        const segments = this.segments();
+        segments[index] = value;
+        return this.segments(segments);
+    }
+    path(path) {
+        if (arguments.length === 0) {
+            return this._path;
+        }
+        const clone = this._noCopyClone();
+        clone._path = path ?? "";
+        return clone;
+    }
+    port(port) {
+        if (arguments.length === 0) {
+            return (0, types_1.int)(this._port);
+        }
+        if (port === true) {
+            return this._port;
+        }
+        const clone = this._noCopyClone();
+        clone._port = (0, types_1.str)(port) ?? undefined;
+        return clone;
+    }
+    protocol(proto) {
+        if (arguments.length === 0) {
+            return this._protocol;
+        }
+        const clone = this._noCopyClone();
+        clone._protocol = proto ?? undefined;
+        return clone;
+    }
+    host(host) {
+        if (arguments.length === 0) {
+            return (ReUri.empty().hostname(this._hostname).port(this._port).href.slice(2) || undefined);
+        }
+        if (host == null) {
+            return this.hostname(null).port(null);
+        }
+        const parsed = ReUri.parse(`//${host}`);
+        return this.hostname(parsed._hostname).port(parsed._port);
+    }
+    hostname(hostname) {
+        if (arguments.length === 0) {
+            return this._hostname;
+        }
+        const clone = this._noCopyClone();
+        clone._hostname = hostname ?? undefined;
+        return clone;
+    }
+    query(query) {
+        if (arguments.length === 0) {
+            return this._query;
+        }
+        const clone = this._noCopyClone();
+        clone._query = query ?? undefined;
+        return clone;
+    }
+    hash(hash) {
+        if (arguments.length === 0) {
+            return this._hash;
+        }
+        const clone = this._noCopyClone();
+        clone._hash = hash ?? undefined;
+        return clone;
+    }
+    _getEncodedPath(skipPayload = false) {
+        if (skipPayload) {
+            return this._path;
+        }
+        return (0, payload_1.getEncodedPath)(this._path, this._payload, this._trace);
+    }
+    _noCopyClone() {
+        return new ReUri(this._protocol, this._hostname, this._path, this._query, this._hash, this._payload, this._trace, this._parsed, this._port);
+    }
+    // Does this URL have a web protocol?
+    get isWeb() {
+        return !!this._protocol && webProtocols.has(this._protocol);
+    }
+    /**
+     * Gets a clone of this instance. The payload is also cloned.
+     */
+    clone() {
+        return new ReUri(this._protocol, this._hostname, this._path, this._query, this._hash, this._payload && { ...this._payload }, this._trace && { ...this._trace }, this._parsed, this._port);
+    }
+    static empty(payload) {
+        return new ReUri(undefined, undefined, "", undefined, undefined, payload, undefined, undefined, undefined);
+    }
+    static parse(input) {
+        if (input == null) {
+            return ReUri.empty();
+        }
+        if (input instanceof ReUri) {
+            return input;
+        }
+        if (typeof input === "object") {
+            return ReUri.empty().parts(input);
+        }
+        if (typeof input !== "string") {
+            throw (0, errors_js_1.inputMustBeString)(input);
+        }
+        const r = urlRegexp.exec(input);
+        if (!r) {
+            throw (0, errors_js_1.inputMustBeUrl)(input);
+        }
+        let [, proto, hostname, port, pathWithPayload, query, fragment] = r;
+        if (port != null && (Number.isNaN(+port) || port === "")) {
+            throw (0, errors_js_1.portMustBeNumeric)(input);
+        }
+        let { payload, tracePayload, path } = (0, payload_1.extractPayload)(pathWithPayload);
+        const somePayload = payload || tracePayload;
+        if (somePayload?.__trim) {
+            // This will only be set if the path is fake and only created for the payload
+            path = "";
+            delete somePayload.__trim;
+        }
+        if (somePayload) {
+            hostname = hostname?.replace(/_([^.]*)$/, ".$1");
+        }
+        return new ReUri(proto?.trim(), hostname?.trim(), path?.trim(), query?.trim(), fragment?.trim(), payload, tracePayload, input, port);
+    }
+    payloadMerge(more) {
+        const payload = Object.assign({}, this._payload, more);
+        return this.payload(payload);
+    }
+    trace(something) {
+        if (arguments.length === 0) {
+            return (this._trace && {
+                ...this._trace
+            });
+        }
+        if (something == null) {
+            return this;
+        }
+        (0, errors_js_1.payloadMustBeObject)(something);
+        const tracePayload = something instanceof ReUri ? something.trace() : something;
+        (0, payload_1.mustValidatePayload)(tracePayload);
+        const clone = this._noCopyClone();
+        clone._trace = {
+            ...this._trace,
+            ...tracePayload
+        };
+        return clone;
+    }
+    /**
+     * Checks if this URI (CHILD) matches another URI (PARENT). The parent can be a string,
+     * a {@link ReUri} or, or an object describing the parts of a URI -- a {@link ReUriParts}.
+     *
+     * CHILD is considered to be a child of PARENT if:
+     * 1. If PARENT has a protocol, it must equal CHILD protocol.
+     * 2. If PARENT has a hostname, it must be a parent of CHILD's hostname.
+     * 3. If PARENT has a port, it must equal CHILD's port.
+     * 4. If PARENT has a path, it must be a parent of CHILD's path.
+     * 5. If PARENT has a query, it must equal CHILD's query.
+     * 6. If PARENT has a hash, it must equal CHILD's hash.
+     * 7. If PARENT has a payload, its properties must match CHILD's payload.
+     * 8. The trace payload is ignored.
+     * @param parent The parent URI to check against.
+     *
+     */
+    matches(parent) {
+        parent = ReUri.parse(parent);
+        if (parent._protocol && parent._protocol !== this._protocol) {
+            return false;
+        }
+        if (parent._hostname && !(0, payload_1.hostnameContains)(this._hostname, parent._hostname)) {
+            return false;
+        }
+        if (parent._port && parent._port !== this._port) {
+            return false;
+        }
+        if (parent._query && parent._query !== this._query) {
+            return false;
+        }
+        if (parent._hash && parent._hash !== this._hash) {
+            return false;
+        }
+        if (parent._payload && !(0, payload_1.payloadContains)(this._payload, parent._payload)) {
+            return false;
+        }
+        const parentSegments = parent.segments();
+        const childSegments = this.segments();
+        for (let i = 0; i < parentSegments.length; i++) {
+            if (parentSegments[i] !== childSegments[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Checks if this URI equals another URI, which can be given as a string, a {@link ReUri} or, or an object describing the parts of a URI -- a
+     * {@link ReUriParts}.
+     * @param other The other URI to check against.
+     * @param skipPayload If true, the payload is ignored.
+     */
+    equal(other, skipPayload = false) {
+        if (this === other) {
+            return true;
+        }
+        other = ReUri.parse(other);
+        const myParts = this.parts();
+        const otherParts = other.parts();
+        for (const key of ["protocol", "hostname", "port", "path", "query", "hash"]) {
+            if (myParts[key] !== otherParts[key]) {
+                return false;
+            }
+        }
+        if (skipPayload) {
+            return true;
+        }
+        if (!this._payload || !other._payload) {
+            return this._payload === other._payload;
+        }
+        return (0, utils_js_1.equal)(this._payload, other._payload);
+    }
+    // An artificial URI is one that can't have been parsed from a string due to an invalid combination of components. For example,
+    // 1. A URL with a port but no hostname.
+    // 2. A URL with a hostname but no protocol.
+    // 3. A URL with
+    get isArtificial() {
+        return !ReUri.parse(this._print(true)).equal(this, true);
+    }
+    payload(something) {
+        if (arguments.length === 0) {
+            return (this._payload && {
+                ...this._payload
+            });
+        }
+        if (this._protocol === "data") {
+            return this;
+        }
+        let payload;
+        payload = something instanceof ReUri ? something.payload() : something;
+        if (payload == null) {
+            payload = undefined;
+        }
+        else {
+            (0, errors_js_1.payloadMustBeObject)(something);
+            (0, payload_1.mustValidatePayload)(payload);
+        }
+        const clone = this._noCopyClone();
+        clone._payload = payload && {
+            ...payload
+        };
+        return clone;
+    }
+    _print(skipPayload = false) {
+        let { _protocol, _hostname, _query, _hash, _port } = this;
+        const somePayload = this._payload || this._trace;
+        skipPayload = skipPayload || ReUri[exports.DEBUG].dontEncodePayloads || false;
+        // If we have a payload, we need to mangle the hostname so payloaded requests don't get sent out to servers.
+        if (somePayload && _hostname != null && !skipPayload && !ReUri[exports.DEBUG].dontEncodePayloads) {
+            _hostname = _hostname.replace(/\.([^.]*)$/, "_$1");
+        }
+        _protocol = _protocol != null ? `${_protocol}:` : _protocol;
+        _hostname = _hostname != null ? `//${_hostname}` : "";
+        _query = _query != null ? `?${_query}` : "";
+        _hash = _hash != null ? `#${_hash}` : "";
+        const strPort = _port != null ? `:${_port}` : "";
+        const path = this._getEncodedPath(skipPayload);
+        return [_protocol, _hostname, strPort, path, _query, _hash].join("");
+    }
+    /**
+     * Is this a fake URL generated by reflectiz?
+     */
+    get isReflectiz() {
+        return !!this._protocol && riProtocols.has(this._protocol);
+    }
+    /**
+     * Does this URL have a non-web protocol?
+     */
+    get isNonWeb() {
+        return !!this._protocol && !webProtocols.has(this._protocol);
+    }
+    /**
+     * Gets the full URI, including the payload.
+     */
+    get href() {
+        return this._print(false);
+    }
+    /**
+     * Gets the full URI, minus the payload.
+     */
+    get canonical() {
+        return this._print(true);
+    }
+    get [(_a = exports.DEBUG, Symbol.toStringTag)]() {
+        return this.href;
+    }
+    toString() {
+        return this.href;
+    }
+}
+exports.ReUri = ReUri;
+ReUri[_a] = {
+    dontEncodePayloads: false
+};
+const urlRegexp = /^(?:([a-zA-Z][A-Za-z\d+-.]*):)?(?:\/\/([^/?#:]*)(?::([^/?#]*))?)?([^?#]*)?(?:\?([^#]*))?(?:#(.*))?$/;
+const webProtocols = new Set(["http", "ws", "https", "wss"]);
+const riProtocols = new Set(["inline", "dynamic", "reflectiz"]);
+Object.defineProperty(ReUri, "__isReuri", {
+    value: true
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reuri.js","sourceRoot":"","sources":["../../src/lib/reuri.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    inputMustBeString,\n    inputMustBeUrl,\n    payloadMustBeObject,\n    portMustBeNumeric,\n    ReUriError\n} from \"./errors.js\";\nimport { equal } from \"./utils.js\";\nimport { int, str } from \"@reflectiz/types\";\nimport {\n    extractPayload,\n    getEncodedPath,\n    hostnameContains,\n    mustValidatePayload,\n    Payload,\n    payloadContains,\n    PayloadOrDefault\n} from \"./payload\";\nimport { Protocol, ReUriCompoundNames, ReUriParts, ReUriPathKey } from \"./parts\";\n\nexport interface ReUriDebugOptions {\n    dontEncodePayloads?: boolean;\n}\n\nexport const DEBUG = Symbol(\"debug\");\n\n/**\n * Represents a URI and allows performing operations and inspecting it.\n *\n * This class is immutable.\n */\nexport class ReUri<TPay extends Payload | undefined = undefined> {\n    static readonly [DEBUG]: ReUriDebugOptions = {\n        dontEncodePayloads: false\n    };\n    private 0: string;\n    // Lots of params needed here\n    // eslint-disable-next-line max-params\n    constructor(\n        private _protocol: Protocol | undefined,\n        private _hostname: string | undefined,\n        private _path: string,\n        private _query: string | undefined,\n        private _hash: string | undefined,\n        private _payload: TPay,\n        private _trace: Payload | undefined,\n        private _parsed: string | undefined,\n        private _port: string | undefined\n    ) {\n        if (_hostname) {\n            this._hostname = _hostname.replace(\"_\", \".\");\n            if (this._hostname.includes(\"_\")) {\n                console.warn(\n                    `The hostname contains multiple underscores, which might not be intended. Current hostname: ${this._hostname}`\n                );\n            }\n        }\n\n        this[0] = this._print(false);\n    }\n\n    static isReuri(other: unknown) {\n        return !!(\n            other &&\n            typeof other === \"object\" &&\n            other.constructor &&\n            \"__isReuri\" in other.constructor\n        );\n    }\n\n    segments(): string[];\n    segments(overwrite: string[]): ReUri<TPay>;\n    segments(overwrite?: string[]) {\n        if (arguments.length === 0) {\n            return this._path.split(\"/\");\n        }\n        const clone = this._noCopyClone();\n        clone._path = overwrite!.join(\"/\");\n        return clone;\n    }\n\n    merge(other: string): ReUri<TPay>;\n    merge(other: ReUri<any>): ReUri<TPay>;\n    merge(other: ReUri<any> | string): ReUri<TPay> {\n        if (typeof other === \"string\") {\n            return this.merge(ReUri.parse(other));\n        }\n        const mergedParts: ReUriParts = {\n            hash: other._hash || this._hash,\n            hostname: other._hostname || this._hostname,\n            path: other._path || this._path,\n            port: other._port || this._port,\n            protocol: other._protocol || this._protocol,\n            query: other._query || this._query,\n            trace: other._trace || this._trace\n        };\n        return this.parts(mergedParts).payloadMerge(other.payload()).trace(other.trace());\n    }\n\n    pick(...keys: ReUriPathKey[]): ReUri<TPay> {\n        let result = ReUri.empty() as ReUri<TPay>;\n        for (const key of keys) {\n            result = result.part(key, this.part(key as ReUriCompoundNames));\n        }\n        return result;\n    }\n\n    parts(): ReUriParts<TPay>;\n    parts<TPay2 extends Payload | undefined = TPay>(\n        overwrite: Partial<ReUriParts<Payload>>\n    ): ReUri<TPay2>;\n    parts(overwrite?: Partial<ReUriParts<Payload>>): any {\n        if (arguments.length === 0) {\n            return {\n                protocol: this._protocol,\n                hostname: this._hostname,\n                port: this._port,\n                path: this._path,\n                query: this._query,\n                hash: this._hash,\n                payload: this._payload,\n                trace: this._trace\n            };\n        }\n        if (!overwrite) {\n            return this;\n        }\n        const clone = this._noCopyClone();\n        clone._protocol = \"protocol\" in overwrite ? overwrite.protocol : clone._protocol;\n        clone._hostname = \"hostname\" in overwrite ? overwrite.hostname : clone._hostname;\n        clone._port = \"port\" in overwrite ? overwrite.port : clone._port;\n        clone._path = \"path\" in overwrite ? (overwrite.path as any) : clone._path;\n        clone._query = \"query\" in overwrite ? overwrite.query : clone._query;\n        clone._hash = \"hash\" in overwrite ? overwrite.hash : clone._hash;\n        clone._payload = \"payload\" in overwrite ? (overwrite.payload as any) : clone._payload;\n        clone._trace = \"trace\" in overwrite ? overwrite.trace : clone._trace;\n        return clone;\n    }\n\n    part(key: \"payload\"): TPay;\n    part(key: \"payload\", value: TPay): ReUri<TPay>;\n    part(key: \"trace\", value: Payload): ReUri<TPay>;\n    part(key: \"trace\"): Payload;\n    part(key: Exclude<ReUriPathKey, \"payload\" | \"trace\">): string | undefined;\n    part(key: ReUriPathKey, value: string | undefined): ReUri<TPay>;\n    part(key: ReUriPathKey, value?: string | TPay | Payload): any {\n        if (arguments.length === 1) {\n            const result = this[key]();\n            return typeof result === \"object\" ? result : str(result);\n        }\n        return this[key](value as any);\n    }\n\n    address(address: string | undefined | null): ReUri<TPay>;\n    address(): string | undefined;\n    address(address?: string): string | ReUri<TPay> | undefined {\n        if (arguments.length === 1) {\n            const parsed = ReUri.parse(address!);\n            return parsed.parts({\n                protocol: this._protocol\n            });\n        }\n        return this.parts({\n            protocol: undefined\n        }).href;\n    }\n\n    resource(resource: string | undefined | null): ReUri<TPay>;\n    resource(): string | undefined;\n    resource(resource?: string): string | ReUri<TPay> | undefined {\n        if (arguments.length === 1) {\n            const parsed = ReUri.parse(resource!);\n            return parsed.parts({\n                protocol: this._protocol,\n                hostname: this._hostname,\n                port: this._port\n            });\n        }\n        return this.parts({\n            protocol: undefined,\n            hostname: undefined,\n            port: undefined\n        }).href;\n    }\n\n    origin(origin: string | undefined | null): ReUri<TPay>;\n    origin(): string | undefined;\n    origin(origin?: string): string | ReUri<TPay> | undefined {\n        if (arguments.length === 1) {\n            const parsed = ReUri.parse(origin!);\n            return this.parts({\n                protocol: parsed._protocol,\n                hostname: parsed._hostname,\n                port: parsed._port\n            });\n        }\n        const parts = this.parts();\n        return (\n            ReUri.empty().parts({\n                protocol: parts.protocol,\n                hostname: parts.hostname,\n                port: parts.port\n            }).href || undefined\n        );\n    }\n\n    segment(index: number): string;\n    segment(index: number, value: string): ReUri<TPay>;\n    segment(index: number, value?: string) {\n        if (arguments.length === 0) {\n            throw new ReUriError(`You must provide an index.`);\n        }\n        if (arguments.length === 1) {\n            return this._path.split(\"/\")[index];\n        }\n        const segments = this.segments();\n        segments[index] = value!;\n        return this.segments(segments);\n    }\n\n    // Gets the path. It can't be nullish.\n    path(): string;\n    // Sets the path to `path`. Null is converted to `\"\"`.\n    path(path: string | undefined | null): ReUri<TPay>;\n    path(path?: string) {\n        if (arguments.length === 0) {\n            return this._path;\n        }\n        const clone = this._noCopyClone();\n        clone._path = path ?? \"\";\n        return clone;\n    }\n\n    port(): number | undefined;\n    port(raw: true): string | undefined;\n    port(port: number | undefined | string | null): ReUri<TPay>;\n    port(port?: number | true | string | null) {\n        if (arguments.length === 0) {\n            return int(this._port);\n        }\n        if (port === true) {\n            return this._port;\n        }\n        const clone = this._noCopyClone();\n        clone._port = str(port) ?? undefined;\n        return clone;\n    }\n\n    // Gets the protocol.\n    protocol(): Protocol | undefined;\n    // Sets the protocol to `proto`.\n    protocol(proto: Protocol | null | undefined): ReUri<TPay>;\n    protocol(proto?: Protocol | null | undefined) {\n        if (arguments.length === 0) {\n            return this._protocol;\n        }\n        const clone = this._noCopyClone();\n        clone._protocol = proto ?? undefined;\n        return clone;\n    }\n\n    // Gets the hostname and port.\n    host(): string | undefined;\n    // Sets the hostname and port.\n    host(host: string | undefined | null): ReUri<TPay>;\n    host(host?: string): any {\n        if (arguments.length === 0) {\n            return (\n                ReUri.empty().hostname(this._hostname).port(this._port).href.slice(2) || undefined\n            );\n        }\n        if (host == null) {\n            return this.hostname(null).port(null);\n        }\n        const parsed = ReUri.parse(`//${host}`);\n        return this.hostname(parsed._hostname).port(parsed._port);\n    }\n\n    // Gets the hostname, which is the domain without the port.\n    hostname(): string | undefined;\n    // Sets the hostname to `hostname`.\n    hostname(hostname: string | undefined | null): ReUri<TPay>;\n    hostname(hostname?: string) {\n        if (arguments.length === 0) {\n            return this._hostname;\n        }\n        const clone = this._noCopyClone();\n        clone._hostname = hostname ?? undefined;\n        return clone;\n    }\n\n    // Gets the query string.\n    query(): string | undefined;\n    // Sets the query string to `query`.\n    query(query: string | null | undefined): ReUri<TPay>;\n    query(query?: string) {\n        if (arguments.length === 0) {\n            return this._query;\n        }\n        const clone = this._noCopyClone();\n        clone._query = query ?? undefined;\n        return clone;\n    }\n\n    // Gets the hash, aka the fragment, without the #.\n    hash(): string;\n    // Sets the hash of this to `hash`, and returns `this`.\n    hash(hash: string | null | undefined): ReUri<TPay>;\n    hash(hash?: string) {\n        if (arguments.length === 0) {\n            return this._hash;\n        }\n        const clone = this._noCopyClone();\n        clone._hash = hash ?? undefined;\n        return clone;\n    }\n\n    private _getEncodedPath(skipPayload = false) {\n        if (skipPayload) {\n            return this._path;\n        }\n        return getEncodedPath(this._path, this._payload, this._trace);\n    }\n\n    private _noCopyClone() {\n        return new ReUri<TPay>(\n            this._protocol,\n            this._hostname,\n            this._path,\n            this._query,\n            this._hash,\n            this._payload,\n            this._trace,\n            this._parsed,\n            this._port\n        );\n    }\n\n    // Does this URL have a web protocol?\n    get isWeb() {\n        return !!this._protocol && webProtocols.has(this._protocol);\n    }\n\n    /**\n     * Gets a clone of this instance. The payload is also cloned.\n     */\n    clone(): ReUri<TPay> {\n        return new ReUri<TPay>(\n            this._protocol,\n            this._hostname,\n            this._path,\n            this._query,\n            this._hash,\n            this._payload && { ...this._payload },\n            this._trace && { ...this._trace },\n            this._parsed,\n            this._port\n        );\n    }\n\n    static empty(): ReUri<undefined>;\n    static empty<TPay extends Payload>(payload: TPay): ReUri<TPay>;\n    static empty<TPay extends Payload>(payload?: TPay) {\n        return new ReUri<TPay>(\n            undefined,\n            undefined,\n            \"\",\n            undefined,\n            undefined,\n            payload!,\n            undefined,\n            undefined,\n            undefined\n        );\n    }\n\n    // Parses `input` as a URI. Errors on bad input.\n    static parse(input: null | undefined): ReUri<undefined>;\n    static parse<TPay extends Payload | undefined>(\n        input: string | ReUri<TPay> | Partial<ReUriParts<Payload>>\n    ): ReUri<TPay>;\n    static parse<TPay extends Payload | undefined>(input: any) {\n        if (input == null) {\n            return ReUri.empty();\n        }\n        if (input instanceof ReUri) {\n            return input;\n        }\n        if (typeof input === \"object\") {\n            return ReUri.empty().parts(input);\n        }\n        if (typeof input !== \"string\") {\n            throw inputMustBeString(input);\n        }\n        const r = urlRegexp.exec(input);\n        if (!r) {\n            throw inputMustBeUrl(input);\n        }\n\n        let [, proto, hostname, port, pathWithPayload, query, fragment] = r;\n        if (port != null && (Number.isNaN(+port) || port === \"\")) {\n            throw portMustBeNumeric(input);\n        }\n        let { payload, tracePayload, path } = extractPayload<TPay>(pathWithPayload);\n        const somePayload = payload || tracePayload;\n        if (somePayload?.__trim) {\n            // This will only be set if the path is fake and only created for the payload\n            path = \"\";\n            delete somePayload.__trim;\n        }\n        if (somePayload) {\n            hostname = hostname?.replace(/_([^.]*)$/, \".$1\");\n        }\n        return new ReUri(\n            proto?.trim(),\n            hostname?.trim(),\n            path?.trim(),\n            query?.trim(),\n            fragment?.trim(),\n            payload!,\n            tracePayload,\n            input,\n            port\n        );\n    }\n\n    payloadMerge<TMore extends Payload>(this: ReUri<undefined>, more: TMore): ReUri<TMore>;\n    payloadMerge<TMore extends Payload>(this: ReUri<TPay>, more: TMore): ReUri<TMore & TPay>;\n    payloadMerge<TMore extends Payload = PayloadOrDefault<TPay>>(more: TMore): ReUri<TPay & TMore> {\n        const payload = Object.assign({}, this._payload, more);\n        return this.payload(payload);\n    }\n\n    trace(): Payload;\n    trace(payloadOwner: ReUri<any>): ReUri<TPay>;\n    trace(tracePayload: Payload): ReUri<TPay>;\n    trace(something?: Payload | ReUri<any>) {\n        if (arguments.length === 0) {\n            return (\n                this._trace && {\n                    ...this._trace\n                }\n            );\n        }\n        if (something == null) {\n            return this;\n        }\n        payloadMustBeObject(something);\n        const tracePayload = something instanceof ReUri ? something.trace() : something;\n        mustValidatePayload(tracePayload);\n        const clone = this._noCopyClone();\n        clone._trace = {\n            ...this._trace,\n            ...tracePayload\n        };\n        return clone;\n    }\n\n    /**\n     * Checks if this URI (CHILD) matches another URI (PARENT). The parent can be a string,\n     * a {@link ReUri} or, or an object describing the parts of a URI -- a {@link ReUriParts}.\n     *\n     * CHILD is considered to be a child of PARENT if:\n     * 1. If PARENT has a protocol, it must equal CHILD protocol.\n     * 2. If PARENT has a hostname, it must be a parent of CHILD's hostname.\n     * 3. If PARENT has a port, it must equal CHILD's port.\n     * 4. If PARENT has a path, it must be a parent of CHILD's path.\n     * 5. If PARENT has a query, it must equal CHILD's query.\n     * 6. If PARENT has a hash, it must equal CHILD's hash.\n     * 7. If PARENT has a payload, its properties must match CHILD's payload.\n     * 8. The trace payload is ignored.\n     * @param parent The parent URI to check against.\n     *\n     */\n    matches(\n        parent: Partial<ReUriParts<Payload | undefined>> | ReUri<Payload | undefined> | string\n    ): boolean {\n        parent = ReUri.parse(parent);\n        if (parent._protocol && parent._protocol !== this._protocol) {\n            return false;\n        }\n        if (parent._hostname && !hostnameContains(this._hostname, parent._hostname)) {\n            return false;\n        }\n\n        if (parent._port && parent._port !== this._port) {\n            return false;\n        }\n        if (parent._query && parent._query !== this._query) {\n            return false;\n        }\n        if (parent._hash && parent._hash !== this._hash) {\n            return false;\n        }\n        if (parent._payload && !payloadContains(this._payload, parent._payload)) {\n            return false;\n        }\n\n        const parentSegments = parent.segments();\n        const childSegments = this.segments();\n        for (let i = 0; i < parentSegments.length; i++) {\n            if (parentSegments[i] !== childSegments[i]) {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    /**\n     * Checks if this URI equals another URI, which can be given as a string, a {@link ReUri} or, or an object describing the parts of a URI -- a\n     * {@link ReUriParts}.\n     * @param other The other URI to check against.\n     * @param skipPayload If true, the payload is ignored.\n     */\n    equal(\n        other: string | ReUri<Payload | undefined> | Partial<ReUriParts<Payload | undefined>>,\n        skipPayload = false\n    ): boolean {\n        if (this === other) {\n            return true;\n        }\n        other = ReUri.parse(other);\n        const myParts = this.parts();\n        const otherParts = other.parts();\n        for (const key of [\"protocol\", \"hostname\", \"port\", \"path\", \"query\", \"hash\"] as const) {\n            if (myParts[key] !== otherParts[key]) {\n                return false;\n            }\n        }\n        if (skipPayload) {\n            return true;\n        }\n        if (!this._payload || !other._payload) {\n            return this._payload === other._payload;\n        }\n        return equal(this._payload, other._payload);\n    }\n\n    // An artificial URI is one that can't have been parsed from a string due to an invalid combination of components. For example,\n    // 1. A URL with a port but no hostname.\n    // 2. A URL with a hostname but no protocol.\n    // 3. A URL with\n    get isArtificial(): boolean {\n        return !ReUri.parse(this._print(true)).equal(this, true);\n    }\n\n    // Gets the payload.\n    payload(): TPay;\n    payload(payload: null | undefined): ReUri<undefined>;\n    // Sets the payload to a clone of `payload`. Disabled for non-http URLs.\n    payload<TOther extends Payload | undefined = PayloadOrDefault<TPay>>(\n        payload: TOther\n    ): ReUri<TOther>;\n    // Sets the payload to the payload of `otherReuri`. Disabled for non-http URLs.\n    payload<TOther extends Payload | undefined = PayloadOrDefault<TPay>>(\n        otherReuri: ReUri<TOther>\n    ): ReUri<TOther>;\n    payload(something?: object | ReUri<Payload> | ReUri<undefined> | null | undefined): any {\n        if (arguments.length === 0) {\n            return (\n                this._payload && {\n                    ...this._payload\n                }\n            );\n        }\n        if (this._protocol === \"data\") {\n            return this;\n        }\n        let payload: any | undefined;\n        payload = something instanceof ReUri ? something.payload() : something;\n        if (payload == null) {\n            payload = undefined;\n        } else {\n            payloadMustBeObject(something);\n            mustValidatePayload(payload);\n        }\n        const clone = this._noCopyClone();\n        clone._payload = payload && {\n            ...payload\n        };\n        return clone;\n    }\n\n    private _print(skipPayload = false) {\n        let { _protocol, _hostname, _query, _hash, _port } = this;\n        const somePayload = this._payload || this._trace;\n        skipPayload = skipPayload || ReUri[DEBUG].dontEncodePayloads || false;\n        // If we have a payload, we need to mangle the hostname so payloaded requests don't get sent out to servers.\n        if (somePayload && _hostname != null && !skipPayload && !ReUri[DEBUG].dontEncodePayloads) {\n            _hostname = _hostname.replace(/\\.([^.]*)$/, \"_$1\");\n        }\n        _protocol = _protocol != null ? `${_protocol}:` : _protocol;\n        _hostname = _hostname != null ? `//${_hostname}` : \"\";\n        _query = _query != null ? `?${_query}` : \"\";\n        _hash = _hash != null ? `#${_hash}` : \"\";\n        const strPort = _port != null ? `:${_port}` : \"\";\n\n        const path = this._getEncodedPath(skipPayload);\n\n        return [_protocol, _hostname, strPort, path, _query, _hash].join(\"\");\n    }\n\n    /**\n     * Is this a fake URL generated by reflectiz?\n     */\n    get isReflectiz() {\n        return !!this._protocol && riProtocols.has(this._protocol);\n    }\n\n    /**\n     * Does this URL have a non-web protocol?\n     */\n    get isNonWeb() {\n        return !!this._protocol && !webProtocols.has(this._protocol);\n    }\n\n    /**\n     * Gets the full URI, including the payload.\n     */\n    get href() {\n        return this._print(false);\n    }\n\n    /**\n     * Gets the full URI, minus the payload.\n     */\n    get canonical() {\n        return this._print(true);\n    }\n\n    get [Symbol.toStringTag]() {\n        return this.href;\n    }\n\n    toString() {\n        return this.href;\n    }\n}\n\nconst urlRegexp =\n    /^(?:([a-zA-Z][A-Za-z\\d+-.]*):)?(?:\\/\\/([^/?#:]*)(?::([^/?#]*))?)?([^?#]*)?(?:\\?([^#]*))?(?:#(.*))?$/;\n\nconst webProtocols = new Set([\"http\", \"ws\", \"https\", \"wss\"]);\n\nconst riProtocols = new Set([\"inline\", \"dynamic\", \"reflectiz\"]);\n\nObject.defineProperty(ReUri, \"__isReuri\", {\n    value: true\n});\n"]}

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function equal(a: any, b: any): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAoB7C"}

package/dist/lib/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equal = void 0;
+function equal(a, b) {
+    if (!a || typeof a !== "object" || !b || typeof b !== "object") {
+        return a === b;
+    }
+    const aProto = Object.getPrototypeOf(a);
+    const bProto = Object.getPrototypeOf(b);
+    if (aProto !== bProto) {
+        return false;
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    for (const key of aKeys) {
+        if (a[key] !== b[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.equal = equal;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLFNBQWdCLEtBQUssQ0FBQyxDQUFNLEVBQUUsQ0FBTTtJQUNoQyxJQUFJLENBQUMsQ0FBQyxJQUFJLE9BQU8sQ0FBQyxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsSUFBSSxPQUFPLENBQUMsS0FBSyxRQUFRLEVBQUU7UUFDNUQsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDO0tBQ2xCO0lBQ0QsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN4QyxNQUFNLE1BQU0sR0FBRyxNQUFNLENBQUMsY0FBYyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3hDLElBQUksTUFBTSxLQUFLLE1BQU0sRUFBRTtRQUNuQixPQUFPLEtBQUssQ0FBQztLQUNoQjtJQUNELE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDN0IsTUFBTSxLQUFLLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM3QixJQUFJLEtBQUssQ0FBQyxNQUFNLEtBQUssS0FBSyxDQUFDLE1BQU0sRUFBRTtRQUMvQixPQUFPLEtBQUssQ0FBQztLQUNoQjtJQUNELEtBQUssTUFBTSxHQUFHLElBQUksS0FBSyxFQUFFO1FBQ3JCLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLENBQUMsRUFBRTtZQUNuQixPQUFPLEtBQUssQ0FBQztTQUNoQjtLQUNKO0lBQ0QsT0FBTyxJQUFJLENBQUM7QUFDaEIsQ0FBQztBQXBCRCxzQkFvQkMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZXF1YWwoYTogYW55LCBiOiBhbnkpOiBib29sZWFuIHtcbiAgICBpZiAoIWEgfHwgdHlwZW9mIGEgIT09IFwib2JqZWN0XCIgfHwgIWIgfHwgdHlwZW9mIGIgIT09IFwib2JqZWN0XCIpIHtcbiAgICAgICAgcmV0dXJuIGEgPT09IGI7XG4gICAgfVxuICAgIGNvbnN0IGFQcm90byA9IE9iamVjdC5nZXRQcm90b3R5cGVPZihhKTtcbiAgICBjb25zdCBiUHJvdG8gPSBPYmplY3QuZ2V0UHJvdG90eXBlT2YoYik7XG4gICAgaWYgKGFQcm90byAhPT0gYlByb3RvKSB7XG4gICAgICAgIHJldHVybiBmYWxzZTtcbiAgICB9XG4gICAgY29uc3QgYUtleXMgPSBPYmplY3Qua2V5cyhhKTtcbiAgICBjb25zdCBiS2V5cyA9IE9iamVjdC5rZXlzKGIpO1xuICAgIGlmIChhS2V5cy5sZW5ndGggIT09IGJLZXlzLmxlbmd0aCkge1xuICAgICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICAgIGZvciAoY29uc3Qga2V5IG9mIGFLZXlzKSB7XG4gICAgICAgIGlmIChhW2tleV0gIT09IGJba2V5XSkge1xuICAgICAgICAgICAgcmV0dXJuIGZhbHNlO1xuICAgICAgICB9XG4gICAgfVxuICAgIHJldHVybiB0cnVlO1xufVxuIl19