@gjsify/util 0.0.4 → 0.1.0

package/lib/esm/index.js

@@ -1,6 +1,580 @@
-export * from "@gjsify/deno_std/node/util";
-import util from "@gjsify/deno_std/node/util";
-var src_default = util;
+import * as types from "./types.js";
+import { getSystemErrorName, getSystemErrorMap } from "./errors.js";
+const kCustomInspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+function inspectValue(value, opts, depth) {
+  if (value === null) return opts.colors ? "\x1B[1mnull\x1B[22m" : "null";
+  if (value === void 0) return opts.colors ? "\x1B[90mundefined\x1B[39m" : "undefined";
+  const maxDepth = opts.depth ?? 2;
+  if (typeof value === "string") {
+    const escaped = value.replace(/\\/g, "\\\\");
+    if (value.includes("'") && !value.includes('"')) {
+      const dq = escaped.replace(/"/g, '\\"');
+      return opts.colors ? `\x1B[32m"${dq}"\x1B[39m` : `"${dq}"`;
+    }
+    const sq = escaped.replace(/'/g, "\\'");
+    return opts.colors ? `\x1B[32m'${sq}'\x1B[39m` : `'${sq}'`;
+  }
+  if (typeof value === "number") {
+    return opts.colors ? `\x1B[33m${value}\x1B[39m` : String(value);
+  }
+  if (typeof value === "bigint") {
+    return opts.colors ? `\x1B[33m${value}n\x1B[39m` : `${value}n`;
+  }
+  if (typeof value === "boolean") {
+    return opts.colors ? `\x1B[33m${value}\x1B[39m` : String(value);
+  }
+  if (typeof value === "symbol") {
+    return opts.colors ? `\x1B[32m${value.toString()}\x1B[39m` : value.toString();
+  }
+  if (typeof value === "function") {
+    const name = value.name ? `: ${value.name}` : "";
+    return opts.colors ? `\x1B[36m[Function${name}]\x1B[39m` : `[Function${name}]`;
+  }
+  if (value !== null && typeof value === "object" && kCustomInspect in value) {
+    const custom = value[kCustomInspect];
+    if (typeof custom === "function") {
+      const result = custom.call(value, depth, opts);
+      if (typeof result === "string") return result;
+      return inspectValue(result, opts, depth);
+    }
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof RegExp) {
+    return opts.colors ? `\x1B[31m${value.toString()}\x1B[39m` : value.toString();
+  }
+  if (value instanceof Error) {
+    return value.stack || value.toString();
+  }
+  if (depth > maxDepth) {
+    return Array.isArray(value) ? "[Array]" : "[Object]";
+  }
+  if (Array.isArray(value)) {
+    return inspectArray(value, opts, depth);
+  }
+  if (value instanceof Map) {
+    const entries = [...value.entries()].map(
+      ([k, v]) => `${inspectValue(k, opts, depth + 1)} => ${inspectValue(v, opts, depth + 1)}`
+    );
+    return `Map(${value.size}) { ${entries.join(", ")} }`;
+  }
+  if (value instanceof Set) {
+    const entries = [...value].map((v) => inspectValue(v, opts, depth + 1));
+    return `Set(${value.size}) { ${entries.join(", ")} }`;
+  }
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+    const name = value.constructor?.name || "TypedArray";
+    const arr = Array.from(value);
+    return `${name}(${arr.length}) [ ${arr.join(", ")} ]`;
+  }
+  return inspectObject(value, opts, depth);
+}
+function inspectArray(arr, opts, depth) {
+  const maxLen = opts.maxArrayLength ?? 100;
+  const len = Math.min(arr.length, maxLen);
+  const items = [];
+  for (let i = 0; i < len; i++) {
+    items.push(inspectValue(arr[i], opts, depth + 1));
+  }
+  if (arr.length > maxLen) {
+    items.push(`... ${arr.length - maxLen} more items`);
+  }
+  if (opts.showHidden) {
+    items.push(`[length]: ${arr.length}`);
+  }
+  const breakLength = opts.breakLength ?? 72;
+  const compact = opts.compact ?? 3;
+  if (typeof compact === "number" && compact > 0 && arr.length > compact) {
+    const indent = "  ";
+    const indentLen = indent.length;
+    const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+    const maxItemLen = Math.max(...items.map((item) => stripAnsi(item).length));
+    const biasedMax = Math.max(maxItemLen - 2, 1);
+    const numItems = items.length;
+    const approxCharHeights = 2.5;
+    const columns = Math.min(
+      Math.round(Math.sqrt(approxCharHeights * biasedMax * numItems) / biasedMax),
+      Math.floor((breakLength - indentLen) / biasedMax),
+      Math.floor((2.5 + numItems - 1) / 2),
+      15
+    );
+    if (columns > 1) {
+      const rows = [];
+      for (let i = 0; i < numItems; i += columns) {
+        rows.push(indent + items.slice(i, Math.min(i + columns, numItems)).join(", "));
+      }
+      return `[
+${rows.join(",\n")}
+]`;
+    }
+  }
+  const singleLine = `[ ${items.join(", ")} ]`;
+  if (singleLine.length <= breakLength) return singleLine;
+  return `[
+${items.map((i) => "  " + i).join(",\n")}
+]`;
+}
+function inspectObject(obj, opts, depth) {
+  const keys = opts.showHidden ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
+  if (opts.sorted) keys.sort();
+  if (keys.length === 0) {
+    const tag = Object.prototype.toString.call(obj);
+    if (tag !== "[object Object]") return tag;
+    return "{}";
+  }
+  const items = keys.map((key) => {
+    const val = inspectValue(obj[key], opts, depth + 1);
+    return `${key}: ${val}`;
+  });
+  const breakLength = opts.breakLength ?? 72;
+  const singleLine = `{ ${items.join(", ")} }`;
+  if (singleLine.length <= breakLength) return singleLine;
+  return `{
+${items.map((i) => "  " + i).join(",\n")}
+}`;
+}
+function inspect(value, opts) {
+  const options = typeof opts === "boolean" ? { showHidden: opts } : { ...opts };
+  if (options.colors === void 0) options.colors = false;
+  return inspectValue(value, options, 0);
+}
+inspect.custom = kCustomInspect;
+inspect.defaultOptions = {
+  showHidden: false,
+  depth: 2,
+  colors: false,
+  maxArrayLength: 100,
+  maxStringLength: 1e4,
+  breakLength: 72,
+  compact: 3,
+  sorted: false
+};
+inspect.colors = {
+  reset: [0, 0],
+  bold: [1, 22],
+  dim: [2, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  blink: [5, 25],
+  inverse: [7, 27],
+  hidden: [8, 28],
+  strikethrough: [9, 29],
+  doubleunderline: [21, 24],
+  black: [30, 39],
+  red: [31, 39],
+  green: [32, 39],
+  yellow: [33, 39],
+  blue: [34, 39],
+  magenta: [35, 39],
+  cyan: [36, 39],
+  white: [37, 39],
+  bgBlack: [40, 49],
+  bgRed: [41, 49],
+  bgGreen: [42, 49],
+  bgYellow: [43, 49],
+  bgBlue: [44, 49],
+  bgMagenta: [45, 49],
+  bgCyan: [46, 49],
+  bgWhite: [47, 49],
+  framed: [51, 54],
+  overlined: [53, 55],
+  gray: [90, 39],
+  grey: [90, 39],
+  redBright: [91, 39],
+  greenBright: [92, 39],
+  yellowBright: [93, 39],
+  blueBright: [94, 39],
+  magentaBright: [95, 39],
+  cyanBright: [96, 39],
+  whiteBright: [97, 39],
+  bgBlackBright: [100, 49],
+  bgRedBright: [101, 49],
+  bgGreenBright: [102, 49],
+  bgYellowBright: [103, 49],
+  bgBlueBright: [104, 49],
+  bgMagentaBright: [105, 49],
+  bgCyanBright: [106, 49],
+  bgWhiteBright: [107, 49]
+};
+inspect.styles = {
+  special: "cyan",
+  number: "yellow",
+  bigint: "yellow",
+  boolean: "yellow",
+  undefined: "grey",
+  null: "bold",
+  string: "green",
+  symbol: "green",
+  date: "magenta",
+  regexp: "red",
+  module: "underline"
+};
+function format(fmt, ...args) {
+  if (fmt === void 0 && args.length === 0) return "";
+  if (typeof fmt !== "string") {
+    if (args.length === 0) return inspect(fmt);
+    const parts = [inspect(fmt)];
+    for (const arg of args) parts.push(inspect(arg));
+    return parts.join(" ");
+  }
+  let i = 0;
+  let result = "";
+  let lastIdx = 0;
+  for (let p = 0; p < fmt.length - 1; p++) {
+    if (fmt[p] !== "%") continue;
+    if (p > lastIdx) result += fmt.slice(lastIdx, p);
+    const next = fmt[p + 1];
+    if (next === "%") {
+      result += "%";
+      lastIdx = p + 2;
+      p++;
+      continue;
+    }
+    if (i >= args.length) {
+      result += "%" + next;
+      lastIdx = p + 2;
+      p++;
+      continue;
+    }
+    const arg = args[i];
+    switch (next) {
+      case "s": {
+        if (typeof arg === "bigint") {
+          result += `${arg}n`;
+        } else if (typeof arg === "symbol") {
+          result += arg.toString();
+        } else if (typeof arg === "number" && Object.is(arg, -0)) {
+          result += "-0";
+        } else if (typeof arg === "object" && arg !== null) {
+          const proto = Object.getPrototypeOf(arg);
+          if (proto === null || typeof arg.toString === "function" && arg.toString !== Object.prototype.toString && arg.toString !== Array.prototype.toString) {
+            try {
+              const str = arg.toString();
+              if (typeof str === "string" && str !== "[object Object]") {
+                result += str;
+              } else {
+                result += inspect(arg, { depth: 0 });
+              }
+            } catch {
+              result += inspect(arg, { depth: 0 });
+            }
+          } else {
+            result += inspect(arg, { depth: 0 });
+          }
+        } else {
+          result += String(arg);
+        }
+        i++;
+        break;
+      }
+      case "d": {
+        if (typeof arg === "bigint") {
+          result += `${arg}n`;
+        } else if (typeof arg === "symbol") {
+          result += "NaN";
+        } else {
+          const n = Number(arg);
+          result += Object.is(n, -0) ? "-0" : String(n);
+        }
+        i++;
+        break;
+      }
+      case "i": {
+        if (typeof arg === "bigint") {
+          result += `${arg}n`;
+        } else if (typeof arg === "symbol") {
+          result += "NaN";
+        } else {
+          const n = Number(arg);
+          if (!isFinite(n)) {
+            result += "NaN";
+          } else {
+            const truncated = Math.trunc(n);
+            result += Object.is(truncated, -0) ? "-0" : String(truncated);
+          }
+        }
+        i++;
+        break;
+      }
+      case "f": {
+        if (typeof arg === "bigint") {
+          result += Number(arg).toString();
+        } else if (typeof arg === "symbol") {
+          result += "NaN";
+        } else {
+          const n = parseFloat(String(arg));
+          result += Object.is(n, -0) ? "-0" : String(n);
+        }
+        i++;
+        break;
+      }
+      case "j":
+        try {
+          result += JSON.stringify(args[i++]);
+        } catch {
+          result += "[Circular]";
+        }
+        break;
+      case "o":
+        result += inspect(args[i++], { showHidden: true, depth: 4 });
+        break;
+      case "O":
+        result += inspect(args[i++], { depth: 4 });
+        break;
+      default:
+        result += "%" + next;
+        break;
+    }
+    lastIdx = p + 2;
+    p++;
+  }
+  if (lastIdx < fmt.length) {
+    result += fmt.slice(lastIdx);
+  }
+  for (; i < args.length; i++) {
+    const arg = args[i];
+    if (typeof arg === "string") {
+      result += " " + arg;
+    } else {
+      result += " " + inspect(arg);
+    }
+  }
+  return result;
+}
+function formatWithOptions(inspectOptions, fmt, ...args) {
+  return format(fmt, ...args);
+}
+const kCustomPromisify = /* @__PURE__ */ Symbol.for("nodejs.util.promisify.custom");
+function promisify(fn) {
+  if (typeof fn !== "function") {
+    throw new TypeError('The "original" argument must be of type Function');
+  }
+  const custom = fn[kCustomPromisify];
+  if (typeof custom === "function") return custom;
+  function promisified(...args) {
+    return new Promise((resolve, reject) => {
+      fn.call(this, ...args, (err, ...values) => {
+        if (err) {
+          reject(err);
+        } else if (values.length <= 1) {
+          resolve(values[0]);
+        } else {
+          resolve(values);
+        }
+      });
+    });
+  }
+  Object.setPrototypeOf(promisified, Object.getPrototypeOf(fn));
+  Object.defineProperty(promisified, kCustomPromisify, { value: promisified });
+  return promisified;
+}
+promisify.custom = kCustomPromisify;
+function callbackify(fn) {
+  if (typeof fn !== "function") {
+    throw new TypeError('The "original" argument must be of type Function');
+  }
+  return function(...args) {
+    const callback = args.pop();
+    if (typeof callback !== "function") {
+      throw new TypeError("The last argument must be of type Function");
+    }
+    fn.apply(this, args).then(
+      (result) => Promise.resolve().then(() => callback(null, result)),
+      (err) => Promise.resolve().then(() => callback(err || new Error()))
+    );
+  };
+}
+function deprecate(fn, msg, code) {
+  let warned = false;
+  function deprecated(...args) {
+    if (!warned) {
+      warned = true;
+      const warning = code ? `[${code}] ${msg}` : msg;
+      console.warn(`DeprecationWarning: ${warning}`);
+    }
+    return fn.apply(this, args);
+  }
+  Object.setPrototypeOf(deprecated, fn);
+  return deprecated;
+}
+function debuglog(section) {
+  let debug;
+  return (...args) => {
+    if (debug === void 0) {
+      const nodeDebug = typeof globalThis.process?.env?.NODE_DEBUG === "string" ? globalThis.process.env.NODE_DEBUG : "";
+      const regex = new RegExp(`\\b${section}\\b`, "i");
+      if (regex.test(nodeDebug)) {
+        const pid = typeof globalThis.process?.pid === "number" ? globalThis.process.pid : 0;
+        debug = (...a) => {
+          console.error(`${section.toUpperCase()} ${pid}:`, ...a);
+        };
+      } else {
+        debug = () => {
+        };
+      }
+    }
+    debug(...args);
+  };
+}
+function inherits(ctor, superCtor) {
+  if (ctor === void 0 || ctor === null) {
+    throw new TypeError('The constructor to "inherits" must not be null or undefined');
+  }
+  if (superCtor === void 0 || superCtor === null) {
+    throw new TypeError('The super constructor to "inherits" must not be null or undefined');
+  }
+  if (superCtor.prototype === void 0) {
+    throw new TypeError('The super constructor to "inherits" must have a prototype');
+  }
+  Object.defineProperty(ctor, "super_", { value: superCtor, writable: true, configurable: true });
+  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isNull(value) {
+  return value === null;
+}
+function isNullOrUndefined(value) {
+  return value == null;
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function isError(value) {
+  return value instanceof Error;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isPrimitive(value) {
+  return value === null || typeof value !== "object" && typeof value !== "function";
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isBuffer(value) {
+  return value instanceof Uint8Array && value.constructor?.name === "Buffer";
+}
+const TextDecoder = globalThis.TextDecoder;
+const TextEncoder = globalThis.TextEncoder;
+function isDeepStrictEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object") return false;
+  const aObj = a;
+  const bObj = b;
+  if (Array.isArray(aObj) && Array.isArray(bObj)) {
+    if (aObj.length !== bObj.length) return false;
+    for (let i = 0; i < aObj.length; i++) {
+      if (!isDeepStrictEqual(aObj[i], bObj[i])) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(aObj) !== Array.isArray(bObj)) return false;
+  if (aObj instanceof Date && bObj instanceof Date) {
+    return aObj.getTime() === bObj.getTime();
+  }
+  if (aObj instanceof RegExp && bObj instanceof RegExp) {
+    return aObj.source === bObj.source && aObj.flags === bObj.flags;
+  }
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!Object.prototype.hasOwnProperty.call(bObj, key)) return false;
+    if (!isDeepStrictEqual(aObj[key], bObj[key])) return false;
+  }
+  return true;
+}
+function toUSVString(string) {
+  if (typeof string.toWellFormed === "function") {
+    return string.toWellFormed();
+  }
+  return string.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "\uFFFD");
+}
+var index_default = {
+  format,
+  formatWithOptions,
+  inspect,
+  promisify,
+  callbackify,
+  deprecate,
+  debuglog,
+  inherits,
+  types,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isString,
+  isSymbol,
+  isUndefined,
+  isObject,
+  isError,
+  isFunction,
+  isRegExp,
+  isArray,
+  isPrimitive,
+  isDate,
+  isBuffer,
+  isDeepStrictEqual,
+  toUSVString,
+  TextDecoder: globalThis.TextDecoder,
+  TextEncoder: globalThis.TextEncoder,
+  getSystemErrorName,
+  getSystemErrorMap
+};
 export {
-  src_default as default
+  TextDecoder,
+  TextEncoder,
+  callbackify,
+  debuglog,
+  index_default as default,
+  deprecate,
+  format,
+  formatWithOptions,
+  getSystemErrorMap,
+  getSystemErrorName,
+  inherits,
+  inspect,
+  isArray,
+  isBoolean,
+  isBuffer,
+  isDate,
+  isDeepStrictEqual,
+  isError,
+  isFunction,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isObject,
+  isPrimitive,
+  isRegExp,
+  isString,
+  isSymbol,
+  isUndefined,
+  promisify,
+  toUSVString,
+  types
 };