vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

package/dist/esm/utils/isNotNullish.d.ts

@@ -0,0 +1 @@
+export declare const isNotNullish: <T>(p: T | null | undefined) => p is T;

package/dist/esm/utils/isNotNullish.js

@@ -0,0 +1 @@
+export const isNotNullish = (p) => p !== null && p !== undefined;

package/dist/esm/utils/isNpmPackage.d.ts

@@ -0,0 +1,17 @@
+export { isNpmPackageImport };
+export { isNpmPackageName };
+export { getNpmPackageName };
+export { getNpmPackageImportPath };
+export { isValidPathAlias };
+export { parse };
+export { isDistinguishable };
+declare function isNpmPackageImport(str: string): boolean;
+declare function isNpmPackageName(str: string | undefined): boolean;
+declare function getNpmPackageName(str: string): null | string;
+declare function getNpmPackageImportPath(str: string): null | string;
+declare function isValidPathAlias(alias: string): boolean;
+declare function isDistinguishable(alias: string): boolean;
+declare function parse(str: string | undefined): null | {
+    pkgName: string;
+    importPath: null | string;
+};

package/dist/esm/utils/isNpmPackage.js

@@ -0,0 +1,94 @@
+export { isNpmPackageImport };
+export { isNpmPackageName };
+export { getNpmPackageName };
+export { getNpmPackageImportPath };
+export { isValidPathAlias };
+// For ./isNpmPackage.spec.ts
+export { parse };
+export { isDistinguishable };
+import { assert } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+function isNpmPackageImport(str) {
+    const res = parse(str);
+    return res !== null;
+}
+function isNpmPackageName(str) {
+    const res = parse(str);
+    return res !== null && res.importPath === null;
+}
+function getNpmPackageName(str) {
+    const res = parse(str);
+    if (!res)
+        return null;
+    return res.pkgName;
+}
+function getNpmPackageImportPath(str) {
+    const res = parse(str);
+    if (!res)
+        return null;
+    return res.importPath;
+}
+function isValidPathAlias(alias) {
+    // Cannot be distinguished from npm package names
+    if (!isDistinguishable(alias))
+        return false;
+    // Ensure path alias starts with a special character.
+    //  - In principle, we could allow path aliases that don't start with special character as long as they can be distinguished from npm package names.
+    //    - But we still enforce path aliases to start with a special character because it's a much simpler rule to follow.
+    if (alias.startsWith('@/'))
+        return true; // Needed by contra.com
+    const firstLetter = alias[0];
+    assert(firstLetter);
+    if (firstLetter === '@' || /[0-9a-z]/.test(firstLetter.toLowerCase()))
+        return false;
+    return true;
+}
+function isDistinguishable(alias) {
+    return (parse(alias) === null &&
+        parse(`${alias}fake-path`) === null &&
+        parse(`${alias}/fake-path`) === null &&
+        parse(`${alias}fake/deep/path`) === null &&
+        parse(`${alias}/fake/deep/path`) === null &&
+        // See note about '-' in ./isNpmPackageName.spec.ts
+        // ```ts
+        // expect(parse('-')).toBe(null) // actually wrong: https://www.npmjs.com/package/-
+        // ```
+        !alias.startsWith('-'));
+}
+// The logic down below is wrong, for example:
+//  - https://www.npmjs.com/package/-
+// The correct logic is complex, see https://github.com/npm/validate-npm-package-name
+// We don't need to be accurate: are there npm packages with weird names that are actually being used?
+function parse(str) {
+    if (!str)
+        return null;
+    let scope = null;
+    if (str.startsWith('@')) {
+        if (!str.includes('/'))
+            return null;
+        const [scope_, ...rest] = str.split('/');
+        scope = scope_;
+        str = rest.join('/');
+        if (!str)
+            return null;
+        if (scope === '@' || invalid(scope.slice(1)))
+            return null;
+    }
+    const [name, ...importPathParts] = str.split('/');
+    if (!name || invalid(name))
+        return null;
+    const importPath = importPathParts.length === 0 ? null : importPathParts.join('/');
+    return {
+        pkgName: scope ? `${scope}/${name}` : name,
+        importPath
+    };
+}
+function invalid(s) {
+    const firstLetter = s[0];
+    if (!firstLetter || !/[a-z0-9]/.test(firstLetter))
+        return true;
+    if (/[^a-z0-9_\-\.]/.test(s))
+        return true;
+    return false;
+}

package/dist/esm/utils/isObject.d.ts

@@ -0,0 +1 @@
+export declare function isObject(value: unknown): value is Record<string, unknown>;

package/dist/esm/utils/isObject.js

@@ -0,0 +1,3 @@
+export function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/esm/utils/isObjectWithKeys.d.ts

@@ -0,0 +1,4 @@
+export { isObjectWithKeys };
+declare function isObjectWithKeys<Keys extends readonly string[]>(obj: unknown, keys: Keys): obj is {
+    [key in Keys[number]]?: unknown;
+};

package/dist/esm/utils/isObjectWithKeys.js

@@ -0,0 +1,13 @@
+import { isPlainObject } from './isPlainObject.js';
+export { isObjectWithKeys };
+function isObjectWithKeys(obj, keys) {
+    if (!isPlainObject(obj)) {
+        return false;
+    }
+    for (const key of Object.keys(obj)) {
+        if (!keys.includes(key)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/esm/utils/isPlainObject.d.ts

@@ -0,0 +1,3 @@
+export { isPlainObject };
+type PlainObject = Record<string, unknown>;
+declare function isPlainObject(value: unknown): value is PlainObject;

package/dist/esm/utils/isPlainObject.js

@@ -0,0 +1,15 @@
+export { isPlainObject };
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    // Support `Object.create(null)`
+    if (Object.getPrototypeOf(value) === null) {
+        return true;
+    }
+    return (
+    /* Doesn't work in Cloudlfare Pages workers
+    value.constructor === Object
+    */
+    value.constructor.name === 'Object');
+}

package/dist/esm/utils/isPromise.d.ts

@@ -0,0 +1 @@
+export declare function isPromise(val: unknown): val is Promise<unknown>;

package/dist/esm/utils/isPromise.js

@@ -0,0 +1,4 @@
+import { isCallable } from './isCallable.js';
+export function isPromise(val) {
+    return typeof val === 'object' && val !== null && 'then' in val && isCallable(val.then);
+}

package/dist/esm/utils/isReact.d.ts

@@ -0,0 +1 @@
+export declare function isReact(): boolean;

package/dist/esm/utils/isReact.js

@@ -0,0 +1,20 @@
+// There doesn't seem to be a reliable way to detect React:
+//  - https://stackoverflow.com/questions/73156433/detect-with-javascript-whether-the-website-is-using-react
+export function isReact() {
+    // Heuristic using values set by React (Dev Tools)
+    // - `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` is an internal API for React Dev Tools
+    //   - https://stackoverflow.com/questions/46807826/how-does-react-developer-tools-determine-that-the-webpage-is-using-react/46808361#46808361
+    //   - In principle, `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` should exist only if React Dev Tools is installed. (Although it seems that it's sometimes defined even when React Dev Tools isn't installed; I don't know why.)
+    // - We use `isReact1`/`isReact2` merely to validate `isReact3` and `isReact4`. Because `isReact1`/`isReact2` can be false negatives:
+    //   - React populates `__REACT_DEVTOOLS_GLOBAL_HOOK__.renderers` fairly late => false negative early in the rendering phase
+    //   - `window.__REACT_DEVTOOLS_GLOBAL_HOOK__` is `undefined` if React Dev Tools isn't installed => false negative
+    const isReact1 = !!window.__REACT_DEVTOOLS_GLOBAL_HOOK__?.renderers?.size;
+    const isReact2 = !!window.__REACT_DEVTOOLS_GLOBAL_HOOK__?.rendererInterfaces?.size;
+    // Heuristic using values set by `@vitejs/plugin-react`
+    const isReact3 = !!window.__vite_plugin_react_preamble_installed__;
+    /* Also set by Preact Vite plugin `@preact/preset-vite`
+    const isReact4 = !!(window as any).$RefreshReg$
+    */
+    // console.log({ isReact1, isReact2, isReact3 })
+    return isReact1 || isReact2 || isReact3;
+}

package/dist/esm/utils/isScriptFile.d.ts

@@ -0,0 +1,8 @@
+export { isScriptFile };
+export { isTemplateFile };
+export { scriptFileExtensions };
+export { scriptFileExtensionList };
+declare const scriptFileExtensionList: readonly ["js", "ts", "cjs", "cts", "mjs", "mts", "jsx", "tsx", "cjsx", "ctsx", "mjsx", "mtsx", "vue", "svelte", "marko", "md", "mdx"];
+declare const scriptFileExtensions: string;
+declare function isScriptFile(filePath: string): boolean;
+declare function isTemplateFile(filePath: string): boolean;

package/dist/esm/utils/isScriptFile.js

@@ -0,0 +1,50 @@
+export { isScriptFile };
+export { isTemplateFile };
+export { scriptFileExtensions };
+export { scriptFileExtensionList };
+import { assert } from './assert.js';
+// We can't use a RegExp:
+//  - Needs to work with Micromatch: https://github.com/micromatch/micromatch because:
+//    - Vite's `import.meta.glob()` uses Micromatch
+//  - We need this to be a whitelist because:
+//   - A pattern `*([a-zA-Z0-9]` doesn't work.
+//     - Because of ReScript: `.res` are ReScript source files which need to be ignored. (The ReScript compiler generates `.js` files alongside `.res` files.)
+//   - Black listing doesn't work.
+//     - We cannot implement a blacklist with a glob pattern.
+//     - A post `import.meta.glob()` blacklist filtering doesn't work because Vite would still process the files (e.g. including them in the bundle).
+// prettier-ignore
+const extJavaScript = [
+    'js',
+    'ts',
+    'cjs',
+    'cts',
+    'mjs',
+    'mts',
+    'jsx',
+    'tsx',
+    'cjsx',
+    'ctsx',
+    'mjsx',
+    'mtsx',
+];
+// prettier-ignore
+const extTemplates = [
+    'vue',
+    'svelte',
+    'marko',
+    'md',
+    'mdx'
+];
+const scriptFileExtensionList = [...extJavaScript, ...extTemplates];
+const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
+function isScriptFile(filePath) {
+    const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
+    assert(!isJavaScriptFile(filePath) || yes);
+    return yes;
+}
+function isJavaScriptFile(filePath) {
+    return /\.(c|m)?(j|t)sx?$/.test(filePath);
+}
+function isTemplateFile(filePath) {
+    return extTemplates.some((ext) => filePath.endsWith('.' + ext));
+}

package/dist/esm/utils/isStemPackageName.d.ts

@@ -0,0 +1 @@
+export declare function isStemPackageName(npmPackageName: string): boolean;

package/dist/esm/utils/isStemPackageName.js

@@ -0,0 +1,10 @@
+export function isStemPackageName(npmPackageName) {
+    if (npmPackageName.startsWith('stem-')) {
+        return true;
+    }
+    const [orgName, pkgName] = npmPackageName.split('/');
+    if (orgName.startsWith('@') && pkgName?.startsWith('stem-')) {
+        return true;
+    }
+    return false;
+}

package/dist/esm/utils/isStringRecord.d.ts

@@ -0,0 +1 @@
+export declare function isStringRecord(thing: unknown): thing is Record<string, string>;

package/dist/esm/utils/isStringRecord.js

@@ -0,0 +1,3 @@
+export function isStringRecord(thing) {
+    return typeof thing === 'object' && thing !== null && Object.values(thing).every((val) => typeof val === 'string');
+}

package/dist/esm/utils/isVitest.d.ts

@@ -0,0 +1 @@
+export declare function isVitest(): boolean;

package/dist/esm/utils/isVitest.js

@@ -0,0 +1,3 @@
+export function isVitest() {
+    return typeof process !== 'undefined' && typeof process.env !== 'undefined' && 'VITEST' in process.env;
+}

package/dist/esm/utils/joinEnglish.d.ts

@@ -0,0 +1,2 @@
+export { joinEnglish };
+declare function joinEnglish(arr: string[], conjunction: 'or' | 'and'): string;

package/dist/esm/utils/joinEnglish.js

@@ -0,0 +1,11 @@
+export { joinEnglish };
+import { assert } from './assert.js';
+// https://stackoverflow.com/questions/53879088/join-an-array-by-commas-and-and/53879103#53879103
+function joinEnglish(arr, conjunction) {
+    assert(arr.length > 0);
+    if (arr.length === 1)
+        return arr[0];
+    const firsts = arr.slice(0, arr.length - 1);
+    const last = arr[arr.length - 1];
+    return firsts.join(', ') + ` ${conjunction} ` + last;
+}

package/dist/esm/utils/mergeCumulativeValues.d.ts

@@ -0,0 +1,2 @@
+export { mergeCumulativeValues };
+declare function mergeCumulativeValues(values: unknown[]): null | unknown[] | Set<unknown>;

package/dist/esm/utils/mergeCumulativeValues.js

@@ -0,0 +1,18 @@
+export { mergeCumulativeValues };
+import { assert } from './assert.js';
+function mergeCumulativeValues(values) {
+    if (values.length === 0)
+        return null;
+    if (values.every((v) => v instanceof Set)) {
+        return new Set(values
+            .map((v) => {
+            assert(v instanceof Set);
+            return [...v];
+        })
+            .flat());
+    }
+    if (values.every((v) => Array.isArray(v))) {
+        return values.flat();
+    }
+    return null;
+}

package/dist/esm/utils/nodeEnv.d.ts

@@ -0,0 +1,4 @@
+export { getNodeEnv };
+export { setNodeEnvToProduction };
+declare function getNodeEnv(): null | undefined | string;
+declare function setNodeEnvToProduction(): void | undefined;

package/dist/esm/utils/nodeEnv.js

@@ -0,0 +1,13 @@
+export { getNodeEnv };
+export { setNodeEnvToProduction };
+function getNodeEnv() {
+    if (typeof process === 'undefined')
+        return null;
+    return process.env.NODE_ENV;
+}
+function setNodeEnvToProduction() {
+    // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
+    const proc = process;
+    const { env } = proc;
+    env.NODE_ENV = 'production';
+}

package/dist/esm/utils/objectAssign.d.ts

@@ -0,0 +1,2 @@
+export { objectAssign };
+declare function objectAssign<Obj extends object, ObjAddendum>(obj: Obj, objAddendum: ObjAddendum): asserts obj is Obj & ObjAddendum;

package/dist/esm/utils/objectAssign.js

@@ -0,0 +1,7 @@
+export { objectAssign };
+// Same as Object.assign() but:
+//  - With type inference
+//  - Preserves property descriptors, which we need for preserving the getters added by addUrlComputedProps()
+function objectAssign(obj, objAddendum) {
+    Object.defineProperties(obj, Object.getOwnPropertyDescriptors(objAddendum));
+}

package/dist/esm/utils/objectEntries.d.ts

@@ -0,0 +1,4 @@
+export { objectEntries };
+type ValueOf<T> = T[keyof T];
+type Entries<T> = [keyof T, ValueOf<T>][];
+declare function objectEntries<T extends object>(obj: T): Entries<T>;

package/dist/esm/utils/objectEntries.js

@@ -0,0 +1,5 @@
+export { objectEntries };
+// Same as `Object.entries()` but with type inference
+function objectEntries(obj) {
+    return Object.entries(obj);
+}

package/dist/esm/utils/objectKeys.d.ts

@@ -0,0 +1,2 @@
+/** Same as Object.keys() but with type inference */
+export declare function objectKeys<T extends Record<string, unknown>>(obj: T): Array<keyof T>;

package/dist/esm/utils/objectKeys.js

@@ -0,0 +1,6 @@
+/** Same as Object.keys() but with type inference */
+export function objectKeys(obj) {
+    return Object.keys(obj);
+}
+// https://stackoverflow.com/questions/52856496/typescript-object-keys-return-string
+// https://github.com/sindresorhus/ts-extras/blob/main/source/object-keys.ts

package/dist/esm/utils/pLimit.d.ts

@@ -0,0 +1,14 @@
+export { pLimit };
+export type PLimit = (job: () => Promise<void>) => Promise<undefined> & {
+    __stamp?: Symbol;
+};
+declare function pLimit(concurrency: number): PLimit;
+export default class Queue {
+    #private;
+    constructor();
+    enqueue(value: any): void;
+    dequeue(): any;
+    clear(): void;
+    get size(): any;
+    [Symbol.iterator](): Generator<any, void, unknown>;
+}

package/dist/esm/utils/pLimit.js

@@ -0,0 +1,131 @@
+/* Copied from https://github.com/sindresorhus/p-limit */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Queue_head, _Queue_tail, _Queue_size;
+export { pLimit };
+function pLimit(concurrency) {
+    if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+        throw new TypeError('Expected concurrency to be a number from 1 and up');
+    }
+    const queue = new Queue();
+    let activeCount = 0;
+    const next = () => {
+        activeCount--;
+        if (queue.size > 0) {
+            queue.dequeue()();
+        }
+    };
+    // @ts-ignore
+    const run = async (fn, resolve, args) => {
+        activeCount++;
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+            await result;
+        }
+        catch { }
+        next();
+    };
+    // @ts-ignore
+    const enqueue = (fn, resolve, args) => {
+        queue.enqueue(run.bind(undefined, fn, resolve, args));
+        (async () => {
+            // This function needs to wait until the next microtask before comparing
+            // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+            // when the run function is dequeued and called. The comparison in the if-statement
+            // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+            await Promise.resolve();
+            if (activeCount < concurrency && queue.size > 0) {
+                queue.dequeue()();
+            }
+        })();
+    };
+    // @ts-ignore
+    const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, args);
+    });
+    Object.defineProperties(generator, {
+        activeCount: {
+            get: () => activeCount
+        },
+        pendingCount: {
+            get: () => queue.size
+        },
+        clearQueue: {
+            value: () => {
+                queue.clear();
+            }
+        }
+    });
+    // @ts-ignore
+    return generator;
+}
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
+class Node {
+    // @ts-ignore
+    constructor(value) {
+        this.value = value;
+    }
+}
+export default class Queue {
+    constructor() {
+        // @ts-ignore
+        _Queue_head.set(this, void 0);
+        // @ts-ignore
+        _Queue_tail.set(this, void 0);
+        // @ts-ignore
+        _Queue_size.set(this, void 0);
+        this.clear();
+    }
+    // @ts-ignore
+    enqueue(value) {
+        var _a;
+        const node = new Node(value);
+        if (__classPrivateFieldGet(this, _Queue_head, "f")) {
+            __classPrivateFieldGet(this, _Queue_tail, "f").next = node;
+            __classPrivateFieldSet(this, _Queue_tail, node, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Queue_head, node, "f");
+            __classPrivateFieldSet(this, _Queue_tail, node, "f");
+        }
+        __classPrivateFieldSet(this, _Queue_size, (_a = __classPrivateFieldGet(this, _Queue_size, "f"), _a++, _a), "f");
+    }
+    dequeue() {
+        var _a;
+        const current = __classPrivateFieldGet(this, _Queue_head, "f");
+        if (!current) {
+            return;
+        }
+        __classPrivateFieldSet(this, _Queue_head, __classPrivateFieldGet(this, _Queue_head, "f").next, "f");
+        __classPrivateFieldSet(this, _Queue_size, (_a = __classPrivateFieldGet(this, _Queue_size, "f"), _a--, _a), "f");
+        return current.value;
+    }
+    clear() {
+        __classPrivateFieldSet(this, _Queue_head, undefined, "f");
+        __classPrivateFieldSet(this, _Queue_tail, undefined, "f");
+        __classPrivateFieldSet(this, _Queue_size, 0, "f");
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _Queue_size, "f");
+    }
+    *[(_Queue_head = new WeakMap(), _Queue_tail = new WeakMap(), _Queue_size = new WeakMap(), Symbol.iterator)]() {
+        let current = __classPrivateFieldGet(this, _Queue_head, "f");
+        while (current) {
+            yield current.value;
+            current = current.next;
+        }
+    }
+}

package/dist/esm/utils/parseUrl-extras.d.ts

@@ -0,0 +1,17 @@
+export { prependBase };
+export { isBaseAssets };
+export { normalizeUrlPathname };
+export { removeBaseServer };
+export { modifyUrlPathname };
+export { removeUrlOrigin };
+export { addUrlOrigin };
+declare function prependBase(url: string, baseServer: string): string;
+declare function removeBaseServer(url: string, baseServer: string): string;
+declare function isBaseAssets(base: string): boolean;
+declare function normalizeUrlPathname(urlOriginal: string, trailingSlash: boolean): string | null;
+declare function modifyUrlPathname(url: string, modifier: (urlPathname: string) => string | null): string;
+declare function removeUrlOrigin(url: string): {
+    urlModified: string;
+    origin: string | null;
+};
+declare function addUrlOrigin(url: string, origin: string | null): string;

package/dist/esm/utils/parseUrl-extras.js

@@ -0,0 +1,93 @@
+export { prependBase };
+export { isBaseAssets };
+export { normalizeUrlPathname };
+export { removeBaseServer };
+export { modifyUrlPathname };
+export { removeUrlOrigin };
+export { addUrlOrigin };
+import { assertUrlComponents, createUrlFromComponents, isBaseServer, parseUrl } from './parseUrl.js';
+import { assert } from './assert.js';
+import { slice } from './slice.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+function prependBase(url, baseServer) {
+    if (baseServer.startsWith('http')) {
+        const baseAssets = baseServer;
+        const baseAssetsNormalized = normalizeBaseAssets(baseAssets);
+        assert(!baseAssetsNormalized.endsWith('/'));
+        assert(url.startsWith('/'));
+        return `${baseAssetsNormalized}${url}`;
+    }
+    assert(isBaseServer(baseServer));
+    const baseServerNormalized = normalizeBaseServer(baseServer);
+    if (baseServerNormalized === '/')
+        return url;
+    assert(!baseServerNormalized.endsWith('/'));
+    assert(url.startsWith('/'));
+    return `${baseServerNormalized}${url}`;
+}
+function removeBaseServer(url, baseServer) {
+    const { hasBaseServer, origin, pathname, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, baseServer);
+    assert(hasBaseServer);
+    assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal);
+    const urlWithoutBase = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
+    return urlWithoutBase;
+}
+function normalizeBaseAssets(baseAssets) {
+    let baseAssetsNormalized = baseAssets;
+    if (baseAssetsNormalized.endsWith('/')) {
+        baseAssetsNormalized = slice(baseAssetsNormalized, 0, -1);
+    }
+    assert(!baseAssetsNormalized.endsWith('/'));
+    return baseAssetsNormalized;
+}
+function normalizeBaseServer(baseServer) {
+    let baseServerNormalized = baseServer;
+    if (baseServerNormalized.endsWith('/') && baseServerNormalized !== '/') {
+        baseServerNormalized = slice(baseServerNormalized, 0, -1);
+    }
+    // We can and should expect `baseServer` to not contain `/` doublets.
+    assert(!baseServerNormalized.endsWith('/') || baseServerNormalized === '/');
+    return baseServerNormalized;
+}
+function isBaseAssets(base) {
+    return base.startsWith('/') || base.startsWith('http://') || base.startsWith('https://');
+}
+function normalizeUrlPathname(urlOriginal, trailingSlash) {
+    const urlNormalized = modifyUrlPathname(urlOriginal, (urlPathname) => {
+        assert(urlPathname.startsWith('/'));
+        let urlPathnameNormalized = '/' + urlPathname.split('/').filter(Boolean).join('/');
+        if (urlPathnameNormalized !== '/') {
+            assert(!urlPathnameNormalized.endsWith('/'));
+            if (trailingSlash) {
+                urlPathnameNormalized = urlPathnameNormalized + '/';
+            }
+        }
+        return urlPathnameNormalized;
+    });
+    if (urlNormalized === urlOriginal)
+        return null;
+    return urlNormalized;
+}
+function modifyUrlPathname(url, modifier) {
+    const { origin, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, '/');
+    const pathnameModified = modifier(pathnameOriginal);
+    if (pathnameModified === null)
+        return url;
+    assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal);
+    const urlModified = createUrlFromComponents(origin, pathnameModified, searchOriginal, hashOriginal);
+    assert((pathnameOriginal === pathnameModified) === (url === urlModified));
+    return urlModified;
+}
+function removeUrlOrigin(url) {
+    const { origin, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, '/');
+    const urlModified = createUrlFromComponents(null, pathnameOriginal, searchOriginal, hashOriginal);
+    return { urlModified, origin };
+}
+function addUrlOrigin(url, origin) {
+    const { origin: originCurrent, pathnameOriginal, searchOriginal, hashOriginal } = parseUrl(url, '/');
+    assert(originCurrent === null);
+    assert(origin === null || origin.startsWith('http'));
+    const urlModified = createUrlFromComponents(origin, pathnameOriginal, searchOriginal, hashOriginal);
+    return urlModified;
+}