initial commit

node_modules/unenv/runtime/node/util/_legacyTypes.cjs

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isUndefined = exports.isSymbol = exports.isString = exports.isRegExp = exports.isPrimitive = exports.isObject = exports.isNumber = exports.isNullOrUndefined = exports.isNull = exports.isFunction = exports.isError = exports.isDeepStrictEqual = exports.isDate = exports.isBuffer = exports.isBoolean = exports.isArray = void 0;
+
+const isRegExp = val => val instanceof RegExp;
+
+exports.isRegExp = isRegExp;
+
+const isDate = val => val instanceof Date;
+
+exports.isDate = isDate;
+
+const isArray = val => Array.isArray(val);
+
+exports.isArray = isArray;
+
+const isBoolean = val => typeof val === "boolean";
+
+exports.isBoolean = isBoolean;
+
+const isNull = val => val === null;
+
+exports.isNull = isNull;
+
+const isNullOrUndefined = val => val === null || val === void 0;
+
+exports.isNullOrUndefined = isNullOrUndefined;
+
+const isNumber = val => typeof val === "number";
+
+exports.isNumber = isNumber;
+
+const isString = val => typeof val === "string";
+
+exports.isString = isString;
+
+const isSymbol = val => typeof val === "symbol";
+
+exports.isSymbol = isSymbol;
+
+const isUndefined = val => typeof val === "undefined";
+
+exports.isUndefined = isUndefined;
+
+const isFunction = val => typeof val === "function";
+
+exports.isFunction = isFunction;
+
+const isBuffer = val => {
+  return val && typeof val === "object" && typeof val.copy === "function" && typeof val.fill === "function" && typeof val.readUInt8 === "function";
+};
+
+exports.isBuffer = isBuffer;
+
+const isDeepStrictEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+
+exports.isDeepStrictEqual = isDeepStrictEqual;
+
+const isObject = val => val !== null && typeof val === "object" && Object.getPrototypeOf(val).isPrototypeOf(Object);
+
+exports.isObject = isObject;
+
+const isError = val => val instanceof Error;
+
+exports.isError = isError;
+
+const isPrimitive = val => {
+  if (typeof val === "object") {
+    return val === null;
+  }
+
+  return typeof val !== "function";
+};
+
+exports.isPrimitive = isPrimitive;

node_modules/unenv/runtime/node/util/_legacyTypes.d.ts

@@ -0,0 +1,17 @@
+import type util from "node:util";
+export declare const isRegExp: typeof util.isRegExp;
+export declare const isDate: typeof util.isDate;
+export declare const isArray: typeof util.isArray;
+export declare const isBoolean: typeof util.isBoolean;
+export declare const isNull: typeof util.isNull;
+export declare const isNullOrUndefined: typeof util.isNullOrUndefined;
+export declare const isNumber: typeof util.isNumber;
+export declare const isString: typeof util.isString;
+export declare const isSymbol: typeof util.isSymbol;
+export declare const isUndefined: typeof util.isUndefined;
+export declare const isFunction: typeof util.isFunction;
+export declare const isBuffer: typeof util.isBuffer;
+export declare const isDeepStrictEqual: typeof util.isDeepStrictEqual;
+export declare const isObject: typeof util.isObject;
+export declare const isError: typeof util.isError;
+export declare const isPrimitive: typeof util.isPrimitive;

node_modules/unenv/runtime/node/util/_legacyTypes.mjs

@@ -0,0 +1,23 @@
+export const isRegExp = (val) => val instanceof RegExp;
+export const isDate = (val) => val instanceof Date;
+export const isArray = (val) => Array.isArray(val);
+export const isBoolean = (val) => typeof val === "boolean";
+export const isNull = (val) => val === null;
+export const isNullOrUndefined = (val) => val === null || val === void 0;
+export const isNumber = (val) => typeof val === "number";
+export const isString = (val) => typeof val === "string";
+export const isSymbol = (val) => typeof val === "symbol";
+export const isUndefined = (val) => typeof val === "undefined";
+export const isFunction = (val) => typeof val === "function";
+export const isBuffer = (val) => {
+  return val && typeof val === "object" && typeof val.copy === "function" && typeof val.fill === "function" && typeof val.readUInt8 === "function";
+};
+export const isDeepStrictEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export const isObject = (val) => val !== null && typeof val === "object" && Object.getPrototypeOf(val).isPrototypeOf(Object);
+export const isError = (val) => val instanceof Error;
+export const isPrimitive = (val) => {
+  if (typeof val === "object") {
+    return val === null;
+  }
+  return typeof val !== "function";
+};

node_modules/unenv/runtime/node/util/_log.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.log = exports.inspect = exports.formatWithOptions = exports.format = exports.debuglog = exports.debug = void 0;
+
+const log = (...args) => {
+  console.log(...args);
+};
+
+exports.log = log;
+
+const debuglog = (section, _cb) => {
+  const fn = (msg, ...params) => {
+    if (fn.enabled) {
+      console.debug(`[${section}] ${msg}`, ...params);
+    }
+  };
+
+  fn.enabled = true;
+  return fn;
+};
+
+exports.debuglog = debuglog;
+const debug = debuglog;
+exports.debug = debug;
+
+const inspect = object => JSON.stringify(object, null, 2);
+
+exports.inspect = inspect;
+
+const format = (...args) => _format(...args);
+
+exports.format = format;
+
+const formatWithOptions = (_options, ...args) => _format(...args);
+
+exports.formatWithOptions = formatWithOptions;
+
+function _format(fmt, ...args) {
+  const re = /(%?)(%([djos]))/g;
+
+  if (args.length > 0) {
+    fmt = fmt.replace(re, (match, escaped, ptn, flag) => {
+      let arg = args.shift();
+
+      switch (flag) {
+        case "o":
+          if (Array.isArray(arg)) {
+            arg = JSON.stringify(arg);
+            break;
+          }
+
+          break;
+
+        case "s":
+          arg = "" + arg;
+          break;
+
+        case "d":
+          arg = Number(arg);
+          break;
+
+        case "j":
+          arg = JSON.stringify(arg);
+          break;
+      }
+
+      if (!escaped) {
+        return arg;
+      }
+
+      args.unshift(arg);
+      return match;
+    });
+  }
+
+  if (args.length > 0) {
+    fmt += " " + args.join(" ");
+  }
+
+  fmt = fmt.replace(/%{2}/g, "%");
+  return "" + fmt;
+}

node_modules/unenv/runtime/node/util/_log.d.ts

@@ -0,0 +1,7 @@
+import type util from "node:util";
+export declare const log: (...args: any[]) => void;
+export declare const debuglog: typeof util.debuglog;
+export declare const debug: typeof util.debug;
+export declare const inspect: typeof util.inspect;
+export declare const format: typeof util.format;
+export declare const formatWithOptions: typeof util.formatWithOptions;

node_modules/unenv/runtime/node/util/_log.mjs

@@ -0,0 +1,51 @@
+export const log = (...args) => {
+  console.log(...args);
+};
+export const debuglog = (section, _cb) => {
+  const fn = (msg, ...params) => {
+    if (fn.enabled) {
+      console.debug(`[${section}] ${msg}`, ...params);
+    }
+  };
+  fn.enabled = true;
+  return fn;
+};
+export const debug = debuglog;
+export const inspect = (object) => JSON.stringify(object, null, 2);
+export const format = (...args) => _format(...args);
+export const formatWithOptions = (_options, ...args) => _format(...args);
+function _format(fmt, ...args) {
+  const re = /(%?)(%([djos]))/g;
+  if (args.length > 0) {
+    fmt = fmt.replace(re, (match, escaped, ptn, flag) => {
+      let arg = args.shift();
+      switch (flag) {
+        case "o":
+          if (Array.isArray(arg)) {
+            arg = JSON.stringify(arg);
+            break;
+          }
+          break;
+        case "s":
+          arg = "" + arg;
+          break;
+        case "d":
+          arg = Number(arg);
+          break;
+        case "j":
+          arg = JSON.stringify(arg);
+          break;
+      }
+      if (!escaped) {
+        return arg;
+      }
+      args.unshift(arg);
+      return match;
+    });
+  }
+  if (args.length > 0) {
+    fmt += " " + args.join(" ");
+  }
+  fmt = fmt.replace(/%{2}/g, "%");
+  return "" + fmt;
+}

node_modules/unenv/runtime/node/util/_promisify.cjs

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.promisify = void 0;
+const customSymbol = Symbol("customPromisify");
+
+function _promisify(fn) {
+  if (fn[customSymbol]) {
+    return fn[customSymbol];
+  }
+
+  return function (...args) {
+    return new Promise((resolve, reject) => {
+      try {
+        fn.call(this, ...args, (err, val) => {
+          if (err) {
+            return reject(err);
+          }
+
+          resolve(val);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+
+_promisify.custom = customSymbol;
+const promisify = _promisify;
+exports.promisify = promisify;

node_modules/unenv/runtime/node/util/_promisify.d.ts

@@ -0,0 +1,2 @@
+import type util from "node:util";
+export declare const promisify: typeof util.promisify;

node_modules/unenv/runtime/node/util/_promisify.mjs

@@ -0,0 +1,22 @@
+const customSymbol = Symbol("customPromisify");
+function _promisify(fn) {
+  if (fn[customSymbol]) {
+    return fn[customSymbol];
+  }
+  return function(...args) {
+    return new Promise((resolve, reject) => {
+      try {
+        fn.call(this, ...args, (err, val) => {
+          if (err) {
+            return reject(err);
+          }
+          resolve(val);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}
+_promisify.custom = customSymbol;
+export const promisify = _promisify;

node_modules/unenv/runtime/node/util/index.cjs

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  TextDecoder: true,
+  TextEncoder: true,
+  deprecate: true,
+  _errnoException: true,
+  _exceptionWithHostPort: true,
+  _extend: true,
+  callbackify: true,
+  getSystemErrorMap: true,
+  getSystemErrorName: true,
+  toUSVString: true,
+  stripVTControlCharacters: true,
+  inherits: true,
+  promisify: true
+};
+exports.getSystemErrorName = exports.getSystemErrorMap = exports.deprecate = exports.default = exports.callbackify = exports._extend = exports._exceptionWithHostPort = exports._errnoException = exports.TextEncoder = exports.TextDecoder = void 0;
+Object.defineProperty(exports, "inherits", {
+  enumerable: true,
+  get: function () {
+    return _inherits.default;
+  }
+});
+Object.defineProperty(exports, "promisify", {
+  enumerable: true,
+  get: function () {
+    return _promisify.promisify;
+  }
+});
+exports.toUSVString = exports.stripVTControlCharacters = void 0;
+
+var _utils = require("../../_internal/utils.cjs");
+
+var _inherits = _interopRequireDefault(require("../../npm/inherits.cjs"));
+
+var legacyTypes = _interopRequireWildcard(require("./_legacyTypes.cjs"));
+
+Object.keys(legacyTypes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === legacyTypes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return legacyTypes[key];
+    }
+  });
+});
+
+var logUtils = _interopRequireWildcard(require("./_log.cjs"));
+
+Object.keys(logUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === logUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return logUtils[key];
+    }
+  });
+});
+
+var _types = _interopRequireDefault(require("./types/index.cjs"));
+
+var _promisify = require("./_promisify.cjs");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const TextDecoder = globalThis.TextDecoder;
+exports.TextDecoder = TextDecoder;
+const TextEncoder = globalThis.TextEncoder;
+exports.TextEncoder = TextEncoder;
+
+const deprecate = fn => fn;
+
+exports.deprecate = deprecate;
+
+const _errnoException = (0, _utils.notImplemented)("util._errnoException");
+
+exports._errnoException = _errnoException;
+
+const _exceptionWithHostPort = (0, _utils.notImplemented)("util._exceptionWithHostPort");
+
+exports._exceptionWithHostPort = _exceptionWithHostPort;
+
+const _extend = (0, _utils.notImplemented)("util._extend");
+
+exports._extend = _extend;
+const callbackify = (0, _utils.notImplemented)("util.callbackify");
+exports.callbackify = callbackify;
+const getSystemErrorMap = (0, _utils.notImplemented)("util.getSystemErrorMap");
+exports.getSystemErrorMap = getSystemErrorMap;
+const getSystemErrorName = (0, _utils.notImplemented)("util.getSystemErrorName");
+exports.getSystemErrorName = getSystemErrorName;
+const toUSVString = (0, _utils.notImplemented)("util.toUSVString");
+exports.toUSVString = toUSVString;
+const stripVTControlCharacters = (0, _utils.notImplemented)("util.stripVTControlCharacters");
+exports.stripVTControlCharacters = stripVTControlCharacters;
+var _default = {
+  _errnoException,
+  _exceptionWithHostPort,
+  _extend,
+  callbackify,
+  deprecate,
+  getSystemErrorMap,
+  getSystemErrorName,
+  inherits: _inherits.default,
+  promisify: _promisify.promisify,
+  stripVTControlCharacters,
+  toUSVString,
+  TextDecoder,
+  TextEncoder,
+  types: _types.default,
+  ...logUtils,
+  ...legacyTypes
+};
+module.exports = _default;

node_modules/unenv/runtime/node/util/index.d.ts

@@ -0,0 +1,18 @@
+import type util from "node:util";
+export * from "./_legacyTypes";
+export * from "./_log";
+export { default as inherits } from "../../npm/inherits";
+export { promisify } from "./_promisify";
+export declare const TextDecoder: typeof util.TextDecoder;
+export declare const TextEncoder: typeof util.TextEncoder;
+export declare const deprecate: typeof util.deprecate;
+export declare const _errnoException: () => any;
+export declare const _exceptionWithHostPort: () => any;
+export declare const _extend: () => any;
+export declare const callbackify: typeof util.callbackify;
+export declare const getSystemErrorMap: typeof util.getSystemErrorMap;
+export declare const getSystemErrorName: typeof util.getSystemErrorName;
+export declare const toUSVString: typeof util.toUSVString;
+export declare const stripVTControlCharacters: typeof util.stripVTControlCharacters;
+declare const _default: any;
+export default _default;

node_modules/unenv/runtime/node/util/index.mjs

@@ -0,0 +1,39 @@
+import { notImplemented } from "../../_internal/utils.mjs";
+import inherits from "../../npm/inherits.mjs";
+import * as legacyTypes from "./_legacyTypes.mjs";
+import * as logUtils from "./_log.mjs";
+import types from "./types/index.mjs";
+import { promisify } from "./_promisify.mjs";
+export * from "./_legacyTypes.mjs";
+export * from "./_log.mjs";
+export { default as inherits } from "../../npm/inherits.mjs";
+export { promisify } from "./_promisify.mjs";
+export const TextDecoder = globalThis.TextDecoder;
+export const TextEncoder = globalThis.TextEncoder;
+export const deprecate = (fn) => fn;
+export const _errnoException = notImplemented("util._errnoException");
+export const _exceptionWithHostPort = notImplemented("util._exceptionWithHostPort");
+export const _extend = notImplemented("util._extend");
+export const callbackify = notImplemented("util.callbackify");
+export const getSystemErrorMap = notImplemented("util.getSystemErrorMap");
+export const getSystemErrorName = notImplemented("util.getSystemErrorName");
+export const toUSVString = notImplemented("util.toUSVString");
+export const stripVTControlCharacters = notImplemented("util.stripVTControlCharacters");
+export default {
+  _errnoException,
+  _exceptionWithHostPort,
+  _extend,
+  callbackify,
+  deprecate,
+  getSystemErrorMap,
+  getSystemErrorName,
+  inherits,
+  promisify,
+  stripVTControlCharacters,
+  toUSVString,
+  TextDecoder,
+  TextEncoder,
+  types,
+  ...logUtils,
+  ...legacyTypes
+};

node_modules/unenv/runtime/node/util/types/_types.cjs

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWeakSet = exports.isWeakMap = exports.isUint8ClampedArray = exports.isUint8Array = exports.isUint32Array = exports.isUint16Array = exports.isTypedArray = exports.isSymbolObject = exports.isStringObject = exports.isSharedArrayBuffer = exports.isSetIterator = exports.isSet = exports.isRegExp = exports.isProxy = exports.isPromise = exports.isNumberObject = exports.isNativeError = exports.isModuleNamespaceObject = exports.isMapIterator = exports.isMap = exports.isKeyObject = exports.isInt8Array = exports.isInt32Array = exports.isInt16Array = exports.isGeneratorObject = exports.isGeneratorFunction = exports.isFloat64Array = exports.isFloat32Array = exports.isExternal = exports.isDate = exports.isDataView = exports.isCryptoKey = exports.isBoxedPrimitive = exports.isBooleanObject = exports.isBigUint64Array = exports.isBigIntObject = exports.isBigInt64Array = exports.isAsyncFunction = exports.isArrayBufferView = exports.isArrayBuffer = exports.isArgumentsObject = exports.isAnyArrayBuffer = void 0;
+
+var _utils = require("../../../_internal/utils.cjs");
+
+const isExternal = (0, _utils.notImplemented)("util.types.isExternal");
+exports.isExternal = isExternal;
+
+const isDate = val => val instanceof Date;
+
+exports.isDate = isDate;
+const isArgumentsObject = (0, _utils.notImplemented)("util.types.isArgumentsObject");
+exports.isArgumentsObject = isArgumentsObject;
+
+const isBigIntObject = val => val instanceof BigInt;
+
+exports.isBigIntObject = isBigIntObject;
+
+const isBooleanObject = val => val instanceof Boolean;
+
+exports.isBooleanObject = isBooleanObject;
+
+const isNumberObject = val => val instanceof Number;
+
+exports.isNumberObject = isNumberObject;
+
+const isStringObject = val => val instanceof String;
+
+exports.isStringObject = isStringObject;
+
+const isSymbolObject = val => val instanceof Symbol;
+
+exports.isSymbolObject = isSymbolObject;
+const isNativeError = (0, _utils.notImplemented)("util.types.isNativeError");
+exports.isNativeError = isNativeError;
+
+const isRegExp = val => val instanceof RegExp;
+
+exports.isRegExp = isRegExp;
+const isAsyncFunction = (0, _utils.notImplemented)("util.types.isAsyncFunction");
+exports.isAsyncFunction = isAsyncFunction;
+const isGeneratorFunction = (0, _utils.notImplemented)("util.types.isGeneratorFunction");
+exports.isGeneratorFunction = isGeneratorFunction;
+const isGeneratorObject = (0, _utils.notImplemented)("util.types.isGeneratorObject");
+exports.isGeneratorObject = isGeneratorObject;
+
+const isPromise = val => val instanceof Promise;
+
+exports.isPromise = isPromise;
+
+const isMap = val => val instanceof Map;
+
+exports.isMap = isMap;
+
+const isSet = val => val instanceof Set;
+
+exports.isSet = isSet;
+const isMapIterator = (0, _utils.notImplemented)("util.types.isMapIterator");
+exports.isMapIterator = isMapIterator;
+const isSetIterator = (0, _utils.notImplemented)("util.types.isSetIterator");
+exports.isSetIterator = isSetIterator;
+
+const isWeakMap = val => val instanceof WeakMap;
+
+exports.isWeakMap = isWeakMap;
+
+const isWeakSet = val => val instanceof WeakSet;
+
+exports.isWeakSet = isWeakSet;
+
+const isArrayBuffer = val => val instanceof ArrayBuffer;
+
+exports.isArrayBuffer = isArrayBuffer;
+
+const isDataView = val => val instanceof DataView;
+
+exports.isDataView = isDataView;
+
+const isSharedArrayBuffer = val => val instanceof SharedArrayBuffer;
+
+exports.isSharedArrayBuffer = isSharedArrayBuffer;
+const isProxy = (0, _utils.notImplemented)("util.types.isProxy");
+exports.isProxy = isProxy;
+const isModuleNamespaceObject = (0, _utils.notImplemented)("util.types.isModuleNamespaceObject");
+exports.isModuleNamespaceObject = isModuleNamespaceObject;
+const isAnyArrayBuffer = (0, _utils.notImplemented)("util.types.isAnyArrayBuffer");
+exports.isAnyArrayBuffer = isAnyArrayBuffer;
+const isBoxedPrimitive = (0, _utils.notImplemented)("util.types.isBoxedPrimitive");
+exports.isBoxedPrimitive = isBoxedPrimitive;
+const isArrayBufferView = (0, _utils.notImplemented)("util.types.isArrayBufferView");
+exports.isArrayBufferView = isArrayBufferView;
+const isTypedArray = (0, _utils.notImplemented)("util.types.isTypedArray");
+exports.isTypedArray = isTypedArray;
+const isUint8Array = (0, _utils.notImplemented)("util.types.isUint8Array");
+exports.isUint8Array = isUint8Array;
+const isUint8ClampedArray = (0, _utils.notImplemented)("util.types.isUint8ClampedArray");
+exports.isUint8ClampedArray = isUint8ClampedArray;
+const isUint16Array = (0, _utils.notImplemented)("util.types.isUint16Array");
+exports.isUint16Array = isUint16Array;
+const isUint32Array = (0, _utils.notImplemented)("util.types.isUint32Array");
+exports.isUint32Array = isUint32Array;
+const isInt8Array = (0, _utils.notImplemented)("util.types.isInt8Array");
+exports.isInt8Array = isInt8Array;
+const isInt16Array = (0, _utils.notImplemented)("util.types.isInt16Array");
+exports.isInt16Array = isInt16Array;
+const isInt32Array = (0, _utils.notImplemented)("util.types.isInt32Array");
+exports.isInt32Array = isInt32Array;
+const isFloat32Array = (0, _utils.notImplemented)("util.types.isFloat32Array");
+exports.isFloat32Array = isFloat32Array;
+const isFloat64Array = (0, _utils.notImplemented)("util.types.isFloat64Array");
+exports.isFloat64Array = isFloat64Array;
+const isBigInt64Array = (0, _utils.notImplemented)("util.types.isBigInt64Array");
+exports.isBigInt64Array = isBigInt64Array;
+const isBigUint64Array = (0, _utils.notImplemented)("util.types.isBigUint64Array");
+exports.isBigUint64Array = isBigUint64Array;
+const isKeyObject = (0, _utils.notImplemented)("util.types.isKeyObject");
+exports.isKeyObject = isKeyObject;
+const isCryptoKey = (0, _utils.notImplemented)("util.types.isCryptoKey");
+exports.isCryptoKey = isCryptoKey;

node_modules/unenv/runtime/node/util/types/_types.d.ts

@@ -0,0 +1,43 @@
+import utilTypes from "node:util/types";
+export declare const isExternal: typeof utilTypes.isExternal;
+export declare const isDate: typeof utilTypes.isDate;
+export declare const isArgumentsObject: typeof utilTypes.isArgumentsObject;
+export declare const isBigIntObject: (val: any) => val is Date;
+export declare const isBooleanObject: typeof utilTypes.isBooleanObject;
+export declare const isNumberObject: typeof utilTypes.isNumberObject;
+export declare const isStringObject: typeof utilTypes.isStringObject;
+export declare const isSymbolObject: typeof utilTypes.isSymbolObject;
+export declare const isNativeError: typeof utilTypes.isNativeError;
+export declare const isRegExp: typeof utilTypes.isRegExp;
+export declare const isAsyncFunction: typeof utilTypes.isAsyncFunction;
+export declare const isGeneratorFunction: typeof utilTypes.isGeneratorFunction;
+export declare const isGeneratorObject: typeof utilTypes.isGeneratorObject;
+export declare const isPromise: typeof utilTypes.isPromise;
+export declare const isMap: typeof utilTypes.isMap;
+export declare const isSet: typeof utilTypes.isSet;
+export declare const isMapIterator: typeof utilTypes.isMapIterator;
+export declare const isSetIterator: typeof utilTypes.isSetIterator;
+export declare const isWeakMap: typeof utilTypes.isWeakMap;
+export declare const isWeakSet: typeof utilTypes.isWeakSet;
+export declare const isArrayBuffer: typeof utilTypes.isArrayBuffer;
+export declare const isDataView: typeof utilTypes.isDataView;
+export declare const isSharedArrayBuffer: typeof utilTypes.isSharedArrayBuffer;
+export declare const isProxy: typeof utilTypes.isProxy;
+export declare const isModuleNamespaceObject: typeof utilTypes.isModuleNamespaceObject;
+export declare const isAnyArrayBuffer: typeof utilTypes.isAnyArrayBuffer;
+export declare const isBoxedPrimitive: typeof utilTypes.isBoxedPrimitive;
+export declare const isArrayBufferView: typeof utilTypes.isArrayBufferView;
+export declare const isTypedArray: typeof utilTypes.isTypedArray;
+export declare const isUint8Array: typeof utilTypes.isUint8Array;
+export declare const isUint8ClampedArray: typeof utilTypes.isUint8ClampedArray;
+export declare const isUint16Array: typeof utilTypes.isUint16Array;
+export declare const isUint32Array: typeof utilTypes.isUint32Array;
+export declare const isInt8Array: typeof utilTypes.isInt8Array;
+export declare const isInt16Array: typeof utilTypes.isInt16Array;
+export declare const isInt32Array: typeof utilTypes.isInt32Array;
+export declare const isFloat32Array: typeof utilTypes.isFloat32Array;
+export declare const isFloat64Array: typeof utilTypes.isFloat64Array;
+export declare const isBigInt64Array: typeof utilTypes.isBigInt64Array;
+export declare const isBigUint64Array: typeof utilTypes.isBigUint64Array;
+export declare const isKeyObject: typeof utilTypes.isKeyObject;
+export declare const isCryptoKey: typeof utilTypes.isCryptoKey;

node_modules/unenv/runtime/node/util/types/_types.mjs

@@ -0,0 +1,43 @@
+import { notImplemented } from "../../../_internal/utils.mjs";
+export const isExternal = notImplemented("util.types.isExternal");
+export const isDate = (val) => val instanceof Date;
+export const isArgumentsObject = notImplemented("util.types.isArgumentsObject");
+export const isBigIntObject = (val) => val instanceof BigInt;
+export const isBooleanObject = (val) => val instanceof Boolean;
+export const isNumberObject = (val) => val instanceof Number;
+export const isStringObject = (val) => val instanceof String;
+export const isSymbolObject = (val) => val instanceof Symbol;
+export const isNativeError = notImplemented("util.types.isNativeError");
+export const isRegExp = (val) => val instanceof RegExp;
+export const isAsyncFunction = notImplemented("util.types.isAsyncFunction");
+export const isGeneratorFunction = notImplemented("util.types.isGeneratorFunction");
+export const isGeneratorObject = notImplemented("util.types.isGeneratorObject");
+export const isPromise = (val) => val instanceof Promise;
+export const isMap = (val) => val instanceof Map;
+export const isSet = (val) => val instanceof Set;
+export const isMapIterator = notImplemented("util.types.isMapIterator");
+export const isSetIterator = notImplemented("util.types.isSetIterator");
+export const isWeakMap = (val) => val instanceof WeakMap;
+export const isWeakSet = (val) => val instanceof WeakSet;
+export const isArrayBuffer = (val) => val instanceof ArrayBuffer;
+export const isDataView = (val) => val instanceof DataView;
+export const isSharedArrayBuffer = (val) => val instanceof SharedArrayBuffer;
+export const isProxy = notImplemented("util.types.isProxy");
+export const isModuleNamespaceObject = notImplemented("util.types.isModuleNamespaceObject");
+export const isAnyArrayBuffer = notImplemented("util.types.isAnyArrayBuffer");
+export const isBoxedPrimitive = notImplemented("util.types.isBoxedPrimitive");
+export const isArrayBufferView = notImplemented("util.types.isArrayBufferView");
+export const isTypedArray = notImplemented("util.types.isTypedArray");
+export const isUint8Array = notImplemented("util.types.isUint8Array");
+export const isUint8ClampedArray = notImplemented("util.types.isUint8ClampedArray");
+export const isUint16Array = notImplemented("util.types.isUint16Array");
+export const isUint32Array = notImplemented("util.types.isUint32Array");
+export const isInt8Array = notImplemented("util.types.isInt8Array");
+export const isInt16Array = notImplemented("util.types.isInt16Array");
+export const isInt32Array = notImplemented("util.types.isInt32Array");
+export const isFloat32Array = notImplemented("util.types.isFloat32Array");
+export const isFloat64Array = notImplemented("util.types.isFloat64Array");
+export const isBigInt64Array = notImplemented("util.types.isBigInt64Array");
+export const isBigUint64Array = notImplemented("util.types.isBigUint64Array");
+export const isKeyObject = notImplemented("util.types.isKeyObject");
+export const isCryptoKey = notImplemented("util.types.isCryptoKey");

node_modules/unenv/runtime/node/util/types/index.cjs

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+module.exports = void 0;
+
+var types = _interopRequireWildcard(require("./_types.cjs"));
+
+Object.keys(types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return types[key];
+    }
+  });
+});
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var _default = types;
+module.exports = _default;

node_modules/unenv/runtime/node/util/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./_types";
+declare const _default: any;
+export default _default;

node_modules/unenv/runtime/node/util/types/index.mjs

@@ -0,0 +1,3 @@
+import * as types from "./_types.mjs";
+export * from "./_types.mjs";
+export default types;