@nextera.one/tps-standard 0.5.3 → 0.5.34

package/dist/index.js

@@ -3,7 +3,7 @@
  * TPS: Temporal Positioning System
  * The Universal Protocol for Space-Time Coordinates.
  * @packageDocumentation
- * @version 0.5.3
+ * @version 0.5.34
  * @license Apache-2.0
  * @copyright 2026 TPS Standards Working Group
  *
@@ -13,8 +13,22 @@
  * - Added structural anchors (bldg, floor, room, zone)
  * - Added geospatial cell systems (S2, H3, Plus Code, what3words)
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TpsDate = exports.TPSUID7RB = exports.TPS = exports.TimeOrder = exports.DefaultCalendars = void 0;
+exports.TPS = exports.Env = void 0;
 // built-in drivers are registered automatically; importing them here
 // ensures they are included when the library bundler/tree-shaker runs.
 const gregorian_1 = require("./drivers/gregorian");
@@ -24,28 +38,13 @@ const persian_1 = require("./drivers/persian");
 const hijri_1 = require("./drivers/hijri");
 const julian_1 = require("./drivers/julian");
 const holocene_1 = require("./drivers/holocene");
-// Calendar codes are plain strings to allow arbitrary user-defined
-// calendars.  The library still exports constants for the built-in values but
-// callers may also supply their own codes.
-exports.DefaultCalendars = {
-    TPS: "tps",
-    GREG: "greg",
-    HIJ: "hij",
-    PER: "per",
-    JUL: "jul",
-    HOLO: "holo",
-    UNIX: "unix",
-};
-/**
- * Specifies the direction of the time-component hierarchy when serializing or
- * deserializing a TPS string.  The default is `'descending'` (millennium → … →
- * second), but `'ascending'` produces the reverse order.
- */
-var TimeOrder;
-(function (TimeOrder) {
-    TimeOrder["DESC"] = "desc";
-    TimeOrder["ASC"] = "asc";
-})(TimeOrder || (exports.TimeOrder = TimeOrder = {}));
+__exportStar(require("./types"), exports);
+__exportStar(require("./uid"), exports);
+__exportStar(require("./date"), exports);
+var env_1 = require("./utils/env");
+Object.defineProperty(exports, "Env", { enumerable: true, get: function () { return env_1.Env; } });
+const tps_string_1 = require("./utils/tps-string");
+const types_1 = require("./types");
 class TPS {
     /**
      * Registers a calendar driver plugin.
@@ -208,7 +207,7 @@ class TPS {
                 timeStr = timeStr.split(/[!;?#]/)[0];
             }
             if (timeStr) {
-                const parsed = this.parseTimeString(timeStr);
+                const parsed = (0, tps_string_1.parseTimeString)(timeStr);
                 if (!parsed)
                     return null;
                 Object.assign(comp, parsed.components);
@@ -231,7 +230,7 @@ class TPS {
             signature = sigMatch.groups.sig;
             timeOnly = input.split(/[!;?#]/)[0];
         }
-        const parsed = this.parseTimeString(timeOnly);
+        const parsed = (0, tps_string_1.parseTimeString)(timeOnly);
         if (!parsed)
             return null;
         const comp = parsed.components;
@@ -293,7 +292,7 @@ class TPS {
             actorPart = `/A:${comp.actor}`;
         }
         // 3. Build Time Part (handles order & signature)
-        const timePart = this.buildTimePart(comp);
+        const timePart = (0, tps_string_1.buildTimePart)(comp);
         // 5. Build Extensions
         let extPart = "";
         if (comp.extensions && Object.keys(comp.extensions).length > 0) {
@@ -314,7 +313,7 @@ class TPS {
      *   supported key is `order` which may be `'ascending'` or `'descending'`.
      * @returns Canonical string (e.g., "T:tps.m3.c1.y26...").
      */
-    static fromDate(date = new Date(), calendar = exports.DefaultCalendars.TPS, opts) {
+    static fromDate(date = new Date(), calendar = types_1.DefaultCalendars.TPS, opts) {
         const normalizedCalendar = calendar.toLowerCase();
         const driver = this.drivers.get(normalizedCalendar);
         if (driver) {
@@ -326,21 +325,21 @@ class TPS {
                 const comp = driver.getComponentsFromDate(date);
                 comp.calendar = normalizedCalendar;
                 comp.order = opts.order;
-                return this.buildTimePart(comp);
+                return (0, tps_string_1.buildTimePart)(comp);
             }
             return driver.getFromDate(date);
         }
         // Fallback for old built-in calendars (shouldn't happen once drivers are
         // registered, but kept for backwards compatibility).
         const comp = { calendar: normalizedCalendar };
-        if (normalizedCalendar === exports.DefaultCalendars.UNIX) {
+        if (normalizedCalendar === types_1.DefaultCalendars.UNIX) {
             const s = (date.getTime() / 1000).toFixed(3);
             comp.unixSeconds = parseFloat(s);
             if (opts?.order)
                 comp.order = opts.order;
-            return this.buildTimePart(comp);
+            return (0, tps_string_1.buildTimePart)(comp);
         }
-        if (normalizedCalendar === exports.DefaultCalendars.GREG) {
+        if (normalizedCalendar === types_1.DefaultCalendars.GREG) {
             const fullYear = date.getUTCFullYear();
             comp.millennium = Math.floor(fullYear / 1000) + 1;
             comp.century = Math.floor((fullYear % 1000) / 100) + 1;
@@ -353,7 +352,7 @@ class TPS {
             comp.millisecond = date.getUTCMilliseconds();
             if (opts?.order)
                 comp.order = opts.order;
-            return this.buildTimePart(comp);
+            return (0, tps_string_1.buildTimePart)(comp);
         }
         throw new Error(`Calendar driver '${normalizedCalendar}' not implemented. Register a driver.`);
     }
@@ -382,7 +381,7 @@ class TPS {
         const parsed = this.parse(tpsString);
         if (!parsed)
             return null;
-        const cal = parsed.calendar || exports.DefaultCalendars.TPS;
+        const cal = parsed.calendar || types_1.DefaultCalendars.TPS;
         const driver = this.drivers.get(cal);
         if (!driver) {
             console.error(`Calendar driver '${cal}' not registered.`);
@@ -479,217 +478,6 @@ class TPS {
         return driver.format(components, format);
     }
     // --- INTERNAL HELPERS ---
-    /**
-     * Generate the canonical `T:` time string for a set of components.  The
-     * `order` field (or `comp.order`) controls whether tokens are emitted in
-     * ascending or descending hierarchy; if undefined the default
-     * `'descending'` orientation is used.
-     *
-     * Drivers may ignore this helper and produce their own time strings if they
-     * implement custom ordering logic.
-     */
-    static buildTimePart(comp) {
-        const calendar = (comp.calendar || "").toLowerCase();
-        if (!/^[a-z]{3,4}$/.test(calendar)) {
-            throw new Error(`Invalid calendar code '${comp.calendar}'. Calendar code width must be 3–4 lowercase letters.`);
-        }
-        let time = `T:${calendar}`;
-        if (calendar === exports.DefaultCalendars.UNIX) {
-            if (comp.unixSeconds !== undefined) {
-                time += `.s${comp.unixSeconds}`;
-            }
-            return time;
-        }
-        // sequence of [prefix, value, rank]
-        // All four of millennium / month / minute / millisecond share the prefix 'm'.
-        // Position within the ordered sequence disambiguates them during parsing.
-        const tokens = [
-            ["m", comp.millennium, 8], // m-token rank 8 → millennium
-            ["c", comp.century, 7],
-            ["y", comp.year, 6],
-            ["m", comp.month, 5], // m-token rank 5 → month
-            ["d", comp.day, 4],
-            ["h", comp.hour, 3],
-            ["m", comp.minute, 2], // m-token rank 2 → minute
-            ["s", comp.second, 1],
-            ["m", comp.millisecond, 0], // m-token rank 0 → millisecond
-        ];
-        const order = comp.order || TimeOrder.DESC;
-        if (order === TimeOrder.ASC)
-            tokens.reverse();
-        for (const [pref, val] of tokens) {
-            if (val !== undefined) {
-                // seconds may be fractional
-                time += `.${pref}${val}`;
-            }
-        }
-        if (comp.signature) {
-            time += `!${comp.signature}`;
-        }
-        return time;
-    }
-    /**
-     * Parse the *time* portion of a TPS string (optionally beginning with
-     * `T:`) into components and determine the component ordering.  This helper
-     * accepts tokens in **any** sequence and will return an `order` value of
-     * `'ascending'` or `'descending'`.
-     *
-     * The caller is responsible for stripping off a leading signature or other
-     * trailer characters; this method will drop anything after `!`, `;`, `?` or
-     * `#`.
-     *
-     * ### `m`-token disambiguation
-     * All four of millennium (rank 8), month (rank 5), minute (rank 2) and
-     * millisecond (rank 0) share the single-character prefix `m`.  They are told
-     * apart by their **position relative to the neighbouring tokens**.  The
-     * algorithm is:
-     *
-     * 1. Pre-scan the non-`m` tokens (c, y, d, h, s) whose ranks are fixed to
-     *    determine whether the string is ascending or descending.
-     * 2. While iterating, track `lastAssignedRank` – the rank of the most
-     *    recently processed token (m or non-m).
-     * 3. When an `m` token is encountered, derive its rank from `lastAssignedRank`
-     *    and the detected order:
-     *    - **DESC**  null → 8 (mill) | rank > 5 → 5 (month) | rank > 2 → 2 (min) | else → 0 (ms)
-     *    - **ASC**   null → 0 (ms)   | rank < 2 → 2 (min)   | rank < 5 → 5 (month) | else → 8 (mill)
-     *
-     * @param input - Time fragment (e.g. `"T:greg.m3.c1.y26"` or `"greg.m0.s25.m30"`)
-     */
-    static parseTimeString(input) {
-        let s = input.trim();
-        // strip off anything after signature or extensions/query/fragment
-        s = s.split(/[!;?#]/)[0];
-        if (s.startsWith("T:"))
-            s = s.slice(2);
-        const parts = s.split(".");
-        if (parts.length === 0)
-            return null;
-        const calendar = parts[0];
-        const comp = { calendar };
-        // Fixed-rank prefixes (unambiguous regardless of position)
-        const fixedRankMap = {
-            c: 7,
-            y: 6,
-            d: 4,
-            h: 3,
-            s: 1,
-        };
-        // ── Step 1: pre-scan non-m tokens to estimate order ─────────────────────
-        // This is only needed to handle the first 'm' token when lastAssignedRank
-        // is still null (nothing has been seen yet).
-        let initialOrder = TimeOrder.DESC;
-        if (calendar !== exports.DefaultCalendars.UNIX) {
-            const nonMRanks = [];
-            for (let i = 1; i < parts.length; i++) {
-                const pr = parts[i]?.charAt(0);
-                if (pr && pr in fixedRankMap)
-                    nonMRanks.push(fixedRankMap[pr]);
-            }
-            if (nonMRanks.length >= 2) {
-                const isAsc = nonMRanks.every((v, i, a) => i === 0 || a[i - 1] <= v);
-                if (isAsc)
-                    initialOrder = TimeOrder.ASC;
-            }
-        }
-        // ── Step 2: resolve the semantic rank of an 'm' token ───────────────────
-        const assignMRank = (lastRank, ord) => {
-            if (ord === TimeOrder.DESC) {
-                if (lastRank === null)
-                    return 8; // first token → millennium
-                if (lastRank > 5)
-                    return 5; // after century / year  → month
-                if (lastRank > 2)
-                    return 2; // after day / hour      → minute
-                return 0; // after second          → millisecond
-            }
-            else {
-                if (lastRank === null)
-                    return 0; // first token → millisecond
-                if (lastRank < 2)
-                    return 2; // after millisecond / second → minute
-                if (lastRank < 5)
-                    return 5; // after minute / hour / day  → month
-                return 8; // after month / year / cent  → millennium
-            }
-        };
-        // ── Step 3: iterate and build components ────────────────────────────────
-        const ranks = [];
-        let lastAssignedRank = null;
-        for (let i = 1; i < parts.length; i++) {
-            const token = parts[i];
-            if (!token)
-                continue;
-            const prefix = token.charAt(0);
-            const value = token.slice(1);
-            // UNIX calendar: single 's' token carries the full unix timestamp
-            if (calendar === exports.DefaultCalendars.UNIX && prefix === "s") {
-                comp.unixSeconds = parseFloat(value);
-                ranks.push(9);
-                continue;
-            }
-            if (prefix === "m") {
-                const rank = assignMRank(lastAssignedRank, initialOrder);
-                switch (rank) {
-                    case 8:
-                        comp.millennium = parseInt(value, 10);
-                        break;
-                    case 5:
-                        comp.month = parseInt(value, 10);
-                        break;
-                    case 2:
-                        comp.minute = parseInt(value, 10);
-                        break;
-                    case 0:
-                        comp.millisecond = parseInt(value, 10);
-                        break;
-                }
-                ranks.push(rank);
-                lastAssignedRank = rank;
-            }
-            else {
-                switch (prefix) {
-                    case "c":
-                        comp.century = parseInt(value, 10);
-                        ranks.push(7);
-                        lastAssignedRank = 7;
-                        break;
-                    case "y":
-                        comp.year = parseInt(value, 10);
-                        ranks.push(6);
-                        lastAssignedRank = 6;
-                        break;
-                    case "d":
-                        comp.day = parseInt(value, 10);
-                        ranks.push(4);
-                        lastAssignedRank = 4;
-                        break;
-                    case "h":
-                        comp.hour = parseInt(value, 10);
-                        ranks.push(3);
-                        lastAssignedRank = 3;
-                        break;
-                    case "s":
-                        comp.second = parseFloat(value);
-                        ranks.push(1);
-                        lastAssignedRank = 1;
-                        break;
-                    default:
-                        // unknown prefix – ignore
-                        break;
-                }
-            }
-        }
-        // ── Step 4: confirm order from the complete rank sequence ────────────────
-        let order = TimeOrder.DESC;
-        if (ranks.length > 1) {
-            const isAsc = ranks.every((v, i, a) => i === 0 || a[i - 1] <= v);
-            const isDesc = ranks.every((v, i, a) => i === 0 || a[i - 1] >= v);
-            if (isAsc && !isDesc)
-                order = TimeOrder.ASC;
-            // mixed / single direction → defaults to DESC
-        }
-        return { components: comp, order };
-    }
     static _mapGroupsToComponents(g) {
         const components = {};
         components.calendar = g.calendar;
@@ -815,582 +603,6 @@ TPS.registerDriver(new persian_1.PersianDriver());
 TPS.registerDriver(new hijri_1.HijriDriver());
 TPS.registerDriver(new julian_1.JulianDriver());
 TPS.registerDriver(new holocene_1.HoloceneDriver());
-/**
- * TPS-UID v1 — Temporal Positioning System Identifier (Binary Reversible)
- *
- * A time-first, reversible identifier that binds an event to a TPS coordinate.
- * Unlike UUIDs, TPS-UID identifies events in spacetime and allows exact
- * reconstruction of the original TPS string.
- *
- * Binary Schema (all integers big-endian):
- * ```
- * MAGIC   4 bytes   "TPU7"
- * VER     1 byte    0x01
- * FLAGS   1 byte    bit0 = compression flag
- * TIME    6 bytes   epoch_ms (48-bit unsigned)
- * NONCE   4 bytes   32-bit random
- * LEN     varint    length of TPS payload
- * TPS     bytes     UTF-8 TPS string (raw or zlib-compressed)
- * ```
- *
- * @example
- * ```ts
- * const tps = 'tps://31.95,35.91@T:greg.m3.c1.y26.m01.d09';
- *
- * // Encode to binary
- * const bytes = TPSUID7RB.encodeBinary(tps);
- *
- * // Encode to base64url string
- * const id = TPSUID7RB.encodeBinaryB64(tps);
- * // → "tpsuid7rb_AFRQV..."
- *
- * // Decode back to original TPS
- * const decoded = TPSUID7RB.decodeBinaryB64(id);
- * console.log(decoded.tps); // exact original TPS
- * ```
- */
-class TPSUID7RB {
-    // ---------------------------
-    // Public API
-    // ---------------------------
-    /**
-     * Encode TPS string to binary bytes (Uint8Array).
-     * This is the canonical form for hashing, signing, and storage.
-     *
-     * @param tps - The TPS string to encode
-     * @param opts - Encoding options (compress, epochMs override)
-     * @returns Binary TPS-UID as Uint8Array
-     */
-    static encodeBinary(tps, opts = {}) {
-        const compress = opts.compress ?? false;
-        const epochMs = opts.epochMs ?? this.epochMsFromTPSString(tps);
-        if (!Number.isInteger(epochMs) || epochMs < 0) {
-            throw new Error("epochMs must be a non-negative integer");
-        }
-        if (epochMs > 0xffffffffffff) {
-            throw new Error("epochMs exceeds 48-bit range");
-        }
-        const flags = compress ? 0x01 : 0x00;
-        // Generate 32-bit nonce
-        const nonceBuf = this.randomBytes(4);
-        const nonce = ((nonceBuf[0] << 24) >>> 0) +
-            ((nonceBuf[1] << 16) >>> 0) +
-            ((nonceBuf[2] << 8) >>> 0) +
-            nonceBuf[3];
-        // Encode TPS to UTF-8
-        const tpsUtf8 = new TextEncoder().encode(tps);
-        // Optionally compress
-        const payload = compress ? this.deflateRaw(tpsUtf8) : tpsUtf8;
-        // Encode length as varint
-        const lenVar = this.uvarintEncode(payload.length);
-        // Construct binary structure
-        const out = new Uint8Array(4 + 1 + 1 + 6 + 4 + lenVar.length + payload.length);
-        let offset = 0;
-        // MAGIC
-        out.set(this.MAGIC, offset);
-        offset += 4;
-        // VER
-        out[offset++] = this.VER;
-        // FLAGS
-        out[offset++] = flags;
-        // TIME (48-bit big-endian)
-        const timeBytes = this.writeU48(epochMs);
-        out.set(timeBytes, offset);
-        offset += 6;
-        // NONCE (32-bit big-endian)
-        out.set(nonceBuf, offset);
-        offset += 4;
-        // LEN (varint)
-        out.set(lenVar, offset);
-        offset += lenVar.length;
-        // TPS payload
-        out.set(payload, offset);
-        return out;
-    }
-    /**
-     * Decode binary bytes back to original TPS string.
-     *
-     * @param bytes - Binary TPS-UID
-     * @returns Decoded result with original TPS string
-     */
-    static decodeBinary(bytes) {
-        // Header min size: 4+1+1+6+4 + 1 (at least 1 byte varint) = 17
-        if (bytes.length < 17) {
-            throw new Error("TPSUID7RB: too short");
-        }
-        // MAGIC
-        if (bytes[0] !== 0x54 ||
-            bytes[1] !== 0x50 ||
-            bytes[2] !== 0x55 ||
-            bytes[3] !== 0x37) {
-            throw new Error("TPSUID7RB: bad magic");
-        }
-        // VERSION
-        const ver = bytes[4];
-        if (ver !== this.VER) {
-            throw new Error(`TPSUID7RB: unsupported version ${ver}`);
-        }
-        // FLAGS
-        const flags = bytes[5];
-        const compressed = (flags & 0x01) === 0x01;
-        // TIME (48-bit big-endian)
-        const epochMs = this.readU48(bytes, 6);
-        // NONCE (32-bit big-endian)
-        const nonce = ((bytes[12] << 24) >>> 0) +
-            ((bytes[13] << 16) >>> 0) +
-            ((bytes[14] << 8) >>> 0) +
-            bytes[15];
-        // LEN (varint at offset 16)
-        let offset = 16;
-        const { value: tpsLen, bytesRead } = this.uvarintDecode(bytes, offset);
-        offset += bytesRead;
-        if (offset + tpsLen > bytes.length) {
-            throw new Error("TPSUID7RB: length overflow");
-        }
-        // TPS payload
-        const payload = bytes.slice(offset, offset + tpsLen);
-        const tpsUtf8 = compressed ? this.inflateRaw(payload) : payload;
-        const tps = new TextDecoder().decode(tpsUtf8);
-        return { version: "tpsuid7rb", epochMs, compressed, nonce, tps };
-    }
-    /**
-     * Encode TPS to base64url string with prefix.
-     * This is the transport/storage form.
-     *
-     * @param tps - The TPS string to encode
-     * @param opts - Encoding options
-     * @returns Base64url encoded TPS-UID with prefix
-     */
-    static encodeBinaryB64(tps, opts) {
-        const bytes = this.encodeBinary(tps, opts ?? {});
-        return `${this.PREFIX}${this.base64UrlEncode(bytes)}`;
-    }
-    /**
-     * Decode base64url string back to original TPS string.
-     *
-     * @param id - Base64url encoded TPS-UID with prefix
-     * @returns Decoded result with original TPS string
-     */
-    static decodeBinaryB64(id) {
-        const s = id.trim();
-        if (!s.startsWith(this.PREFIX)) {
-            throw new Error("TPSUID7RB: missing prefix");
-        }
-        const b64 = s.slice(this.PREFIX.length);
-        const bytes = this.base64UrlDecode(b64);
-        return this.decodeBinary(bytes);
-    }
-    /**
-     * Validate base64url encoded TPS-UID format.
-     * Note: This validates shape only; binary decode is authoritative.
-     *
-     * @param id - String to validate
-     * @returns true if format is valid
-     */
-    static validateBinaryB64(id) {
-        return this.REGEX.test(id.trim());
-    }
-    /**
-     * Generate a TPS-UID from the current time and optional location.
-     *
-     * @param opts - Generation options
-     * @returns Base64url encoded TPS-UID
-     */
-    static generate(opts) {
-        const now = new Date();
-        const time = TPS.fromDate(now, exports.DefaultCalendars.TPS, {
-            order: opts?.order,
-        });
-        let space = "unknown";
-        if (opts?.latitude !== undefined && opts?.longitude !== undefined) {
-            space = `${opts.latitude},${opts.longitude}`;
-            if (opts.altitude !== undefined) {
-                space += `,${opts.altitude}m`;
-            }
-        }
-        const tps = `tps://${space}@${time}`;
-        return this.encodeBinaryB64(tps, {
-            compress: opts?.compress,
-            epochMs: now.getTime(),
-        });
-    }
-    // ---------------------------
-    // TPS String Helpers
-    // ---------------------------
-    /**
-     * Generate a TPS string from a Date and optional location.
-     */
-    /**
-     * Parse epoch milliseconds from a TPS string.
-     * Supports both URI format (tps://...) and time-only format (T:greg...)
-     */
-    static epochMsFromTPSString(tps) {
-        const date = TPS.toDate(tps);
-        if (date)
-            return date.getTime();
-        // If parse fails due to unsupported/extended extension payloads,
-        // strip extensions/query/fragment and retry. Epoch only depends on time.
-        const stripped = tps.replace(/;[^?#]*/, "").replace(/[?#].*$/, "");
-        const retryDate = TPS.toDate(stripped);
-        if (!retryDate)
-            throw new Error("TPS: unable to parse date for epoch");
-        return retryDate.getTime();
-    }
-    // ---------------------------
-    // Binary Helpers
-    // ---------------------------
-    /** Write 48-bit unsigned integer (big-endian) */
-    static writeU48(epochMs) {
-        const b = new Uint8Array(6);
-        // Use BigInt for proper 48-bit handling
-        const v = BigInt(epochMs);
-        b[0] = Number((v >> 40n) & 0xffn);
-        b[1] = Number((v >> 32n) & 0xffn);
-        b[2] = Number((v >> 24n) & 0xffn);
-        b[3] = Number((v >> 16n) & 0xffn);
-        b[4] = Number((v >> 8n) & 0xffn);
-        b[5] = Number(v & 0xffn);
-        return b;
-    }
-    /** Read 48-bit unsigned integer (big-endian) */
-    static readU48(bytes, offset) {
-        const v = (BigInt(bytes[offset]) << 40n) +
-            (BigInt(bytes[offset + 1]) << 32n) +
-            (BigInt(bytes[offset + 2]) << 24n) +
-            (BigInt(bytes[offset + 3]) << 16n) +
-            (BigInt(bytes[offset + 4]) << 8n) +
-            BigInt(bytes[offset + 5]);
-        const n = Number(v);
-        if (!Number.isSafeInteger(n)) {
-            throw new Error("TPSUID7RB: u48 not safe integer");
-        }
-        return n;
-    }
-    /** Encode unsigned integer as LEB128 varint */
-    static uvarintEncode(n) {
-        if (!Number.isInteger(n) || n < 0) {
-            throw new Error("uvarint must be non-negative int");
-        }
-        const out = [];
-        let x = n >>> 0;
-        while (x >= 0x80) {
-            out.push((x & 0x7f) | 0x80);
-            x >>>= 7;
-        }
-        out.push(x);
-        return new Uint8Array(out);
-    }
-    /** Decode LEB128 varint */
-    static uvarintDecode(bytes, offset) {
-        let x = 0;
-        let s = 0;
-        let i = 0;
-        while (true) {
-            if (offset + i >= bytes.length) {
-                throw new Error("uvarint overflow");
-            }
-            const b = bytes[offset + i];
-            if (b < 0x80) {
-                if (i > 9 || (i === 9 && b > 1)) {
-                    throw new Error("uvarint too large");
-                }
-                x |= b << s;
-                return { value: x >>> 0, bytesRead: i + 1 };
-            }
-            x |= (b & 0x7f) << s;
-            s += 7;
-            i++;
-            if (i > 10) {
-                throw new Error("uvarint too long");
-            }
-        }
-    }
-    // ---------------------------
-    // Base64url Helpers
-    // ---------------------------
-    /** Encode bytes to base64url (no padding) */
-    static base64UrlEncode(bytes) {
-        // Node.js environment
-        if (typeof Buffer !== "undefined") {
-            return Buffer.from(bytes)
-                .toString("base64")
-                .replace(/\+/g, "-")
-                .replace(/\//g, "_")
-                .replace(/=+$/g, "");
-        }
-        // Browser environment
-        let binary = "";
-        for (let i = 0; i < bytes.length; i++) {
-            binary += String.fromCharCode(bytes[i]);
-        }
-        return btoa(binary)
-            .replace(/\+/g, "-")
-            .replace(/\//g, "_")
-            .replace(/=+$/g, "");
-    }
-    /** Decode base64url to bytes */
-    static base64UrlDecode(b64url) {
-        // Add padding
-        const padLen = (4 - (b64url.length % 4)) % 4;
-        const b64 = (b64url + "=".repeat(padLen))
-            .replace(/-/g, "+")
-            .replace(/_/g, "/");
-        // Node.js environment
-        if (typeof Buffer !== "undefined") {
-            return new Uint8Array(Buffer.from(b64, "base64"));
-        }
-        // Browser environment
-        const binary = atob(b64);
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i++) {
-            bytes[i] = binary.charCodeAt(i);
-        }
-        return bytes;
-    }
-    // ---------------------------
-    // Compression Helpers
-    // ---------------------------
-    /** Compress using zlib deflate raw */
-    static deflateRaw(data) {
-        // Node.js environment
-        if (typeof require !== "undefined") {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const zlib = require("zlib");
-                return new Uint8Array(zlib.deflateRawSync(Buffer.from(data)));
-            }
-            catch {
-                throw new Error("TPSUID7RB: compression not available");
-            }
-        }
-        // Browser: would need pako or similar library
-        throw new Error("TPSUID7RB: compression not available in browser");
-    }
-    /** Decompress using zlib inflate raw */
-    static inflateRaw(data) {
-        // Node.js environment
-        if (typeof require !== "undefined") {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const zlib = require("zlib");
-                return new Uint8Array(zlib.inflateRawSync(Buffer.from(data)));
-            }
-            catch {
-                throw new Error("TPSUID7RB: decompression failed");
-            }
-        }
-        // Browser: would need pako or similar library
-        throw new Error("TPSUID7RB: decompression not available in browser");
-    }
-    // ---------------------------
-    // Cryptographic Sealing (Ed25519)
-    // ---------------------------
-    /**
-     * Seal (sign) a TPS string to create a cryptographically verifiable TPS-UID.
-     * This appends an Ed25519 signature to the binary form.
-     *
-     * @param tps - The TPS string to seal
-     * @param privateKey - Ed25519 private key (hex or buffer)
-     * @param opts - Encoding options
-     * @returns Sealed binary TPS-UID
-     */
-    static seal(tps, privateKey, opts) {
-        // 1. Create standard binary (unsealed first)
-        // We force the SEAL flag (bit 1) to be 0 initially for the "content to sign"
-        // But wait, we want the signature to cover the header too.
-        // Strategy: Construct the full binary with SEAL flag OFF, sign it, then set SEAL flag ON and append sig.
-        // Actually, the standard way is:
-        // Content = MAGIC + VER + FLAGS(with seal bit set) + TIME + NONCE + LEN + PAYLOAD
-        // Signature = Sign(Content)
-        // Final = Content + SEAL_TYPE + SIGNATURE
-        const compress = opts?.compress ?? false;
-        const epochMs = opts?.epochMs ?? this.epochMsFromTPSString(tps);
-        // Validate epoch
-        if (!Number.isInteger(epochMs) || epochMs < 0 || epochMs > 0xffffffffffff) {
-            throw new Error("epochMs must be a valid 48-bit non-negative integer");
-        }
-        // Flags: Bit 0 = compress, Bit 1 = sealed
-        const flags = (compress ? 0x01 : 0x00) | 0x02; // Set SEAL bit
-        // Generate Nonce
-        const nonceBuf = this.randomBytes(4);
-        // Encode Payload
-        const tpsUtf8 = new TextEncoder().encode(tps);
-        const payload = compress ? this.deflateRaw(tpsUtf8) : tpsUtf8;
-        const lenVar = this.uvarintEncode(payload.length);
-        // Construct Content (Header + Payload)
-        const contentLen = 4 + 1 + 1 + 6 + 4 + lenVar.length + payload.length;
-        const content = new Uint8Array(contentLen);
-        let offset = 0;
-        content.set(this.MAGIC, offset);
-        offset += 4;
-        content[offset++] = this.VER;
-        content[offset++] = flags;
-        content.set(this.writeU48(epochMs), offset);
-        offset += 6;
-        content.set(nonceBuf, offset);
-        offset += 4;
-        content.set(lenVar, offset);
-        offset += lenVar.length;
-        content.set(payload, offset);
-        // Sign the content
-        const signature = this.signEd25519(content, privateKey);
-        const sealType = 0x01; // Ed25519
-        // Final Output: Content + SealType (1) + Signature (64)
-        const final = new Uint8Array(contentLen + 1 + signature.length);
-        final.set(content, 0);
-        final.set([sealType], contentLen);
-        final.set(signature, contentLen + 1);
-        return final;
-    }
-    /**
-     * Verify a sealed TPS-UID and decode it.
-     * Throws if signature is invalid or not sealed.
-     *
-     * @param sealedBytes - The binary sealed TPS-UID
-     * @param publicKey - Ed25519 public key (hex or buffer) to verify against
-     * @returns Decoded result
-     */
-    static verifyAndDecode(sealedBytes, publicKey) {
-        if (sealedBytes.length < 18)
-            throw new Error("TPSUID7RB: too short");
-        // Check Magic
-        if (sealedBytes[0] !== 0x54 ||
-            sealedBytes[1] !== 0x50 ||
-            sealedBytes[2] !== 0x55 ||
-            sealedBytes[3] !== 0x37) {
-            throw new Error("TPSUID7RB: bad magic");
-        }
-        // Check Flags for Sealed Bit (bit 1)
-        const flags = sealedBytes[5];
-        if ((flags & 0x02) === 0) {
-            throw new Error("TPSUID7RB: not a sealed UID");
-        }
-        // 1. Parse the structure to find where content ends
-        // We need to parse LEN and Payload to find the split point
-        let offset = 16; // Start of LEN
-        // Decode LEN
-        const { value: tpsLen, bytesRead } = this.uvarintDecode(sealedBytes, offset);
-        offset += bytesRead;
-        const payloadEnd = offset + tpsLen;
-        if (payloadEnd > sealedBytes.length) {
-            throw new Error("TPSUID7RB: length overflow (truncated)");
-        }
-        // The Content to verify matches exactly [0 ... payloadEnd]
-        const content = sealedBytes.slice(0, payloadEnd);
-        // After content: SealType (1 byte) + Signature
-        if (sealedBytes.length <= payloadEnd + 1) {
-            throw new Error("TPSUID7RB: missing signature data");
-        }
-        const sealType = sealedBytes[payloadEnd];
-        if (sealType !== 0x01) {
-            throw new Error(`TPSUID7RB: unsupported seal type 0x${sealType.toString(16)}`);
-        }
-        const signature = sealedBytes.slice(payloadEnd + 1);
-        if (signature.length !== 64) {
-            throw new Error(`TPSUID7RB: invalid Ed25519 signature length ${signature.length}`);
-        }
-        // Verify
-        const isValid = this.verifyEd25519(content, signature, publicKey);
-        if (!isValid) {
-            throw new Error("TPSUID7RB: signature verification failed");
-        }
-        // Decode (reuse standard logic, but ignoring the extra bytes at end is fine?)
-        // Actually standard logic doesn't expect trailing bytes unless we tell it to.
-        // But since we verified, we can just slice the content and decode that as a strict binary
-        // EXCEPT standard decodeBinary checks strict length.
-        // So we manually decode the components here to be safe and efficient.
-        return this.decodeBinary(content); // Reuse strict decoder on the content part
-    }
-    // --- Crypto Implementation (Ed25519) ---
-    static signEd25519(data, privateKey) {
-        if (typeof require !== "undefined") {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const crypto = require("crypto");
-                let key;
-                if (typeof privateKey === "string") {
-                    if (privateKey.includes("PRIVATE KEY")) {
-                        // PEM format — use directly
-                        key = privateKey;
-                    }
-                    else {
-                        // Hex-encoded DER/PKCS8
-                        key = crypto.createPrivateKey({
-                            key: Buffer.from(privateKey, "hex"),
-                            format: "der",
-                            type: "pkcs8",
-                        });
-                    }
-                }
-                else if (typeof privateKey === "object" &&
-                    privateKey !== null &&
-                    "asymmetricKeyType" in privateKey) {
-                    // Node.js KeyObject (e.g. from crypto.generateKeyPairSync)
-                    key = privateKey;
-                }
-                else {
-                    // Buffer or Uint8Array — assume DER/PKCS8 encoded
-                    key = crypto.createPrivateKey({
-                        key: Buffer.from(privateKey),
-                        format: "der",
-                        type: "pkcs8",
-                    });
-                }
-                return new Uint8Array(crypto.sign(null, data, key));
-            }
-            catch (e) {
-                throw new Error("TPSUID7RB: signing failed (check key format)");
-            }
-        }
-        throw new Error("TPSUID7RB: signing not available in browser");
-    }
-    static verifyEd25519(data, signature, publicKey) {
-        if (typeof require !== "undefined") {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const crypto = require("crypto");
-                return crypto.verify(null, data, publicKey, signature);
-            }
-            catch {
-                return false;
-            }
-        }
-        throw new Error("TPSUID7RB: verification not available in browser");
-    }
-    // ---------------------------
-    // Random Bytes
-    // ---------------------------
-    /** Generate cryptographically secure random bytes */
-    static randomBytes(length) {
-        // Node.js environment
-        if (typeof require !== "undefined") {
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                const crypto = require("crypto");
-                return new Uint8Array(crypto.randomBytes(length));
-            }
-            catch {
-                // Fallback to crypto.getRandomValues
-            }
-        }
-        // Browser or fallback
-        if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-            const bytes = new Uint8Array(length);
-            crypto.getRandomValues(bytes);
-            return bytes;
-        }
-        throw new Error("TPSUID7RB: no crypto available");
-    }
-}
-exports.TPSUID7RB = TPSUID7RB;
-/** Magic bytes: "TPU7" */
-TPSUID7RB.MAGIC = new Uint8Array([0x54, 0x50, 0x55, 0x37]);
-/** Version 1 */
-TPSUID7RB.VER = 0x01;
-/** String prefix for base64url encoded form */
-TPSUID7RB.PREFIX = "tpsuid7rb_";
-/** Regex for validating base64url encoded form */
-TPSUID7RB.REGEX = /^tpsuid7rb_[A-Za-z0-9_-]+$/;
 /**
  * `TpsDate` is a Date-like wrapper with native TPS conversion helpers.
  *
@@ -1401,161 +613,4 @@ TPSUID7RB.REGEX = /^tpsuid7rb_[A-Za-z0-9_-]+$/;
  * - `new TpsDate(tpsString)`
  * - `new TpsDate(year, monthIndex, day?, hour?, minute?, second?, ms?)`
  */
-class TpsDate {
-    getTpsComponents() {
-        const parsed = TPS.parse(this.toTPS(exports.DefaultCalendars.TPS));
-        if (!parsed) {
-            throw new Error("TpsDate: failed to derive TPS components");
-        }
-        return parsed;
-    }
-    getTpsFullYear() {
-        const comp = this.getTpsComponents();
-        return (comp.millennium - 1) * 1000 + (comp.century - 1) * 100 + comp.year;
-    }
-    constructor(...args) {
-        if (args.length === 0) {
-            this.internal = new Date();
-            return;
-        }
-        if (args.length === 1) {
-            const value = args[0];
-            if (value instanceof TpsDate) {
-                this.internal = new Date(value.getTime());
-                return;
-            }
-            if (value instanceof Date) {
-                this.internal = new Date(value.getTime());
-                return;
-            }
-            if (typeof value === "string" && TpsDate.looksLikeTPS(value)) {
-                const parsed = TPS.toDate(value);
-                if (!parsed) {
-                    throw new RangeError(`Invalid TPS date string: ${value}`);
-                }
-                this.internal = parsed;
-                return;
-            }
-            this.internal = new Date(value);
-            return;
-        }
-        const [year, monthIndex, day, hours, minutes, seconds, ms] = args;
-        this.internal = new Date(year, monthIndex, day ?? 1, hours ?? 0, minutes ?? 0, seconds ?? 0, ms ?? 0);
-    }
-    static looksLikeTPS(input) {
-        const s = input.trim();
-        return s.startsWith("tps://") || s.startsWith("T:") || s.startsWith("t:");
-    }
-    static now() {
-        return Date.now();
-    }
-    static parse(input) {
-        if (this.looksLikeTPS(input)) {
-            const d = TPS.toDate(input);
-            return d ? d.getTime() : Number.NaN;
-        }
-        return Date.parse(input);
-    }
-    static UTC(year, monthIndex, day, hours, minutes, seconds, ms) {
-        return Date.UTC(year, monthIndex, day ?? 1, hours ?? 0, minutes ?? 0, seconds ?? 0, ms ?? 0);
-    }
-    static fromTPS(tps) {
-        return new TpsDate(tps);
-    }
-    toGregorianDate() {
-        return new Date(this.internal.getTime());
-    }
-    toDate() {
-        return this.toGregorianDate();
-    }
-    toTPS(calendar = exports.DefaultCalendars.TPS, opts) {
-        return TPS.fromDate(this.internal, calendar, opts);
-    }
-    toTPSURI(calendar = exports.DefaultCalendars.TPS, opts) {
-        const time = this.toTPS(calendar, { order: opts?.order });
-        const comp = TPS.parse(time);
-        if (opts?.latitude !== undefined && opts?.longitude !== undefined) {
-            comp.latitude = opts.latitude;
-            comp.longitude = opts.longitude;
-            if (opts.altitude !== undefined)
-                comp.altitude = opts.altitude;
-        }
-        else if (opts?.isHiddenLocation) {
-            comp.isHiddenLocation = true;
-        }
-        else if (opts?.isRedactedLocation) {
-            comp.isRedactedLocation = true;
-        }
-        else {
-            comp.isUnknownLocation = true;
-        }
-        return TPS.toURI(comp);
-    }
-    getTime() {
-        return this.internal.getTime();
-    }
-    valueOf() {
-        return this.internal.valueOf();
-    }
-    toString() {
-        return this.toTPS(exports.DefaultCalendars.TPS);
-    }
-    toISOString() {
-        return this.internal.toISOString();
-    }
-    toUTCString() {
-        return this.internal.toUTCString();
-    }
-    toJSON() {
-        return this.internal.toJSON();
-    }
-    getFullYear() {
-        return this.getTpsFullYear();
-    }
-    getUTCFullYear() {
-        return this.getTpsFullYear();
-    }
-    getMonth() {
-        return this.getTpsComponents().month - 1;
-    }
-    getUTCMonth() {
-        return this.getTpsComponents().month - 1;
-    }
-    getDate() {
-        return this.getTpsComponents().day;
-    }
-    getUTCDate() {
-        return this.getTpsComponents().day;
-    }
-    getHours() {
-        return this.getTpsComponents().hour;
-    }
-    getUTCHours() {
-        return this.getTpsComponents().hour;
-    }
-    getMinutes() {
-        return this.getTpsComponents().minute;
-    }
-    getUTCMinutes() {
-        return this.getTpsComponents().minute;
-    }
-    getSeconds() {
-        return this.getTpsComponents().second;
-    }
-    getUTCSeconds() {
-        return this.getTpsComponents().second;
-    }
-    getMilliseconds() {
-        return this.getTpsComponents().millisecond;
-    }
-    getUTCMilliseconds() {
-        return this.getTpsComponents().millisecond;
-    }
-    [Symbol.toPrimitive](hint) {
-        if (hint === "number")
-            return this.valueOf();
-        return this.toString();
-    }
-}
-exports.TpsDate = TpsDate;
 //# sourceMappingURL=index.js.map