@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/logger/console.js

@@ -1,119 +1,96 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var console_exports = {};
-__export(console_exports, {
-  constructConsole: () => constructConsole,
-  ensurePrototypeInitialized: () => ensurePrototypeInitialized
-});
-module.exports = __toCommonJS(console_exports);
-var import_node_process = __toESM(require("node:process"));
-var import_object = require("../primordials/object");
-var import_reflect = require("../primordials/reflect");
-var import_internal = require("./_internal");
-var import_node = require("./node");
-var import_symbols = require("./symbols");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_primordials_object = require('../primordials/object.js');
+const require_primordials_reflect = require('../primordials/reflect.js');
+const require_logger__internal = require('./_internal.js');
+const require_logger_symbols = require('./symbols.js');
+const require_logger_node = require('./node.js');
+let node_process = require("node:process");
+node_process = require_runtime.__toESM(node_process);
+
+//#region src/logger/console.ts
+/**
+* @file Lazy `Console` construction + dynamic prototype mirroring for `Logger`.
+*   Both helpers exist as free functions (rather than `Logger` static methods)
+*   because:
+*
+*   - `constructConsole` caches the resolved `node:console` module so multiple
+*     `new Logger()` calls don't pay the require cost more than once. Caching
+*     at the function level is simpler than a class field that has to thread
+*     through all callers.
+*   - `ensurePrototypeInitialized` walks `globalConsole` once at first use and
+*     copies any console method that isn't already on `Logger.prototype`. Doing
+*     this lazily (rather than at module load) is what lets the logger be
+*     imported during early Node.js bootstrap before stdout is ready, which
+*     would otherwise crash with `ERR_CONSOLE_WRITABLE_STREAM`. Note on the
+*     apparent circular import with `core.ts`: `ensurePrototypeInitialized`
+*     mutates `Logger.prototype`, so it imports `Logger` from `./core`.
+*     `core.ts` calls `ensurePrototypeInitialized()` from inside a method body,
+*     so the import cycle never resolves at module-load time — by the time
+*     `ensurePrototypeInitialized` actually runs, both modules are fully
+*     evaluated. Same pattern as `fs/path-cache` ↔ `fs/_internal`.
+*/
 let _Console;
 let _prototypeInitialized = false;
-// @__NO_SIDE_EFFECTS__
+/**
+* Construct a new Console instance.
+*/
+/* @__NO_SIDE_EFFECTS__ */
 function constructConsole(...args) {
-  if (_Console === void 0) {
-    const nodeConsole = require("node:console");
-    _Console = nodeConsole.Console;
-  }
-  return (0, import_reflect.ReflectConstruct)(
-    _Console,
-    // eslint-disable-line no-undef
-    args
-  );
+	/* c8 ignore next - Lazy-init second-call branch; module-singleton. */
+	if (_Console === void 0) _Console = (/* @__PURE__ */ require("node:console")).Console;
+	return require_primordials_reflect.ReflectConstruct(_Console, args);
 }
+/**
+* Lazily add dynamic console methods to Logger prototype.
+*
+* This is deferred until first access to avoid calling
+* Object.entries(globalConsole) during early Node.js bootstrap before stdout is
+* ready.
+*/
 function ensurePrototypeInitialized() {
-  if (_prototypeInitialized) {
-    return;
-  }
-  _prototypeInitialized = true;
-  const entries = [
-    [
-      (0, import_symbols.getKGroupIndentationWidthSymbol)(),
-      {
-        ...import_internal.consolePropAttributes,
-        value: 2
-      }
-    ],
-    [
-      Symbol.toStringTag,
-      {
-        __proto__: null,
-        configurable: true,
-        value: "logger"
-      }
-    ]
-  ];
-  for (const { 0: key, 1: value } of (0, import_object.ObjectEntries)(import_internal.globalConsole)) {
-    if (!import_node.Logger.prototype[key] && typeof value === "function") {
-      const { [key]: func } = {
-        [key](...args) {
-          let con = import_internal.privateConsole.get(this);
-          if (con === void 0) {
-            const ctorArgs = import_internal.privateConstructorArgs.get(this) ?? [];
-            import_internal.privateConstructorArgs.delete(this);
-            if (ctorArgs.length) {
-              con = /* @__PURE__ */ constructConsole(...ctorArgs);
-            } else {
-              con = /* @__PURE__ */ constructConsole({
-                stdout: import_node_process.default.stdout,
-                stderr: import_node_process.default.stderr
-              });
-              for (const { 0: k, 1: method } of import_internal.boundConsoleEntries) {
-                con[k] = method;
-              }
-            }
-            import_internal.privateConsole.set(this, con);
-          }
-          const result = con[key](...args);
-          return result === void 0 || result === con ? this : result;
-        }
-      };
-      entries.push([
-        key,
-        {
-          ...import_internal.consolePropAttributes,
-          value: func
-        }
-      ]);
-    }
-  }
-  (0, import_object.ObjectDefineProperties)(import_node.Logger.prototype, (0, import_object.ObjectFromEntries)(entries));
+	if (_prototypeInitialized) return;
+	_prototypeInitialized = true;
+	const entries = [[require_logger_symbols.getKGroupIndentationWidthSymbol(), {
+		...require_logger__internal.consolePropAttributes,
+		value: 2
+	}], [Symbol.toStringTag, {
+		__proto__: null,
+		configurable: true,
+		value: "logger"
+	}]];
+	for (const { 0: key, 1: value } of require_primordials_object.ObjectEntries(require_logger__internal.globalConsole)) if (!require_logger_node.Logger.prototype[key] && typeof value === "function") {
+		const { [key]: func } = { [key](...args) {
+			/* c8 ignore start */
+			let con = require_logger__internal.privateConsole.get(this);
+			if (con === void 0) {
+				const ctorArgs = require_logger__internal.privateConstructorArgs.get(this) ?? [];
+				require_logger__internal.privateConstructorArgs.delete(this);
+				if (ctorArgs.length) con = /* @__PURE__ */ constructConsole(...ctorArgs);
+				else {
+					con = /* @__PURE__ */ constructConsole({
+						stdout: node_process.default.stdout,
+						stderr: node_process.default.stderr
+					});
+					for (const { 0: k, 1: method } of require_logger__internal.boundConsoleEntries) con[k] = method;
+				}
+				require_logger__internal.privateConsole.set(this, con);
+			}
+			/* c8 ignore stop */
+			const result = con[key](...args);
+			/* c8 ignore next */
+			return result === void 0 || result === con ? this : result;
+		} };
+		entries.push([key, {
+			...require_logger__internal.consolePropAttributes,
+			value: func
+		}]);
+	}
+	require_primordials_object.ObjectDefineProperties(require_logger_node.Logger.prototype, require_primordials_object.ObjectFromEntries(entries));
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  constructConsole,
-  ensurePrototypeInitialized
-});
+
+//#endregion
+exports.constructConsole = constructConsole;
+exports.ensurePrototypeInitialized = ensurePrototypeInitialized;

package/dist/logger/default.js

@@ -1,37 +1,23 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var default_exports = {};
-__export(default_exports, {
-  getDefaultLogger: () => getDefaultLogger
-});
-module.exports = __toCommonJS(default_exports);
-var import_logger = require("./logger");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_logger_node = require('./node.js');
+
+//#region src/logger/default.ts
+/**
+* @file Shared-default `Logger` singleton. One process-wide instance,
+*   constructed lazily on first call so importing the module during early
+*   bootstrap doesn't try to resolve `node:console` before stdout is ready
+*   (Node side) or touch `globalThis.console` during a service-worker cold
+*   start (browser side). The `Logger` class itself comes from `./logger`,
+*   which the package.json `'browser'` condition routes to the right
+*   implementation per platform.
+*/
 let sharedLogger;
 function getDefaultLogger() {
-  if (sharedLogger === void 0) {
-    sharedLogger = new import_logger.Logger();
-  }
-  return sharedLogger;
+	if (sharedLogger === void 0) sharedLogger = new require_logger_node.Logger();
+	return sharedLogger;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getDefaultLogger
-});
+
+//#endregion
+exports.getDefaultLogger = getDefaultLogger;

package/dist/logger/logger.js

@@ -1,30 +1,6 @@
 "use strict";
-/* Socket Lib - Built with esbuild */
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var logger_exports = {};
-__export(logger_exports, {
-  Logger: () => import_node.Logger
-});
-module.exports = __toCommonJS(logger_exports);
-var import_node = require("./node");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Logger
-});
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_logger_node = require('./node.js');
+
+exports.Logger = require_logger_node.Logger;