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

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;
+}

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

@@ -0,0 +1,22 @@
+export { parseUrl };
+export { isParsable };
+export { assertUsageUrl };
+export { isBaseServer };
+export { assertUrlComponents };
+export { createUrlFromComponents };
+declare function isParsable(url: string): boolean;
+declare function assertUsageUrl(url: unknown, errPrefix: string): asserts url is string;
+declare function parseUrl(url: string, baseServer: string): {
+    origin: null | string;
+    pathname: string;
+    pathnameOriginal: string;
+    hasBaseServer: boolean;
+    search: Record<string, string>;
+    searchAll: Record<string, string[]>;
+    searchOriginal: null | string;
+    hash: string;
+    hashOriginal: null | string;
+};
+declare function isBaseServer(baseServer: string): boolean;
+declare function assertUrlComponents(url: string, origin: string | null, pathname: string, searchOriginal: string | null, hashOriginal: string | null): void;
+declare function createUrlFromComponents(origin: string | null, pathname: string, searchOriginal: string | null, hashOriginal: string | null): string;

package/dist/esm/utils/parseUrl.js

@@ -0,0 +1,216 @@
+// 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
+// Unit tests at ./parseUrl.spec.ts
+export { parseUrl };
+export { isParsable };
+export { assertUsageUrl };
+export { isBaseServer };
+export { assertUrlComponents };
+export { createUrlFromComponents };
+import { slice } from './slice.js';
+import { assert, assertUsage } from './assert.js';
+import pc from '@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 === '');
+}
+function assertUsageUrl(url, errPrefix) {
+    assert(errPrefix.includes(' but '));
+    assertUsage(typeof url === 'string', `${errPrefix} should be a string`);
+    if (isParsable(url))
+        return;
+    if (!url.startsWith('/') && !url.includes(':')) {
+        assertUsage(false, `${errPrefix} is ${pc.cyan(url)} and it should be /${pc.cyan(url)} instead (URL pathnames should start with a leading slash)`);
+    }
+    else {
+        assertUsage(false, `${errPrefix} isn't a valid URL`);
+    }
+}
+function parseUrl(url, baseServer) {
+    assert(isParsable(url));
+    assert(baseServer.startsWith('/'));
+    // Hash
+    const [urlWithoutHash, ...hashList] = url.split('#');
+    assert(urlWithoutHash !== undefined);
+    const hashOriginal = ['', ...hashList].join('#') || null;
+    assert(hashOriginal === null || hashOriginal.startsWith('#'));
+    const hash = hashOriginal === null ? '' : decodeSafe(hashOriginal.slice(1));
+    // Search
+    const [urlWithoutHashNorSearch, ...searchList] = urlWithoutHash.split('?');
+    assert(urlWithoutHashNorSearch !== undefined);
+    const searchOriginal = ['', ...searchList].join('?') || null;
+    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);
+    assert(origin === null || origin === decodeSafe(origin)); // AFAICT decoding the origin is useless
+    assert(pathnameResolved.startsWith('/'));
+    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);
+    assert(pathname.startsWith('/'));
+    return {
+        origin,
+        pathname,
+        pathnameOriginal: pathnameOriginal,
+        hasBaseServer,
+        search,
+        searchAll,
+        searchOriginal,
+        hash,
+        hashOriginal
+    };
+}
+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 };
+        }
+        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) {
+    assert(urlPathname.startsWith('/'));
+    assert(!urlPathname.includes('?'));
+    assert(!urlPathname.includes('#'));
+}
+function analyzeBaseServer(urlPathnameWithBase, baseServer) {
+    assertPathname(urlPathnameWithBase);
+    assert(isBaseServer(baseServer));
+    // Mutable
+    let urlPathname = urlPathnameWithBase;
+    assert(urlPathname.startsWith('/'));
+    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 === slice(baseServer, 0, -1)) {
+        baseServerNormalized = slice(baseServer, 0, -1);
+        assert(urlPathname === baseServerNormalized);
+    }
+    if (!urlPathname.startsWith(baseServerNormalized)) {
+        const pathname = urlPathnameWithBase;
+        return { pathname, hasBaseServer: false };
+    }
+    assert(urlPathname.startsWith('/') || urlPathname.startsWith('http'));
+    assert(urlPathname.startsWith(baseServerNormalized));
+    urlPathname = urlPathname.slice(baseServerNormalized.length);
+    if (!urlPathname.startsWith('/'))
+        urlPathname = '/' + urlPathname;
+    assert(urlPathname.startsWith('/'));
+    return { pathname: urlPathname, hasBaseServer: true };
+}
+function isBaseServer(baseServer) {
+    return baseServer.startsWith('/');
+}
+function assertUrlComponents(url, origin, pathname, searchOriginal, hashOriginal) {
+    const urlRecreated = createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal);
+    assert(url === urlRecreated);
+}
+function createUrlFromComponents(origin, pathname, searchOriginal, hashOriginal) {
+    const urlRecreated = `${origin || ''}${pathname}${searchOriginal || ''}${hashOriginal || ''}`;
+    return urlRecreated;
+}

package/dist/esm/utils/path-shim.d.ts

@@ -0,0 +1,2 @@
+export { pathJoin };
+declare function pathJoin(path1: string, path2: string): string;

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

@@ -0,0 +1,12 @@
+export { pathJoin };
+// Simple shim for `import * from "node:path"` used by the server runtime.
+// Robust alternative: https://github.com/unjs/pathe
+import { assert } from './assert.js';
+function pathJoin(path1, path2) {
+    assert(!path1.includes('\\'));
+    assert(!path2.includes('\\'));
+    let joined = [...path1.split('/'), ...path2.split('/')].filter(Boolean).join('/');
+    if (path1.startsWith('/'))
+        joined = '/' + joined;
+    return joined;
+}

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

@@ -0,0 +1,11 @@
+export { projectInfo };
+export type { ProjectTag };
+type PackageName = typeof projectInfo.npmPackageName;
+type ProjectVersion = typeof projectInfo.projectVersion;
+type ProjectTag = `[${PackageName}]` | `[${PackageName}@${ProjectVersion}]`;
+declare const projectInfo: {
+    projectName: "Vike";
+    projectVersion: "0.4.142-commit-8bf568b";
+    npmPackageName: "vike";
+    githubRepository: "https://github.com/vikejs/vike";
+};

package/dist/esm/utils/projectInfo.js

@@ -0,0 +1,11 @@
+export { projectInfo };
+import { onProjectInfo } from './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'
+};
+// 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.)
+onProjectInfo(projectInfo.projectVersion);

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

@@ -0,0 +1 @@
+export declare function removeEmptyLines(msg: string): string;

package/dist/esm/utils/removeEmptyLines.js

@@ -0,0 +1,6 @@
+export function removeEmptyLines(msg) {
+    return msg
+        .split('\n')
+        .filter((line) => line.trim() !== '')
+        .join('\n');
+}

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

@@ -0,0 +1 @@
+export declare function removeFileExtention(filePath: string): string;

package/dist/esm/utils/removeFileExtention.js

@@ -0,0 +1,3 @@
+export function removeFileExtention(filePath) {
+    return filePath.split('.').slice(0, -1).join('.');
+}

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

@@ -0,0 +1,2 @@
+export { resolve };
+declare function resolve(importPath: string, cwd: string): string | null;

package/dist/esm/utils/resolve.js

@@ -0,0 +1,57 @@
+export { resolve };
+import { assert } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.js';
+import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
+import { scriptFileExtensionList } from './isScriptFile.js';
+import { createRequire } from 'module';
+// @ts-ignore Shimed by dist-cjs-fixup.js for CJS build.
+const importMetaUrl = import.meta.url;
+const require_ = createRequire(importMetaUrl);
+assertIsNotBrowser();
+assertIsNotProductionRuntime();
+function resolve(importPath, cwd) {
+    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 = toPosixPath(importedFile);
+    }
+    return importedFile;
+}
+function removeFileExtention(importPath) {
+    for (const ext of scriptFileExtensionList) {
+        const suffix = `.${ext}`;
+        if (importPath.endsWith(suffix)) {
+            return importPath.slice(0, -1 * suffix.length);
+        }
+    }
+    return importPath;
+}
+function addFileExtensionsToRequireResolve() {
+    const added = [];
+    scriptFileExtensionList.forEach((ext) => {
+        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/esm/utils/serverSideRouteTo.d.ts

@@ -0,0 +1,2 @@
+export { serverSideRouteTo };
+declare function serverSideRouteTo(url: string): void;

package/dist/esm/utils/serverSideRouteTo.js

@@ -0,0 +1,4 @@
+export { serverSideRouteTo };
+function serverSideRouteTo(url) {
+    window.location.href = url;
+}

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

@@ -0,0 +1 @@
+export declare function sleep(milliseconds: number): Promise<void>;

package/dist/esm/utils/sleep.js

@@ -0,0 +1,3 @@
+export function sleep(milliseconds) {
+    return new Promise((r) => setTimeout(r, milliseconds));
+}

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

@@ -0,0 +1,3 @@
+export { slice };
+declare function slice<Element, T extends Array<Element>>(thing: T, from: number, to: number): T;
+declare function slice(thing: string, from: number, to: number): string;

package/dist/esm/utils/slice.js

@@ -0,0 +1,33 @@
+import { assert } from './assert.js';
+export { slice };
+function slice(thing, from, to) {
+    if (typeof thing === 'string') {
+        return sliceArray(thing.split(''), from, to).join('');
+    }
+    else {
+        return sliceArray(thing, from, to);
+    }
+}
+function sliceArray(list, from, to) {
+    const listSlice = [];
+    let start = from >= 0 ? from : list.length + from;
+    assert(start >= 0 && start <= list.length);
+    let end = to >= 0 ? to : list.length + to;
+    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];
+        assert(el !== undefined);
+        listSlice.push(el);
+        start++;
+    }
+    return listSlice;
+}

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

@@ -0,0 +1,8 @@
+export { higherFirst };
+export { lowerFirst };
+export { makeFirst };
+export { makeLast };
+declare function higherFirst<T>(getValue: (element: T) => number): (element1: T, element2: T) => 0 | 1 | -1;
+declare function lowerFirst<T>(getValue: (element: T) => number): (element1: T, element2: T) => 0 | 1 | -1;
+declare function makeFirst<T>(getValue: (element: T) => boolean | null): (element1: T, element2: T) => 0 | 1 | -1;
+declare function makeLast<T>(getValue: (element: T) => boolean | null): (element1: T, element2: T) => 0 | 1 | -1;

package/dist/esm/utils/sorter.js

@@ -0,0 +1,57 @@
+import { assert } from './assert.js';
+export { higherFirst };
+export { lowerFirst };
+export { makeFirst };
+export { makeLast };
+// -1 => element1 first (i.e. `indexOf(element1) < indexOf(element2)`)
+// +1 => element2 first (i.e. `indexOf(element2) < indexOf(element1)`)
+// 0 => keep original order of element1 and element2
+function higherFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        if (val1 === val2) {
+            return 0;
+        }
+        return val1 > val2 ? -1 : 1;
+    };
+}
+function lowerFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        if (val1 === val2) {
+            return 0;
+        }
+        return val1 < val2 ? -1 : 1;
+    };
+}
+function makeFirst(getValue) {
+    return (element1, element2) => {
+        const val1 = getValue(element1);
+        const val2 = getValue(element2);
+        assert([true, false, null].includes(val1));
+        assert([true, false, null].includes(val2));
+        if (val1 === val2) {
+            return 0;
+        }
+        if (val1 === true || val2 === false) {
+            return -1;
+        }
+        if (val2 === true || val1 === false) {
+            return 1;
+        }
+        assert(false);
+    };
+}
+function makeLast(getValue) {
+    return makeFirst((element) => {
+        const val = getValue(element);
+        if (val === null) {
+            return null;
+        }
+        else {
+            return !val;
+        }
+    });
+}

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

@@ -0,0 +1,2 @@
+export { stringifyStringArray };
+declare function stringifyStringArray(stringList: string[] | readonly string[]): string;

package/dist/esm/utils/stringifyStringArray.js

@@ -0,0 +1,4 @@
+export { stringifyStringArray };
+function stringifyStringArray(stringList) {
+    return '[' + stringList.map((str) => "'" + str + "'").join(', ') + ']';
+}

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

@@ -0,0 +1,2 @@
+export { stripAnsi };
+declare function stripAnsi(string: string): string;

package/dist/esm/utils/stripAnsi.js

@@ -0,0 +1,19 @@
+export { stripAnsi };
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+const ansiRegex = getAnsiRegex();
+// Copied from https://github.com/chalk/strip-ansi/blob/1fdc531d4046cbaa830460f5c74452bf1f0a0884/index.js
+function stripAnsi(string) {
+    // Even though the regex is global, we don't need to reset the `.lastIndex`
+    // because unlike `.exec()` and `.test()`, `.replace()` does it automatically
+    // and doing it manually has a performance penalty.
+    return string.replace(ansiRegex, '');
+}
+// Copied from https://github.com/chalk/ansi-regex/blob/02fa893d619d3da85411acc8fd4e2eea0e95a9d9/index.js
+function getAnsiRegex() {
+    const pattern = [
+        '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+        '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))'
+    ].join('|');
+    return new RegExp(pattern, 'g');
+}

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

@@ -0,0 +1 @@
+export declare const styleFileRE: RegExp;

package/dist/esm/utils/styleFileRE.js

@@ -0,0 +1,2 @@
+// Copied from https://github.com/vitejs/vite/blob/d649daba7682791178b711d9a3e44a6b5d00990c/packages/vite/src/node/plugins/css.ts#L90-L91
+export const styleFileRE = /\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\?)/;

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

@@ -0,0 +1,2 @@
+export { throttle };
+declare function throttle(func: Function, waitTime: number): () => void;

package/dist/esm/utils/throttle.js

@@ -0,0 +1,13 @@
+export { throttle };
+function throttle(func, waitTime) {
+    let isQueued = false;
+    return () => {
+        if (!isQueued) {
+            isQueued = true;
+            setTimeout(() => {
+                isQueued = false;
+                func();
+            }, waitTime);
+        }
+    };
+}

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

@@ -0,0 +1 @@
+export {};