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

package/dist/esm/utils/getDependencyPackageJson.js

@@ -0,0 +1,85 @@
+export { getDependencyPackageJson };
+export { getDependencyPackageJsonPath };
+export { getDependencyRootDir };
+// There doesn't seem to be any alternative:
+//  - https://github.com/antfu/local-pkg
+//  - https://stackoverflow.com/questions/74640378/find-and-read-package-json-of-a-dependency
+//  - https://stackoverflow.com/questions/58442451/finding-the-root-directory-of-a-dependency-in-npm
+//  - https://stackoverflow.com/questions/10111163/how-can-i-get-the-path-of-a-module-i-have-loaded-via-require-that-is-not-mine/63441056#63441056
+import { assert, assertUsage } from './assert.js';
+import { isNpmPackageName } from './isNpmPackage.js';
+import { toPosixPath } from './filesystemPathHandling.js';
+import { isObject } from './isObject.js';
+import path from 'path';
+import fs from 'fs';
+import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.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);
+assertIsNotProductionRuntime();
+function getDependencyPackageJson(npmPackageName, userAppRootDir) {
+    const packageJsonPath = getDependencyPackageJsonPath(npmPackageName, userAppRootDir);
+    const packageJson = fs.readFileSync(packageJsonPath, 'utf8');
+    assert(isObject(packageJson));
+    return packageJson;
+}
+function getDependencyRootDir(npmPackageName, userAppRootDir) {
+    const rootDir = path.posix.dirname(getDependencyPackageJsonPath(npmPackageName, userAppRootDir));
+    return rootDir;
+}
+function getDependencyPackageJsonPath(npmPackageName, userAppRootDir) {
+    assert(isNpmPackageName(npmPackageName));
+    let packageJsonPath = resolvePackageJsonDirectly(npmPackageName, userAppRootDir);
+    if (!packageJsonPath) {
+        packageJsonPath = resolvePackageJsonWithMainEntry(npmPackageName, userAppRootDir);
+    }
+    assertUsage(packageJsonPath, `Cannot read ${npmPackageName}/package.json. Define package.json#exports["./package.json"] with the value "./package.json" in the package.json of ${npmPackageName}.`);
+    packageJsonPath = toPosixPath(packageJsonPath);
+    assert(packageJsonPath.endsWith('/package.json'), packageJsonPath); // package.json#exports["package.json"] may point to another file than package.json
+    return packageJsonPath;
+}
+function resolvePackageJsonDirectly(npmPackageName, userAppRootDir) {
+    let packageJsonPath;
+    try {
+        packageJsonPath = require_.resolve(`${npmPackageName}/package.json`, { paths: [userAppRootDir] });
+    }
+    catch (err) {
+        if (isUnexpectedError(err))
+            throw err;
+        return null;
+    }
+    return packageJsonPath;
+}
+function resolvePackageJsonWithMainEntry(npmPackageName, userAppRootDir) {
+    let mainEntry;
+    try {
+        mainEntry = require_.resolve(npmPackageName, { paths: [userAppRootDir] });
+    }
+    catch (err) {
+        if (isUnexpectedError(err))
+            throw err;
+        return null;
+    }
+    const packageJsonPath = searchPackageJSON(mainEntry);
+    return packageJsonPath;
+}
+// If the npm package doesn't define package.json#exports then require.resolve(`${npmPackageName}/package.json`) just works.
+// This means we can assume packageJson#exports to be defined and, consequently, we can assume the error code to always be ERR_PACKAGE_PATH_NOT_EXPORTED.
+// (If MODULE_NOT_FOUND is thrown then this means that npmPackageName isn't installed.)
+function isUnexpectedError(err) {
+    return err?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED';
+}
+// Copied and adapted from https://github.com/antfu/local-pkg
+function searchPackageJSON(dir) {
+    let packageJsonPath;
+    while (true) {
+        assert(dir);
+        const newDir = path.dirname(dir);
+        assert(newDir !== dir);
+        dir = newDir;
+        packageJsonPath = path.join(dir, 'package.json');
+        if (fs.existsSync(packageJsonPath))
+            return packageJsonPath;
+    }
+}

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

@@ -0,0 +1,2 @@
+export { getFileExtension };
+declare function getFileExtension(id: string): string | null;

package/dist/esm/utils/getFileExtension.js

@@ -0,0 +1,14 @@
+export { getFileExtension };
+import { slice } from './slice.js';
+function getFileExtension(id) {
+    id = id.split('?')[0];
+    const fileName = slice(id.split('/'), -1, 0)[0];
+    if (!fileName) {
+        return null;
+    }
+    const fileExtension = slice(fileName.split('.'), -1, 0)[0];
+    if (!fileExtension) {
+        return null;
+    }
+    return fileExtension;
+}

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

@@ -0,0 +1,5 @@
+export { getFilePathAbsolute };
+export { getFilePathRelativeToUserRootDir };
+import type { ResolvedConfig } from 'vite';
+declare function getFilePathAbsolute(filePath: string, config: ResolvedConfig): string;
+declare function getFilePathRelativeToUserRootDir(filePathAbsolute: string, userRootDir: string, alwaysRelative?: boolean): string;

package/dist/esm/utils/getFilePathAbsolute.js

@@ -0,0 +1,64 @@
+export { getFilePathAbsolute };
+export { getFilePathRelativeToUserRootDir };
+import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
+import { assert } from './assert.js';
+import path from 'path';
+import { assertIsNotProductionRuntime } from './assertIsNotProductionRuntime.js';
+import { isNpmPackageImport } from './isNpmPackage.js';
+import { assertPathIsFilesystemAbsolute } from './assertPathIsFilesystemAbsolute.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);
+assertIsNotProductionRuntime();
+// Vite handles paths such as /pages/index.page.js which are relative to `config.root`.
+// Make them absolute starting from the filesystem root.
+// Also resolve plus files living in npm packages such as restack/renderer/+onRenderHtml.js
+function getFilePathAbsolute(filePath, config) {
+    assertPosixPath(filePath);
+    if (filePath.startsWith('/@fs/')) {
+        return filePath;
+    }
+    let filePathUnresolved;
+    if (isNpmPackageImport(filePath)) {
+        filePathUnresolved = filePath;
+    }
+    else {
+        assert(filePath.startsWith('/'));
+        const { root } = config;
+        assertPathIsFilesystemAbsolute(root);
+        filePathUnresolved = path.posix.join(root, filePath);
+        assertPathIsFilesystemAbsolute(filePathUnresolved);
+    }
+    let filePathAbsolute;
+    try {
+        filePathAbsolute = require_.resolve(filePathUnresolved, { paths: [config.root] });
+    }
+    catch (err) {
+        console.error(err);
+        assert(false);
+    }
+    filePathAbsolute = toPosixPath(filePathAbsolute);
+    assertPathIsFilesystemAbsolute(filePathAbsolute);
+    return filePathAbsolute;
+}
+function getFilePathRelativeToUserRootDir(filePathAbsolute, userRootDir, alwaysRelative = false) {
+    assertPosixPath(filePathAbsolute);
+    assertPosixPath(userRootDir);
+    let filePathRelativeToUserRootDir = path.posix.relative(userRootDir, filePathAbsolute);
+    if (filePathAbsolute.startsWith(userRootDir)) {
+        assert(!filePathRelativeToUserRootDir.startsWith('.') && !filePathRelativeToUserRootDir.startsWith('/'), 
+        // Surprinsingly, this assertion seem to fail sometimes: https://github.com/vikejs/vike/issues/1139
+        { filePathRelativeToUserRootDir, filePathAbsolute, userRootDir });
+        filePathRelativeToUserRootDir = `/${filePathRelativeToUserRootDir}`;
+        return filePathRelativeToUserRootDir;
+    }
+    else {
+        if (alwaysRelative) {
+            return filePathRelativeToUserRootDir;
+        }
+        else {
+            return filePathAbsolute;
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+export declare function getGlobalObject<T extends Record<string, unknown> = never>(key: `${string}.ts`, defaultValue: T): T;
+declare global {
+    var __vike: undefined | Record<string, Record<string, unknown>>;
+}

package/dist/esm/utils/getGlobalObject.js

@@ -0,0 +1,7 @@
+export function getGlobalObject(
+// We use the filename as key; each `getGlobalObject()` call should live in a unique filename.
+key, defaultValue) {
+    const allGlobalObjects = (globalThis.__vike = globalThis.__vike || {});
+    const globalObject = (allGlobalObjects[key] = allGlobalObjects[key] || defaultValue);
+    return globalObject;
+}

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

@@ -0,0 +1,2 @@
+export { getMostSimilar };
+declare function getMostSimilar(word: string, words: string[]): null | string;

package/dist/esm/utils/getMostSimilar.js

@@ -0,0 +1,66 @@
+export { getMostSimilar };
+import { assert } from './assert.js';
+import { higherFirst } from './sorter.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+assertIsNotBrowser();
+function getMostSimilar(word, words) {
+    if (words.length === 0)
+        return null;
+    const exactMatch = words.find((w) => w === word);
+    if (exactMatch)
+        return exactMatch;
+    const lowerCaseMatch = words.find((w) => w.toLowerCase() === word.toLowerCase());
+    if (lowerCaseMatch)
+        return lowerCaseMatch;
+    const mostSimilar = words
+        .map((w) => ({
+        word: w,
+        similarity: getSimilarity(w, word)
+    }))
+        .sort(higherFirst(({ similarity }) => similarity))[0];
+    assert(mostSimilar);
+    if (mostSimilar.similarity >= 0.8) {
+        return mostSimilar.word;
+    }
+    else {
+        return null;
+    }
+}
+// https://stackoverflow.com/questions/10473745/compare-strings-javascript-return-of-likely/36566052#36566052
+function getSimilarity(s1, s2) {
+    var longer = s1;
+    var shorter = s2;
+    if (s1.length < s2.length) {
+        longer = s2;
+        shorter = s1;
+    }
+    var longerLength = longer.length;
+    if (longerLength == 0) {
+        return 1.0;
+    }
+    return (longerLength - editDistance(longer, shorter)) / longerLength;
+}
+function editDistance(s1, s2) {
+    s1 = s1.toLowerCase();
+    s2 = s2.toLowerCase();
+    var costs = new Array();
+    for (var i = 0; i <= s1.length; i++) {
+        var lastValue = i;
+        for (var j = 0; j <= s2.length; j++) {
+            if (i == 0)
+                costs[j] = j;
+            else {
+                if (j > 0) {
+                    var newValue = costs[j - 1];
+                    if (s1.charAt(i - 1) != s2.charAt(j - 1))
+                        newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
+                    costs[j - 1] = lastValue;
+                    lastValue = newValue;
+                }
+            }
+        }
+        if (i > 0)
+            costs[s2.length] = lastValue;
+    }
+    return costs[s2.length];
+}

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

@@ -0,0 +1,16 @@
+export { getOutDirs };
+export { getOutDirs_prerender };
+export { resolveOutDir };
+import type { UserConfig, ResolvedConfig } from 'vite';
+type OutDirs = {
+    /** Absolute path to `outDir` */
+    outDirRoot: string;
+    /** Absolute path to `${outDir}/client` */
+    outDirClient: string;
+    /** Absolute path to `${outDir}/server` */
+    outDirServer: string;
+};
+declare function getOutDirs(config: ResolvedConfig): OutDirs;
+declare function getOutDirs_prerender(config: ResolvedConfig): OutDirs;
+/** Appends `client/` or `server/` to `config.build.outDir` */
+declare function resolveOutDir(config: UserConfig): string;

package/dist/esm/utils/getOutDirs.js

@@ -0,0 +1,115 @@
+export { getOutDirs };
+export { getOutDirs_prerender };
+export { resolveOutDir };
+import { viteIsSSR } from './viteIsSSR.js';
+import { assert, assertUsage } from './assert.js';
+import { pathJoin } from './path-shim.js';
+import { assertPosixPath, toPosixPath } from './filesystemPathHandling.js';
+import pc from '@brillout/picocolors';
+function getOutDirs(config) {
+    const outDir = getOutDirFromResolvedConfig(config);
+    assertOutDirResolved(outDir, config);
+    assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
+    assert('/client'.length === '/server'.length);
+    const outDirRoot = outDir.slice(0, -1 * '/client'.length);
+    return getOutDirsAll(outDirRoot, config.root);
+}
+function getOutDirs_prerender(config) {
+    const outDirRoot = getOutDirFromResolvedConfig(config);
+    assert(isOutDirRoot(outDirRoot));
+    return getOutDirsAll(outDirRoot, config.root);
+}
+/** Appends `client/` or `server/` to `config.build.outDir` */
+function resolveOutDir(config) {
+    const outDir = getOutDirFromUserConfig(config) || 'dist';
+    // outDir may already be resolved when using Telefunc + vike (because both Telefunc and vike use this logic)
+    if (!isOutDirRoot(outDir)) {
+        assertOutDirResolved(outDir, config);
+        return outDir;
+    }
+    else {
+        const { outDirClient, outDirServer } = determineOutDirs(outDir);
+        if (viteIsSSR(config)) {
+            return outDirServer;
+        }
+        else {
+            return outDirClient;
+        }
+    }
+}
+function determineOutDirs(outDirRoot) {
+    assertPosixPath(outDirRoot);
+    assert(isOutDirRoot(outDirRoot));
+    const outDirClient = pathJoin(outDirRoot, 'client');
+    const outDirServer = pathJoin(outDirRoot, 'server');
+    assertIsNotOutDirRoot(outDirClient);
+    assertIsNotOutDirRoot(outDirServer);
+    return { outDirClient, outDirServer };
+}
+function getOutDirsAll(outDirRoot, root) {
+    if (!outDirIsAbsolutePath(outDirRoot)) {
+        assertPosixPath(outDirRoot);
+        assertPosixPath(root);
+        outDirRoot = pathJoin(root, outDirRoot);
+    }
+    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
+    outDirRoot = outDirRoot + '/';
+    outDirClient = outDirClient + '/';
+    outDirServer = outDirServer + '/';
+    assertNormalization(outDirRoot);
+    assertNormalization(outDirClient);
+    assertNormalization(outDirServer);
+    return { outDirRoot, outDirClient, outDirServer };
+}
+function assertNormalization(outDirAny) {
+    assertPosixPath(outDirAny);
+    assert(outDirIsAbsolutePath(outDirAny));
+    assert(outDirAny.endsWith('/'));
+    assert(!outDirAny.endsWith('//'));
+}
+function isOutDirRoot(outDirRot) {
+    const p = outDirRot.split('/').filter(Boolean);
+    const lastDir = p[p.length - 1];
+    return lastDir !== 'client' && lastDir !== 'server';
+}
+function assertIsNotOutDirRoot(outDir) {
+    assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
+}
+/** `outDir` ends with `/server` or `/client` */
+function assertOutDirResolved(outDir, config) {
+    assertPosixPath(outDir);
+    assertIsNotOutDirRoot(outDir);
+    assert('/client'.length === '/server'.length);
+    const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
+    const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
+    if (viteIsSSR(config)) {
+        assertUsage(outDir.endsWith('/server'), wrongUsage);
+    }
+    else {
+        assertUsage(outDir.endsWith('/client'), wrongUsage);
+    }
+}
+function getOutDirFromUserConfig(config) {
+    let outDir = config.build?.outDir;
+    if (outDir === undefined)
+        return undefined;
+    // I believe Vite normalizes config.build.outDir only if config is ResolvedConfig
+    outDir = toPosixPath(outDir);
+    return outDir;
+}
+function getOutDirFromResolvedConfig(config) {
+    let outDir = config.build.outDir;
+    // Vite seems to be buggy and doesn't always normalize config.build.outDir
+    outDir = toPosixPath(outDir);
+    return outDir;
+}
+function outDirIsAbsolutePath(outDir) {
+    // There doesn't seem to be a better alternative to determine whether `outDir` is an aboslute path
+    //  - Very unlikely that `outDir`'s first dir macthes the filesystem's first dir
+    //    - Although more likely to happen with Docker
+    return getFirstDir(outDir) === getFirstDir(process.cwd());
+}
+function getFirstDir(p) {
+    const firstDir = p.split(/\/|\\/).filter(Boolean)[0];
+    return firstDir;
+}

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

@@ -0,0 +1,2 @@
+export { getPropAccessNotation };
+declare function getPropAccessNotation(key: string): `.${string}` | `[${string}]`;

package/dist/esm/utils/getPropAccessNotation.js

@@ -0,0 +1,7 @@
+export { getPropAccessNotation };
+function getPropAccessNotation(key) {
+    return isKeyDotNotationCompatible(key) ? `.${key}` : `[${JSON.stringify(key)}]`;
+}
+function isKeyDotNotationCompatible(key) {
+    return /^[a-z0-9\$_]+$/i.test(key);
+}

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

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

package/dist/esm/utils/getRandomId.js

@@ -0,0 +1,12 @@
+export { getRandomId };
+import { assert } from './assert.js';
+// https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript
+function getRandomId(length) {
+    let randomId = '';
+    while (randomId.length < length) {
+        randomId += Math.random().toString(36).slice(2);
+    }
+    randomId = randomId.slice(0, length);
+    assert(/^[a-z0-9]+$/.test(randomId) && randomId.length === length);
+    return randomId;
+}

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

@@ -0,0 +1 @@
+export declare function getTerminalWidth(): number | undefined;

package/dist/esm/utils/getTerminWidth.js

@@ -0,0 +1,4 @@
+export function getTerminalWidth() {
+    // https://stackoverflow.com/questions/30335637/get-width-of-terminal-in-node-js/30335724#30335724
+    return ((typeof process !== 'undefined' && typeof process.stdout !== 'undefined' && process.stdout.columns) || undefined);
+}

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

@@ -0,0 +1 @@
+export declare function getValuePrintable(value: unknown): null | string;

package/dist/esm/utils/getValuePrintable.js

@@ -0,0 +1,7 @@
+export function getValuePrintable(value) {
+    if ([null, undefined].includes(value))
+        return String(value);
+    if (['undefined', 'boolean', 'number', 'string'].includes(typeof value))
+        return JSON.stringify(value);
+    return null;
+}

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

@@ -0,0 +1,14 @@
+export { hasProp };
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'boolean'): obj is ObjectType & Record<PropName, boolean>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'number'): obj is ObjectType & Record<PropName, number>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string'): obj is ObjectType & Record<PropName, string>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'object'): obj is ObjectType & Record<PropName, Record<string, unknown>>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'array'): obj is ObjectType & Record<PropName, unknown[]>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'string[]'): obj is ObjectType & Record<PropName, string[]>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'function'): obj is ObjectType & Record<PropName, (...args: any[]) => unknown>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'undefined'): obj is ObjectType & Record<PropName, undefined>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'null'): obj is ObjectType & Record<PropName, null>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'true'): obj is ObjectType & Record<PropName, true>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName, type: 'false'): obj is ObjectType & Record<PropName, false>;
+declare function hasProp<ObjectType, PropName extends PropertyKey, Enum>(obj: ObjectType, prop: PropName, type: Enum[]): obj is ObjectType & Record<PropName, Enum>;
+declare function hasProp<ObjectType, PropName extends PropertyKey>(obj: ObjectType, prop: PropName): obj is ObjectType & Record<PropName, unknown>;

package/dist/esm/utils/hasProp.js

@@ -0,0 +1,45 @@
+export { hasProp };
+// - https://2ality.com/2020/06/type-guards-assertion-functions-typescript.html
+// - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
+import { isCallable } from './isCallable.js';
+import { isObject } from './isObject.js';
+// prettier-ignore
+function hasProp(obj, prop, type = 'unknown') {
+    if (!isObject(obj))
+        return false;
+    if (!(prop in obj)) {
+        return type === 'undefined';
+    }
+    if (type === 'unknown') {
+        return true;
+    }
+    const propValue = obj[prop];
+    if (type === 'array') {
+        return Array.isArray(propValue);
+    }
+    if (type === 'object') {
+        return isObject(propValue);
+    }
+    if (type === 'string[]') {
+        return Array.isArray(propValue) && propValue.every(el => typeof el === 'string');
+    }
+    if (type === 'function') {
+        return isCallable(propValue);
+    }
+    if (Array.isArray(type)) {
+        return typeof propValue === 'string' && type.includes(propValue);
+    }
+    if (type === 'null') {
+        return propValue === null;
+    }
+    if (type === 'undefined') {
+        return propValue === undefined;
+    }
+    if (type === 'true') {
+        return propValue === true;
+    }
+    if (type === 'false') {
+        return propValue === false;
+    }
+    return typeof propValue === type;
+}

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

@@ -0,0 +1 @@
+export declare function hasPropertyGetter(obj: Object, prop: string): boolean;

package/dist/esm/utils/hasPropertyGetter.js

@@ -0,0 +1,4 @@
+export function hasPropertyGetter(obj, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    return !!descriptor && !('value' in descriptor) && !!descriptor.get;
+}

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

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

package/dist/esm/utils/humanizeTime.js

@@ -0,0 +1,22 @@
+export { humanizeTime };
+function humanizeTime(milliseconds) {
+    const seconds = milliseconds / 1000;
+    if (seconds < 120) {
+        const n = round(seconds);
+        return `${n} second${plural(n)}`;
+    }
+    {
+        const minutes = seconds / 60;
+        const n = round(minutes);
+        return `${n} minute${plural(n)}`;
+    }
+}
+function round(n) {
+    let rounded = n.toFixed(1);
+    if (rounded.endsWith('.0'))
+        rounded = rounded.slice(0, -2);
+    return rounded;
+}
+function plural(n) {
+    return n === '1' ? '' : 's';
+}

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

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

package/dist/esm/utils/isBrowser.js

@@ -0,0 +1,5 @@
+export function isBrowser() {
+    // Using `typeof window !== 'undefined'` alone is not enough because some users use https://www.npmjs.com/package/ssr-window
+    return typeof window !== 'undefined' && typeof window.scrollY === 'number';
+    // Alternatively, test whether environment is a *real* browser: https://github.com/brillout/picocolors/blob/d59a33a0fd52a8a33e4158884069192a89ce0113/picocolors.js#L87-L89
+}

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

@@ -0,0 +1 @@
+export declare function isCallable<T extends (...args: any[]) => any>(thing: T | unknown): thing is T;

package/dist/esm/utils/isCallable.js

@@ -0,0 +1,3 @@
+export function isCallable(thing) {
+    return thing instanceof Function || typeof thing === 'function';
+}

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

@@ -0,0 +1,7 @@
+export { isDev1 };
+export { isDev1_onConfigureServer };
+export { isDev2 };
+declare function isDev1(): boolean;
+declare function isDev1_onConfigureServer(): void | undefined;
+import type { ResolvedConfig } from 'vite';
+declare function isDev2(config: ResolvedConfig): boolean;

package/dist/esm/utils/isDev.js

@@ -0,0 +1,29 @@
+export { isDev1 };
+export { isDev1_onConfigureServer };
+export { isDev2 };
+// There isn't any reliable way to test whether Vite is ran as dev/build/preview/optimizeDep
+//  - Failed attempt to make a PR: https://github.com/brillout/vite/tree/fix/config-operation
+// ********
+// Method 1 - most reliable
+// ********
+import { assert } from './assert.js';
+import { getGlobalObject } from './getGlobalObject.js';
+const globalObject = getGlobalObject('utils/isDev.ts', { isDev: false, isDev_wasCalled: false });
+function isDev1() {
+    globalObject.isDev_wasCalled = true;
+    return globalObject.isDev;
+}
+function isDev1_onConfigureServer() {
+    // configureServer() is called more than once when user presses Vite's dev server reload hotkey <r>
+    if (globalObject.isDev)
+        return;
+    assert(!globalObject.isDev_wasCalled);
+    globalObject.isDev = true;
+}
+function isDev2(config) {
+    const isDev = config.command === 'serve' &&
+        // Mode is 'development' by default: https://github.com/vitejs/vite/blob/bf9c49f521b7a6730231c35754d5e1f9c3a6a16e/packages/vite/src/node/config.ts#L383
+        // Note that user can override this: https://github.com/vitejs/vite/blob/bf9c49f521b7a6730231c35754d5e1f9c3a6a16e/packages/vite/src/node/cli.ts#L126
+        config.mode === 'development';
+    return isDev;
+}

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

@@ -0,0 +1,2 @@
+export { isEquivalentError };
+declare function isEquivalentError(err1: unknown, err2: unknown): boolean;

package/dist/esm/utils/isEquivalentError.js

@@ -0,0 +1,15 @@
+import { isObject } from './isObject.js';
+import { deepEqual } from './deepEqual.js';
+export { isEquivalentError };
+function isEquivalentError(err1, err2) {
+    return (isObject(err1) &&
+        isObject(err2) &&
+        err1.constructor === err2.constructor &&
+        deepEqual({ ...err1, stack: null }, { ...err2, stack: null }) &&
+        // 'message' and 'stack' are usually non-emurable
+        err2.message === err2.message
+    /* Doesn't work because: the stack trace isn't exactly the same between the original page rendering and the fallback error page rendering
+    err2.stack === err2.stack
+    */
+    );
+}

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

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

package/dist/esm/utils/isHtml.js

@@ -0,0 +1,7 @@
+// Unit tests at ./isHtml.spec.ts
+export { isHtml };
+function isHtml(str) {
+    // Copied and adapted from https://stackoverflow.com/questions/15458876/check-if-a-string-is-html-or-not/51325984#51325984
+    const re = /(<\/[^<]+>)|(<[^<]+\/>)/;
+    return re.test(str);
+}

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

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