Use Buffer.isBuffer and node:util/types in util module

src/bun.js/module_loader.zig

@@ -1810,6 +1810,17 @@ pub const ModuleLoader = struct {
                         .hash = 0,
                     };
                 },
+                .@"node:util" => {
+                    return ResolvedSource{
+                        .allocator = null,
+                        .source_code = ZigString.init(
+                            @as(string, jsModuleFromFile(jsc_vm.load_builtins_from_path, "./util.exports.js")),
+                        ),
+                        .specifier = ZigString.init("node:util"),
+                        .source_url = ZigString.init("node:util"),
+                        .hash = 0,
+                    };
+                },
                 .@"undici" => {
                     return ResolvedSource{
                         .allocator = null,
@@ -1985,6 +1996,7 @@ pub const HardcodedModule = enum {
     @"node:timers/promises",
     @"node:tty",
     @"node:url",
+    @"node:util",
     @"node:util/types",
     @"undici",
     @"ws",
@@ -2026,6 +2038,7 @@ pub const HardcodedModule = enum {
             .{ "node:timers/promises", HardcodedModule.@"node:timers/promises" },
             .{ "node:tty", HardcodedModule.@"node:tty" },
             .{ "node:url", HardcodedModule.@"node:url" },
+            .{ "node:util", HardcodedModule.@"node:util" },
             .{ "node:util/types", HardcodedModule.@"node:util/types" },
             .{ "undici", HardcodedModule.@"undici" },
             .{ "ws", HardcodedModule.@"ws" },
@@ -2036,11 +2049,11 @@ pub const HardcodedModule = enum {
         .{
             .{ "assert", "node:assert" },
             .{ "buffer", "node:buffer" },
+            .{ "bun", "bun" },
             .{ "bun:ffi", "bun:ffi" },
             .{ "bun:jsc", "bun:jsc" },
             .{ "bun:sqlite", "bun:sqlite" },
             .{ "bun:wrap", "bun:wrap" },
-            .{ "bun", "bun" },
             .{ "child_process", "node:child_process" },
             .{ "depd", "depd" },
             .{ "detect-libc", "detect-libc" },
@@ -2078,6 +2091,7 @@ pub const HardcodedModule = enum {
             .{ "node:tty", "node:tty" },
             .{ "node:url", "node:url" },
             .{ "node:util", "node:util" },
+            .{ "node:util/types", "node:util/types" },
             .{ "os", "node:os" },
             .{ "path", "node:path" },
             .{ "path/posix", "node:path/posix" },
@@ -2097,6 +2111,7 @@ pub const HardcodedModule = enum {
             .{ "undici", "undici" },
             .{ "url", "node:url" },
             .{ "util", "node:util" },
+            .{ "util/types", "node:util/types" },
             .{ "ws", "ws" },
             .{ "ws/lib/websocket", "ws" },
         },

src/bun.js/util.exports.js

@@ -0,0 +1,635 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) =>
+  function __require() {
+    return (
+      mod ||
+        (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod),
+      mod.exports
+    );
+  };
+export function isBuffer(value) {
+  return (
+    Buffer.isBuffer(value) ||
+    // incase it ends up as a browserify buffer
+    (typeof arg?.copy === "function" &&
+      typeof arg?.fill === "function" &&
+      typeof arg?.readUInt8 === "function")
+  );
+}
+
+// node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/inherits/inherits_browser.js"(exports, module2) {
+    module2.exports = function inherits(ctor, superCtor) {
+      ctor.super_ = superCtor;
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true,
+        },
+      });
+    };
+  },
+});
+
+const exports = {};
+var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
+var formatRegExp = /%[sdj%]/g;
+function format(f) {
+  if (!isString(f)) {
+    var objects = [];
+    for (var i = 0; i < arguments.length; i++) {
+      objects.push(inspect(arguments[i]));
+    }
+    return objects.join(" ");
+  }
+  var i = 1;
+  var args = arguments;
+  var len = args.length;
+  var str = String(f).replace(formatRegExp, function (x2) {
+    if (x2 === "%%") return "%";
+    if (i >= len) return x2;
+    switch (x2) {
+      case "%s":
+        return String(args[i++]);
+      case "%d":
+        return Number(args[i++]);
+      case "%j":
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return "[Circular]";
+        }
+      default:
+        return x2;
+    }
+  });
+  for (var x = args[i]; i < len; x = args[++i]) {
+    if (isNull(x) || !isObject(x)) {
+      str += " " + x;
+    } else {
+      str += " " + inspect(x);
+    }
+  }
+  return str;
+}
+exports.format = format;
+function deprecate(fn, msg) {
+  if (typeof process !== "undefined" && process.noDeprecation === true) {
+    return fn;
+  }
+  if (typeof process === "undefined") {
+    return function () {
+      return exports.deprecate(fn, msg).apply(this, arguments);
+    };
+  }
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (process.throwDeprecation) {
+        throw new Error(msg);
+      } else if (process.traceDeprecation) {
+        console.trace(msg);
+      } else {
+        console.error(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
+  return deprecated;
+}
+exports.deprecate = deprecate;
+var debugs = {};
+var debugEnvRegex = /^$/;
+if (process.env.NODE_DEBUG) {
+  debugEnv = process.env.NODE_DEBUG;
+  debugEnv = debugEnv
+    .replace(/[|\\{}()[\]^$+?.]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/,/g, "$|^")
+    .toUpperCase();
+  debugEnvRegex = new RegExp("^" + debugEnv + "$", "i");
+}
+var debugEnv;
+function debuglog(set) {
+  set = set.toUpperCase();
+  if (!debugs[set]) {
+    if (debugEnvRegex.test(set)) {
+      var pid = process.pid;
+      debugs[set] = function () {
+        var msg = exports.format.apply(exports, arguments);
+        console.error("%s %d: %s", set, pid, msg);
+      };
+    } else {
+      debugs[set] = function () {};
+    }
+  }
+  return debugs[set];
+}
+exports.debuglog = debuglog;
+function inspect(obj, opts) {
+  var ctx = {
+    seen: [],
+    stylize: stylizeNoColor,
+  };
+  if (arguments.length >= 3) ctx.depth = arguments[2];
+  if (arguments.length >= 4) ctx.colors = arguments[3];
+  if (isBoolean(opts)) {
+    ctx.showHidden = opts;
+  } else if (opts) {
+    exports._extend(ctx, opts);
+  }
+  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+  if (isUndefined(ctx.depth)) ctx.depth = 2;
+  if (isUndefined(ctx.colors)) ctx.colors = false;
+  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+  if (ctx.colors) ctx.stylize = stylizeWithColor;
+  return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+inspect.colors = {
+  bold: [1, 22],
+  italic: [3, 23],
+  underline: [4, 24],
+  inverse: [7, 27],
+  white: [37, 39],
+  grey: [90, 39],
+  black: [30, 39],
+  blue: [34, 39],
+  cyan: [36, 39],
+  green: [32, 39],
+  magenta: [35, 39],
+  red: [31, 39],
+  yellow: [33, 39],
+};
+inspect.styles = {
+  special: "cyan",
+  number: "yellow",
+  boolean: "yellow",
+  undefined: "grey",
+  null: "bold",
+  string: "green",
+  date: "magenta",
+  regexp: "red",
+};
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+  if (style) {
+    return (
+      "\x1B[" +
+      inspect.colors[style][0] +
+      "m" +
+      str +
+      "\x1B[" +
+      inspect.colors[style][1] +
+      "m"
+    );
+  } else {
+    return str;
+  }
+}
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+function arrayToHash(array) {
+  var hash = {};
+  array.forEach(function (val, idx) {
+    hash[val] = true;
+  });
+  return hash;
+}
+function formatValue(ctx, value, recurseTimes) {
+  if (
+    ctx.customInspect &&
+    value &&
+    isFunction(value.inspect) &&
+    value.inspect !== exports.inspect &&
+    !(value.constructor && value.constructor.prototype === value)
+  ) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret)) {
+      ret = formatValue(ctx, ret, recurseTimes);
+    }
+    return ret;
+  }
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive) {
+    return primitive;
+  }
+  var keys = Object.keys(value);
+  var visibleKeys = arrayToHash(keys);
+  if (ctx.showHidden) {
+    keys = Object.getOwnPropertyNames(value);
+  }
+  if (
+    isError(value) &&
+    (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)
+  ) {
+    return formatError(value);
+  }
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ": " + value.name : "";
+      return ctx.stylize("[Function" + name + "]", "special");
+    }
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+    }
+    if (isDate(value)) {
+      return ctx.stylize(Date.prototype.toString.call(value), "date");
+    }
+    if (isError(value)) {
+      return formatError(value);
+    }
+  }
+  var base = "",
+    array = false,
+    braces = ["{", "}"];
+  if (isArray(value)) {
+    array = true;
+    braces = ["[", "]"];
+  }
+  if (isFunction(value)) {
+    var n = value.name ? ": " + value.name : "";
+    base = " [Function" + n + "]";
+  }
+  if (isRegExp(value)) {
+    base = " " + RegExp.prototype.toString.call(value);
+  }
+  if (isDate(value)) {
+    base = " " + Date.prototype.toUTCString.call(value);
+  }
+  if (isError(value)) {
+    base = " " + formatError(value);
+  }
+  if (keys.length === 0 && (!array || value.length == 0)) {
+    return braces[0] + base + braces[1];
+  }
+  if (recurseTimes < 0) {
+    if (isRegExp(value)) {
+      return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+    } else {
+      return ctx.stylize("[Object]", "special");
+    }
+  }
+  ctx.seen.push(value);
+  var output;
+  if (array) {
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  } else {
+    output = keys.map(function (key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  }
+  ctx.seen.pop();
+  return reduceToSingleString(output, base, braces);
+}
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
+  if (isString(value)) {
+    var simple =
+      "'" +
+      JSON.stringify(value)
+        .replace(/^"|"$/g, "")
+        .replace(/'/g, "\\'")
+        .replace(/\\"/g, '"') +
+      "'";
+    return ctx.stylize(simple, "string");
+  }
+  if (isNumber(value)) return ctx.stylize("" + value, "number");
+  if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
+  if (isNull(value)) return ctx.stylize("null", "null");
+}
+function formatError(value) {
+  return "[" + Error.prototype.toString.call(value) + "]";
+}
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length; i < l; ++i) {
+    if (hasOwnProperty(value, String(i))) {
+      output.push(
+        formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true),
+      );
+    } else {
+      output.push("");
+    }
+  }
+  keys.forEach(function (key) {
+    if (!key.match(/^\d+$/)) {
+      output.push(
+        formatProperty(ctx, value, recurseTimes, visibleKeys, key, true),
+      );
+    }
+  });
+  return output;
+}
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  desc = Object.getOwnPropertyDescriptor(value, key) || {
+    value: value[key],
+  };
+  if (desc.get) {
+    if (desc.set) {
+      str = ctx.stylize("[Getter/Setter]", "special");
+    } else {
+      str = ctx.stylize("[Getter]", "special");
+    }
+  } else {
+    if (desc.set) {
+      str = ctx.stylize("[Setter]", "special");
+    }
+  }
+  if (!hasOwnProperty(visibleKeys, key)) {
+    name = "[" + key + "]";
+  }
+  if (!str) {
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes)) {
+        str = formatValue(ctx, desc.value, null);
+      } else {
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      }
+      if (str.indexOf("\n") > -1) {
+        if (array) {
+          str = str
+            .split("\n")
+            .map(function (line) {
+              return "  " + line;
+            })
+            .join("\n")
+            .substr(2);
+        } else {
+          str =
+            "\n" +
+            str
+              .split("\n")
+              .map(function (line) {
+                return "   " + line;
+              })
+              .join("\n");
+        }
+      }
+    } else {
+      str = ctx.stylize("[Circular]", "special");
+    }
+  }
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/)) {
+      return str;
+    }
+    name = JSON.stringify("" + key);
+    if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+      name = name.substr(1, name.length - 2);
+      name = ctx.stylize(name, "name");
+    } else {
+      name = name
+        .replace(/'/g, "\\'")
+        .replace(/\\"/g, '"')
+        .replace(/(^"|"$)/g, "'");
+      name = ctx.stylize(name, "string");
+    }
+  }
+  return name + ": " + str;
+}
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0;
+  var length = output.reduce(function (prev, cur) {
+    numLinesEst++;
+    if (cur.indexOf("\n") >= 0) numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+  }, 0);
+  if (length > 60) {
+    return (
+      braces[0] +
+      (base === "" ? "" : base + "\n ") +
+      " " +
+      output.join(",\n  ") +
+      " " +
+      braces[1]
+    );
+  }
+  return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+}
+const types = import.meta.require("node:util/types");
+exports.types = types;
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+exports.isArray = isArray;
+function isBoolean(arg) {
+  return typeof arg === "boolean";
+}
+exports.isBoolean = isBoolean;
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+exports.isNumber = isNumber;
+function isString(arg) {
+  return typeof arg === "string";
+}
+exports.isString = isString;
+function isSymbol(arg) {
+  return typeof arg === "symbol";
+}
+exports.isSymbol = isSymbol;
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+var isRegExp = (exports.isRegExp = exports.types.isRegExp);
+function isObject(arg) {
+  return typeof arg === "object" && arg !== null;
+}
+exports.isObject = isObject;
+var isDate = (exports.isDate = exports.types.isDate);
+var isError = (exports.isError = exports.types.isNativeError);
+function isFunction(arg) {
+  return typeof arg === "function";
+}
+var isFunction = (exports.isFunction = isFunction);
+function isPrimitive(arg) {
+  return (
+    arg === null ||
+    typeof arg === "boolean" ||
+    typeof arg === "number" ||
+    typeof arg === "string" ||
+    typeof arg === "symbol" ||
+    typeof arg === "undefined"
+  );
+}
+exports.isPrimitive = isPrimitive;
+exports.isBuffer = isBuffer;
+function pad(n) {
+  return n < 10 ? "0" + n.toString(10) : n.toString(10);
+}
+var months = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+function timestamp() {
+  var d = new Date();
+  var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(
+    ":",
+  );
+  return [d.getDate(), months[d.getMonth()], time].join(" ");
+}
+var log = (exports.log = function () {
+  console.log("%s - %s", timestamp(), exports.format.apply(exports, arguments));
+});
+var inherits = (exports.inherits = require_inherits_browser());
+var _extend = (exports._extend = function (origin, add) {
+  if (!add || !isObject(add)) return origin;
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin;
+});
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+var kCustomPromisifiedSymbol =
+  typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+var promisify = (exports.promisify = function promisify(original) {
+  if (typeof original !== "function")
+    throw new TypeError('The "original" argument must be of type Function');
+  if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+    var fn = original[kCustomPromisifiedSymbol];
+    if (typeof fn !== "function") {
+      throw new TypeError(
+        'The "util.promisify.custom" argument must be of type Function',
+      );
+    }
+    Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+      value: fn,
+      enumerable: false,
+      writable: false,
+      configurable: true,
+    });
+    return fn;
+  }
+  function fn() {
+    var promiseResolve, promiseReject;
+    var promise = new Promise(function (resolve, reject) {
+      promiseResolve = resolve;
+      promiseReject = reject;
+    });
+    var args = [];
+    for (var i = 0; i < arguments.length; i++) {
+      args.push(arguments[i]);
+    }
+    args.push(function (err, value) {
+      if (err) {
+        promiseReject(err);
+      } else {
+        promiseResolve(value);
+      }
+    });
+    try {
+      original.apply(this, args);
+    } catch (err) {
+      promiseReject(err);
+    }
+    return promise;
+  }
+  Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+  if (kCustomPromisifiedSymbol)
+    Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+      value: fn,
+      enumerable: false,
+      writable: false,
+      configurable: true,
+    });
+  return Object.defineProperties(fn, getOwnPropertyDescriptors(original));
+});
+exports.promisify.custom = kCustomPromisifiedSymbol;
+function callbackifyOnRejected(reason, cb) {
+  if (!reason) {
+    var newReason = new Error("Promise was rejected with a falsy value");
+    newReason.reason = reason;
+    reason = newReason;
+  }
+  return cb(reason);
+}
+function callbackify(original) {
+  if (typeof original !== "function") {
+    throw new TypeError('The "original" argument must be of type Function');
+  }
+  function callbackified() {
+    var args = [];
+    for (var i = 0; i < arguments.length; i++) {
+      args.push(arguments[i]);
+    }
+    var maybeCb = args.pop();
+    if (typeof maybeCb !== "function") {
+      throw new TypeError("The last argument must be of type Function");
+    }
+    var self = this;
+    var cb = function () {
+      return maybeCb.apply(self, arguments);
+    };
+    original.apply(this, args).then(
+      function (ret) {
+        process.nextTick(cb, null, null, ret);
+      },
+      function (rej) {
+        process.nextTick(callbackifyOnRejected, null, rej, cb);
+      },
+    );
+  }
+  Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
+  Object.defineProperties(callbackified, getOwnPropertyDescriptors(original));
+  return callbackified;
+}
+exports.callbackify = callbackify;
+export var TextEncoder = (exports.TextDecoder = globalThis.TextEncoder);
+export var TextDecoder = (exports.TextEncoder = globalThis.TextDecoder);
+exports[Symbol.for("CommonJS")] = 0;
+export default exports;
+
+export {
+  format,
+  deprecate,
+  debuglog,
+  inspect,
+  isArray,
+  isBoolean,
+  isNull,
+  isNullOrUndefined,
+  isNumber,
+  isString,
+  isSymbol,
+  isUndefined,
+  isRegExp,
+  isObject,
+  isDate,
+  isError,
+  isFunction,
+  isPrimitive,
+  log,
+  inherits,
+  promisify,
+  callbackify,
+};