vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/cjs/utils/pLimit.js

@@ -0,0 +1,135 @@
+"use strict";
+/* 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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pLimit = void 0;
+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;
+}
+exports.pLimit = pLimit;
+/*
+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;
+    }
+}
+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;
+        }
+    }
+}
+exports.default = Queue;

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

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

package/dist/cjs/utils/parseUrl.js

@@ -0,0 +1,221 @@
+"use strict";
+// We don't use new URL() as it doesn't exactly do what we need, for example:
+//  - It loses the original URL parts (which we need to manipulate and recreate URLs)
+//  - It doesn't support the tauri:// protocol
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUrlFromComponents = exports.assertUrlComponents = exports.isBaseServer = exports.assertUsageUrl = exports.isParsable = exports.parseUrl = void 0;
+const slice_js_1 = require("./slice.js");
+const assert_js_1 = require("./assert.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const PROTOCOLS = ['http://', 'https://', 'tauri://'];
+function isParsable(url) {
+    // `parseUrl()` works with these URLs
+    return (PROTOCOLS.some((p) => url.startsWith(p)) ||
+        url.startsWith('/') ||
+        url.startsWith('.') ||
+        url.startsWith('?') ||
+        url.startsWith('#') ||
+        url === '');
+}
+exports.isParsable = isParsable;
+function assertUsageUrl(url, errPrefix) {
+    (0, assert_js_1.assert)(errPrefix.includes(' but '));
+    (0, assert_js_1.assertUsage)(typeof url === 'string', `${errPrefix} should be a string`);
+    if (isParsable(url))
+        return;
+    if (!url.startsWith('/') && !url.includes(':')) {
+        (0, assert_js_1.assertUsage)(false, `${errPrefix} is ${picocolors_1.default.cyan(url)} and it should be /${picocolors_1.default.cyan(url)} instead (URL pathnames should start with a leading slash)`);
+    }
+    else {
+        (0, assert_js_1.assertUsage)(false, `${errPrefix} isn't a valid URL`);
+    }
+}
+exports.assertUsageUrl = assertUsageUrl;
+function parseUrl(url, baseServer) {
+    (0, assert_js_1.assert)(isParsable(url));
+    (0, assert_js_1.assert)(baseServer.startsWith('/'));
+    // Hash
+    const [urlWithoutHash, ...hashList] = url.split('#');
+    (0, assert_js_1.assert)(urlWithoutHash !== undefined);
+    const hashOriginal = ['', ...hashList].join('#') || null;
+    (0, assert_js_1.assert)(hashOriginal === null || hashOriginal.startsWith('#'));
+    const hash = hashOriginal === null ? '' : decodeSafe(hashOriginal.slice(1));
+    // Search
+    const [urlWithoutHashNorSearch, ...searchList] = urlWithoutHash.split('?');
+    (0, assert_js_1.assert)(urlWithoutHashNorSearch !== undefined);
+    const searchOriginal = ['', ...searchList].join('?') || null;
+    (0, assert_js_1.assert)(searchOriginal === null || searchOriginal.startsWith('?'));
+    const search = {};
+    const searchAll = {};
+    Array.from(new URLSearchParams(searchOriginal || '')).forEach(([key, val]) => {
+        search[key] = val;
+        searchAll[key] = [...(searchAll[key] || []), val];
+    });
+    // Origin + pathname
+    const { origin, pathname: pathnameResolved } = parsePathname(urlWithoutHashNorSearch, baseServer);
+    (0, assert_js_1.assert)(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
+    (0, assert_js_1.assert)(pathnameResolved.startsWith('/'));
+    (0, assert_js_1.assert)(origin === null || url.startsWith(origin));
+    // `pathnameOriginal`
+    const pathnameOriginal = urlWithoutHashNorSearch.slice((origin || '').length);
+    assertUrlComponents(url, origin, pathnameOriginal, searchOriginal, hashOriginal);
+    // Base URL
+    let { pathname, hasBaseServer } = analyzeBaseServer(pathnameResolved, baseServer);
+    pathname = decodePathname(pathname);
+    (0, assert_js_1.assert)(pathname.startsWith('/'));
+    return {
+        origin,
+        pathname,
+        pathnameOriginal: pathnameOriginal,
+        hasBaseServer,
+        search,
+        searchAll,
+        searchOriginal,
+        hash,
+        hashOriginal
+    };
+}
+exports.parseUrl = parseUrl;
+function decodeSafe(urlComponent) {
+    try {
+        return decodeURIComponent(urlComponent);
+    }
+    catch { }
+    try {
+        return decodeURI(urlComponent);
+    }
+    catch { }
+    return urlComponent;
+}
+function decodePathname(urlPathname) {
+    urlPathname = urlPathname
+        .split('/')
+        .map((dir) => decodeSafe(dir).split('/').join('%2F'))
+        .join('/');
+    urlPathname = urlPathname.replace(/\s/g, '');
+    return urlPathname;
+}
+function parsePathname(urlWithoutHashNorSearch, baseServer) {
+    {
+        const { origin, pathname } = parseOrigin(urlWithoutHashNorSearch);
+        if (origin) {
+            return { origin, pathname };
+        }
+        (0, assert_js_1.assert)(pathname === urlWithoutHashNorSearch);
+    }
+    if (urlWithoutHashNorSearch.startsWith('/')) {
+        return { origin: null, pathname: urlWithoutHashNorSearch };
+    }
+    else {
+        // In the browser, this is the Base URL of the current URL
+        // Safe access `window?.document?.baseURI` for users who shim `window` in Node.js
+        const base = (typeof window !== 'undefined' && window?.document?.baseURI) || baseServer;
+        const pathname = resolveUrlPathnameRelative(urlWithoutHashNorSearch, base);
+        // We need to parse the origin in case `base === window.document.baseURI`
+        const parsed = parseOrigin(pathname);
+        return parsed;
+    }
+}
+function parseOrigin(url) {
+    if (!PROTOCOLS.some((protocol) => url.startsWith(protocol))) {
+        return { pathname: url, origin: null };
+    }
+    else {
+        const [originPart1, originPart2, originPart3, ...pathnameParts] = url.split('/');
+        const origin = [originPart1, originPart2, originPart3].join('/');
+        const pathname = ['', ...pathnameParts].join('/') || '/';
+        return { origin, pathname };
+    }
+}
+// Adapted from https://stackoverflow.com/questions/14780350/convert-relative-path-to-absolute-using-javascript/14780463#14780463
+function resolveUrlPathnameRelative(pathnameRelative, base) {
+    const stack = base.split('/');
+    const parts = pathnameRelative.split('/');
+    let baseRestoreTrailingSlash = base.endsWith('/');
+    if (pathnameRelative.startsWith('.')) {
+        // remove current file name
+        stack.pop();
+    }
+    for (const i in parts) {
+        const p = parts[i];
+        if (p == '' && i === '0')
+            continue;
+        if (p == '.')
+            continue;
+        if (p == '..')
+            stack.pop();
+        else {
+            baseRestoreTrailingSlash = false;
+            stack.push(p);
+        }
+    }
+    let pathnameAbsolute = stack.join('/');
+    if (baseRestoreTrailingSlash && !pathnameAbsolute.endsWith('/'))
+        pathnameAbsolute += '/';
+    return pathnameAbsolute;
+}
+/* Not needed anymore?
+function assertUsageBaseServer(baseServer: string, usageErrorMessagePrefix: string = '') {
+  assertUsage(
+    !baseServer.startsWith('http'),
+    usageErrorMessagePrefix +
+      '`base` is not allowed to start with `http`. Consider using `baseAssets` instead, see https://vike.dev/base-url'
+  )
+  assertUsage(
+    baseServer.startsWith('/'),
+    usageErrorMessagePrefix + 'Wrong `base` value `' + baseServer + '`; `base` should start with `/`.'
+  )
+  assert(isBaseServer(baseServer))
+}
+*/
+function assertPathname(urlPathname) {
+    (0, assert_js_1.assert)(urlPathname.startsWith('/'));
+    (0, assert_js_1.assert)(!urlPathname.includes('?'));
+    (0, assert_js_1.assert)(!urlPathname.includes('#'));
+}
+function analyzeBaseServer(urlPathnameWithBase, baseServer) {
+    assertPathname(urlPathnameWithBase);
+    (0, assert_js_1.assert)(isBaseServer(baseServer));
+    // Mutable
+    let urlPathname = urlPathnameWithBase;
+    (0, assert_js_1.assert)(urlPathname.startsWith('/'));
+    (0, assert_js_1.assert)(baseServer.startsWith('/'));
+    if (baseServer === '/') {
+        const pathname = urlPathnameWithBase;
+        return { pathname, hasBaseServer: true };
+    }
+    // Support `url === '/some-base-url' && baseServer === '/some-base-url/'`
+    let baseServerNormalized = baseServer;
+    if (baseServer.endsWith('/') && urlPathname === (0, slice_js_1.slice)(baseServer, 0, -1)) {
+        baseServerNormalized = (0, slice_js_1.slice)(baseServer, 0, -1);
+        (0, assert_js_1.assert)(urlPathname === baseServerNormalized);
+    }
+    if (!urlPathname.startsWith(baseServerNormalized)) {
+        const pathname = urlPathnameWithBase;
+        return { pathname, hasBaseServer: false };
+    }
+    (0, assert_js_1.assert)(urlPathname.startsWith('/') || urlPathname.startsWith('http'));
+    (0, assert_js_1.assert)(urlPathname.startsWith(baseServerNormalized));
+    urlPathname = urlPathname.slice(baseServerNormalized.length);
+    if (!urlPathname.startsWith('/'))
+        urlPathname = '/' + urlPathname;
+    (0, assert_js_1.assert)(urlPathname.startsWith('/'));
+    return { pathname: urlPathname, hasBaseServer: true };
+}
+function isBaseServer(baseServer) {
+    return baseServer.startsWith('/');
+}
+exports.isBaseServer = isBaseServer;
+function assertUrlComponents(url, origin, pathname, searchOriginal, hashOriginal) {
+    const urlRecreated = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
+    (0, assert_js_1.assert)(url === urlRecreated);
+}
+exports.assertUrlComponents = assertUrlComponents;
+function createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal) {
+    const urlRecreated = `${origin || ''}${pathname}${searchOriginal || ''}${hashOriginal || ''}`;
+    return urlRecreated;
+}
+exports.createUrlFromComponents = createUrlFromComponents;

package/dist/cjs/utils/path-shim.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathJoin = void 0;
+// Simple shim for `import * from "node:path"` used by the server runtime.
+// Robust alternative: https://github.com/unjs/pathe
+const assert_js_1 = require("./assert.js");
+function pathJoin(path1, path2) {
+    (0, assert_js_1.assert)(!path1.includes('\\'));
+    (0, assert_js_1.assert)(!path2.includes('\\'));
+    let joined = [...path1.split('/'), ...path2.split('/')].filter(Boolean).join('/');
+    if (path1.startsWith('/'))
+        joined = '/' + joined;
+    return joined;
+}
+exports.pathJoin = pathJoin;

package/dist/cjs/utils/projectInfo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectInfo = void 0;
+const assertSingleInstance_js_1 = require("./assertSingleInstance.js");
+const PROJECT_VERSION = '0.4.142-commit-8bf568b';
+const projectInfo = {
+    projectName: 'Vike',
+    projectVersion: PROJECT_VERSION,
+    npmPackageName: 'vike',
+    githubRepository: 'https://github.com/vikejs/vike'
+};
+exports.projectInfo = projectInfo;
+// Trick: since `utils/asserts.ts` depends on this file (`utils/projectInfo.ts`), we can have confidence that this file is always instantiated. So that we don't have to initialize this code snippet at every possible entry. (There are a *lot* of entries: `client/router/`, `client/`, `node/`, `node/plugin/`, `node/cli`, etc.)
+(0, assertSingleInstance_js_1.onProjectInfo)(projectInfo.projectVersion);

package/dist/cjs/utils/removeEmptyLines.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeEmptyLines = void 0;
+function removeEmptyLines(msg) {
+    return msg
+        .split('\n')
+        .filter((line) => line.trim() !== '')
+        .join('\n');
+}
+exports.removeEmptyLines = removeEmptyLines;

package/dist/cjs/utils/removeFileExtention.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeFileExtention = void 0;
+function removeFileExtention(filePath) {
+    return filePath.split('.').slice(0, -1).join('.');
+}
+exports.removeFileExtention = removeFileExtention;

package/dist/cjs/utils/resolve.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = void 0;
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+const assertIsNotProductionRuntime_js_1 = require("./assertIsNotProductionRuntime.js");
+const filesystemPathHandling_js_1 = require("./filesystemPathHandling.js");
+const isScriptFile_js_1 = require("./isScriptFile.js");
+const module_1 = require("module");
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = `file://${__filename}`;
+const require_ = (0, module_1.createRequire)(importMetaUrl);
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+(0, assertIsNotProductionRuntime_js_1.assertIsNotProductionRuntime)();
+function resolve(importPath, cwd) {
+    (0, filesystemPathHandling_js_1.assertPosixPath)(cwd);
+    const clean = addFileExtensionsToRequireResolve();
+    importPath = removeFileExtention(importPath);
+    let importedFile;
+    try {
+        importedFile = require_.resolve(importPath, { paths: [cwd] });
+    }
+    catch {
+        importedFile = null;
+    }
+    finally {
+        clean();
+    }
+    if (importedFile) {
+        importedFile = (0, filesystemPathHandling_js_1.toPosixPath)(importedFile);
+    }
+    return importedFile;
+}
+exports.resolve = resolve;
+function removeFileExtention(importPath) {
+    for (const ext of isScriptFile_js_1.scriptFileExtensionList) {
+        const suffix = `.${ext}`;
+        if (importPath.endsWith(suffix)) {
+            return importPath.slice(0, -1 * suffix.length);
+        }
+    }
+    return importPath;
+}
+function addFileExtensionsToRequireResolve() {
+    const added = [];
+    isScriptFile_js_1.scriptFileExtensionList.forEach((ext) => {
+        (0, assert_js_1.assert)(!ext.includes('.'));
+        ext = `.${ext}`;
+        if (!require.extensions[ext]) {
+            require.extensions[ext] = require.extensions['.js'];
+            added.push(ext);
+        }
+    });
+    const clean = () => {
+        added.forEach((ext) => {
+            delete require.extensions[ext];
+        });
+    };
+    return clean;
+}

package/dist/cjs/utils/serverSideRouteTo.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverSideRouteTo = void 0;
+function serverSideRouteTo(url) {
+    window.location.href = url;
+}
+exports.serverSideRouteTo = serverSideRouteTo;

package/dist/cjs/utils/sleep.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+function sleep(milliseconds) {
+    return new Promise((r) => setTimeout(r, milliseconds));
+}
+exports.sleep = sleep;

package/dist/cjs/utils/slice.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slice = void 0;
+const assert_js_1 = require("./assert.js");
+function slice(thing, from, to) {
+    if (typeof thing === 'string') {
+        return sliceArray(thing.split(''), from, to).join('');
+    }
+    else {
+        return sliceArray(thing, from, to);
+    }
+}
+exports.slice = slice;
+function sliceArray(list, from, to) {
+    const listSlice = [];
+    let start = from >= 0 ? from : list.length + from;
+    (0, assert_js_1.assert)(start >= 0 && start <= list.length);
+    let end = to >= 0 ? to : list.length + to;
+    (0, assert_js_1.assert)(end >= 0 && end <= list.length);
+    while (true) {
+        if (start === end) {
+            break;
+        }
+        if (start === list.length) {
+            start = 0;
+        }
+        if (start === end) {
+            break;
+        }
+        const el = list[start];
+        (0, assert_js_1.assert)(el !== undefined);
+        listSlice.push(el);
+        start++;
+    }
+    return listSlice;
+}