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

package/dist/cjs/utils/getValuePrintable.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValuePrintable = void 0;
+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;
+}
+exports.getValuePrintable = getValuePrintable;

package/dist/cjs/utils/hasProp.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasProp = void 0;
+// - https://2ality.com/2020/06/type-guards-assertion-functions-typescript.html
+// - https://www.typescriptlang.org/play?#code/GYVwdgxgLglg9mABDAzgFQJ4AcCmdgAUAbgIYA2IOAXIiWBgDSJTbWIDkARnHGTnewCUNUhRzIUibr35gA3AFgAUKEiwEEzLnzFylGnUbNWNdmBABbTjgBOQkXvGpE5q7cUrw0eElRa8hKL6tPRMLLimKFA2MGAA5vaIQU6SUTHxHqreGn6sOskGocYRHOAA1mBwAO5gickSiOWVNZle6r7oeYGOhUbhbGmxcYgAvKVgFdW1wlI8fHSIAN7KiMiExeIjW+OTNeyIgksrq4g2OFAgNkjRlMcAvsdnF1cb+EmOo9v9Hg9KyhAIKK0GhNKajRAAFgATMplCQUChbFACLltIQSEwzJZrHZBIJ-oCZAA6MhwOIEEj4v6eNQ+WgIpEEAFgAAmMHaIImzTAM3hiJsUEkzLZ7SOShOa0QTIQIp8hyelzAx1WUAAFjZqi4cFVEABRGwamwEdgAQQZArpADESDAyEJlHcgA
+const isCallable_js_1 = require("./isCallable.js");
+const isObject_js_1 = require("./isObject.js");
+// prettier-ignore
+function hasProp(obj, prop, type = 'unknown') {
+    if (!(0, isObject_js_1.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 (0, isObject_js_1.isObject)(propValue);
+    }
+    if (type === 'string[]') {
+        return Array.isArray(propValue) && propValue.every(el => typeof el === 'string');
+    }
+    if (type === 'function') {
+        return (0, isCallable_js_1.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;
+}
+exports.hasProp = hasProp;

package/dist/cjs/utils/hasPropertyGetter.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPropertyGetter = void 0;
+function hasPropertyGetter(obj, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    return !!descriptor && !('value' in descriptor) && !!descriptor.get;
+}
+exports.hasPropertyGetter = hasPropertyGetter;

package/dist/cjs/utils/humanizeTime.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanizeTime = void 0;
+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)}`;
+    }
+}
+exports.humanizeTime = humanizeTime;
+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/cjs/utils/isBrowser.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = void 0;
+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
+}
+exports.isBrowser = isBrowser;

package/dist/cjs/utils/isCallable.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCallable = void 0;
+function isCallable(thing) {
+    return thing instanceof Function || typeof thing === 'function';
+}
+exports.isCallable = isCallable;

package/dist/cjs/utils/isDev.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDev2 = exports.isDev1_onConfigureServer = exports.isDev1 = void 0;
+// 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
+// ********
+const assert_js_1 = require("./assert.js");
+const getGlobalObject_js_1 = require("./getGlobalObject.js");
+const globalObject = (0, getGlobalObject_js_1.getGlobalObject)('utils/isDev.ts', { isDev: false, isDev_wasCalled: false });
+function isDev1() {
+    globalObject.isDev_wasCalled = true;
+    return globalObject.isDev;
+}
+exports.isDev1 = isDev1;
+function isDev1_onConfigureServer() {
+    // configureServer() is called more than once when user presses Vite's dev server reload hotkey <r>
+    if (globalObject.isDev)
+        return;
+    (0, assert_js_1.assert)(!globalObject.isDev_wasCalled);
+    globalObject.isDev = true;
+}
+exports.isDev1_onConfigureServer = isDev1_onConfigureServer;
+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;
+}
+exports.isDev2 = isDev2;

package/dist/cjs/utils/isEquivalentError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEquivalentError = void 0;
+const isObject_js_1 = require("./isObject.js");
+const deepEqual_js_1 = require("./deepEqual.js");
+function isEquivalentError(err1, err2) {
+    return ((0, isObject_js_1.isObject)(err1) &&
+        (0, isObject_js_1.isObject)(err2) &&
+        err1.constructor === err2.constructor &&
+        (0, deepEqual_js_1.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
+    */
+    );
+}
+exports.isEquivalentError = isEquivalentError;

package/dist/cjs/utils/isHtml.js

@@ -0,0 +1,10 @@
+"use strict";
+// Unit tests at ./isHtml.spec.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHtml = void 0;
+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);
+}
+exports.isHtml = isHtml;

package/dist/cjs/utils/isNodeJS.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNodeJS = void 0;
+function isNodeJS() {
+    if (typeof process === 'undefined')
+        return false;
+    if (!process.cwd)
+        return false;
+    // https://stackoverflow.com/questions/4224606/how-to-check-whether-a-script-is-running-under-node-js/35813135#35813135
+    if (!process.versions || typeof process.versions.node === 'undefined')
+        return false;
+    // https://stackoverflow.com/questions/4224606/how-to-check-whether-a-script-is-running-under-node-js/35813135#comment92529277_35813135
+    if (!process.release || process.release.name !== 'node')
+        return false;
+    return true;
+}
+exports.isNodeJS = isNodeJS;

package/dist/cjs/utils/isNotNullish.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotNullish = void 0;
+const isNotNullish = (p) => p !== null && p !== undefined;
+exports.isNotNullish = isNotNullish;

package/dist/cjs/utils/isNpmPackage.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDistinguishable = exports.parse = exports.isValidPathAlias = exports.getNpmPackageImportPath = exports.getNpmPackageName = exports.isNpmPackageName = exports.isNpmPackageImport = void 0;
+const assert_js_1 = require("./assert.js");
+const assertIsNotBrowser_js_1 = require("./assertIsNotBrowser.js");
+(0, assertIsNotBrowser_js_1.assertIsNotBrowser)();
+function isNpmPackageImport(str) {
+    const res = parse(str);
+    return res !== null;
+}
+exports.isNpmPackageImport = isNpmPackageImport;
+function isNpmPackageName(str) {
+    const res = parse(str);
+    return res !== null && res.importPath === null;
+}
+exports.isNpmPackageName = isNpmPackageName;
+function getNpmPackageName(str) {
+    const res = parse(str);
+    if (!res)
+        return null;
+    return res.pkgName;
+}
+exports.getNpmPackageName = getNpmPackageName;
+function getNpmPackageImportPath(str) {
+    const res = parse(str);
+    if (!res)
+        return null;
+    return res.importPath;
+}
+exports.getNpmPackageImportPath = getNpmPackageImportPath;
+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];
+    (0, assert_js_1.assert)(firstLetter);
+    if (firstLetter === '@' || /[0-9a-z]/.test(firstLetter.toLowerCase()))
+        return false;
+    return true;
+}
+exports.isValidPathAlias = isValidPathAlias;
+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('-'));
+}
+exports.isDistinguishable = isDistinguishable;
+// 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
+    };
+}
+exports.parse = parse;
+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/cjs/utils/isObject.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = void 0;
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+exports.isObject = isObject;

package/dist/cjs/utils/isObjectWithKeys.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectWithKeys = void 0;
+const isPlainObject_js_1 = require("./isPlainObject.js");
+function isObjectWithKeys(obj, keys) {
+    if (!(0, isPlainObject_js_1.isPlainObject)(obj)) {
+        return false;
+    }
+    for (const key of Object.keys(obj)) {
+        if (!keys.includes(key)) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.isObjectWithKeys = isObjectWithKeys;

package/dist/cjs/utils/isPlainObject.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = void 0;
+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');
+}
+exports.isPlainObject = isPlainObject;

package/dist/cjs/utils/isPromise.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPromise = void 0;
+const isCallable_js_1 = require("./isCallable.js");
+function isPromise(val) {
+    return typeof val === 'object' && val !== null && 'then' in val && (0, isCallable_js_1.isCallable)(val.then);
+}
+exports.isPromise = isPromise;

package/dist/cjs/utils/isReact.js

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

package/dist/cjs/utils/isScriptFile.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptFileExtensionList = exports.scriptFileExtensions = exports.isTemplateFile = exports.isScriptFile = void 0;
+const assert_js_1 = require("./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];
+exports.scriptFileExtensionList = scriptFileExtensionList;
+const scriptFileExtensions = '(' + scriptFileExtensionList.join('|') + ')';
+exports.scriptFileExtensions = scriptFileExtensions;
+function isScriptFile(filePath) {
+    const yes = scriptFileExtensionList.some((ext) => filePath.endsWith('.' + ext));
+    (0, assert_js_1.assert)(!isJavaScriptFile(filePath) || yes);
+    return yes;
+}
+exports.isScriptFile = isScriptFile;
+function isJavaScriptFile(filePath) {
+    return /\.(c|m)?(j|t)sx?$/.test(filePath);
+}
+function isTemplateFile(filePath) {
+    return extTemplates.some((ext) => filePath.endsWith('.' + ext));
+}
+exports.isTemplateFile = isTemplateFile;

package/dist/cjs/utils/isStemPackageName.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStemPackageName = void 0;
+function isStemPackageName(npmPackageName) {
+    if (npmPackageName.startsWith('stem-')) {
+        return true;
+    }
+    const [orgName, pkgName] = npmPackageName.split('/');
+    if (orgName.startsWith('@') && pkgName?.startsWith('stem-')) {
+        return true;
+    }
+    return false;
+}
+exports.isStemPackageName = isStemPackageName;

package/dist/cjs/utils/isStringRecord.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStringRecord = void 0;
+function isStringRecord(thing) {
+    return typeof thing === 'object' && thing !== null && Object.values(thing).every((val) => typeof val === 'string');
+}
+exports.isStringRecord = isStringRecord;

package/dist/cjs/utils/isVitest.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVitest = void 0;
+function isVitest() {
+    return typeof process !== 'undefined' && typeof process.env !== 'undefined' && 'VITEST' in process.env;
+}
+exports.isVitest = isVitest;

package/dist/cjs/utils/joinEnglish.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinEnglish = void 0;
+const assert_js_1 = require("./assert.js");
+// https://stackoverflow.com/questions/53879088/join-an-array-by-commas-and-and/53879103#53879103
+function joinEnglish(arr, conjunction) {
+    (0, assert_js_1.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;
+}
+exports.joinEnglish = joinEnglish;

package/dist/cjs/utils/mergeCumulativeValues.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeCumulativeValues = void 0;
+const assert_js_1 = require("./assert.js");
+function mergeCumulativeValues(values) {
+    if (values.length === 0)
+        return null;
+    if (values.every((v) => v instanceof Set)) {
+        return new Set(values
+            .map((v) => {
+            (0, assert_js_1.assert)(v instanceof Set);
+            return [...v];
+        })
+            .flat());
+    }
+    if (values.every((v) => Array.isArray(v))) {
+        return values.flat();
+    }
+    return null;
+}
+exports.mergeCumulativeValues = mergeCumulativeValues;

package/dist/cjs/utils/nodeEnv.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setNodeEnvToProduction = exports.getNodeEnv = void 0;
+function getNodeEnv() {
+    if (typeof process === 'undefined')
+        return null;
+    return process.env.NODE_ENV;
+}
+exports.getNodeEnv = getNodeEnv;
+function setNodeEnvToProduction() {
+    // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
+    const proc = process;
+    const { env } = proc;
+    env.NODE_ENV = 'production';
+}
+exports.setNodeEnvToProduction = setNodeEnvToProduction;

package/dist/cjs/utils/objectAssign.js

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

package/dist/cjs/utils/objectEntries.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectEntries = void 0;
+// Same as `Object.entries()` but with type inference
+function objectEntries(obj) {
+    return Object.entries(obj);
+}
+exports.objectEntries = objectEntries;

package/dist/cjs/utils/objectKeys.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectKeys = void 0;
+/** Same as Object.keys() but with type inference */
+function objectKeys(obj) {
+    return Object.keys(obj);
+}
+exports.objectKeys = objectKeys;
+// https://stackoverflow.com/questions/52856496/typescript-object-keys-return-string
+// https://github.com/sindresorhus/ts-extras/blob/main/source/object-keys.ts