@socketsecurity/lib 6.0.2 → 6.0.4

package/dist/tables/padding.js

@@ -1,51 +1,41 @@
 "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 padding_exports = {};
-__export(padding_exports, {
-  displayWidth: () => displayWidth,
-  padText: () => padText
-});
-module.exports = __toCommonJS(padding_exports);
-var import_math = require("../primordials/math");
-var import_width = require("../strings/width");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_math = require('../primordials/math.js');
+const require_strings_width = require('../strings/width.js');
+
+//#region src/tables/padding.ts
+/**
+* @file Cell padding + display-width measurement — shared helpers used by both
+*   the simple and bordered table renderers. `displayWidth` routes through
+*   `stringWidth` so multi-cell glyphs (full-width CJK, emoji, combined code
+*   points) contribute their actual terminal column count rather than a naive
+*   `.length`.
+*/
+/**
+* Calculate display width accounting for ANSI codes, CJK, and emoji. Uses
+* `stringWidth` so multi-cell glyphs (full-width CJK, emoji, combined code
+* points) contribute their actual terminal column count to padding.
+*/
 function displayWidth(text) {
-  return (0, import_width.stringWidth)(text);
+	return /* @__PURE__ */ require_strings_width.stringWidth(text);
 }
+/**
+* Pad text to specified width with alignment.
+*/
 function padText(text, width, align = "left") {
-  const textWidth = displayWidth(text);
-  const padding = (0, import_math.MathMax)(0, width - textWidth);
-  switch (align) {
-    case "right":
-      return " ".repeat(padding) + text;
-    case "center": {
-      const leftPad = Math.floor(padding / 2);
-      const rightPad = padding - leftPad;
-      return " ".repeat(leftPad) + text + " ".repeat(rightPad);
-    }
-    default:
-      return text + " ".repeat(padding);
-  }
+	const padding = require_primordials_math.MathMax(0, width - displayWidth(text));
+	switch (align) {
+		case "right": return " ".repeat(padding) + text;
+		case "center": {
+			const leftPad = Math.floor(padding / 2);
+			const rightPad = padding - leftPad;
+			return " ".repeat(leftPad) + text + " ".repeat(rightPad);
+		}
+		default: return text + " ".repeat(padding);
+	}
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  displayWidth,
-  padText
-});
+
+//#endregion
+exports.displayWidth = displayWidth;
+exports.padText = padText;

package/dist/tables/simple.js

@@ -1,73 +1,65 @@
 "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 simple_exports = {};
-__export(simple_exports, {
-  formatSimpleTable: () => formatSimpleTable
-});
-module.exports = __toCommonJS(simple_exports);
-var import_yoctocolors_cjs = __toESM(require("../external/yoctocolors-cjs"));
-var import_array = require("../primordials/array");
-var import_math = require("../primordials/math");
-var import_padding = require("./padding");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_primordials_math = require('../primordials/math.js');
+const require_primordials_array = require('../primordials/array.js');
+const require_tables_padding = require('./padding.js');
+let src_external_yoctocolors_cjs = require("../external/yoctocolors-cjs");
+src_external_yoctocolors_cjs = require_runtime.__toESM(src_external_yoctocolors_cjs);
+
+//#region src/tables/simple.ts
+/**
+* @file Borderless table renderer — columns separated by two spaces, header
+*   underlined with `─`. Lighter weight than `formatTable` (no box-drawing
+*   characters); the right choice when the surface is rendering to a context
+*   that doesn't reliably support box-drawing glyphs.
+*/
+/**
+* Format data as a simple table without borders. Lighter weight alternative to
+* formatTable().
+*
+* @example
+*   import { formatSimpleTable } from '@socketsecurity/lib/tables/simple'
+*   import colors from 'yoctocolors-cjs'
+*
+*   const data = [
+*     { name: 'lodash', version: '4.17.21' },
+*     { name: 'react', version: '18.2.0' },
+*   ]
+*   const columns = [
+*     { key: 'name', header: 'Package' },
+*     { key: 'version', header: 'Version' },
+*   ]
+*   console.log(formatSimpleTable(data, columns))
+*   // Output:
+*   // Package  Version
+*   // ───────  ───────
+*   // lodash   4.17.21
+*   // react    18.2.0
+*
+* @param data - Array of data objects.
+* @param columns - Column configuration.
+*
+* @returns Formatted table string
+*/
 function formatSimpleTable(data, columns) {
-  if (data.length === 0) {
-    return "(no data)";
-  }
-  const widths = columns.map((col) => {
-    const headerWidth = (0, import_padding.displayWidth)(col.header);
-    const maxDataWidth = (0, import_math.MathMax)(
-      ...data.map((row) => (0, import_padding.displayWidth)(String(row[col.key] ?? "")))
-    );
-    return col.width ?? (0, import_math.MathMax)(headerWidth, maxDataWidth);
-  });
-  const lines = [];
-  const headerCells = columns.map(
-    (col, i) => (0, import_padding.padText)(import_yoctocolors_cjs.default.bold(col.header), widths[i], col.align)
-  );
-  (0, import_array.ArrayPrototypePush)(lines, headerCells.join("  "));
-  const separators = widths.map((w) => import_yoctocolors_cjs.default.dim("\u2500".repeat(w)));
-  (0, import_array.ArrayPrototypePush)(lines, separators.join("  "));
-  for (const row of data) {
-    const cells = columns.map((col, i) => {
-      let value = String(row[col.key] ?? "");
-      if (col.color) {
-        value = col.color(value);
-      }
-      return (0, import_padding.padText)(value, widths[i], col.align);
-    });
-    (0, import_array.ArrayPrototypePush)(lines, cells.join("  "));
-  }
-  return lines.join("\n");
+	if (data.length === 0) return "(no data)";
+	const widths = columns.map((col) => {
+		const headerWidth = require_tables_padding.displayWidth(col.header);
+		const maxDataWidth = require_primordials_math.MathMax(...data.map((row) => require_tables_padding.displayWidth(String(row[col.key] ?? ""))));
+		return col.width ?? require_primordials_math.MathMax(headerWidth, maxDataWidth);
+	});
+	const lines = [];
+	require_primordials_array.ArrayPrototypePush(lines, columns.map((col, i) => require_tables_padding.padText(src_external_yoctocolors_cjs.default.bold(col.header), widths[i], col.align)).join("  "));
+	require_primordials_array.ArrayPrototypePush(lines, widths.map((w) => src_external_yoctocolors_cjs.default.dim("─".repeat(w))).join("  "));
+	for (const row of data) require_primordials_array.ArrayPrototypePush(lines, columns.map((col, i) => {
+		let value = String(row[col.key] ?? "");
+		if (col.color) value = col.color(value);
+		return require_tables_padding.padText(value, widths[i], col.align);
+	}).join("  "));
+	return lines.join("\n");
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  formatSimpleTable
-});
+
+//#endregion
+exports.formatSimpleTable = formatSimpleTable;

package/dist/tables/types.js

@@ -1,18 +1,2 @@
 "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 __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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+/* Socket Lib - Built with rolldown */

package/dist/temporal/instant.js

@@ -1,91 +1,82 @@
 "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 instant_exports = {};
-__export(instant_exports, {
-  Instant: () => Instant,
-  describe: () => describe,
-  epochNanosecondsImpl: () => epochNanosecondsImpl,
-  isValidEpochNanoseconds: () => isValidEpochNanoseconds
-});
-module.exports = __toCommonJS(instant_exports);
-var import_globals = require("../primordials/globals");
-var import_error = require("../primordials/error");
-var import_slots = require("./slots");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../primordials/error.js');
+const require_primordials_globals = require('../primordials/globals.js');
+const require_temporal_slots = require('./slots.js');
+
+//#region src/temporal/instant.ts
+/**
+* @file Spec clause 8 — Temporal.Instant Objects. Implements the class,
+*   constructor, and the validity predicate. Pass 1 of the rollout; statics
+*   (`from`, `fromEpochMilliseconds`, `compare`) and prototype operations
+*   (`epochMilliseconds`, `toString`, arithmetic) follow in pass 2. Spec:
+*   https://tc39.es/proposal-temporal/#sec-temporal-instant-objects Ref:
+*   js-temporal/temporal-polyfill `lib/instant.ts` Operations implemented (✓)
+*   and intentionally absent (✗), in section order so a reader can scan against
+*   the spec: ✓ 8.1.1 Temporal.Instant ( epochNanoseconds ) — constructor ✓
+*   8.1.1.x IsValidEpochNanoseconds ( epochNanoseconds ) — abstract op ✓ 8.5.6
+*   get Temporal.Instant.prototype.epochNanoseconds — prototype ✗ 8.4.2
+*   Temporal.Instant.from ( item ) — pass 2 ✗ 8.4.3
+*   Temporal.Instant.fromEpochMilliseconds ( ms ) — pass 2 ✗ 8.4.7
+*   Temporal.Instant.compare ( one, two ) — pass 2 ✗ 8.5.5 get
+*   Temporal.Instant.prototype.epochMilliseconds — pass 2 ✗ 8.5.13
+*   Temporal.Instant.prototype.toString ( [ options ] ) — pass 2 ✗ 8.5.x add /
+*   subtract / until / since / round / equals / etc. — later.
+*/
 const NS_MAX_INSTANT = 8640000000000000000000n;
-const NS_MIN_INSTANT = -NS_MAX_INSTANT;
+const NS_MIN_INSTANT = -8640000000000000000000n;
+/**
+* Spec's IsValidEpochNanoseconds. Exported for testability.
+*/
 function isValidEpochNanoseconds(epochNanoseconds) {
-  if (epochNanoseconds < NS_MIN_INSTANT || epochNanoseconds > NS_MAX_INSTANT) {
-    return false;
-  }
-  return true;
-}
-class Instant {
-  constructor(epochNanoseconds) {
-    let ns;
-    try {
-      ns = (0, import_globals.BigIntCtor)(epochNanoseconds);
-    } catch {
-      throw new import_error.TypeErrorCtor(
-        `Temporal.Instant: epochNanoseconds must be coercible to BigInt; saw ${describe(epochNanoseconds)}. Pass a bigint literal (e.g. 1700000000000000000n) or a numeric string.`
-      );
-    }
-    if (!isValidEpochNanoseconds(ns)) {
-      throw new import_error.RangeErrorCtor(
-        `Temporal.Instant: epochNanoseconds out of range; saw ${ns}n. Must be in [-8.64e21, 8.64e21] (\xB1100,000,000 days from 1970-01-01T00:00:00Z).`
-      );
-    }
-    (0, import_slots.setInstantSlots)(this, ns);
-  }
+	if (epochNanoseconds < NS_MIN_INSTANT || epochNanoseconds > NS_MAX_INSTANT) return false;
+	return true;
 }
+/**
+* Temporal.Instant — an exact, nanosecond-resolution point on the UTC timeline.
+* Backed by a `bigint` `[[Nanoseconds]]` slot in the range ±8.64e21 (±100
+* million days from the Unix epoch).
+*
+* Construct via `new Temporal.Instant(epochNanoseconds)` or, in pass 2, the
+* various `from*` statics.
+*/
+var Instant = class {
+	constructor(epochNanoseconds) {
+		let ns;
+		try {
+			ns = require_primordials_globals.BigIntCtor(epochNanoseconds);
+		} catch {
+			throw new require_primordials_error.TypeErrorCtor(`Temporal.Instant: epochNanoseconds must be coercible to BigInt; saw ${describe(epochNanoseconds)}. Pass a bigint literal (e.g. 1700000000000000000n) or a numeric string.`);
+		}
+		if (!isValidEpochNanoseconds(ns)) throw new require_primordials_error.RangeErrorCtor(`Temporal.Instant: epochNanoseconds out of range; saw ${ns}n. Must be in [-8.64e21, 8.64e21] (±100,000,000 days from 1970-01-01T00:00:00Z).`);
+		require_temporal_slots.setInstantSlots(this, ns);
+	}
+};
 function epochNanosecondsImpl() {
-  const instant = this;
-  if (!(0, import_slots.hasInstantSlot)(instant)) {
-    throw new import_error.TypeErrorCtor(
-      `Temporal.Instant.prototype.epochNanoseconds: receiver lacks [[InitializedTemporalInstant]] internal slot; saw ${describe(instant)}. Call on a Temporal.Instant instance constructed via 'new Temporal.Instant(\u2026)'.`
-    );
-  }
-  const ns = (0, import_slots.getInstantNanoseconds)(instant);
-  return ns;
+	const instant = this;
+	if (!require_temporal_slots.hasInstantSlot(instant)) throw new require_primordials_error.TypeErrorCtor(`Temporal.Instant.prototype.epochNanoseconds: receiver lacks [[InitializedTemporalInstant]] internal slot; saw ${describe(instant)}. Call on a Temporal.Instant instance constructed via 'new Temporal.Instant(…)'.`);
+	return require_temporal_slots.getInstantNanoseconds(instant);
 }
 Object.defineProperty(Instant.prototype, "epochNanoseconds", {
-  get: epochNanosecondsImpl,
-  configurable: true
+	get: epochNanosecondsImpl,
+	configurable: true
 });
+/**
+* One-line description of an arbitrary value for error messages.
+*/
 function describe(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "bigint") {
-    return `${value}n`;
-  }
-  if (typeof value === "object") {
-    const ctor = value.constructor;
-    return ctor && ctor.name ? `<${ctor.name}>` : "<object>";
-  }
-  return typeof value === "string" ? JSON.stringify(value) : String(value);
+	if (value === null) return "null";
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "object") {
+		const ctor = value.constructor;
+		return ctor && ctor.name ? `<${ctor.name}>` : "<object>";
+	}
+	return typeof value === "string" ? JSON.stringify(value) : String(value);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Instant,
-  describe,
-  epochNanosecondsImpl,
-  isValidEpochNanoseconds
-});
+
+//#endregion
+exports.Instant = Instant;
+exports.describe = describe;
+exports.epochNanosecondsImpl = epochNanosecondsImpl;
+exports.isValidEpochNanoseconds = isValidEpochNanoseconds;

package/dist/temporal/now.js

@@ -1,34 +1,43 @@
 "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 now_exports = {};
-__export(now_exports, {
-  instant: () => instant
-});
-module.exports = __toCommonJS(now_exports);
-var import_instant = require("./instant");
-var import_system = require("./system");
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_temporal_instant = require('./instant.js');
+const require_temporal_system = require('./system.js');
+
+//#region src/temporal/now.ts
+/**
+* @file Spec clause 6 — Temporal.Now. The `Temporal.Now` namespace exposes
+*   host-reading operations that return live wallclock state. Pass 1 ships
+*   `instant()`; the other `Now.*` operations (`timeZoneId`,
+*   `plainDateTimeISO`, …) land when a caller needs them. Spec:
+*   https://tc39.es/proposal-temporal/#sec-temporal-now-object Ref:
+*   js-temporal/temporal-polyfill `lib/now.ts` Operations implemented (✓) and
+*   intentionally absent (✗), in section order: ✓ 6.3.3 Temporal.Now.instant (
+*   ) ✗ 6.3.4 Temporal.Now.timeZoneId ( ) ✗ 6.3.5 Temporal.Now.zonedDateTime (
+*   calendar [ , temporalTimeZoneLike ] ) ✗ 6.3.6 Temporal.Now.zonedDateTimeISO
+*   ( [ temporalTimeZoneLike ] ) ✗ 6.3.7 Temporal.Now.plainDateTime ( calendar
+*   [ , temporalTimeZoneLike ] ) ✗ 6.3.8 Temporal.Now.plainDateTimeISO ( [
+*   temporalTimeZoneLike ] ) ✗ 6.3.9 Temporal.Now.plainDate ( calendar [ ,
+*   temporalTimeZoneLike ] ) ✗ 6.3.10 Temporal.Now.plainDateISO ( [
+*   temporalTimeZoneLike ] ) ✗ 6.3.11 Temporal.Now.plainTimeISO ( [
+*   temporalTimeZoneLike ] )
+*/
+var now_exports = /* @__PURE__ */ require_runtime.__exportAll({ instant: () => instant });
+/**
+* Returns a `Temporal.Instant` representing the current UTC time. Resolution is
+* nanosecond on Node, millisecond on hosts without `process.hrtime.bigint` (see
+* `system.ts`).
+*/
 function instant() {
-  return new import_instant.Instant((0, import_system.systemUTCEpochNanoseconds)());
+	return new require_temporal_instant.Instant(require_temporal_system.systemUTCEpochNanoseconds());
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  instant
-});
+
+//#endregion
+exports.instant = instant;
+Object.defineProperty(exports, 'now_exports', {
+  enumerable: true,
+  get: function () {
+    return now_exports;
+  }
+});

package/dist/temporal/slots.js

@@ -1,45 +1,51 @@
 "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 slots_exports = {};
-__export(slots_exports, {
-  getInstantNanoseconds: () => getInstantNanoseconds,
-  hasInstantSlot: () => hasInstantSlot,
-  setInstantSlots: () => setInstantSlots
-});
-module.exports = __toCommonJS(slots_exports);
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/temporal/slots.ts
+/**
+* @file Internal-slot machinery for Temporal objects. The TC39 Temporal spec
+*   models per-object state as non-introspectable internal slots —
+*   `[[InitializedTemporalInstant]]`, `[[Nanoseconds]]`,
+*   `[[InitializedTemporalDuration]]`, etc. Slots are not observable via
+*   property access, `Reflect`, or iteration. Slot presence is the spec's
+*   identity check, distinct from `instanceof` (which coincides on
+*   freshly-constructed instances but diverges under
+*   `Object.create(C.prototype)`, where instanceof passes but slots are
+*   absent). One `WeakMap` per slot, or `WeakSet` for boolean presence.
+*   Receiver is the key. `WeakMap` semantics keep slot storage out of the GC
+*   graph, matching the spec's "internal slot" wording. Spec reference:
+*   https://tc39.es/proposal-temporal/ — search for
+*   `[[InitializedTemporalInstant]]` and `RequireInternalSlot`. Reference impl:
+*   js-temporal/temporal-polyfill `lib/slots.ts` (pinned commit in README.md).
+*/
 const _initializedInstant = /* @__PURE__ */ new WeakSet();
 const _instantNanoseconds = /* @__PURE__ */ new WeakMap();
+/**
+* Read `[[Nanoseconds]]`. Caller MUST gate on `hasInstantSlot` first; behaviour
+* on absent-slot input is undefined.
+*/
 function getInstantNanoseconds(o) {
-  return _instantNanoseconds.get(o);
+	return _instantNanoseconds.get(o);
 }
+/**
+* Spec's `RequireInternalSlot(O, [[InitializedTemporalInstant]])` predicate.
+* Returns false for non-object inputs.
+*/
 function hasInstantSlot(o) {
-  return typeof o === "object" && o !== null && _initializedInstant.has(o);
+	return typeof o === "object" && o !== null && _initializedInstant.has(o);
 }
+/**
+* Install `[[InitializedTemporalInstant]]` and `[[Nanoseconds]]` on a receiver.
+* Caller is responsible for range-validating `nanoseconds` against
+* `IsValidEpochNanoseconds` first; this function does not.
+*/
 function setInstantSlots(o, nanoseconds) {
-  _initializedInstant.add(o);
-  _instantNanoseconds.set(o, nanoseconds);
+	_initializedInstant.add(o);
+	_instantNanoseconds.set(o, nanoseconds);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getInstantNanoseconds,
-  hasInstantSlot,
-  setInstantSlots
-});
+
+//#endregion
+exports.getInstantNanoseconds = getInstantNanoseconds;
+exports.hasInstantSlot = hasInstantSlot;
+exports.setInstantSlots = setInstantSlots;