@socketsecurity/lib 5.27.0 → 6.0.0

package/dist/strings/width.js

@@ -0,0 +1,95 @@
+"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 width_exports = {};
+__export(width_exports, {
+  getEastAsianWidth: () => getEastAsianWidth,
+  stringWidth: () => stringWidth
+});
+module.exports = __toCommonJS(width_exports);
+var import_strip = require("../ansi/strip");
+var import_regexp = require("../primordials/regexp");
+var import_string = require("../primordials/string");
+let _eastAsianWidth;
+// @__NO_SIDE_EFFECTS__
+function getEastAsianWidth() {
+  if (_eastAsianWidth === void 0) {
+    _eastAsianWidth = require("../external/get-east-asian-width").eastAsianWidth;
+  }
+  return _eastAsianWidth;
+}
+const segmenter = new Intl.Segmenter();
+let zeroWidthClusterRegex;
+let leadingNonPrintingRegex;
+let emojiRegex;
+try {
+  zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$", "v");
+  leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+", "v");
+  emojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+} catch {
+  zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark})+$", "u");
+  leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}]+/u;
+  emojiRegex = new RegExp("^\\p{Extended_Pictographic}$", "u");
+}
+// @__NO_SIDE_EFFECTS__
+function stringWidth(text) {
+  if (typeof text !== "string" || !text.length) {
+    return 0;
+  }
+  const plainText = (0, import_strip.stripAnsi)(text);
+  if (!plainText.length) {
+    return 0;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: false };
+  const eastAsianWidth = /* @__PURE__ */ getEastAsianWidth();
+  for (const { segment } of segmenter.segment(plainText)) {
+    if ((0, import_regexp.RegExpPrototypeTest)(zeroWidthClusterRegex, segment)) {
+      continue;
+    }
+    if ((0, import_regexp.RegExpPrototypeTest)(emojiRegex, segment)) {
+      width += 2;
+      continue;
+    }
+    const baseSegment = segment.replace(leadingNonPrintingRegex, "");
+    const codePoint = (0, import_string.StringPrototypeCodePointAt)(baseSegment, 0);
+    if (codePoint === void 0) {
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    if (segment.length > 1) {
+      for (const char of segment.slice(1)) {
+        const charCode = (0, import_string.StringPrototypeCharCodeAt)(char, 0);
+        if (charCode >= 65280 && charCode <= 65519) {
+          const trailingCodePoint = (0, import_string.StringPrototypeCodePointAt)(char, 0);
+          if (trailingCodePoint !== void 0) {
+            width += eastAsianWidth(trailingCodePoint, eastAsianWidthOptions);
+          }
+        }
+      }
+    }
+  }
+  return width;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getEastAsianWidth,
+  stringWidth
+});

package/dist/tables/bordered.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Bordered table renderer using Unicode box-drawing characters (`┌`, `─`,
+ *   `│`, `┴`, …). The right choice when the output context renders box-drawing
+ *   reliably (modern terminals, GitHub markdown, most CI runners). Shares
+ *   column-width calculation, alignment, and padding with the simple renderer
+ *   via `./padding`.
+ */
+import type { TableColumn } from './types';
+/**
+ * Format data as an ASCII table with borders.
+ *
+ * @example
+ *   import { formatTable } from '@socketsecurity/lib/tables/bordered'
+ *   import colors from 'yoctocolors-cjs'
+ *
+ *   const data = [
+ *     { name: 'lodash', version: '4.17.21', issues: 0 },
+ *     { name: 'react', version: '18.2.0', issues: 2 },
+ *   ]
+ *   const columns = [
+ *     { key: 'name', header: 'Package' },
+ *     { key: 'version', header: 'Version', align: 'center' },
+ *     {
+ *       key: 'issues',
+ *       header: 'Issues',
+ *       align: 'right',
+ *       color: v => (v === '0' ? colors.green(v) : colors.red(v)),
+ *     },
+ *   ]
+ *   console.log(formatTable(data, columns))
+ *   // Output:
+ *   // ┌─────────┬─────────┬────────┐
+ *   // │ Package │ Version │ Issues │
+ *   // ├─────────┼─────────┼────────┤
+ *   // │ lodash  │ 4.17.21 │      0 │
+ *   // │ react   │ 18.2.0  │      2 │
+ *   // └─────────┴─────────┴────────┘
+ *
+ * @param data - Array of data objects.
+ * @param columns - Column configuration.
+ *
+ * @returns Formatted table string
+ */
+export declare function formatTable(data: Array<Record<string, unknown>>, columns: TableColumn[]): string;

package/dist/tables/bordered.js

@@ -0,0 +1,84 @@
+"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 bordered_exports = {};
+__export(bordered_exports, {
+  formatTable: () => formatTable
+});
+module.exports = __toCommonJS(bordered_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");
+function formatTable(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 topBorder = `\u250C\u2500${widths.map((w) => "\u2500".repeat(w)).join("\u2500\u252C\u2500")}\u2500\u2510`;
+  (0, import_array.ArrayPrototypePush)(lines, import_yoctocolors_cjs.default.dim(topBorder));
+  const headerCells = columns.map((col, i) => {
+    const text = import_yoctocolors_cjs.default.bold(col.header);
+    return (0, import_padding.padText)(text, widths[i], col.align);
+  });
+  (0, import_array.ArrayPrototypePush)(
+    lines,
+    import_yoctocolors_cjs.default.dim("\u2502 ") + headerCells.join(import_yoctocolors_cjs.default.dim(" \u2502 ")) + import_yoctocolors_cjs.default.dim(" \u2502")
+  );
+  const headerSep = `\u251C\u2500${widths.map((w) => "\u2500".repeat(w)).join("\u2500\u253C\u2500")}\u2500\u2524`;
+  (0, import_array.ArrayPrototypePush)(lines, import_yoctocolors_cjs.default.dim(headerSep));
+  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,
+      import_yoctocolors_cjs.default.dim("\u2502 ") + cells.join(import_yoctocolors_cjs.default.dim(" \u2502 ")) + import_yoctocolors_cjs.default.dim(" \u2502")
+    );
+  }
+  const bottomBorder = `\u2514\u2500${widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2534\u2500")}\u2500\u2518`;
+  (0, import_array.ArrayPrototypePush)(lines, import_yoctocolors_cjs.default.dim(bottomBorder));
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatTable
+});

package/dist/tables/padding.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @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`.
+ */
+import type { ColumnAlignment } from './types';
+/**
+ * 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.
+ */
+export declare function displayWidth(text: string): number;
+/**
+ * Pad text to specified width with alignment.
+ */
+export declare function padText(text: string, width: number, align?: ColumnAlignment): string;

package/dist/tables/padding.js

@@ -0,0 +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 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");
+function displayWidth(text) {
+  return (0, import_width.stringWidth)(text);
+}
+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);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  displayWidth,
+  padText
+});

package/dist/tables/simple.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @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.
+ */
+import type { TableColumn } from './types';
+/**
+ * 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
+ */
+export declare function formatSimpleTable(data: Array<Record<string, unknown>>, columns: TableColumn[]): string;

package/dist/tables/simple.js

@@ -0,0 +1,73 @@
+"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");
+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");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  formatSimpleTable
+});

package/dist/tables/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Public type surface for `tables/*` modules — the `ColumnAlignment`
+ *   union + `TableColumn` config record. Pure types, no runtime side effects.
+ */
+export type ColumnAlignment = 'left' | 'right' | 'center';
+/**
+ * Table column configuration.
+ */
+export type TableColumn = {
+    key: string;
+    header: string;
+    align?: ColumnAlignment | undefined;
+    width?: number | undefined;
+    color?: ((value: string) => string) | undefined;
+};

package/dist/tables/types.js

@@ -0,0 +1,18 @@
+"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);

package/dist/temporal/instant.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @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.
+ */
+/**
+ * Spec's IsValidEpochNanoseconds. Exported for testability.
+ */
+export declare function isValidEpochNanoseconds(epochNanoseconds: bigint): boolean;
+/**
+ * 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.
+ */
+export declare class Instant {
+    readonly epochNanoseconds: bigint;
+    constructor(epochNanoseconds: bigint | number | string);
+}
+export declare function epochNanosecondsImpl(this: Instant): bigint;
+/**
+ * One-line description of an arbitrary value for error messages.
+ */
+export declare function describe(value: unknown): string;

package/dist/temporal/instant.js

@@ -0,0 +1,91 @@
+"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");
+const NS_MAX_INSTANT = 8640000000000000000000n;
+const NS_MIN_INSTANT = -NS_MAX_INSTANT;
+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);
+  }
+}
+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;
+}
+Object.defineProperty(Instant.prototype, "epochNanoseconds", {
+  get: epochNanosecondsImpl,
+  configurable: true
+});
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Instant,
+  describe,
+  epochNanosecondsImpl,
+  isValidEpochNanoseconds
+});

package/dist/temporal/now.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @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 ] )
+ */
+import { Instant } from './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`).
+ */
+export declare function instant(): Instant;

package/dist/temporal/now.js

@@ -0,0 +1,34 @@
+"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");
+function instant() {
+  return new import_instant.Instant((0, import_system.systemUTCEpochNanoseconds)());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  instant
+});

package/dist/temporal/slots.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @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).
+ */
+/**
+ * Read `[[Nanoseconds]]`. Caller MUST gate on `hasInstantSlot` first; behaviour
+ * on absent-slot input is undefined.
+ */
+export declare function getInstantNanoseconds(o: object): bigint;
+/**
+ * Spec's `RequireInternalSlot(O, [[InitializedTemporalInstant]])` predicate.
+ * Returns false for non-object inputs.
+ */
+export declare function hasInstantSlot(o: unknown): o is object;
+/**
+ * Install `[[InitializedTemporalInstant]]` and `[[Nanoseconds]]` on a receiver.
+ * Caller is responsible for range-validating `nanoseconds` against
+ * `IsValidEpochNanoseconds` first; this function does not.
+ */
+export declare function setInstantSlots(o: object, nanoseconds: bigint): void;