@gjsify/util 0.0.4 → 0.1.0

package/lib/esm/types/index.js

@@ -1,6 +1,300 @@
-export * from "@gjsify/deno_std/node/util/types";
-import types from "@gjsify/deno_std/node/util/types";
+const _toString = Object.prototype.toString;
+const _bigIntValueOf = BigInt.prototype.valueOf;
+const _booleanValueOf = Boolean.prototype.valueOf;
+const _dateValueOf = Date.prototype.valueOf;
+const _numberValueOf = Number.prototype.valueOf;
+const _stringValueOf = String.prototype.valueOf;
+const _symbolValueOf = Symbol.prototype.valueOf;
+const _weakMapHas = WeakMap.prototype.has;
+const _weakSetHas = WeakSet.prototype.has;
+const _getArrayBufferByteLength = Object.getOwnPropertyDescriptor(
+  ArrayBuffer.prototype,
+  "byteLength"
+).get;
+const _getSharedArrayBufferByteLength = typeof SharedArrayBuffer !== "undefined" ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get : void 0;
+const _getTypedArrayToStringTag = Object.getOwnPropertyDescriptor(
+  Object.getPrototypeOf(Uint8Array).prototype,
+  Symbol.toStringTag
+).get;
+const _getSetSize = Object.getOwnPropertyDescriptor(Set.prototype, "size").get;
+const _getMapSize = Object.getOwnPropertyDescriptor(Map.prototype, "size").get;
+function isObjectLike(value) {
+  return value !== null && typeof value === "object";
+}
+function isAnyArrayBuffer(value) {
+  return isArrayBuffer(value) || isSharedArrayBuffer(value);
+}
+function isArrayBuffer(value) {
+  try {
+    _getArrayBufferByteLength.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSharedArrayBuffer(value) {
+  if (_getSharedArrayBufferByteLength === void 0) return false;
+  try {
+    _getSharedArrayBufferByteLength.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isArrayBufferView(value) {
+  return ArrayBuffer.isView(value);
+}
+function isTypedArray(value) {
+  return _getTypedArrayToStringTag.call(value) !== void 0;
+}
+function isUint8Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Uint8Array";
+}
+function isUint8ClampedArray(value) {
+  return _getTypedArrayToStringTag.call(value) === "Uint8ClampedArray";
+}
+function isUint16Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Uint16Array";
+}
+function isUint32Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Uint32Array";
+}
+function isInt8Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Int8Array";
+}
+function isInt16Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Int16Array";
+}
+function isInt32Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Int32Array";
+}
+function isFloat32Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Float32Array";
+}
+function isFloat64Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "Float64Array";
+}
+function isBigInt64Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "BigInt64Array";
+}
+function isBigUint64Array(value) {
+  return _getTypedArrayToStringTag.call(value) === "BigUint64Array";
+}
+function isDataView(value) {
+  return ArrayBuffer.isView(value) && _getTypedArrayToStringTag.call(value) === void 0;
+}
+function isMap(value) {
+  try {
+    _getMapSize.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSet(value) {
+  try {
+    _getSetSize.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isWeakMap(value) {
+  try {
+    _weakMapHas.call(value, null);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isWeakSet(value) {
+  try {
+    _weakSetHas.call(value, null);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMapIterator(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === "Map Iterator";
+}
+function isSetIterator(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === "Set Iterator";
+}
+function isDate(value) {
+  try {
+    _dateValueOf.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRegExp(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === void 0 && _toString.call(value) === "[object RegExp]";
+}
+function isNativeError(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === void 0 && _toString.call(value) === "[object Error]";
+}
+function isAsyncFunction(value) {
+  return typeof value === "function" && value[Symbol.toStringTag] === "AsyncFunction";
+}
+function isGeneratorFunction(value) {
+  return typeof value === "function" && value[Symbol.toStringTag] === "GeneratorFunction";
+}
+function isGeneratorObject(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === "Generator";
+}
+function isPromise(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === "Promise";
+}
+function isBooleanObject(value) {
+  if (!isObjectLike(value)) return false;
+  try {
+    _booleanValueOf.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isNumberObject(value) {
+  if (!isObjectLike(value)) return false;
+  try {
+    _numberValueOf.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isStringObject(value) {
+  if (!isObjectLike(value)) return false;
+  try {
+    _stringValueOf.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSymbolObject(value) {
+  if (!isObjectLike(value)) return false;
+  try {
+    _symbolValueOf.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isBigIntObject(value) {
+  if (!isObjectLike(value)) return false;
+  try {
+    _bigIntValueOf.call(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isBoxedPrimitive(value) {
+  return isBooleanObject(value) || isStringObject(value) || isNumberObject(value) || isSymbolObject(value) || isBigIntObject(value);
+}
+function isArgumentsObject(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === void 0 && _toString.call(value) === "[object Arguments]";
+}
+function isModuleNamespaceObject(value) {
+  return isObjectLike(value) && value[Symbol.toStringTag] === "Module";
+}
+function isProxy(value) {
+  return false;
+}
+function isCryptoKey(value) {
+  return isObjectLike(value) && _toString.call(value) === "[object CryptoKey]";
+}
+function isKeyObject(value) {
+  return false;
+}
+const types = {
+  isAnyArrayBuffer,
+  isArrayBuffer,
+  isArrayBufferView,
+  isArgumentsObject,
+  isAsyncFunction,
+  isBigInt64Array,
+  isBigUint64Array,
+  isBigIntObject,
+  isBooleanObject,
+  isBoxedPrimitive,
+  isCryptoKey,
+  isDataView,
+  isDate,
+  isFloat32Array,
+  isFloat64Array,
+  isGeneratorFunction,
+  isGeneratorObject,
+  isInt8Array,
+  isInt16Array,
+  isInt32Array,
+  isKeyObject,
+  isMap,
+  isMapIterator,
+  isModuleNamespaceObject,
+  isNativeError,
+  isNumberObject,
+  isPromise,
+  isProxy,
+  isRegExp,
+  isSet,
+  isSetIterator,
+  isSharedArrayBuffer,
+  isStringObject,
+  isSymbolObject,
+  isTypedArray,
+  isUint8Array,
+  isUint8ClampedArray,
+  isUint16Array,
+  isUint32Array,
+  isWeakMap,
+  isWeakSet
+};
 var types_default = types;
 export {
-  types_default as default
+  types_default as default,
+  isAnyArrayBuffer,
+  isArgumentsObject,
+  isArrayBuffer,
+  isArrayBufferView,
+  isAsyncFunction,
+  isBigInt64Array,
+  isBigIntObject,
+  isBigUint64Array,
+  isBooleanObject,
+  isBoxedPrimitive,
+  isCryptoKey,
+  isDataView,
+  isDate,
+  isFloat32Array,
+  isFloat64Array,
+  isGeneratorFunction,
+  isGeneratorObject,
+  isInt16Array,
+  isInt32Array,
+  isInt8Array,
+  isKeyObject,
+  isMap,
+  isMapIterator,
+  isModuleNamespaceObject,
+  isNativeError,
+  isNumberObject,
+  isPromise,
+  isProxy,
+  isRegExp,
+  isSet,
+  isSetIterator,
+  isSharedArrayBuffer,
+  isStringObject,
+  isSymbolObject,
+  isTypedArray,
+  isUint16Array,
+  isUint32Array,
+  isUint8Array,
+  isUint8ClampedArray,
+  isWeakMap,
+  isWeakSet
 };

package/lib/esm/types.js

@@ -0,0 +1,6 @@
+export * from "./types/index.js";
+import types from "./types/index.js";
+var types_default = types;
+export {
+  types_default as default
+};

package/lib/types/errors.d.ts

@@ -0,0 +1,2 @@
+export declare function getSystemErrorName(err: number): string;
+export declare function getSystemErrorMap(): Map<number, [string, string]>;

package/lib/types/index.d.ts

@@ -1,3 +1,98 @@
-export * from '@gjsify/deno_std/node/util';
-import util from '@gjsify/deno_std/node/util';
-export default util;
+import type { InspectOptions } from 'node:util';
+import * as types from './types.js';
+import { getSystemErrorName, getSystemErrorMap } from './errors.js';
+export { types };
+export { getSystemErrorName, getSystemErrorMap };
+declare const kCustomInspect: unique symbol;
+export declare function inspect(value: unknown, opts?: boolean | InspectOptions): string;
+export declare namespace inspect {
+    var custom: typeof kCustomInspect;
+    var defaultOptions: {
+        showHidden: boolean;
+        depth: number;
+        colors: boolean;
+        maxArrayLength: number;
+        maxStringLength: number;
+        breakLength: number;
+        compact: number;
+        sorted: boolean;
+    };
+    var colors: Record<string, [number, number]>;
+    var styles: Record<string, string>;
+}
+export declare function format(fmt: string, ...args: unknown[]): string;
+export declare function formatWithOptions(inspectOptions: InspectOptions, fmt: string, ...args: unknown[]): string;
+declare const kCustomPromisify: unique symbol;
+export declare function promisify<T extends (...args: unknown[]) => void>(fn: T): (...args: unknown[]) => Promise<unknown>;
+export declare namespace promisify {
+    var custom: typeof kCustomPromisify;
+}
+export declare function callbackify<T>(fn: () => Promise<T>): (callback: (err: Error | null, result?: T) => void) => void;
+export declare function callbackify<T>(fn: (...args: unknown[]) => Promise<T>): (...args: unknown[]) => void;
+export declare function deprecate<T extends (...args: unknown[]) => unknown>(fn: T, msg: string, code?: string): T;
+export declare function debuglog(section: string): (...args: unknown[]) => void;
+export declare function inherits(ctor: Function, superCtor: Function): void;
+export declare function isBoolean(value: unknown): value is boolean;
+export declare function isNull(value: unknown): value is null;
+export declare function isNullOrUndefined(value: unknown): value is null | undefined;
+export declare function isNumber(value: unknown): value is number;
+export declare function isString(value: unknown): value is string;
+export declare function isSymbol(value: unknown): value is symbol;
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function isObject(value: unknown): value is object;
+export declare function isError(value: unknown): value is Error;
+export declare function isFunction(value: unknown): value is Function;
+export declare function isRegExp(value: unknown): value is RegExp;
+export declare function isArray(value: unknown): value is unknown[];
+export declare function isPrimitive(value: unknown): boolean;
+export declare function isDate(value: unknown): value is Date;
+export declare function isBuffer(value: unknown): boolean;
+export declare const TextDecoder: {
+    new (label?: string, options?: TextDecoderOptions): TextDecoder;
+    prototype: TextDecoder;
+};
+export declare const TextEncoder: {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+};
+export declare function isDeepStrictEqual(a: unknown, b: unknown): boolean;
+export declare function toUSVString(string: string): string;
+declare const _default: {
+    format: typeof format;
+    formatWithOptions: typeof formatWithOptions;
+    inspect: typeof inspect;
+    promisify: typeof promisify;
+    callbackify: typeof callbackify;
+    deprecate: typeof deprecate;
+    debuglog: typeof debuglog;
+    inherits: typeof inherits;
+    types: typeof types;
+    isBoolean: typeof isBoolean;
+    isNull: typeof isNull;
+    isNullOrUndefined: typeof isNullOrUndefined;
+    isNumber: typeof isNumber;
+    isString: typeof isString;
+    isSymbol: typeof isSymbol;
+    isUndefined: typeof isUndefined;
+    isObject: typeof isObject;
+    isError: typeof isError;
+    isFunction: typeof isFunction;
+    isRegExp: typeof isRegExp;
+    isArray: typeof isArray;
+    isPrimitive: typeof isPrimitive;
+    isDate: typeof isDate;
+    isBuffer: typeof isBuffer;
+    isDeepStrictEqual: typeof isDeepStrictEqual;
+    toUSVString: typeof toUSVString;
+    TextDecoder: {
+        new (label?: string, options?: TextDecoderOptions): TextDecoder;
+        prototype: TextDecoder;
+    };
+    TextEncoder: {
+        new (): TextEncoder;
+        prototype: TextEncoder;
+    };
+    getSystemErrorName: typeof getSystemErrorName;
+    getSystemErrorMap: typeof getSystemErrorMap;
+};
+export default _default;

package/lib/types/types/index.d.ts

@@ -1,3 +1,85 @@
-export * from '@gjsify/deno_std/node/util/types';
-import types from '@gjsify/deno_std/node/util/types';
+export declare function isAnyArrayBuffer(value: unknown): value is ArrayBuffer | SharedArrayBuffer;
+export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
+export declare function isSharedArrayBuffer(value: unknown): value is SharedArrayBuffer;
+export declare function isArrayBufferView(value: unknown): value is ArrayBufferView;
+export declare function isTypedArray(value: unknown): boolean;
+export declare function isUint8Array(value: unknown): value is Uint8Array;
+export declare function isUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
+export declare function isUint16Array(value: unknown): value is Uint16Array;
+export declare function isUint32Array(value: unknown): value is Uint32Array;
+export declare function isInt8Array(value: unknown): value is Int8Array;
+export declare function isInt16Array(value: unknown): value is Int16Array;
+export declare function isInt32Array(value: unknown): value is Int32Array;
+export declare function isFloat32Array(value: unknown): value is Float32Array;
+export declare function isFloat64Array(value: unknown): value is Float64Array;
+export declare function isBigInt64Array(value: unknown): value is BigInt64Array;
+export declare function isBigUint64Array(value: unknown): value is BigUint64Array;
+export declare function isDataView(value: unknown): value is DataView;
+export declare function isMap(value: unknown): value is Map<unknown, unknown>;
+export declare function isSet(value: unknown): value is Set<unknown>;
+export declare function isWeakMap(value: unknown): value is WeakMap<WeakKey, unknown>;
+export declare function isWeakSet(value: unknown): value is WeakSet<WeakKey>;
+export declare function isMapIterator(value: unknown): boolean;
+export declare function isSetIterator(value: unknown): boolean;
+export declare function isDate(value: unknown): value is Date;
+export declare function isRegExp(value: unknown): value is RegExp;
+export declare function isNativeError(value: unknown): value is Error;
+export declare function isAsyncFunction(value: unknown): boolean;
+export declare function isGeneratorFunction(value: unknown): value is GeneratorFunction;
+export declare function isGeneratorObject(value: unknown): value is Generator;
+export declare function isPromise(value: unknown): value is Promise<unknown>;
+export declare function isBooleanObject(value: unknown): boolean;
+export declare function isNumberObject(value: unknown): boolean;
+export declare function isStringObject(value: unknown): boolean;
+export declare function isSymbolObject(value: unknown): boolean;
+export declare function isBigIntObject(value: unknown): boolean;
+export declare function isBoxedPrimitive(value: unknown): boolean;
+export declare function isArgumentsObject(value: unknown): value is IArguments;
+export declare function isModuleNamespaceObject(value: unknown): boolean;
+export declare function isProxy(value: unknown): boolean;
+export declare function isCryptoKey(value: unknown): boolean;
+export declare function isKeyObject(value: unknown): boolean;
+declare const types: {
+    isAnyArrayBuffer: typeof isAnyArrayBuffer;
+    isArrayBuffer: typeof isArrayBuffer;
+    isArrayBufferView: typeof isArrayBufferView;
+    isArgumentsObject: typeof isArgumentsObject;
+    isAsyncFunction: typeof isAsyncFunction;
+    isBigInt64Array: typeof isBigInt64Array;
+    isBigUint64Array: typeof isBigUint64Array;
+    isBigIntObject: typeof isBigIntObject;
+    isBooleanObject: typeof isBooleanObject;
+    isBoxedPrimitive: typeof isBoxedPrimitive;
+    isCryptoKey: typeof isCryptoKey;
+    isDataView: typeof isDataView;
+    isDate: typeof isDate;
+    isFloat32Array: typeof isFloat32Array;
+    isFloat64Array: typeof isFloat64Array;
+    isGeneratorFunction: typeof isGeneratorFunction;
+    isGeneratorObject: typeof isGeneratorObject;
+    isInt8Array: typeof isInt8Array;
+    isInt16Array: typeof isInt16Array;
+    isInt32Array: typeof isInt32Array;
+    isKeyObject: typeof isKeyObject;
+    isMap: typeof isMap;
+    isMapIterator: typeof isMapIterator;
+    isModuleNamespaceObject: typeof isModuleNamespaceObject;
+    isNativeError: typeof isNativeError;
+    isNumberObject: typeof isNumberObject;
+    isPromise: typeof isPromise;
+    isProxy: typeof isProxy;
+    isRegExp: typeof isRegExp;
+    isSet: typeof isSet;
+    isSetIterator: typeof isSetIterator;
+    isSharedArrayBuffer: typeof isSharedArrayBuffer;
+    isStringObject: typeof isStringObject;
+    isSymbolObject: typeof isSymbolObject;
+    isTypedArray: typeof isTypedArray;
+    isUint8Array: typeof isUint8Array;
+    isUint8ClampedArray: typeof isUint8ClampedArray;
+    isUint16Array: typeof isUint16Array;
+    isUint32Array: typeof isUint32Array;
+    isWeakMap: typeof isWeakMap;
+    isWeakSet: typeof isWeakSet;
+};
 export default types;

package/lib/types/types.d.ts

@@ -0,0 +1,3 @@
+export * from './types/index.js';
+import types from './types/index.js';
+export default types;

package/package.json

@@ -1,33 +1,30 @@
 {
   "name": "@gjsify/util",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Node.js util module for Gjs",
   "type": "module",
-  "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
   "types": "lib/types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/esm/index.js"
-      },
-      "require": {
-        "types": "./lib/types/index.d.ts",
-        "default": "./lib/cjs/index.js"
-      }
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/esm/index.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/esm/types.js"
     }
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/util'",
-    "build": "yarn print:name && yarn build:gjsify && yarn build:types",
+    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo test.gjs.mjs test.node.mjs || exit 0",
+    "check": "tsc --noEmit",
+    "build": "yarn build:gjsify && yarn build:types",
     "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
-    "build:types": "tsc --project tsconfig.types.json || exit 0",
+    "build:types": "tsc",
     "build:test": "yarn build:test:gjs && yarn build:test:node",
     "build:test:gjs": "gjsify build src/test.ts --app gjs --outfile test.gjs.mjs",
     "build:test:node": "gjsify build src/test.ts --app node --outfile test.node.mjs",
-    "test": "yarn print:name && yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
+    "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
     "test:gjs": "gjs -m test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
@@ -37,18 +34,10 @@
     "util"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.0.4",
-    "@gjsify/unit": "^0.0.4",
-    "@types/inherits": "^0.0.33",
-    "@types/node": "^20.10.5",
-    "typescript": "^5.3.3"
-  },
-  "dependencies": {
-    "@gjsify/deno_std": "^0.0.4",
-    "is-arguments": "^1.1.1",
-    "is-generator-function": "^1.0.10",
-    "is-typed-array": "^1.1.12",
-    "util": "^0.12.5",
-    "which-typed-array": "^1.1.13"
+    "@gjsify/cli": "^0.1.0",
+    "@gjsify/unit": "^0.1.0",
+    "@types/inherits": "^2.0.0",
+    "@types/node": "^25.5.0",
+    "typescript": "^6.0.2"
   }
 }

package/src/errors.ts

@@ -0,0 +1,101 @@
+// Reference: Node.js lib/internal/errors.js — system error name mapping (Linux errno codes)
+// Reimplemented for GJS
+
+const linuxErrors: Record<number, string> = {
+  [-1]: 'EPERM', [-2]: 'ENOENT', [-3]: 'ESRCH', [-4]: 'EINTR',
+  [-5]: 'EIO', [-6]: 'ENXIO', [-7]: 'E2BIG', [-8]: 'ENOEXEC',
+  [-9]: 'EBADF', [-10]: 'ECHILD', [-11]: 'EAGAIN', [-12]: 'ENOMEM',
+  [-13]: 'EACCES', [-14]: 'EFAULT', [-15]: 'ENOTBLK', [-16]: 'EBUSY',
+  [-17]: 'EEXIST', [-18]: 'EXDEV', [-19]: 'ENODEV', [-20]: 'ENOTDIR',
+  [-21]: 'EISDIR', [-22]: 'EINVAL', [-23]: 'ENFILE', [-24]: 'EMFILE',
+  [-25]: 'ENOTTY', [-26]: 'ETXTBSY', [-27]: 'EFBIG', [-28]: 'ENOSPC',
+  [-29]: 'ESPIPE', [-30]: 'EROFS', [-31]: 'EMLINK', [-32]: 'EPIPE',
+  [-33]: 'EDOM', [-34]: 'ERANGE', [-35]: 'EDEADLK', [-36]: 'ENAMETOOLONG',
+  [-37]: 'ENOLCK', [-38]: 'ENOSYS', [-39]: 'ENOTEMPTY', [-40]: 'ELOOP',
+  [-42]: 'ENOMSG', [-43]: 'EIDRM', [-44]: 'ECHRNG', [-45]: 'EL2NSYNC',
+  [-46]: 'EL3HLT', [-47]: 'EL3RST', [-48]: 'ELNRNG', [-49]: 'EUNATCH',
+  [-50]: 'ENOCSI', [-51]: 'EL2HLT', [-52]: 'EBADE', [-53]: 'EBADR',
+  [-54]: 'EXFULL', [-55]: 'ENOANO', [-56]: 'EBADRQC', [-57]: 'EBADSLT',
+  [-59]: 'EBFONT', [-60]: 'ENOSTR', [-61]: 'ENODATA', [-62]: 'ETIME',
+  [-63]: 'ENOSR', [-64]: 'ENONET', [-65]: 'ENOPKG', [-66]: 'EREMOTE',
+  [-67]: 'ENOLINK', [-68]: 'EADV', [-69]: 'ESRMNT', [-70]: 'ECOMM',
+  [-71]: 'EPROTO', [-72]: 'EMULTIHOP', [-73]: 'EDOTDOT', [-74]: 'EBADMSG',
+  [-75]: 'EOVERFLOW', [-76]: 'ENOTUNIQ', [-77]: 'EBADFD', [-78]: 'EREMCHG',
+  [-79]: 'ELIBACC', [-80]: 'ELIBBAD', [-81]: 'ELIBSCN', [-82]: 'ELIBMAX',
+  [-83]: 'ELIBEXEC', [-84]: 'EILSEQ', [-85]: 'ERESTART', [-86]: 'ESTRPIPE',
+  [-87]: 'EUSERS', [-88]: 'ENOTSOCK', [-89]: 'EDESTADDRREQ', [-90]: 'EMSGSIZE',
+  [-91]: 'EPROTOTYPE', [-92]: 'ENOPROTOOPT', [-93]: 'EPROTONOSUPPORT',
+  [-94]: 'ESOCKTNOSUPPORT', [-95]: 'ENOTSUP', [-96]: 'EPFNOSUPPORT',
+  [-97]: 'EAFNOSUPPORT', [-98]: 'EADDRINUSE', [-99]: 'EADDRNOTAVAIL',
+  [-100]: 'ENETDOWN', [-101]: 'ENETUNREACH', [-102]: 'ENETRESET',
+  [-103]: 'ECONNABORTED', [-104]: 'ECONNRESET', [-105]: 'ENOBUFS',
+  [-106]: 'EISCONN', [-107]: 'ENOTCONN', [-108]: 'ESHUTDOWN',
+  [-109]: 'ETOOMANYREFS', [-110]: 'ETIMEDOUT', [-111]: 'ECONNREFUSED',
+  [-112]: 'EHOSTDOWN', [-113]: 'EHOSTUNREACH', [-114]: 'EALREADY',
+  [-115]: 'EINPROGRESS', [-116]: 'ESTALE', [-117]: 'EUCLEAN',
+  [-118]: 'ENOTNAM', [-119]: 'ENAVAIL', [-120]: 'EISNAM',
+  [-121]: 'EREMOTEIO', [-122]: 'EDQUOT', [-123]: 'ENOMEDIUM',
+  [-124]: 'EMEDIUMTYPE', [-125]: 'ECANCELED', [-126]: 'ENOKEY',
+  [-127]: 'EKEYEXPIRED', [-128]: 'EKEYREVOKED', [-129]: 'EKEYREJECTED',
+};
+
+const darwinErrors: Record<number, string> = {
+  [-1]: 'EPERM', [-2]: 'ENOENT', [-3]: 'ESRCH', [-4]: 'EINTR',
+  [-5]: 'EIO', [-6]: 'ENXIO', [-7]: 'E2BIG', [-8]: 'ENOEXEC',
+  [-9]: 'EBADF', [-10]: 'ECHILD', [-11]: 'EDEADLK', [-12]: 'ENOMEM',
+  [-13]: 'EACCES', [-14]: 'EFAULT', [-15]: 'ENOTBLK', [-16]: 'EBUSY',
+  [-17]: 'EEXIST', [-18]: 'EXDEV', [-19]: 'ENODEV', [-20]: 'ENOTDIR',
+  [-21]: 'EISDIR', [-22]: 'EINVAL', [-23]: 'ENFILE', [-24]: 'EMFILE',
+  [-25]: 'ENOTTY', [-26]: 'ETXTBSY', [-27]: 'EFBIG', [-28]: 'ENOSPC',
+  [-29]: 'ESPIPE', [-30]: 'EROFS', [-31]: 'EMLINK', [-32]: 'EPIPE',
+  [-33]: 'EDOM', [-34]: 'ERANGE', [-35]: 'EAGAIN', [-36]: 'EINPROGRESS',
+  [-37]: 'EALREADY', [-38]: 'ENOTSOCK', [-39]: 'EDESTADDRREQ',
+  [-40]: 'EMSGSIZE', [-41]: 'EPROTOTYPE', [-42]: 'ENOPROTOOPT',
+  [-43]: 'EPROTONOSUPPORT', [-44]: 'ESOCKTNOSUPPORT', [-45]: 'ENOTSUP',
+  [-46]: 'EPFNOSUPPORT', [-47]: 'EAFNOSUPPORT', [-48]: 'EADDRINUSE',
+  [-49]: 'EADDRNOTAVAIL', [-50]: 'ENETDOWN', [-51]: 'ENETUNREACH',
+  [-52]: 'ENETRESET', [-53]: 'ECONNABORTED', [-54]: 'ECONNRESET',
+  [-55]: 'ENOBUFS', [-56]: 'EISCONN', [-57]: 'ENOTCONN',
+  [-58]: 'ESHUTDOWN', [-59]: 'ETOOMANYREFS', [-60]: 'ETIMEDOUT',
+  [-61]: 'ECONNREFUSED', [-62]: 'ELOOP', [-63]: 'ENAMETOOLONG',
+  [-64]: 'EHOSTDOWN', [-65]: 'EHOSTUNREACH', [-66]: 'ENOTEMPTY',
+  [-67]: 'EPROCLIM', [-68]: 'EUSERS', [-69]: 'EDQUOT', [-70]: 'ESTALE',
+  [-71]: 'EREMOTE', [-72]: 'EBADRPC', [-73]: 'ERPCMISMATCH',
+  [-74]: 'EPROGUNAVAIL', [-75]: 'EPROGMISMATCH', [-76]: 'EPROCUNAVAIL',
+  [-77]: 'ENOLCK', [-78]: 'ENOSYS', [-79]: 'EFTYPE', [-80]: 'EAUTH',
+  [-81]: 'ENEEDAUTH', [-82]: 'EPWROFF', [-83]: 'EDEVERR',
+  [-84]: 'EOVERFLOW', [-85]: 'EBADEXEC', [-86]: 'EBADARCH',
+  [-87]: 'ESHLIBVERS', [-88]: 'EBADMACHO', [-89]: 'ECANCELED',
+  [-90]: 'EIDRM', [-91]: 'ENOMSG', [-92]: 'EILSEQ', [-93]: 'ENOATTR',
+  [-94]: 'EBADMSG', [-95]: 'EMULTIHOP', [-96]: 'ENODATA',
+  [-97]: 'ENOLINK', [-98]: 'ENOSR', [-99]: 'ENOSTR', [-100]: 'EPROTO',
+  [-101]: 'ETIME', [-102]: 'EOPNOTSUPP',
+};
+
+function getPlatform(): string {
+  if (typeof globalThis.process?.platform === 'string') return globalThis.process.platform;
+  return 'linux';
+}
+
+export function getSystemErrorName(err: number): string {
+  if (typeof err !== 'number') {
+    throw new TypeError('The "err" argument must be of type number. Received type ' + typeof err);
+  }
+  if (err >= 0) {
+    throw new RangeError(`The value of "err" is out of range. It must be a negative integer. Received ${err}`);
+  }
+
+  const platform = getPlatform();
+  const map = platform === 'darwin' ? darwinErrors : linuxErrors;
+  return map[err] || `Unknown system error ${err}`;
+}
+
+export function getSystemErrorMap(): Map<number, [string, string]> {
+  const platform = getPlatform();
+  const map = platform === 'darwin' ? darwinErrors : linuxErrors;
+  const result = new Map<number, [string, string]>();
+  for (const [key, name] of Object.entries(map)) {
+    result.set(Number(key), [name, '']);
+  }
+  return result;
+}