@nextera.one/tps-standard 0.6.0 → 0.8.0

package/dist/tps.min.js

@@ -0,0 +1,3786 @@
+/*! TPS v0.8.0 | Apache-2.0 */
+var TPS = (function (exports) {
+    'use strict';
+
+    /**
+     * TPS: Temporal Positioning System
+     * Shared types and interfaces.
+     */
+    /**
+     * Calendar codes are plain strings to allow arbitrary user-defined
+     * calendars. The library still exports constants for the built-in values.
+     */
+    const DefaultCalendars = {
+        TPS: "tps",
+        GREG: "greg",
+        HIJ: "hij",
+        PER: "per",
+        JUL: "jul",
+        HOLO: "holo",
+        UNIX: "unix",
+        CHIN: "chin",
+    };
+    /**
+     * Specifies the direction of the time-component hierarchy when serializing or
+     * deserializing a TPS string. The default is 'descending'.
+     */
+    exports.TimeOrder = void 0;
+    (function (TimeOrder) {
+        TimeOrder["DESC"] = "desc";
+        TimeOrder["ASC"] = "asc";
+    })(exports.TimeOrder || (exports.TimeOrder = {}));
+
+    const TPS_DAY_MS = 24 * 60 * 60 * 1000;
+    const TPS_DAYS_PER_WEEK = 7;
+    const TPS_WEEKS_PER_MONTH = 4;
+    const TPS_MONTHS_PER_YEAR = 12;
+    const TPS_DAYS_PER_MONTH = TPS_DAYS_PER_WEEK * TPS_WEEKS_PER_MONTH;
+    const TPS_DAYS_PER_YEAR = TPS_DAYS_PER_MONTH * TPS_MONTHS_PER_YEAR;
+    const TPS_EPOCH_START_MS = Date.UTC(1999, 7, 11, 7, 0, 0, 0);
+    function floorDiv(value, divisor) {
+        return Math.floor(value / divisor);
+    }
+    function mod(value, divisor) {
+        return ((value % divisor) + divisor) % divisor;
+    }
+    function getFractionalMilliseconds(second) {
+        if (second === undefined)
+            return 0;
+        const fractional = second - Math.floor(second);
+        return Math.round(fractional * 1000);
+    }
+    function normalizeIndexedParts(dayIndex, dayFraction) {
+        const roundedSubDayMilliseconds = Math.round(dayFraction * TPS_DAY_MS);
+        const dayCarry = floorDiv(roundedSubDayMilliseconds, TPS_DAY_MS);
+        const subDayMilliseconds = mod(roundedSubDayMilliseconds, TPS_DAY_MS);
+        const normalizedDayIndex = dayIndex + dayCarry;
+        return {
+            dayIndex: normalizedDayIndex,
+            dayFraction: subDayMilliseconds / TPS_DAY_MS,
+            subDayMilliseconds,
+        };
+    }
+    function splitTpsFullYear(fullYear) {
+        const millennium = floorDiv(fullYear, 1000) + 1;
+        const withinMillennium = mod(fullYear, 1000);
+        const century = floorDiv(withinMillennium, 100) + 1;
+        const year = mod(fullYear, 100);
+        return { millennium, century, year };
+    }
+    function getTpsFullYear(components) {
+        if (components.millennium !== undefined ||
+            components.century !== undefined) {
+            return (((components.millennium ?? 1) - 1) * 1000 +
+                ((components.century ?? 1) - 1) * 100 +
+                (components.year ?? 0));
+        }
+        return components.year ?? 0;
+    }
+    function getTpsDayOfMonth(components) {
+        const day = components.day ?? 1;
+        const week = components.week;
+        if (week !== undefined && day >= 1 && day <= TPS_DAYS_PER_WEEK) {
+            return (week - 1) * TPS_DAYS_PER_WEEK + day;
+        }
+        return day;
+    }
+    function getTpsSubDayMilliseconds(input) {
+        if (input instanceof Date) {
+            const indexed = getTpsIndexedFromDate(input);
+            return indexed.subDayMilliseconds;
+        }
+        if (input.subDayMilliseconds !== undefined) {
+            return input.subDayMilliseconds;
+        }
+        const hour = input.hour ?? 0;
+        const minute = input.minute ?? 0;
+        const second = Math.floor(input.second ?? 0);
+        const millisecond = input.millisecond ?? getFractionalMilliseconds(input.second);
+        return (hour * 60 * 60 * 1000 +
+            minute * 60 * 1000 +
+            second * 1000 +
+            millisecond);
+    }
+    function getTpsIndexedFromDate(date) {
+        const deltaMs = date.getTime() - TPS_EPOCH_START_MS;
+        const dayIndex = floorDiv(deltaMs, TPS_DAY_MS);
+        const subDayMilliseconds = mod(deltaMs, TPS_DAY_MS);
+        return {
+            dayIndex,
+            dayFraction: subDayMilliseconds / TPS_DAY_MS,
+            subDayMilliseconds,
+        };
+    }
+    function buildTpsComponentsFromDayIndex(dayIndex, dayFraction = 0) {
+        const indexed = normalizeIndexedParts(dayIndex, dayFraction);
+        const fullYear = floorDiv(indexed.dayIndex, TPS_DAYS_PER_YEAR);
+        const dayOfYear = mod(indexed.dayIndex, TPS_DAYS_PER_YEAR);
+        const month = floorDiv(dayOfYear, TPS_DAYS_PER_MONTH) + 1;
+        const dayOfMonth = mod(dayOfYear, TPS_DAYS_PER_MONTH) + 1;
+        const week = floorDiv(dayOfMonth - 1, TPS_DAYS_PER_WEEK) + 1;
+        let remainder = indexed.subDayMilliseconds;
+        const hour = floorDiv(remainder, 60 * 60 * 1000);
+        remainder = mod(remainder, 60 * 60 * 1000);
+        const minute = floorDiv(remainder, 60 * 1000);
+        remainder = mod(remainder, 60 * 1000);
+        const second = floorDiv(remainder, 1000);
+        const millisecond = mod(remainder, 1000);
+        return {
+            calendar: "tps",
+            ...splitTpsFullYear(fullYear),
+            month,
+            week,
+            day: dayOfMonth,
+            hour,
+            minute,
+            second,
+            millisecond,
+            dayIndex: indexed.dayIndex,
+            dayFraction: indexed.dayFraction,
+            subDayMilliseconds: indexed.subDayMilliseconds,
+        };
+    }
+    function normalizeTpsComponents(components) {
+        if (components.dayIndex !== undefined) {
+            const dayFraction = components.dayFraction ??
+                (getTpsSubDayMilliseconds(components) / TPS_DAY_MS);
+            const normalized = buildTpsComponentsFromDayIndex(components.dayIndex, dayFraction);
+            return {
+                ...components,
+                ...normalized,
+                calendar: "tps",
+                fractionPrecision: components.fractionPrecision,
+            };
+        }
+        const fullYear = getTpsFullYear(components);
+        const month = components.month ?? 1;
+        const dayOfMonth = getTpsDayOfMonth(components);
+        const subDayMilliseconds = getTpsSubDayMilliseconds(components);
+        const week = components.week ?? floorDiv(dayOfMonth - 1, TPS_DAYS_PER_WEEK) + 1;
+        const timeParts = buildTpsComponentsFromDayIndex(fullYear * TPS_DAYS_PER_YEAR +
+            (month - 1) * TPS_DAYS_PER_MONTH +
+            (dayOfMonth - 1), subDayMilliseconds / TPS_DAY_MS);
+        return {
+            ...components,
+            ...splitTpsFullYear(fullYear),
+            ...timeParts,
+            calendar: "tps",
+            month,
+            week,
+            day: dayOfMonth,
+            dayIndex: fullYear * TPS_DAYS_PER_YEAR +
+                (month - 1) * TPS_DAYS_PER_MONTH +
+                (dayOfMonth - 1),
+            dayFraction: subDayMilliseconds / TPS_DAY_MS,
+            subDayMilliseconds,
+        };
+    }
+    function getTpsDayIndex(input) {
+        if (input instanceof Date) {
+            return getTpsIndexedFromDate(input).dayIndex;
+        }
+        if (input.dayIndex !== undefined) {
+            return input.dayIndex;
+        }
+        const fullYear = getTpsFullYear(input);
+        const month = input.month ?? 1;
+        const dayOfMonth = getTpsDayOfMonth(input);
+        return (fullYear * TPS_DAYS_PER_YEAR +
+            (month - 1) * TPS_DAYS_PER_MONTH +
+            (dayOfMonth - 1));
+    }
+    function getTpsDayFraction(input) {
+        if (input instanceof Date) {
+            return getTpsIndexedFromDate(input).dayFraction;
+        }
+        if (input.dayFraction !== undefined) {
+            return input.dayFraction;
+        }
+        return getTpsSubDayMilliseconds(input) / TPS_DAY_MS;
+    }
+    function parseTpsIndexedToken(token) {
+        const match = token.trim().match(/^i(\d+)(?:\.(\d+))?$/i);
+        if (!match)
+            return null;
+        const dayIndex = Number(match[1]);
+        if (!Number.isSafeInteger(dayIndex) || dayIndex < 0) {
+            return null;
+        }
+        const digits = match[2];
+        if (digits && digits.endsWith("0")) {
+            return null;
+        }
+        const dayFraction = digits ? Number(`0.${digits}`) : 0;
+        if (!Number.isFinite(dayFraction) || dayFraction < 0 || dayFraction >= 1) {
+            return null;
+        }
+        const normalized = normalizeIndexedParts(dayIndex, dayFraction);
+        return {
+            ...normalized,
+            fractionPrecision: digits?.length,
+        };
+    }
+    function formatTpsIndexedToken(components, precision) {
+        const normalized = normalizeTpsComponents(components);
+        const dayIndex = normalized.dayIndex ?? 0;
+        const dayFraction = normalized.dayFraction ?? 0;
+        const effectivePrecision = precision ?? normalized.fractionPrecision ?? 9;
+        let fraction = "";
+        if (dayFraction > 0 && effectivePrecision > 0) {
+            fraction = dayFraction
+                .toFixed(effectivePrecision)
+                .slice(2)
+                .replace(/0+$/g, "");
+        }
+        return fraction ? `i${dayIndex}.${fraction}` : `i${dayIndex}`;
+    }
+    function isTpsIndexedToken(token) {
+        return /^i\d+(?:\.\d+)?$/i.test(token.trim());
+    }
+    function validateTpsComponents(components) {
+        const month = components.month ?? 1;
+        const day = components.day ?? 1;
+        const week = components.week;
+        const hour = components.hour ?? 0;
+        const minute = components.minute ?? 0;
+        const second = components.second ?? 0;
+        const millisecond = components.millisecond ?? getFractionalMilliseconds(components.second);
+        if (components.dayIndex !== undefined &&
+            (!Number.isSafeInteger(components.dayIndex) || components.dayIndex < 0)) {
+            return false;
+        }
+        if (components.dayFraction !== undefined &&
+            (!Number.isFinite(components.dayFraction) ||
+                components.dayFraction < 0 ||
+                components.dayFraction >= 1)) {
+            return false;
+        }
+        if (month < 1 || month > TPS_MONTHS_PER_YEAR)
+            return false;
+        if (day < 1 || day > TPS_DAYS_PER_MONTH)
+            return false;
+        if (week !== undefined && (week < 1 || week > TPS_WEEKS_PER_MONTH)) {
+            return false;
+        }
+        if (week !== undefined && day > TPS_DAYS_PER_WEEK) {
+            const expectedWeek = floorDiv(day - 1, TPS_DAYS_PER_WEEK) + 1;
+            if (expectedWeek !== week)
+                return false;
+        }
+        if (hour < 0 || hour > 23)
+            return false;
+        if (minute < 0 || minute > 59)
+            return false;
+        if (second < 0 || second >= 60)
+            return false;
+        if (millisecond < 0 || millisecond >= 1000)
+            return false;
+        return true;
+    }
+
+    /**
+     * Generate the canonical `T:` time string for a set of components.
+     */
+    function buildTimePart(comp, options) {
+        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 === DefaultCalendars.UNIX) {
+            if (comp.unixSeconds !== undefined) {
+                time += `.s${comp.unixSeconds}`;
+            }
+            return time;
+        }
+        if (calendar === DefaultCalendars.TPS && options?.timeMode === "indexed-fraction") {
+            time += `.${formatTpsIndexedToken(comp, options.indexedPrecision)}`;
+            if (comp.signature) {
+                time += `!${comp.signature}`;
+            }
+            return time;
+        }
+        const source = calendar === DefaultCalendars.TPS ? normalizeTpsComponents(comp) : comp;
+        const tokens = [
+            ["m", source.millennium, 8],
+            ["c", source.century, 7],
+            ["y", source.year, 6],
+            ["m", source.month, 5],
+            ...(calendar === DefaultCalendars.TPS && source.week !== undefined
+                ? [["w", source.week, 4.5]]
+                : []),
+            ["d", source.day, 4],
+            ["h", source.hour, 3],
+            ["m", source.minute, 2],
+            ["s", source.second, 1],
+            ["m", source.millisecond, 0],
+        ];
+        const order = options?.order || source.order || exports.TimeOrder.DESC;
+        const activeTokens = order === exports.TimeOrder.ASC ? [...tokens].reverse() : tokens;
+        for (const [pref, val] of activeTokens) {
+            if (val !== undefined) {
+                time += `.${pref}${val}`;
+            }
+        }
+        if (source.signature) {
+            time += `!${source.signature}`;
+        }
+        return time;
+    }
+    /**
+     * Parse the time portion of a TPS string into components.
+     */
+    function parseTimeString(input) {
+        let s = input.trim();
+        s = s.split(/[!;?#]/)[0];
+        if (s.startsWith("T:"))
+            s = s.slice(2);
+        const firstDot = s.indexOf(".");
+        const calendar = firstDot === -1 ? s : s.slice(0, firstDot);
+        const rawTokenString = firstDot === -1 ? "" : s.slice(firstDot + 1);
+        if (calendar === DefaultCalendars.TPS && isTpsIndexedToken(rawTokenString)) {
+            const indexed = parseTpsIndexedToken(rawTokenString);
+            if (!indexed)
+                return null;
+            return {
+                components: normalizeTpsComponents({
+                    calendar,
+                    ...indexed,
+                }),
+                order: exports.TimeOrder.DESC,
+            };
+        }
+        if (calendar === DefaultCalendars.TPS && /^i/i.test(rawTokenString)) {
+            return null;
+        }
+        const parts = s.split(".");
+        if (parts.length === 0)
+            return null;
+        const comp = { calendar };
+        const fixedRankMap = {
+            c: 7,
+            y: 6,
+            w: 4.5,
+            d: 4,
+            h: 3,
+            s: 1,
+        };
+        let initialOrder = exports.TimeOrder.DESC;
+        if (calendar !== 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 = exports.TimeOrder.ASC;
+            }
+        }
+        const assignMRank = (lastRank, ord) => {
+            if (ord === exports.TimeOrder.DESC) {
+                if (lastRank === null)
+                    return 8;
+                if (lastRank > 5)
+                    return 5;
+                if (lastRank > 2)
+                    return 2;
+                return 0;
+            }
+            else {
+                if (lastRank === null)
+                    return 0;
+                if (lastRank < 2)
+                    return 2;
+                if (lastRank < 5)
+                    return 5;
+                return 8;
+            }
+        };
+        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);
+            if (calendar === 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 {
+                const rank = fixedRankMap[prefix];
+                if (rank !== undefined) {
+                    switch (prefix) {
+                        case "c":
+                            comp.century = parseInt(value, 10);
+                            break;
+                        case "y":
+                            comp.year = parseInt(value, 10);
+                            break;
+                        case "w":
+                            comp.week = parseInt(value, 10);
+                            break;
+                        case "d":
+                            comp.day = parseInt(value, 10);
+                            break;
+                        case "h":
+                            comp.hour = parseInt(value, 10);
+                            break;
+                        case "s":
+                            comp.second = parseFloat(value);
+                            break;
+                    }
+                    ranks.push(rank);
+                    lastAssignedRank = rank;
+                }
+            }
+        }
+        let order = exports.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 = exports.TimeOrder.ASC;
+        }
+        if (calendar === DefaultCalendars.TPS &&
+            comp.month !== undefined &&
+            comp.day !== undefined &&
+            comp.month >= 1 &&
+            comp.day >= 1) {
+            return {
+                components: normalizeTpsComponents(comp),
+                order,
+            };
+        }
+        return { components: comp, order };
+    }
+
+    /**
+     * Gregorian calendar driver.
+     * Supports robust validation and canonical Date conversions.
+     */
+    class GregorianDriver {
+        constructor() {
+            this.code = "greg";
+        }
+        getComponentsFromDate(date) {
+            const fullYear = date.getUTCFullYear();
+            return {
+                calendar: this.code,
+                millennium: Math.floor(fullYear / 1000) + 1,
+                century: Math.floor((fullYear % 1000) / 100) + 1,
+                year: fullYear % 100,
+                month: date.getUTCMonth() + 1,
+                day: date.getUTCDate(),
+                hour: date.getUTCHours(),
+                minute: date.getUTCMinutes(),
+                second: date.getUTCSeconds(),
+                millisecond: date.getUTCMilliseconds(),
+            };
+        }
+        getDateFromComponents(components) {
+            const m = components.millennium ?? 0;
+            const c = components.century ?? 1;
+            const y = components.year ?? 0;
+            const fullYear = (m - 1) * 1000 + (c - 1) * 100 + y;
+            return new Date(Date.UTC(fullYear, (components.month || 1) - 1, components.day || 1, components.hour || 0, components.minute || 0, Math.floor(components.second || 0), components.millisecond ??
+                Math.round(((components.second || 0) % 1) * 1000)));
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        // --- optional helpers --------------------------------------------------
+        parseDate(input, format) {
+            const s = input.trim();
+            const m = s.match(/^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/);
+            if (!m) {
+                throw new Error(`GregorianDriver.parseDate: unsupported format "${input}"`);
+            }
+            const year = parseInt(m[1], 10);
+            const month = parseInt(m[2], 10);
+            const day = parseInt(m[3], 10);
+            const hour = m[4] !== undefined ? parseInt(m[4], 10) : undefined;
+            const minute = m[5] !== undefined ? parseInt(m[5], 10) : undefined;
+            const second = m[6] !== undefined ? parseInt(m[6], 10) : undefined;
+            const millisecond = m[7] !== undefined ? parseInt((m[7] + "000").slice(0, 3), 10) : undefined;
+            const comp = {
+                calendar: this.code,
+                year,
+                month,
+                day,
+            };
+            if (hour !== undefined)
+                comp.hour = hour;
+            if (minute !== undefined)
+                comp.minute = minute;
+            if (second !== undefined)
+                comp.second = second;
+            if (millisecond !== undefined)
+                comp.millisecond = millisecond;
+            return comp;
+        }
+        format(components, format) {
+            const y = components.year !== undefined
+                ? String(components.year).padStart(4, "0")
+                : "0000";
+            const mo = components.month !== undefined
+                ? String(components.month).padStart(2, "0")
+                : "01";
+            const d = components.day !== undefined
+                ? String(components.day).padStart(2, "0")
+                : "01";
+            let out = `${y}-${mo}-${d}`;
+            if (components.hour !== undefined ||
+                components.minute !== undefined ||
+                components.second !== undefined ||
+                components.millisecond !== undefined) {
+                const h = components.hour !== undefined
+                    ? String(components.hour).padStart(2, "0")
+                    : "00";
+                const mi = components.minute !== undefined
+                    ? String(components.minute).padStart(2, "0")
+                    : "00";
+                const s = components.second !== undefined
+                    ? String(Math.floor(components.second)).padStart(2, "0")
+                    : "00";
+                const ms = components.millisecond !== undefined
+                    ? String(components.millisecond).padStart(3, "0")
+                    : "000";
+                out += `T${h}:${mi}:${s}.${ms}`;
+            }
+            return out;
+        }
+        isLeap(y) {
+            return (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
+        }
+        validate(input) {
+            if (typeof input === "string") {
+                return /^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)?$/.test(input.trim());
+            }
+            if (typeof input === "object") {
+                const y = input.year ?? 0;
+                const m = input.month ?? 1;
+                const d = input.day ?? 1;
+                if (y < 0 || m < 1 || m > 12 || d < 1)
+                    return false;
+                const daysInMonth = [
+                    31,
+                    this.isLeap(y) ? 29 : 28,
+                    31,
+                    30,
+                    31,
+                    30,
+                    31,
+                    31,
+                    30,
+                    31,
+                    30,
+                    31,
+                ];
+                return d <= daysInMonth[m - 1];
+            }
+            return false;
+        }
+        getMetadata() {
+            return {
+                name: "Gregorian",
+                monthNames: [
+                    "January",
+                    "February",
+                    "March",
+                    "April",
+                    "May",
+                    "June",
+                    "July",
+                    "August",
+                    "September",
+                    "October",
+                    "November",
+                    "December",
+                ],
+                dayNames: [
+                    "Sunday",
+                    "Monday",
+                    "Tuesday",
+                    "Wednesday",
+                    "Thursday",
+                    "Friday",
+                    "Saturday",
+                ],
+                monthsPerYear: 12,
+                epochYear: 1,
+            };
+        }
+    }
+
+    /**
+     * Unix calendar driver. Represents the epoch timestamp in seconds with
+     * fractional milliseconds.
+     */
+    class UnixDriver {
+        constructor() {
+            this.code = "unix";
+        }
+        getComponentsFromDate(date) {
+            const s = (date.getTime() / 1000).toFixed(3);
+            return { calendar: this.code, unixSeconds: parseFloat(s) };
+        }
+        getDateFromComponents(components) {
+            if (components.unixSeconds !== undefined) {
+                return new Date(components.unixSeconds * 1000);
+            }
+            return new Date(0);
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        parseDate(input, _format) {
+            const s = input.trim();
+            if (!/^[0-9]+(?:\.[0-9]+)?$/.test(s)) {
+                throw new Error(`UnixDriver.parseDate: unsupported format "${input}"`);
+            }
+            return { calendar: this.code, unixSeconds: parseFloat(s) };
+        }
+        format(components, _format) {
+            if (components.unixSeconds === undefined)
+                throw new Error("UnixDriver.format: missing unixSeconds");
+            return new Date(components.unixSeconds * 1000).toISOString();
+        }
+        validate(input) {
+            if (typeof input === "string")
+                return /^[0-9]+(?:\.[0-9]+)?$/.test(input.trim());
+            if (typeof input === "object")
+                return typeof input.unixSeconds === "number" && !isNaN(input.unixSeconds);
+            return false;
+        }
+        getMetadata() {
+            return {
+                name: "Unix Epoch",
+                monthsPerYear: 0,
+            };
+        }
+    }
+
+    /**
+     * TPS calendar driver for canonical TPS time strings.
+     *
+     * TPS Calendar characteristics:
+     * - Epoch anchor: 1999-08-11T07:00:00.000Z
+     * - Day boundary: 07:00 Gregorian / UTC
+     * - Year shape: 12 months × 4 weeks × 7 days = 336 days
+     */
+    class TpsDriver {
+        constructor() {
+            this.code = "tps";
+            this.name = "TPS Indexed";
+        }
+        getComponentsFromDate(date) {
+            const deltaMs = date.getTime() - TPS_EPOCH_START_MS;
+            const dayIndex = Math.floor(deltaMs / TPS_DAY_MS);
+            const dayFraction = ((deltaMs % TPS_DAY_MS) + TPS_DAY_MS) % TPS_DAY_MS / TPS_DAY_MS;
+            return buildTpsComponentsFromDayIndex(dayIndex, dayFraction);
+        }
+        getDateFromComponents(components) {
+            const normalized = normalizeTpsComponents({
+                ...components,
+                calendar: this.code,
+            });
+            const dayIndex = normalized.dayIndex ?? 0;
+            const subDayMilliseconds = normalized.subDayMilliseconds ?? 0;
+            return new Date(TPS_EPOCH_START_MS + dayIndex * TPS_DAY_MS + subDayMilliseconds);
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        parseDate(input, _format) {
+            const s = input.trim();
+            const indexed = parseTpsIndexedToken(s);
+            if (indexed) {
+                return normalizeTpsComponents({
+                    calendar: this.code,
+                    ...indexed,
+                });
+            }
+            const m = s.match(/^(-?\d{1,6})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/);
+            if (!m)
+                throw new Error(`TpsDriver.parseDate: unsupported format "${input}"`);
+            const year = parseInt(m[1], 10);
+            const month = parseInt(m[2], 10);
+            const day = parseInt(m[3], 10);
+            if (month < 1 || month > TPS_MONTHS_PER_YEAR) {
+                throw new Error(`TpsDriver.parseDate: invalid TPS month ${month} (expected 1-12)`);
+            }
+            if (day < 1 || day > TPS_DAYS_PER_MONTH) {
+                throw new Error(`TpsDriver.parseDate: invalid TPS day ${day} (expected 1-28)`);
+            }
+            const hour = m[4] !== undefined ? parseInt(m[4], 10) : undefined;
+            const minute = m[5] !== undefined ? parseInt(m[5], 10) : undefined;
+            const second = m[6] !== undefined ? parseInt(m[6], 10) : undefined;
+            const millisecond = m[7] !== undefined ? parseInt((m[7] + "000").slice(0, 3), 10) : undefined;
+            const comp = {
+                calendar: this.code,
+                year,
+                month,
+                day,
+            };
+            if (hour !== undefined)
+                comp.hour = hour;
+            if (minute !== undefined)
+                comp.minute = minute;
+            if (second !== undefined)
+                comp.second = second;
+            if (millisecond !== undefined)
+                comp.millisecond = millisecond;
+            return normalizeTpsComponents(comp);
+        }
+        format(components, _format) {
+            const normalized = normalizeTpsComponents({
+                ...components,
+                calendar: this.code,
+            });
+            const fullYear = getTpsFullYear(normalized);
+            const y = normalized.year !== undefined
+                ? String(fullYear).padStart(4, "0")
+                : "0000";
+            const mo = normalized.month !== undefined
+                ? String(normalized.month).padStart(2, "0")
+                : "01";
+            const d = normalized.day !== undefined
+                ? String(normalized.day).padStart(2, "0")
+                : "01";
+            let out = `${y}-${mo}-${d}`;
+            if (normalized.hour !== undefined ||
+                normalized.minute !== undefined ||
+                normalized.second !== undefined ||
+                normalized.millisecond !== undefined) {
+                const h = normalized.hour !== undefined
+                    ? String(normalized.hour).padStart(2, "0")
+                    : "00";
+                const mi = normalized.minute !== undefined
+                    ? String(normalized.minute).padStart(2, "0")
+                    : "00";
+                const s = normalized.second !== undefined
+                    ? String(Math.floor(normalized.second)).padStart(2, "0")
+                    : "00";
+                const ms = normalized.millisecond !== undefined
+                    ? String(normalized.millisecond).padStart(3, "0")
+                    : "000";
+                out += `T${h}:${mi}:${s}.${ms}`;
+            }
+            return out;
+        }
+        validate(input) {
+            if (typeof input === "string") {
+                if (parseTpsIndexedToken(input.trim())) {
+                    return true;
+                }
+                try {
+                    return validateTpsComponents(this.parseDate(input));
+                }
+                catch {
+                    return false;
+                }
+            }
+            if (typeof input === "object") {
+                return validateTpsComponents(input);
+            }
+            return false;
+        }
+        getMetadata() {
+            return {
+                name: "TPS Native (epoch-based 12x4x7)",
+                monthNames: [
+                    "Month 1",
+                    "Month 2",
+                    "Month 3",
+                    "Month 4",
+                    "Month 5",
+                    "Month 6",
+                    "Month 7",
+                    "Month 8",
+                    "Month 9",
+                    "Month 10",
+                    "Month 11",
+                    "Month 12",
+                ],
+                dayNames: [
+                    "Day 1",
+                    "Day 2",
+                    "Day 3",
+                    "Day 4",
+                    "Day 5",
+                    "Day 6",
+                    "Day 7",
+                ],
+                monthsPerYear: TPS_MONTHS_PER_YEAR,
+                epochYear: 1999,
+                isLunar: false,
+            };
+        }
+    }
+
+    /**
+     * Shared Calendar Math Utilities
+     */
+    /**
+     * Gregorian -> Julian Day Number
+     */
+    function gregorianToJdn(gy, gm, gd) {
+        const a = Math.floor((14 - gm) / 12);
+        const y = gy + 4800 - a;
+        const m = gm + 12 * a - 3;
+        return (gd +
+            Math.floor((153 * m + 2) / 5) +
+            365 * y +
+            Math.floor(y / 4) -
+            Math.floor(y / 100) +
+            Math.floor(y / 400) -
+            32045);
+    }
+    /**
+     * Julian Day Number -> Gregorian
+     */
+    function jdnToGregorian(jdn) {
+        const a = jdn + 32044;
+        const b = Math.floor((4 * a + 3) / 146097);
+        const c = a - Math.floor((146097 * b) / 4);
+        const d = Math.floor((4 * c + 3) / 1461);
+        const e = c - Math.floor((1461 * d) / 4);
+        const m = Math.floor((5 * e + 2) / 153);
+        const gd = e - Math.floor((153 * m + 2) / 5) + 1;
+        const gm = m + 3 - 12 * Math.floor(m / 10);
+        const gy = 100 * b + d - 4800 + Math.floor(m / 10);
+        return { gy, gm, gd };
+    }
+    /**
+     * Julian -> Julian Day Number
+     */
+    function julianToJdn(jy, jm, jd) {
+        const a = Math.floor((14 - jm) / 12);
+        const y = jy + 4800 - a;
+        const m = jm + 12 * a - 3;
+        return (jd + Math.floor((153 * m + 2) / 5) + 365 * y + Math.floor(y / 4) - 32083);
+    }
+    /**
+     * Julian Day Number -> Julian
+     */
+    function jdnToJulian(jdn) {
+        const c = jdn + 32082;
+        const d = Math.floor((4 * c + 3) / 1461);
+        const e = c - Math.floor((1461 * d) / 4);
+        const m = Math.floor((5 * e + 2) / 153);
+        const jd = e - Math.floor((153 * m + 2) / 5) + 1;
+        const jm = m + 3 - 12 * Math.floor(m / 10);
+        const jy = d - 4800 + Math.floor(m / 10);
+        return { jy, jm, jd };
+    }
+    /**
+     * Persian -> Julian Day Number
+     */
+    function persianToJdn(jy, jm, jd) {
+        const EPOCH = 1948320;
+        const epbase = jy - (jy >= 0 ? 474 : 473);
+        const epyear = 474 + (epbase % 2820);
+        return (jd +
+            (jm <= 7 ? (jm - 1) * 31 : (jm - 1) * 30 + 6) +
+            Math.floor((epyear * 682 - 110) / 2816) +
+            (epyear - 1) * 365 +
+            Math.floor(epbase / 2820) * 1029983 +
+            EPOCH -
+            1);
+    }
+    /**
+     * Julian Day Number -> Persian
+     */
+    function jdnToPersian(jdn) {
+        const depoch = jdn - persianToJdn(475, 1, 1);
+        const cycle = Math.floor(depoch / 1029983);
+        const cyear = depoch % 1029983;
+        let ycycle;
+        if (cyear === 1029982) {
+            ycycle = 2820;
+        }
+        else {
+            const aux1 = Math.floor(cyear / 366);
+            const aux2 = cyear % 366;
+            ycycle =
+                Math.floor((2134 * aux1 + 2816 * aux2 + 2815) / 1028522) + aux1 + 1;
+        }
+        const jy = ycycle + 2820 * cycle + 474;
+        const yday = jdn - persianToJdn(jy, 1, 1) + 1;
+        const jm = yday <= 186 ? Math.ceil(yday / 31) : Math.ceil((yday - 6) / 30);
+        const jd = jdn - persianToJdn(jy, jm, 1) + 1;
+        return { jy: jy <= 0 ? jy - 1 : jy, jm, jd };
+    }
+    /**
+     * Convert Gregorian to Hijri (Tabular Islamic Calendar).
+     */
+    function gregorianToHijri(gy, gm, gd) {
+        const jdn = gregorianToJdn(gy, gm, gd);
+        const L = jdn - 1948440 + 10632;
+        const N = Math.floor((L - 1) / 10631);
+        const L2 = L - 10631 * N + 354;
+        const J = Math.floor((10985 - L2) / 5316) * Math.floor((50 * L2) / 17719) +
+            Math.floor(L2 / 5670) * Math.floor((43 * L2) / 15238);
+        const L3 = L2 -
+            Math.floor((30 - J) / 15) * Math.floor((17719 * J) / 50) -
+            Math.floor(J / 16) * Math.floor((15238 * J) / 43) +
+            29;
+        const hm = Math.floor((24 * L3) / 709);
+        const hd = L3 - Math.floor((709 * hm) / 24);
+        const hy = 30 * N + J - 30;
+        return { hy, hm, hd };
+    }
+    /**
+     * Convert Hijri to Gregorian.
+     */
+    function hijriToGregorian(hy, hm, hd) {
+        const jdn = Math.floor((11 * hy + 3) / 30) +
+            354 * hy +
+            30 * hm -
+            Math.floor((hm - 1) / 2) +
+            hd +
+            1948440 -
+            385;
+        return jdnToGregorian(jdn);
+    }
+
+    class PersianDriver {
+        constructor() {
+            this.code = "per";
+            this.name = "Persian (Jalali/Solar Hijri)";
+            this.MONTH_NAMES = [
+                "Farvardin",
+                "Ordibehesht",
+                "Khordad",
+                "Tir",
+                "Mordad",
+                "Shahrivar",
+                "Mehr",
+                "Aban",
+                "Azar",
+                "Dey",
+                "Bahman",
+                "Esfand",
+            ];
+            this.MONTH_NAMES_SHORT = [
+                "Far",
+                "Ord",
+                "Kho",
+                "Tir",
+                "Mor",
+                "Sha",
+                "Meh",
+                "Aba",
+                "Aza",
+                "Dey",
+                "Bah",
+                "Esf",
+            ];
+            this.DAY_NAMES = [
+                "Yekshanbeh",
+                "Doshanbeh",
+                "Seshanbeh",
+                "Chaharshanbeh",
+                "Panjshanbeh",
+                "Jomeh",
+                "Shanbeh",
+            ];
+            /** Days per month (non-leap): 6×31 + 5×30 + 1×29 = 365 */
+            this.DAYS_IN_MONTH = [
+                31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29,
+            ];
+        }
+        getComponentsFromDate(date) {
+            const jdn = gregorianToJdn(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+            const { jy, jm, jd } = jdnToPersian(jdn);
+            return {
+                calendar: this.code,
+                millennium: Math.floor(jy / 1000) + 1,
+                century: Math.floor((jy % 1000) / 100) + 1,
+                year: jy % 100,
+                month: jm,
+                day: jd,
+                hour: date.getUTCHours(),
+                minute: date.getUTCMinutes(),
+                second: date.getUTCSeconds(),
+                millisecond: date.getUTCMilliseconds(),
+            };
+        }
+        getDateFromComponents(components) {
+            let jy;
+            if (components.millennium !== undefined) {
+                const m = components.millennium ?? 0;
+                const c = components.century ?? 1;
+                const y = components.year ?? 0;
+                jy = (m - 1) * 1000 + (c - 1) * 100 + y;
+            }
+            else {
+                jy = components.year ?? 1;
+            }
+            const jm = components.month ?? 1;
+            const jd = components.day ?? 1;
+            const jdn = persianToJdn(jy, jm, jd);
+            const { gy, gm, gd } = jdnToGregorian(jdn);
+            return new Date(Date.UTC(gy, gm - 1, gd, components.hour ?? 0, components.minute ?? 0, Math.floor(components.second ?? 0), components.millisecond ?? 0));
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        parseDate(input, format) {
+            const trimmed = input.trim();
+            if (format === "short" ||
+                (trimmed.includes("/") && trimmed.split("/")[0].length <= 2)) {
+                const parts = trimmed.split("/").map(Number);
+                let fullYear, month, day;
+                if (parts[0] > 31) {
+                    [fullYear, month, day] = parts;
+                }
+                else {
+                    [day, month, fullYear] = parts;
+                }
+                return {
+                    calendar: this.code,
+                    millennium: Math.floor(fullYear / 1000) + 1,
+                    century: Math.floor((fullYear % 1000) / 100) + 1,
+                    year: fullYear % 100,
+                    month,
+                    day,
+                };
+            }
+            const segments = trimmed.split(/[\s,T]+/);
+            const [parsedYear, month, day] = segments[0].split(/[-/]/).map(Number);
+            const result = { calendar: this.code };
+            const fullYear = parsedYear;
+            result.millennium = Math.floor(fullYear / 1000) + 1;
+            result.century = Math.floor((fullYear % 1000) / 100) + 1;
+            result.year = fullYear % 100;
+            result.month = month;
+            result.day = day;
+            if (segments[1]) {
+                const [h, m, s] = segments[1].split(":").map(Number);
+                result.hour = h ?? 0;
+                result.minute = m ?? 0;
+                result.second = s ?? 0;
+            }
+            return result;
+        }
+        format(components, format) {
+            const pad = (n) => String(n ?? 0).padStart(2, "0");
+            let fullYear;
+            if (components.millennium !== undefined) {
+                const m = components.millennium ?? 0;
+                const c = components.century ?? 1;
+                const y = components.year ?? 0;
+                fullYear = (m - 1) * 1000 + (c - 1) * 100 + y;
+            }
+            else {
+                fullYear = components.year ?? 0;
+            }
+            if (format === "short")
+                return `${components.day}/${pad(components.month)}/${fullYear}`;
+            if (format === "long") {
+                const mn = this.MONTH_NAMES[(components.month ?? 1) - 1];
+                return `${components.day} ${mn} ${fullYear}`;
+            }
+            let out = `${fullYear}-${pad(components.month)}-${pad(components.day)}`;
+            if (components.hour !== undefined) {
+                out += ` ${pad(components.hour)}:${pad(components.minute)}:${pad(Math.floor(components.second ?? 0))}`;
+            }
+            return out;
+        }
+        validate(input) {
+            let comp;
+            if (typeof input === "string") {
+                try {
+                    comp = this.parseDate(input);
+                }
+                catch {
+                    return false;
+                }
+            }
+            else {
+                comp = input;
+            }
+            const { year, month, day } = comp;
+            if (year === undefined || year < 1)
+                return false;
+            if (month === undefined || month < 1 || month > 12)
+                return false;
+            if (day === undefined || day < 1)
+                return false;
+            // leap check
+            const leapYears = [1, 5, 9, 13, 17, 22, 26, 30];
+            const cycle = ((year - 1) % 33) + 1;
+            const isLeap = leapYears.includes(cycle);
+            let max = this.DAYS_IN_MONTH[month - 1];
+            if (month === 12 && isLeap)
+                max = 30;
+            return day <= max;
+        }
+        getMetadata() {
+            return {
+                name: "Persian (Jalali/Solar Hijri)",
+                monthNames: this.MONTH_NAMES,
+                monthNamesShort: this.MONTH_NAMES_SHORT,
+                dayNames: this.DAY_NAMES,
+                dayNamesShort: this.DAY_NAMES.map((d) => d.slice(0, 3)),
+                isLunar: false,
+                monthsPerYear: 12,
+                epochYear: 622,
+            };
+        }
+    }
+
+    class HijriDriver {
+        constructor() {
+            this.code = "hij";
+            this.name = "Hijri (Islamic Calendar)";
+            this.MONTH_NAMES = [
+                "Muharram",
+                "Safar",
+                "Rabi' al-Awwal",
+                "Rabi' al-Thani",
+                "Jumada al-Ula",
+                "Jumada al-Thani",
+                "Rajab",
+                "Sha'ban",
+                "Ramadan",
+                "Shawwal",
+                "Dhu al-Qi'dah",
+                "Dhu al-Hijjah",
+            ];
+            this.MONTH_NAMES_SHORT = [
+                "Muh",
+                "Saf",
+                "Rab I",
+                "Rab II",
+                "Jum I",
+                "Jum II",
+                "Raj",
+                "Sha",
+                "Ram",
+                "Shaw",
+                "Dhu Q",
+                "Dhu H",
+            ];
+            this.DAY_NAMES = [
+                "al-Ahad",
+                "al-Ithnayn",
+                "ath-Thulatha",
+                "al-Arbi'a",
+                "al-Khamis",
+                "al-Jumu'ah",
+                "as-Sabt",
+            ];
+        }
+        getComponentsFromDate(date) {
+            const { hy, hm, hd } = gregorianToHijri(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+            return {
+                calendar: this.code,
+                millennium: Math.floor(hy / 1000) + 1,
+                century: Math.floor((hy % 1000) / 100) + 1,
+                year: hy % 100,
+                month: hm,
+                day: hd,
+                hour: date.getUTCHours(),
+                minute: date.getUTCMinutes(),
+                second: date.getUTCSeconds(),
+                millisecond: date.getUTCMilliseconds(),
+            };
+        }
+        getDateFromComponents(components) {
+            let hy;
+            if (components.millennium !== undefined) {
+                const m = components.millennium ?? 0;
+                const c = components.century ?? 1;
+                const y = components.year ?? 0;
+                hy = (m - 1) * 1000 + (c - 1) * 100 + y;
+            }
+            else {
+                hy = components.year ?? 1;
+            }
+            const hm = components.month ?? 1;
+            const hd = components.day ?? 1;
+            const { gy, gm, gd } = hijriToGregorian(hy, hm, hd);
+            return new Date(Date.UTC(gy, gm - 1, gd, components.hour ?? 0, components.minute ?? 0, Math.floor(components.second ?? 0), components.millisecond ?? 0));
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        parseDate(input, format) {
+            const trimmed = input.trim();
+            if (format === "short" ||
+                (trimmed.includes("/") && trimmed.split("/")[0].length <= 2)) {
+                const [day, month, year] = trimmed.split("/").map(Number);
+                return {
+                    calendar: this.code,
+                    millennium: Math.floor(year / 1000) + 1,
+                    century: Math.floor((year % 1000) / 100) + 1,
+                    year: year % 100,
+                    month,
+                    day,
+                };
+            }
+            const segments = trimmed.split(/[\s,T]+/);
+            const [fullYear, month, day] = segments[0].split("-").map(Number);
+            const result = {
+                calendar: this.code,
+                millennium: Math.floor(fullYear / 1000) + 1,
+                century: Math.floor((fullYear % 1000) / 100) + 1,
+                year: fullYear % 100,
+                month,
+                day,
+            };
+            if (segments[1]) {
+                const [h, m, s] = segments[1].split(":").map(Number);
+                result.hour = h ?? 0;
+                result.minute = m ?? 0;
+                result.second = s ?? 0;
+            }
+            return result;
+        }
+        format(components, format) {
+            const pad = (n) => String(n ?? 0).padStart(2, "0");
+            let fullYear;
+            if (components.millennium !== undefined) {
+                const m = components.millennium ?? 0;
+                const c = components.century ?? 1;
+                const y = components.year ?? 0;
+                fullYear = (m - 1) * 1000 + (c - 1) * 100 + y;
+            }
+            else {
+                fullYear = components.year ?? 0;
+            }
+            if (format === "short")
+                return `${components.day}/${pad(components.month)}/${fullYear}`;
+            if (format === "long") {
+                const mn = this.MONTH_NAMES[(components.month ?? 1) - 1];
+                return `${components.day} ${mn} ${fullYear}`;
+            }
+            let out = `${fullYear}-${pad(components.month)}-${pad(components.day)}`;
+            if (components.hour !== undefined) {
+                out += ` ${pad(components.hour)}:${pad(components.minute)}:${pad(Math.floor(components.second ?? 0))}`;
+            }
+            return out;
+        }
+        validate(input) {
+            let comp;
+            if (typeof input === "string") {
+                try {
+                    comp = this.parseDate(input);
+                }
+                catch {
+                    return false;
+                }
+            }
+            else {
+                comp = input;
+            }
+            const { year, month, day } = comp;
+            let fullYear;
+            if (comp.millennium !== undefined) {
+                fullYear =
+                    ((comp.millennium ?? 0) - 1) * 1000 +
+                        ((comp.century ?? 1) - 1) * 100 +
+                        (year ?? 0);
+            }
+            else {
+                fullYear = year ?? 0;
+            }
+            if (fullYear < 1)
+                return false;
+            if (!month || month < 1 || month > 12)
+                return false;
+            if (!day || day < 1)
+                return false;
+            // leap check (cycle of 30 years)
+            const isLeap = new Set([2, 5, 7, 10, 13, 16, 18, 21, 24, 26, 29]).has(((fullYear - 1) % 30) + 1);
+            const maxDays = month === 12 && isLeap ? 30 : month % 2 === 1 ? 30 : 29;
+            return day <= maxDays;
+        }
+        getMetadata() {
+            return {
+                name: "Hijri (Islamic Calendar)",
+                monthNames: this.MONTH_NAMES,
+                monthNamesShort: this.MONTH_NAMES_SHORT,
+                dayNames: this.DAY_NAMES,
+                dayNamesShort: this.DAY_NAMES.map((d) => d.slice(0, 3)),
+                isLunar: true,
+                monthsPerYear: 12,
+                epochYear: 1,
+            };
+        }
+    }
+
+    class JulianDriver {
+        constructor() {
+            this.code = "jul";
+            this.name = "Julian Calendar";
+            this.MONTH_NAMES = [
+                "Januarius",
+                "Februarius",
+                "Martius",
+                "Aprilis",
+                "Maius",
+                "Junius",
+                "Julius",
+                "Augustus",
+                "September",
+                "October",
+                "November",
+                "December",
+            ];
+            this.MONTH_NAMES_SHORT = [
+                "Jan",
+                "Feb",
+                "Mar",
+                "Apr",
+                "May",
+                "Jun",
+                "Jul",
+                "Aug",
+                "Sep",
+                "Oct",
+                "Nov",
+                "Dec",
+            ];
+            this.DAYS_IN_MONTH = [
+                31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
+            ];
+        }
+        getComponentsFromDate(date) {
+            const jdn = gregorianToJdn(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+            const { jy, jm, jd } = jdnToJulian(jdn);
+            return {
+                calendar: this.code,
+                millennium: Math.floor(jy / 1000) + 1,
+                century: Math.floor((jy % 1000) / 100) + 1,
+                year: jy % 100,
+                month: jm,
+                day: jd,
+                hour: date.getUTCHours(),
+                minute: date.getUTCMinutes(),
+                second: date.getUTCSeconds(),
+                millisecond: date.getUTCMilliseconds(),
+            };
+        }
+        getDateFromComponents(components) {
+            let fullYear;
+            if (components.millennium !== undefined) {
+                const m = components.millennium ?? 0;
+                const c = components.century ?? 1;
+                const y = components.year ?? 0;
+                fullYear = (m - 1) * 1000 + (c - 1) * 100 + y;
+            }
+            else {
+                fullYear = components.year ?? 1;
+            }
+            const jm = components.month ?? 1;
+            const jd = components.day ?? 1;
+            const jdn = julianToJdn(fullYear, jm, jd);
+            const { gy, gm, gd } = jdnToGregorian(jdn);
+            return new Date(Date.UTC(gy, gm - 1, gd, components.hour ?? 0, components.minute ?? 0, Math.floor(components.second ?? 0), components.millisecond ?? 0));
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        parseDate(input, _format) {
+            const trimmed = input.trim();
+            const m = trimmed.match(/^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/);
+            if (!m)
+                throw new Error(`JulianDriver.parseDate: unsupported format "${input}"`);
+            const fullYear = parseInt(m[1], 10);
+            const result = {
+                calendar: this.code,
+                millennium: Math.floor(fullYear / 1000) + 1,
+                century: Math.floor((fullYear % 1000) / 100) + 1,
+                year: fullYear % 100,
+                month: parseInt(m[2], 10),
+                day: parseInt(m[3], 10),
+            };
+            if (m[4] !== undefined)
+                result.hour = parseInt(m[4], 10);
+            if (m[5] !== undefined)
+                result.minute = parseInt(m[5], 10);
+            if (m[6] !== undefined)
+                result.second = parseInt(m[6], 10);
+            if (m[7] !== undefined)
+                result.millisecond = parseInt((m[7] + "000").slice(0, 3), 10);
+            return result;
+        }
+        format(components, _format) {
+            const pad = (n, w = 2) => String(n ?? 0).padStart(w, "0");
+            let fullYear;
+            if (components.millennium !== undefined) {
+                const m = components.millennium ?? 0;
+                const c = components.century ?? 1;
+                const y = components.year ?? 0;
+                fullYear = (m - 1) * 1000 + (c - 1) * 100 + y;
+            }
+            else {
+                fullYear = components.year ?? 0;
+            }
+            let out = `${pad(fullYear, 4)}-${pad(components.month)}-${pad(components.day)}`;
+            if (components.hour !== undefined ||
+                components.minute !== undefined ||
+                components.second !== undefined ||
+                components.millisecond !== undefined) {
+                out += `T${pad(components.hour)}:${pad(components.minute)}:${pad(Math.floor(components.second ?? 0))}`;
+                if (components.millisecond !== undefined)
+                    out += `.${pad(components.millisecond, 3)}`;
+            }
+            return out;
+        }
+        validate(input) {
+            if (typeof input === "string") {
+                return /^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)?$/.test(input.trim());
+            }
+            if (typeof input === "object") {
+                let fullYear;
+                if (input.millennium !== undefined) {
+                    fullYear =
+                        ((input.millennium ?? 0) - 1) * 1000 +
+                            ((input.century ?? 1) - 1) * 100 +
+                            (input.year ?? 0);
+                }
+                else {
+                    fullYear = input.year ?? 0;
+                }
+                const { month, day } = input;
+                if (month === undefined || day === undefined)
+                    return false;
+                if (month < 1 || month > 12 || day < 1)
+                    return false;
+                let maxDay = this.DAYS_IN_MONTH[month - 1];
+                if (month === 2 && fullYear % 4 === 0)
+                    maxDay = 29;
+                return day <= maxDay;
+            }
+            return false;
+        }
+        getMetadata() {
+            return {
+                name: "Julian Calendar",
+                monthNames: this.MONTH_NAMES,
+                monthNamesShort: this.MONTH_NAMES_SHORT,
+                isLunar: false,
+                monthsPerYear: 12,
+                epochYear: 1,
+            };
+        }
+    }
+
+    /**
+     * Holocene (Human Era) Calendar Driver
+     */
+    class HoloceneDriver {
+        constructor() {
+            this.code = "holo";
+            this.name = "Holocene (Human Era)";
+            this.gregorian = new GregorianDriver();
+            this.YEAR_OFFSET = 10000;
+        }
+        getComponentsFromDate(date) {
+            const greg = this.gregorian.getComponentsFromDate(date);
+            const fullYear = date.getUTCFullYear() + this.YEAR_OFFSET;
+            return {
+                ...greg,
+                calendar: this.code,
+                millennium: Math.floor(fullYear / 1000) + 1,
+                century: Math.floor((fullYear % 1000) / 100) + 1,
+                year: fullYear % 100,
+            };
+        }
+        getDateFromComponents(components) {
+            const m = components.millennium ?? 0;
+            const c = components.century ?? 1;
+            const y = components.year ?? 0;
+            const holoYear = (m - 1) * 1000 + (c - 1) * 100 + y;
+            const gregYear = holoYear - this.YEAR_OFFSET;
+            return new Date(Date.UTC(gregYear, (components.month ?? 1) - 1, components.day ?? 1, components.hour ?? 0, components.minute ?? 0, Math.floor(components.second ?? 0), components.millisecond ??
+                Math.round(((components.second ?? 0) % 1) * 1000)));
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        parseDate(input, _format) {
+            const m = input
+                .trim()
+                .match(/^(\d{4,5})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?$/);
+            if (!m)
+                throw new Error(`HoloceneDriver.parseDate: unsupported format "${input}"`);
+            const result = {
+                calendar: this.code,
+                year: parseInt(m[1], 10),
+                month: parseInt(m[2], 10),
+                day: parseInt(m[3], 10),
+            };
+            if (m[4] !== undefined)
+                result.hour = parseInt(m[4], 10);
+            if (m[5] !== undefined)
+                result.minute = parseInt(m[5], 10);
+            if (m[6] !== undefined)
+                result.second = parseInt(m[6], 10);
+            if (m[7] !== undefined)
+                result.millisecond = parseInt((m[7] + "000").slice(0, 3), 10);
+            return result;
+        }
+        format(components, _format) {
+            const pad = (n, w = 2) => String(n ?? 0).padStart(w, "0");
+            let holoYear;
+            if (components.millennium !== undefined) {
+                const m = components.millennium ?? 0;
+                const c = components.century ?? 1;
+                const y = components.year ?? 0;
+                holoYear = (m - 1) * 1000 + (c - 1) * 100 + y;
+            }
+            else {
+                holoYear = components.year ?? 0;
+            }
+            let out = `${String(holoYear).padStart(5, "0")}-${pad(components.month)}-${pad(components.day)}`;
+            if (components.hour !== undefined ||
+                components.minute !== undefined ||
+                components.second !== undefined) {
+                out += `T${pad(components.hour)}:${pad(components.minute)}:${pad(Math.floor(components.second ?? 0))}`;
+            }
+            return out;
+        }
+        validate(input) {
+            if (typeof input === "string") {
+                return /^\d{4,5}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)?$/.test(input.trim());
+            }
+            if (typeof input === "object") {
+                return this.gregorian.validate({
+                    year: input.year,
+                    month: input.month,
+                    day: input.day,
+                });
+            }
+            return false;
+        }
+        getMetadata() {
+            return {
+                name: "Holocene (Human Era)",
+                monthNames: [
+                    "January",
+                    "February",
+                    "March",
+                    "April",
+                    "May",
+                    "June",
+                    "July",
+                    "August",
+                    "September",
+                    "October",
+                    "November",
+                    "December",
+                ],
+                isLunar: false,
+                monthsPerYear: 12,
+                epochYear: -1e4,
+            };
+        }
+    }
+
+    /**
+     * Chinese Lunisolar Calendar Driver
+     *
+     * Calendar characteristics:
+     * - Traditional lunisolar calendar (月 months follow lunar phases, years follow solar)
+     * - Year expressed as Sexagenary (干支 Ganzhi) cycle: 60-year repeating pattern
+     * - Also expressed relative to the legendary emperor Huangdi (epoch ~2698 BCE)
+     * - Months: 12 or 13 (leap month / 闰月 rùnyuè in some years)
+     * - This implementation uses a simplified tabular algorithm accurate from ~1900–2100
+     *
+     * Data source: Pre-computed month start Julian Day Numbers for 1900–2100
+     * based on the Hong Kong Observatory almanac algorithm.
+     */
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Core Chinese Calendar Arithmetic
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Approximate start of Chinese Lunar Month 1 (正月) for each Gregorian year.
+     * Derived from the New Moon nearest to 'rain water' (雨水, around Feb 19).
+     * Each entry is [month, day] in Gregorian for the start of that year's month 1.
+     *
+     * For simplicity we use the Gregorian Spring Festival date as month-1 start,
+     * which is accurate to within ±1 day for the intended display purpose.
+     */
+    const SPRING_FESTIVAL = {
+        1900: [1, 31],
+        1901: [2, 19],
+        1902: [2, 8],
+        1903: [1, 29],
+        1904: [2, 16],
+        1905: [2, 4],
+        1906: [1, 25],
+        1907: [2, 13],
+        1908: [2, 2],
+        1909: [1, 22],
+        1910: [2, 10],
+        1911: [1, 30],
+        1912: [2, 18],
+        1913: [2, 6],
+        1914: [1, 26],
+        1915: [2, 14],
+        1916: [2, 3],
+        1917: [1, 23],
+        1918: [2, 11],
+        1919: [2, 1],
+        1920: [2, 20],
+        1921: [2, 8],
+        1922: [1, 28],
+        1923: [2, 16],
+        1924: [2, 5],
+        1925: [1, 25],
+        1926: [2, 13],
+        1927: [2, 2],
+        1928: [1, 23],
+        1929: [2, 10],
+        1930: [1, 30],
+        1931: [2, 17],
+        1932: [2, 6],
+        1933: [1, 26],
+        1934: [2, 14],
+        1935: [2, 4],
+        1936: [1, 24],
+        1937: [2, 11],
+        1938: [1, 31],
+        1939: [2, 19],
+        1940: [2, 8],
+        1941: [1, 27],
+        1942: [2, 15],
+        1943: [2, 5],
+        1944: [1, 25],
+        1945: [2, 13],
+        1946: [2, 2],
+        1947: [1, 22],
+        1948: [2, 10],
+        1949: [1, 29],
+        1950: [2, 17],
+        1951: [2, 6],
+        1952: [1, 27],
+        1953: [2, 14],
+        1954: [2, 3],
+        1955: [1, 24],
+        1956: [2, 12],
+        1957: [1, 31],
+        1958: [2, 18],
+        1959: [2, 8],
+        1960: [1, 28],
+        1961: [2, 15],
+        1962: [2, 5],
+        1963: [1, 25],
+        1964: [2, 13],
+        1965: [2, 2],
+        1966: [1, 21],
+        1967: [2, 9],
+        1968: [1, 30],
+        1969: [2, 17],
+        1970: [2, 6],
+        1971: [1, 27],
+        1972: [2, 15],
+        1973: [2, 3],
+        1974: [1, 23],
+        1975: [2, 11],
+        1976: [1, 31],
+        1977: [2, 18],
+        1978: [2, 7],
+        1979: [1, 28],
+        1980: [2, 16],
+        1981: [2, 5],
+        1982: [1, 25],
+        1983: [2, 13],
+        1984: [2, 2],
+        1985: [2, 20],
+        1986: [2, 9],
+        1987: [1, 29],
+        1988: [2, 17],
+        1989: [2, 6],
+        1990: [1, 27],
+        1991: [2, 15],
+        1992: [2, 4],
+        1993: [1, 23],
+        1994: [2, 10],
+        1995: [1, 31],
+        1996: [2, 19],
+        1997: [2, 7],
+        1998: [1, 28],
+        1999: [2, 16],
+        2000: [2, 5],
+        2001: [1, 24],
+        2002: [2, 12],
+        2003: [2, 1],
+        2004: [1, 22],
+        2005: [2, 9],
+        2006: [1, 29],
+        2007: [2, 18],
+        2008: [2, 7],
+        2009: [1, 26],
+        2010: [2, 14],
+        2011: [2, 3],
+        2012: [1, 23],
+        2013: [2, 10],
+        2014: [1, 31],
+        2015: [2, 19],
+        2016: [2, 8],
+        2017: [1, 28],
+        2018: [2, 16],
+        2019: [2, 5],
+        2020: [1, 25],
+        2021: [2, 12],
+        2022: [2, 1],
+        2023: [1, 22],
+        2024: [2, 10],
+        2025: [1, 29],
+        2026: [2, 17],
+        2027: [2, 6],
+        2028: [1, 26],
+        2029: [2, 13],
+        2030: [2, 3],
+        2031: [1, 23],
+        2032: [2, 11],
+        2033: [1, 31],
+        2034: [2, 19],
+        2035: [2, 8],
+        2036: [1, 28],
+        2037: [2, 15],
+        2038: [2, 4],
+        2039: [1, 24],
+        2040: [2, 12],
+        2041: [2, 1],
+        2042: [1, 22],
+        2043: [2, 10],
+        2044: [1, 30],
+        2045: [2, 17],
+        2046: [2, 6],
+        2047: [1, 26],
+        2048: [2, 14],
+        2049: [2, 2],
+        2050: [1, 23],
+        2051: [2, 11],
+        2052: [2, 1],
+        2053: [2, 19],
+        2054: [2, 8],
+        2055: [1, 28],
+        2056: [2, 15],
+        2057: [2, 4],
+        2058: [1, 24],
+        2059: [2, 12],
+        2060: [2, 2],
+        2061: [1, 21],
+        2062: [2, 9],
+        2063: [1, 29],
+        2064: [2, 17],
+        2065: [2, 5],
+        2066: [1, 26],
+        2067: [2, 14],
+        2068: [2, 3],
+        2069: [1, 23],
+        2070: [2, 11],
+        2071: [2, 1],
+        2072: [1, 21],
+        2073: [2, 8],
+        2074: [1, 28],
+        2075: [2, 15],
+        2076: [2, 5],
+        2077: [1, 24],
+        2078: [2, 12],
+        2079: [2, 2],
+        2080: [1, 22],
+        2081: [2, 9],
+        2082: [1, 29],
+        2083: [2, 17],
+        2084: [2, 6],
+        2085: [1, 26],
+        2086: [2, 14],
+        2087: [2, 3],
+        2088: [1, 24],
+        2089: [2, 10],
+        2090: [1, 30],
+        2091: [2, 17],
+        2092: [2, 7],
+        2093: [1, 27],
+        2094: [2, 15],
+        2095: [2, 4],
+        2096: [1, 25],
+        2097: [2, 12],
+        2098: [2, 1],
+        2099: [1, 21],
+        2100: [2, 9],
+    };
+    /** Chinese Heavenly Stems (天干 Tiāngān) */
+    const HEAVENLY_STEMS = [
+        "甲",
+        "乙",
+        "丙",
+        "丁",
+        "戊",
+        "己",
+        "庚",
+        "辛",
+        "壬",
+        "癸",
+    ];
+    const HEAVENLY_STEMS_ROMAN = [
+        "Jiǎ",
+        "Yǐ",
+        "Bǐng",
+        "Dīng",
+        "Wù",
+        "Jǐ",
+        "Gēng",
+        "Xīn",
+        "Rén",
+        "Guǐ",
+    ];
+    /** Chinese Earthly Branches (地支 Dìzhī) — zodiac animals */
+    const EARTHLY_BRANCHES = [
+        "子",
+        "丑",
+        "寅",
+        "卯",
+        "辰",
+        "巳",
+        "午",
+        "未",
+        "申",
+        "酉",
+        "戌",
+        "亥",
+    ];
+    const ZODIAC_EN = [
+        "Rat",
+        "Ox",
+        "Tiger",
+        "Rabbit",
+        "Dragon",
+        "Snake",
+        "Horse",
+        "Goat",
+        "Monkey",
+        "Rooster",
+        "Dog",
+        "Pig",
+    ];
+    /** Chinese month names */
+    const MONTH_NAMES_ZH = [
+        "正月",
+        "二月",
+        "三月",
+        "四月",
+        "五月",
+        "六月",
+        "七月",
+        "八月",
+        "九月",
+        "十月",
+        "十一月",
+        "十二月",
+    ];
+    const MONTH_NAMES_EN = [
+        "Zhēngyuè",
+        "Èryuè",
+        "Sānyuè",
+        "Sìyuè",
+        "Wǔyuè",
+        "Liùyuè",
+        "Qīyuè",
+        "Bāyuè",
+        "Jiǔyuè",
+        "Shíyuè",
+        "Shíyīyuè",
+        "Shíèryuè",
+    ];
+    /** Huangdi Epoch: Year 2698 BCE is year 1 of the Chinese Calendar */
+    const HUANGDI_OFFSET = 2698;
+    /**
+     * Convert a Gregorian date to Chinese lunar date components.
+     * Returns { chineseYear, month, day, heavenlyStem, earthlyBranch, zodiac }
+     */
+    function gregorianToChinese(gy, gm, gd) {
+        // Locate the Chinese year whose Spring Festival (month 1, day 1) is on or before the given date
+        const inputJdn = gregorianToJdn(gy, gm, gd);
+        let chineseYear = gy; // The Chinese New Year typically starts in the same Gregorian year
+        // Check if input is before this year's Spring Festival → use previous year's cycle
+        let sf = SPRING_FESTIVAL[chineseYear];
+        if (!sf) {
+            // Clamp to data range
+            chineseYear = Math.max(1900, Math.min(2100, chineseYear));
+            sf = SPRING_FESTIVAL[chineseYear] ?? [2, 1];
+        }
+        const sfJdn = gregorianToJdn(chineseYear, sf[0], sf[1]);
+        if (inputJdn < sfJdn) {
+            chineseYear -= 1;
+            sf = SPRING_FESTIVAL[chineseYear] ?? [2, 1];
+        }
+        const yearStartJdn = gregorianToJdn(chineseYear, sf[0], sf[1]);
+        const dayOfYear = inputJdn - yearStartJdn; // 0-indexed
+        // Approximate month and day. Chinese months alternate 29/30 days.
+        // Average lunar month ≈ 29.53 days
+        const approxMonth = Math.floor(dayOfYear / 29.53);
+        const month = Math.min(approxMonth + 1, 12); // 1-indexed, cap at 12
+        const monthStartDay = Math.round(approxMonth * 29.53);
+        const day = dayOfYear - monthStartDay + 1;
+        // Sexagenary cycle (干支 gānzhī) — 60-year cycle, epoch 4 BCE = year 1
+        const cycleYear = (((chineseYear - 4) % 60) + 60) % 60;
+        const heavenlyStem = HEAVENLY_STEMS_ROMAN[cycleYear % 10];
+        const earthlyBranch = ZODIAC_EN[cycleYear % 12];
+        const zodiac = earthlyBranch;
+        const huangdiYear = chineseYear + HUANGDI_OFFSET;
+        return {
+            chineseYear: huangdiYear,
+            month: Math.max(1, month),
+            day: Math.max(1, day),
+            heavenlyStem,
+            earthlyBranch,
+            zodiac,
+        };
+    }
+    /**
+     * Convert a Chinese Huangdi year + month + day back to an approximate Gregorian date.
+     */
+    function chineseToGregorian(huangdiYear, month, day) {
+        const chineseYear = huangdiYear - HUANGDI_OFFSET;
+        const yearClamped = Math.max(1900, Math.min(2100, chineseYear));
+        const sf = SPRING_FESTIVAL[yearClamped] ?? [2, 1];
+        // Start JDN of Chinese year 1st month
+        const yearStartJdn = gregorianToJdn(yearClamped, sf[0], sf[1]);
+        // Approx JDN for given month/day
+        const approxJdn = yearStartJdn + Math.round((month - 1) * 29.53) + (day - 1);
+        return jdnToGregorian(approxJdn);
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Driver Class
+    // ─────────────────────────────────────────────────────────────────────────────
+    class ChineseDriver {
+        constructor() {
+            this.code = "chin";
+            this.name = "Chinese Lunisolar";
+        }
+        getComponentsFromDate(date) {
+            const gy = date.getUTCFullYear();
+            const gm = date.getUTCMonth() + 1;
+            const gd = date.getUTCDate();
+            const { chineseYear, month, day } = gregorianToChinese(gy, gm, gd);
+            // Store as TPS year field (full Huangdi year); millennium/century/year decomposition
+            const millennium = Math.floor(chineseYear / 1000) + 1;
+            const century = Math.floor((chineseYear % 1000) / 100) + 1;
+            const year = chineseYear % 100;
+            return {
+                calendar: this.code,
+                millennium,
+                century,
+                year,
+                month,
+                day,
+                hour: date.getUTCHours(),
+                minute: date.getUTCMinutes(),
+                second: date.getUTCSeconds(),
+                millisecond: date.getUTCMilliseconds(),
+            };
+        }
+        getDateFromComponents(components) {
+            // Reconstruct full Huangdi year
+            const millennium = components.millennium ?? 5;
+            const century = components.century ?? 1;
+            const year = components.year ?? 0;
+            const huangdiYear = (millennium - 1) * 1000 + (century - 1) * 100 + year;
+            const { gy, gm, gd } = chineseToGregorian(huangdiYear, components.month ?? 1, components.day ?? 1);
+            return new Date(Date.UTC(gy, gm - 1, gd, components.hour ?? 0, components.minute ?? 0, Math.floor(components.second ?? 0), components.millisecond ?? 0));
+        }
+        getFromDate(date) {
+            const comp = this.getComponentsFromDate(date);
+            return buildTimePart(comp);
+        }
+        parseDate(input, _format) {
+            const trimmed = input.trim();
+            // Accept ISO-like: "4722-03-15" or "4722/03/15"
+            const parts = trimmed.split(/[-/]/).map(Number);
+            if (parts.length < 2)
+                return { calendar: this.code };
+            const [huangdiYear, month, day = 1] = parts;
+            const millennium = Math.floor(huangdiYear / 1000) + 1;
+            const century = Math.floor((huangdiYear % 1000) / 100) + 1;
+            const year = huangdiYear % 100;
+            return { calendar: this.code, millennium, century, year, month, day };
+        }
+        format(components, format) {
+            const millennium = components.millennium ?? 5;
+            const century = components.century ?? 1;
+            const year = components.year ?? 0;
+            const huangdiYear = (millennium - 1) * 1000 + (century - 1) * 100 + year;
+            const month = components.month ?? 1;
+            const day = components.day ?? 1;
+            if (format === "zh") {
+                const monthName = MONTH_NAMES_ZH[month - 1] ?? `${month}月`;
+                return `${huangdiYear}年${monthName}${day}日`;
+            }
+            if (format === "ganzhi") {
+                const chineseYear = huangdiYear - HUANGDI_OFFSET;
+                const cycleYear = (((chineseYear - 4) % 60) + 60) % 60;
+                const stem = HEAVENLY_STEMS[cycleYear % 10];
+                const branch = EARTHLY_BRANCHES[cycleYear % 12];
+                const zodiac = ZODIAC_EN[cycleYear % 12];
+                return `${stem}${branch} (${zodiac}) Year, Month ${month}, Day ${day}`;
+            }
+            // Default: ISO-like with Huangdi year
+            const pad = (n) => String(n).padStart(2, "0");
+            return `${huangdiYear}-${pad(month)}-${pad(day)}`;
+        }
+        validate(input) {
+            let comp;
+            if (typeof input === "string") {
+                try {
+                    comp = this.parseDate(input);
+                }
+                catch {
+                    return false;
+                }
+            }
+            else {
+                comp = input;
+            }
+            const { month, day } = comp;
+            if (!month || month < 1 || month > 12)
+                return false;
+            if (!day || day < 1 || day > 30)
+                return false;
+            return true;
+        }
+        getMetadata() {
+            return {
+                name: "Chinese Lunisolar",
+                monthNames: MONTH_NAMES_EN,
+                monthNamesShort: MONTH_NAMES_EN.map((n) => n.slice(0, 3)),
+                dayNames: ["Rì", "Yuè", "Huǒ", "Shuǐ", "Mù", "Jīn", "Tǔ"], // Sun/Mon/Tue…Sat equivalents
+                isLunar: true,
+                monthsPerYear: 12,
+                epochYear: -2698, // 2698 BCE
+            };
+        }
+    }
+
+    /**
+     * Environment & Compatibility Layer
+     * Abstracts Node.js vs Browser differences.
+     */
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const isNode = typeof require !== "undefined";
+    /**
+     * Node.js crypto module (conditional)
+     */
+    const crypto = isNode ? require("crypto") : null;
+    /**
+     * Node.js zlib module (conditional)
+     */
+    const zlib = isNode ? require("zlib") : null;
+    const Env = {
+        isNode,
+        randomBytes(length) {
+            if (isNode && crypto) {
+                return new Uint8Array(crypto.randomBytes(length));
+            }
+            if (typeof window !== "undefined" && window.crypto) {
+                return window.crypto.getRandomValues(new Uint8Array(length));
+            }
+            throw new Error("TPS: randomBytes not available in this environment");
+        },
+        deflate(data) {
+            if (isNode && zlib) {
+                return new Uint8Array(zlib.deflateRawSync(data));
+            }
+            throw new Error("TPS: deflate not available in this environment");
+        },
+        inflate(data) {
+            if (isNode && zlib) {
+                return new Uint8Array(zlib.inflateRawSync(data));
+            }
+            throw new Error("TPS: inflate not available in this environment");
+        },
+        signEd25519(data, privateKey) {
+            if (isNode && crypto) {
+                let key;
+                if (typeof privateKey === "string") {
+                    if (privateKey.includes("PRIVATE KEY")) {
+                        key = privateKey;
+                    }
+                    else {
+                        key = crypto.createPrivateKey({
+                            key: Buffer.from(privateKey, "hex"),
+                            format: "der",
+                            type: "pkcs8",
+                        });
+                    }
+                }
+                else if (typeof privateKey === "object" &&
+                    privateKey !== null &&
+                    "asymmetricKeyType" in privateKey) {
+                    key = privateKey;
+                }
+                else {
+                    key = crypto.createPrivateKey({
+                        key: Buffer.from(privateKey),
+                        format: "der",
+                        type: "pkcs8",
+                    });
+                }
+                return new Uint8Array(crypto.sign(null, data, key));
+            }
+            throw new Error("TPS: signEd25519 not available in this environment");
+        },
+        verifyEd25519(data, signature, publicKey) {
+            if (isNode && crypto) {
+                return crypto.verify(null, data, publicKey, signature);
+            }
+            throw new Error("TPS: verifyEd25519 not available in this environment");
+        },
+    };
+
+    /**
+     * TPS-UID v1 — Temporal Positioning System Identifier (Binary Reversible)
+     */
+    class TPSUID7RB {
+        static encodeBinary(tps, opts = {}) {
+            tps = TPS.expandIndexedTime(tps) ?? tps;
+            const compress = opts.compress ?? false;
+            const epochMs = opts.epochMs ?? this.epochMsFromTPSString(tps);
+            if (!Number.isInteger(epochMs) || epochMs < 0 || epochMs > 0xffffffffffff) {
+                throw new Error("TPSUID7RB: Invalid epochMs (must be 48-bit non-negative integer)");
+            }
+            const flags = compress ? 0x01 : 0x00;
+            const nonceBuf = Env.randomBytes(4);
+            const tpsUtf8 = new TextEncoder().encode(tps);
+            const payload = compress ? Env.deflate(tpsUtf8) : tpsUtf8;
+            const lenVar = this.uvarintEncode(payload.length);
+            const out = new Uint8Array(4 + 1 + 1 + 6 + 4 + lenVar.length + payload.length);
+            let offset = 0;
+            out.set(this.MAGIC, offset);
+            offset += 4;
+            out[offset++] = this.VER;
+            out[offset++] = flags;
+            out.set(this.writeU48(epochMs), offset);
+            offset += 6;
+            out.set(nonceBuf, offset);
+            offset += 4;
+            out.set(lenVar, offset);
+            offset += lenVar.length;
+            out.set(payload, offset);
+            return out;
+        }
+        static decodeBinary(bytes) {
+            if (bytes.length < 17)
+                throw new Error("TPSUID7RB: too short");
+            if (bytes[0] !== 0x54 ||
+                bytes[1] !== 0x50 ||
+                bytes[2] !== 0x55 ||
+                bytes[3] !== 0x37) {
+                throw new Error("TPSUID7RB: bad magic");
+            }
+            const ver = bytes[4];
+            if (ver !== this.VER)
+                throw new Error(`TPSUID7RB: unsupported version ${ver}`);
+            const flags = bytes[5];
+            const compressed = (flags & 0x01) === 0x01;
+            const epochMs = this.readU48(bytes, 6);
+            const nonce = ((bytes[12] << 24) >>> 0) +
+                ((bytes[13] << 16) >>> 0) +
+                ((bytes[14] << 8) >>> 0) +
+                bytes[15];
+            let offset = 16;
+            const { value: tpsLen, bytesRead } = this.uvarintDecode(bytes, offset);
+            offset += bytesRead;
+            if (offset + tpsLen > bytes.length)
+                throw new Error("TPSUID7RB: length overflow");
+            const payload = bytes.slice(offset, offset + tpsLen);
+            const tpsUtf8 = compressed ? Env.inflate(payload) : payload;
+            const tps = new TextDecoder().decode(tpsUtf8);
+            return { version: "tpsuid7rb", epochMs, compressed, nonce, tps };
+        }
+        static encodeBinaryB64(tps, opts) {
+            const bytes = this.encodeBinary(tps, opts ?? {});
+            return `${this.PREFIX}${this.base64UrlEncode(bytes)}`;
+        }
+        static decodeBinaryB64(id) {
+            const s = id.trim();
+            if (!s.startsWith(this.PREFIX))
+                throw new Error("TPSUID7RB: missing prefix");
+            return this.decodeBinary(this.base64UrlDecode(s.slice(this.PREFIX.length)));
+        }
+        static validateBinaryB64(id) {
+            return this.REGEX.test(id.trim());
+        }
+        static generate(opts) {
+            const now = new Date();
+            const time = TPS.fromDate(now, 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(),
+            });
+        }
+        static seal(tps, privateKey, opts) {
+            tps = TPS.expandIndexedTime(tps) ?? tps;
+            const compress = opts?.compress ?? false;
+            const epochMs = opts?.epochMs ?? this.epochMsFromTPSString(tps);
+            if (!Number.isInteger(epochMs) || epochMs < 0 || epochMs > 0xffffffffffff) {
+                throw new Error("TPSUID7RB: Invalid epochMs");
+            }
+            const flags = (compress ? 0x01 : 0x00) | 0x02; // Set SEAL bit
+            const nonceBuf = Env.randomBytes(4);
+            const tpsUtf8 = new TextEncoder().encode(tps);
+            const payload = compress ? Env.deflate(tpsUtf8) : tpsUtf8;
+            const lenVar = this.uvarintEncode(payload.length);
+            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);
+            const signature = Env.signEd25519(content, privateKey);
+            const final = new Uint8Array(contentLen + 1 + signature.length);
+            final.set(content, 0);
+            final.set([0x01], contentLen); // Ed25519 type
+            final.set(signature, contentLen + 1);
+            return final;
+        }
+        static verifyAndDecode(sealedBytes, publicKey) {
+            if (sealedBytes.length < 18)
+                throw new Error("TPSUID7RB: too short");
+            if (sealedBytes[5] & 0x02 ? false : true)
+                throw new Error("TPSUID7RB: not sealed");
+            let offset = 16;
+            const { value: tpsLen, bytesRead } = this.uvarintDecode(sealedBytes, offset);
+            const payloadEnd = offset + bytesRead + tpsLen;
+            const content = sealedBytes.slice(0, payloadEnd);
+            const signature = sealedBytes.slice(payloadEnd + 1);
+            if (!Env.verifyEd25519(content, signature, publicKey)) {
+                throw new Error("TPSUID7RB: verification failed");
+            }
+            return this.decodeBinary(content);
+        }
+        static epochMsFromTPSString(tps) {
+            tps = TPS.expandIndexedTime(tps) ?? tps;
+            const date = TPS.toDate(tps);
+            if (date)
+                return date.getTime();
+            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();
+        }
+        static writeU48(epochMs) {
+            const b = new Uint8Array(6);
+            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;
+        }
+        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]);
+            return Number(v);
+        }
+        static uvarintEncode(n) {
+            const out = [];
+            let x = n >>> 0;
+            while (x >= 0x80) {
+                out.push((x & 0x7f) | 0x80);
+                x >>>= 7;
+            }
+            out.push(x);
+            return new Uint8Array(out);
+        }
+        static uvarintDecode(bytes, offset) {
+            let x = 0, s = 0, i = 0;
+            while (true) {
+                const b = bytes[offset + i];
+                if (b < 0x80) {
+                    x |= b << s;
+                    return { value: x >>> 0, bytesRead: i + 1 };
+                }
+                x |= (b & 0x7f) << s;
+                s += 7;
+                i++;
+            }
+        }
+        static base64UrlEncode(bytes) {
+            if (typeof Buffer !== "undefined") {
+                return Buffer.from(bytes)
+                    .toString("base64")
+                    .replace(/\+/g, "-")
+                    .replace(/\//g, "_")
+                    .replace(/=+$/g, "");
+            }
+            return btoa(String.fromCharCode(...bytes))
+                .replace(/\+/g, "-")
+                .replace(/\//g, "_")
+                .replace(/=+$/g, "");
+        }
+        static base64UrlDecode(b64url) {
+            const padLen = (4 - (b64url.length % 4)) % 4;
+            const b64 = (b64url + "=".repeat(padLen))
+                .replace(/-/g, "+")
+                .replace(/_/g, "/");
+            if (typeof Buffer !== "undefined")
+                return new Uint8Array(Buffer.from(b64, "base64"));
+            const binary = atob(b64);
+            return new Uint8Array(Array.from(binary).map((c) => c.charCodeAt(0)));
+        }
+    }
+    TPSUID7RB.MAGIC = new Uint8Array([0x54, 0x50, 0x55, 0x37]);
+    TPSUID7RB.VER = 0x01;
+    TPSUID7RB.PREFIX = "tpsuid7rb_";
+    TPSUID7RB.REGEX = /^tpsuid7rb_[A-Za-z0-9_-]+$/;
+
+    /**
+     * TpsDate Date-like wrapper with native TPS conversion helpers.
+     */
+    class TpsDate {
+        constructor(...args) {
+            this._cachedComponents = null;
+            this._cachedTps = null;
+            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:");
+        }
+        getTpsComponents() {
+            const currentTps = this.toTPS(DefaultCalendars.TPS);
+            if (this._cachedTps === currentTps && this._cachedComponents) {
+                return this._cachedComponents;
+            }
+            const parsed = TPS.parse(currentTps);
+            if (!parsed) {
+                throw new Error("TpsDate: failed to derive TPS components");
+            }
+            this._cachedTps = currentTps;
+            this._cachedComponents = parsed;
+            return parsed;
+        }
+        getTpsFullYear() {
+            const comp = this.getTpsComponents();
+            return (comp.millennium - 1) * 1000 + (comp.century - 1) * 100 + comp.year;
+        }
+        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 = DefaultCalendars.TPS, opts) {
+            return TPS.fromDate(this.internal, calendar, opts);
+        }
+        toTPSURI(calendar = DefaultCalendars.TPS, opts) {
+            const time = this.toTPS(calendar, {
+                order: opts?.order,
+                timeMode: opts?.timeMode,
+                indexedPrecision: opts?.indexedPrecision,
+            });
+            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(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();
+        }
+    }
+
+    /**
+     * TPS DriverManager
+     * Manages the registry of calendar driver plugins.
+     */
+    /**
+     * A dedicated registry for TPS calendar driver plugins.
+     * The global `TPS` class exposes a shared singleton instance (`TPS.driverManager`).
+     */
+    class DriverManager {
+        constructor() {
+            this.registry = new Map();
+        }
+        /**
+         * Registers a calendar driver.
+         * Overwrites any previously registered driver with the same code.
+         */
+        register(driver) {
+            if (!driver || !driver.code) {
+                throw new Error("DriverManager: driver must have a valid `code` string.");
+            }
+            this.registry.set(driver.code, driver);
+        }
+        /**
+         * Returns the driver registered for the given calendar code, or `undefined`.
+         */
+        get(code) {
+            return this.registry.get(code);
+        }
+        /**
+         * Returns `true` if a driver with the given code has been registered.
+         */
+        has(code) {
+            return this.registry.has(code);
+        }
+        /**
+         * Returns an array of all registered calendar codes.
+         */
+        list() {
+            return Array.from(this.registry.keys());
+        }
+        /**
+         * Removes a driver from the registry.
+         * Returns `true` if the driver existed and was removed.
+         */
+        unregister(code) {
+            return this.registry.delete(code);
+        }
+    }
+
+    /**
+     * Timezone Utilities
+     *
+     * Provides lightweight, zero-dependency helpers for converting between
+     * UTC timestamps and local timestamps in a given IANA timezone or
+     * fixed UTC offset.
+     *
+     * Used by `TPS.toDate()` when the parsed extensions include a `tz` key.
+     *
+     * Examples:
+     *   tz=Asia/Tehran   → IANA timezone name
+     *   tz=+03:30        → fixed UTC offset
+     *   tz=IRST          → abbreviated names (best-effort, common ones mapped)
+     */
+    /** Map of common abbreviated timezone names to IANA names. */
+    const TZ_ABBR = {
+        // Middle East
+        IRST: "Asia/Tehran",
+        IRDT: "Asia/Tehran",
+        AST: "Asia/Riyadh",
+        AST3: "Asia/Riyadh",
+        // Europe
+        CET: "Europe/Paris",
+        CEST: "Europe/Paris",
+        EET: "Europe/Athens",
+        EEST: "Europe/Athens",
+        WET: "Europe/Lisbon",
+        WEST: "Europe/Lisbon",
+        // Americas
+        EST: "America/New_York",
+        EDT: "America/New_York",
+        CST: "America/Chicago",
+        CDT: "America/Chicago",
+        MST: "America/Denver",
+        MDT: "America/Denver",
+        PST: "America/Los_Angeles",
+        PDT: "America/Los_Angeles",
+        // Asia Pacific
+        JST: "Asia/Tokyo",
+        KST: "Asia/Seoul",
+        IST: "Asia/Kolkata",
+        CST8: "Asia/Shanghai",
+        AEST: "Australia/Sydney",
+        AEDT: "Australia/Sydney",
+        // UTC variants
+        UTC: "UTC",
+        GMT: "UTC",
+        Z: "UTC",
+    };
+    /**
+     * Parse a `tz` string into an IANA timezone name, or return null if unrecognized.
+     */
+    function resolveIANA(tz) {
+        if (!tz)
+            return null;
+        // Direct IANA name (e.g. "Asia/Tehran")
+        if (tz.includes("/"))
+            return tz;
+        // Common abbreviation lookup
+        const abbr = TZ_ABBR[tz.toUpperCase()];
+        if (abbr)
+            return abbr;
+        return null;
+    }
+    /**
+     * Parses a fixed offset string like "+03:30", "-05:00", "+0530" into ms.
+     * Returns NaN if the string is not a valid offset.
+     */
+    function parseFixedOffset(tz) {
+        const m = tz.match(/^([+-])(\d{1,2}):?(\d{2})$/);
+        if (!m)
+            return NaN;
+        const sign = m[1] === "+" ? 1 : -1;
+        const h = parseInt(m[2], 10);
+        const min = parseInt(m[3], 10);
+        return sign * (h * 60 + min) * 60000;
+    }
+    /**
+     * Returns the UTC offset in milliseconds for a given IANA timezone at a
+     * specific UTC moment. Uses `Intl.DateTimeFormat` for correctness.
+     *
+     * Returns 0 (UTC) if the timezone is unrecognised by the runtime.
+     */
+    function getIANAOffsetMs(ianaName, atUtcMs) {
+        try {
+            // Build a formatter that reports both UTC and local time parts
+            const fmt = new Intl.DateTimeFormat("en-US", {
+                timeZone: ianaName,
+                year: "numeric",
+                month: "2-digit",
+                day: "2-digit",
+                hour: "2-digit",
+                minute: "2-digit",
+                second: "2-digit",
+                hour12: false,
+            });
+            const parts = Object.fromEntries(fmt.formatToParts(new Date(atUtcMs)).map((p) => [p.type, p.value]));
+            // Reconstruct the local time as UTC
+            const localMs = Date.UTC(parseInt(parts.year), parseInt(parts.month) - 1, parseInt(parts.day), parseInt(parts.hour === "24" ? "0" : parts.hour), parseInt(parts.minute), parseInt(parts.second));
+            return localMs - atUtcMs;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Given a UTC timestamp (ms), returns the equivalent *local* millisecond
+     * value for the given `tz` string.
+     *
+     * This is useful for display: `utcMs + offsetMs` gives local wall-clock time.
+     */
+    function utcToLocal(utcMs, tz) {
+        // Try fixed offset first (e.g. "+03:30")
+        const fixed = parseFixedOffset(tz);
+        if (!isNaN(fixed))
+            return utcMs + fixed;
+        const iana = resolveIANA(tz);
+        if (!iana)
+            return utcMs; // Unknown tz — return UTC unchanged
+        return utcMs + getIANAOffsetMs(iana, utcMs);
+    }
+    /**
+     * Given a *local* timestamp (ms) in `tz`, returns the equivalent UTC ms.
+     *
+     * Used when converting a calendar date expressed in local time back to UTC.
+     */
+    function localToUtc(localMs, tz) {
+        // Try fixed offset first
+        const fixed = parseFixedOffset(tz);
+        if (!isNaN(fixed))
+            return localMs - fixed;
+        const iana = resolveIANA(tz);
+        if (!iana)
+            return localMs;
+        // Approximation: compute the offset at the approximate UTC moment
+        // (offset iteration is overkill for a scheduling library)
+        const approxUtcMs = localMs - getIANAOffsetMs(iana, localMs);
+        // One correction pass for DST edge-cases
+        const correctedOffset = getIANAOffsetMs(iana, approxUtcMs);
+        return localMs - correctedOffset;
+    }
+    /**
+     * Returns the UTC offset string (e.g. "+03:30") for a given IANA timezone
+     * at the current moment. Useful for formatting and display.
+     */
+    function getOffsetString(tz, atUtcMs = Date.now()) {
+        // Fast-path for UTC/GMT/Z
+        const upper = tz.toUpperCase();
+        if (upper === "UTC" || upper === "GMT" || upper === "Z")
+            return "+00:00";
+        const fixed = parseFixedOffset(tz);
+        if (!isNaN(fixed))
+            return tz;
+        const iana = resolveIANA(tz);
+        if (!iana)
+            return "+00:00";
+        const offsetMs = getIANAOffsetMs(iana, atUtcMs);
+        const sign = offsetMs >= 0 ? "+" : "-";
+        const abs = Math.abs(offsetMs);
+        const h = Math.floor(abs / 3600000)
+            .toString()
+            .padStart(2, "0");
+        const m = Math.floor((abs % 3600000) / 60000)
+            .toString()
+            .padStart(2, "0");
+        return `${sign}${h}:${m}`;
+    }
+
+    /**
+     * TPS: Temporal Positioning System
+     * The Universal Protocol for Space-Time Coordinates.
+     * @packageDocumentation
+     * @version 0.8.0
+     * @license Apache-2.0
+     * @copyright 2026 TPS Standards Working Group
+     *
+     * v0.5.35 Changes:
+     * - Added TPS.now(), TPS.diff(), TPS.add() convenience methods
+     * - Added Chinese Lunisolar (chin) calendar driver
+     * - Added DriverManager (driver registry separated from TPS class)
+     * - Added timezone utility (src/utils/timezone.ts) with IANA + offset support
+     * - TPS.toDate() now respects ;tz= extensions when present
+     * - ESM dual-mode exports + browser IIFE bundle
+     *
+     * v0.5.0 Changes:
+     * - Added Actor anchor (A:) for provenance tracking
+     * - Added Signature (!) for cryptographic verification
+     * - Added structural anchors (bldg, floor, room, zone)
+     * - Added geospatial cell systems (S2, H3, Plus Code, what3words)
+     */
+    // built-in drivers are registered automatically; importing them here
+    // ensures they are included when the library bundler/tree-shaker runs.
+    class TPS {
+        /**
+         * Registers a calendar driver plugin.
+         * @param driver - The driver instance to register.
+         */
+        static registerDriver(driver) {
+            this.driverManager.register(driver);
+        }
+        /**
+         * Gets a registered calendar driver.
+         * @param code - The calendar code.
+         * @returns The driver or undefined.
+         */
+        static getDriver(code) {
+            return this.driverManager.get(code);
+        }
+        // --- CORE METHODS ---
+        /**
+         * SANITIZER: Normalises a raw TPS input string before validation.
+         *
+         * Pure string-based — no parsing into components, no regex beyond simple
+         * character checks, no re-serialisation via buildTimePart / toURI.
+         *
+         * Token ranks (descending): m(8) c(7) y(6) m(5) d(4) h(3) m(2) s(1) m(0)
+         */
+        static sanitizeTimeInput(input) {
+            // ── 1. Whitespace ────────────────────────────────────────────────────────
+            let s = input.trim().replace(/\s+/g, "");
+            if (!s)
+                return s;
+            // ── 1.2 Compact scheme normalization (v0.6.0) ──────────────────────────
+            // TPS:...    → tps://...   (generic compact)
+            // NIP4:x     → tps://net:ip4:x   (IPv4 shorthand)
+            // NIP6:x     → tps://net:ip6:x   (IPv6 shorthand)
+            // NODE:x     → tps://node:x      (logical node shorthand)
+            if (/^TPS:/i.test(s) && !s.toLowerCase().startsWith("tps://")) {
+                // TPS:L:... or TPS:lat,lon... → tps://...
+                s = "tps://" + s.slice(4); // strip 'TPS:'
+            }
+            else if (/^NIP4:/i.test(s)) {
+                s = "tps://net:ip4:" + s.slice(5);
+            }
+            else if (/^NIP6:/i.test(s)) {
+                s = "tps://net:ip6:" + s.slice(5);
+            }
+            else if (/^NODE:/i.test(s)) {
+                s = "tps://node:" + s.slice(5);
+            }
+            // ── 1.5 Convert legacy "/T:" separators to the new canonical "@T:".
+            // The input may contain "/T:" from older versions; we normalise early so
+            // subsequent logic can assume only the '@' form.
+            if (s.includes("/T:")) {
+                s = s.replace(/\/T:/g, "@T:");
+            }
+            // ── 2. Scheme casing ─────────────────────────────────────────────────────
+            if (s.slice(0, 6).toLowerCase() === "tps://") {
+                s = "tps://" + s.slice(6);
+            }
+            // ── 3. T: prefix casing (time-only strings) ──────────────────────────────
+            if (!s.startsWith("tps://") && s.slice(0, 2).toLowerCase() === "t:") {
+                s = "T:" + s.slice(2);
+            }
+            // ── 4. Locate T: section ─────────────────────────────────────────────────
+            let tStart = -1;
+            if (s.startsWith("T:")) {
+                tStart = 0;
+            }
+            else {
+                const atT = s.indexOf("@T:");
+                if (atT !== -1)
+                    tStart = atT + 1;
+            }
+            if (tStart === -1)
+                return s; // no T: section — return as-is
+            const beforeT = s.slice(0, tStart); // URI prefix or empty
+            const timeAndRest = s.slice(tStart); // T:cal.tok...  [!sig][;ext]
+            // Isolate token section from any trailing suffix (!sig / ;ext / ?q / #f)
+            const suffixIdx = timeAndRest.search(/[!;?#]/);
+            const timeSuffix = suffixIdx !== -1 ? timeAndRest.slice(suffixIdx) : "";
+            const timePart = suffixIdx !== -1 ? timeAndRest.slice(0, suffixIdx) : timeAndRest;
+            // timePart = "T:greg.m3.c1.y26.m01.d07.h13.m20.s45"
+            // Split off calendar code
+            const afterColon = timePart.slice(timePart.indexOf(":") + 1); // "greg.m3.c1..."
+            const firstDot = afterColon.indexOf(".");
+            const cal = (firstDot !== -1 ? afterColon.slice(0, firstDot) : afterColon).toLowerCase();
+            const tokenStr = firstDot !== -1 ? afterColon.slice(firstDot + 1) : "";
+            // If no calendar code was provided at all (e.g. "T:"), bail out early
+            // rather than inventing a default calendar.  The string will remain
+            // unparsable so validation can report it as invalid.
+            if (!cal) {
+                return s;
+            }
+            // No tokens at all — fill every slot with 0 and return
+            if (!tokenStr) {
+                return `${beforeT}T:${cal}.m0.c0.y0.m0.d0.h0.m0.s0.m0${timeSuffix}`;
+            }
+            if (/^i/i.test(tokenStr)) {
+                return `${beforeT}T:${cal}.${tokenStr}${timeSuffix}`;
+            }
+            const tokens = tokenStr
+                .split(".")
+                .filter((t) => t.length >= 2 && /^[a-z]/.test(t))
+                .map((t) => ({ p: t[0], v: t.slice(1) }));
+            // ── 6. Detect order from non-m tokens (c=7, y=6, w=4.5, d=4, h=3, s=1) ──
+            const nonMRank = {
+                c: 7,
+                y: 6,
+                w: 4.5,
+                d: 4,
+                h: 3,
+                s: 1,
+            };
+            const nonMSeq = tokens
+                .filter((t) => t.p !== "m" && nonMRank[t.p] !== undefined)
+                .map((t) => nonMRank[t.p]);
+            let isAsc = false;
+            if (nonMSeq.length >= 2) {
+                // ascending when every consecutive rank-diff is positive
+                isAsc = nonMSeq.every((r, i) => i === 0 || r > nonMSeq[i - 1]);
+            }
+            // ── 7. Reverse tokens if ascending ───────────────────────────────────────
+            if (isAsc)
+                tokens.reverse();
+            // ── 8. Disambiguate 'm' tokens by DESC position ──────────────────────────
+            // DESC slot order for m tokens: rank 8 (millennium), 5 (month), 2 (minute), 0 (ms)
+            const mDescRanks = [8, 5, 2, 0];
+            const byRank = new Map();
+            let mIdx = 0;
+            for (const tok of tokens) {
+                if (tok.p === "m") {
+                    if (mIdx < mDescRanks.length)
+                        byRank.set(mDescRanks[mIdx++], tok.v);
+                }
+                else {
+                    const r = nonMRank[tok.p];
+                    if (r !== undefined)
+                        byRank.set(r, tok.v);
+                }
+            }
+            // ── 9. Build complete DESC token string, filling gaps with '0' ───────────
+            const descSlots = [
+                ["m", 8],
+                ["c", 7],
+                ["y", 6],
+                ["m", 5],
+                ...(tokens.some((t) => t.p === "w") ? [["w", 4.5]] : []),
+                ["d", 4],
+                ["h", 3],
+                ["m", 2],
+                ["s", 1],
+                ["m", 0],
+            ];
+            const finalTokenStr = descSlots
+                .map(([p, r]) => p + (byRank.get(r) ?? "0"))
+                .join(".");
+            return `${beforeT}T:${cal}.${finalTokenStr}${timeSuffix}`;
+        }
+        static validate(input) {
+            const sanitized = this.sanitizeTimeInput(input);
+            const matchesRegex = sanitized.startsWith("tps://")
+                ? this.REGEX_URI.test(sanitized)
+                : this.REGEX_TIME.test(sanitized);
+            if (!matchesRegex)
+                return false;
+            const indexedMatch = sanitized.match(/(?:^T:|@T:)([a-z]{3,4})\.(i[^!;?#]+)/i);
+            if (indexedMatch) {
+                if (indexedMatch[1].toLowerCase() !== DefaultCalendars.TPS) {
+                    return false;
+                }
+                if (!isTpsIndexedToken(indexedMatch[2])) {
+                    return this.parse(sanitized) !== null;
+                }
+                return this.parse(sanitized) !== null;
+            }
+            return true;
+        }
+        static parse(input) {
+            // Always sanitize first so we operate on the canonical form.  This also
+            // rewrites any legacy "/T:" separators to "@T:" so the regex below can
+            // remain strict.
+            input = this.sanitizeTimeInput(input);
+            // quick fail via regex to rule out obviously bad strings
+            if (input.startsWith("tps://")) {
+                const match = this.REGEX_URI.exec(input);
+                if (!match || !match.groups)
+                    return null;
+                const comp = this._mapGroupsToComponents(match.groups);
+                // extract the raw time portion and parse it separately
+                const atIdx = input.indexOf("@T:");
+                let timeStr = "";
+                let signature;
+                if (atIdx !== -1) {
+                    timeStr = input.slice(atIdx + 1); // include the leading 'T:'
+                    // if there's a signature, capture it first
+                    const sigMatch = timeStr.match(/!(?<sig>[^;?#]+)/);
+                    if (sigMatch && sigMatch.groups && sigMatch.groups.sig) {
+                        signature = sigMatch.groups.sig;
+                    }
+                    // cut off signature, extensions, query, or fragment
+                    timeStr = timeStr.split(/[!;?#]/)[0];
+                }
+                if (timeStr) {
+                    const parsed = parseTimeString(timeStr);
+                    if (!parsed)
+                        return null;
+                    Object.assign(comp, parsed.components);
+                    comp.order = parsed.order;
+                }
+                if (signature) {
+                    comp.signature = signature;
+                }
+                return comp;
+            }
+            // time-only string
+            const match = this.REGEX_TIME.exec(input);
+            if (!match || !match.groups)
+                return null;
+            // isolate signature if present
+            let timeOnly = input;
+            let signature;
+            const sigMatch = input.match(/!(?<sig>[^;?#]+)/);
+            if (sigMatch && sigMatch.groups && sigMatch.groups.sig) {
+                signature = sigMatch.groups.sig;
+                timeOnly = input.split(/[!;?#]/)[0];
+            }
+            else {
+                // Strip extension/query/fragment suffix so parseTimeString sees only tokens
+                timeOnly = input.split(/[;?#]/)[0];
+            }
+            const parsed = parseTimeString(timeOnly);
+            if (!parsed)
+                return null;
+            const comp = parsed.components;
+            if (signature)
+                comp.signature = signature;
+            comp.order = parsed.order;
+            // Route through the same group mapper used by REGEX_URI for consistency
+            // (handles extensions ;KEY:val and context #C:key=val)
+            const syntheticGroups = {
+                calendar: match.groups.calendar ?? "",
+                signature: match.groups.signature ?? "",
+                extensions: match.groups.extensions ?? "",
+                context: match.groups.context ?? "",
+                location: "", // no location in time-only string
+                actor: "",
+            };
+            const mappedComp = this._mapGroupsToComponents(syntheticGroups);
+            // Merge temporal components from parseTimeString with mapped metadata
+            Object.assign(comp, {
+                signature: mappedComp.signature || comp.signature,
+                extensions: mappedComp.extensions || comp.extensions,
+                context: mappedComp.context,
+            });
+            return comp;
+        }
+        static buildTimeString(comp, opts) {
+            let time = buildTimePart(comp, opts);
+            if (comp.extensions && Object.keys(comp.extensions).length > 0) {
+                const extStrings = Object.entries(comp.extensions).map(([k, v]) => {
+                    return `${k.toUpperCase()}:${v}`;
+                });
+                time += `;${extStrings.join(";")}`;
+            }
+            if (comp.context && Object.keys(comp.context).length > 0) {
+                const ctxStrings = Object.entries(comp.context).map(([k, v]) => `${k}=${v}`);
+                time += `#C:${ctxStrings.join(";")}`;
+            }
+            return time;
+        }
+        static toTpsNativeComponents(input) {
+            if (input instanceof Date) {
+                return normalizeTpsComponents({
+                    calendar: DefaultCalendars.TPS,
+                    ...buildTpsComponentsFromDayIndex(getTpsDayIndex(input), getTpsDayFraction(input)),
+                });
+            }
+            if (typeof input === "string") {
+                const parsed = this.parse(input);
+                if (!parsed || parsed.calendar !== DefaultCalendars.TPS)
+                    return null;
+                return normalizeTpsComponents(parsed);
+            }
+            if ((input.calendar ?? DefaultCalendars.TPS) !== DefaultCalendars.TPS) {
+                return null;
+            }
+            return normalizeTpsComponents({
+                ...input,
+                calendar: DefaultCalendars.TPS,
+            });
+        }
+        static renderTpsLikeInput(originalInput, comp, opts) {
+            const sanitized = this.sanitizeTimeInput(originalInput);
+            return sanitized.startsWith("tps://")
+                ? this.toURI(comp, opts)
+                : this.buildTimeString(comp, opts);
+        }
+        /**
+         * SERIALIZER: Converts a components object into a full TPS URI.
+         * @param comp - The TPS components.
+         * @returns Full URI string (e.g. "tps://...").
+         */
+        static toURI(comp, opts) {
+            // ── 1. Location layers (v0.6.0) ──────────────────────────────────────────
+            // Build an ordered list of location layer strings, then join with ";"
+            const layers = [];
+            // Privacy shorthand takes priority
+            if (comp.isHiddenLocation) {
+                layers.push("L:~");
+            }
+            else if (comp.isRedactedLocation) {
+                layers.push("L:redacted");
+            }
+            else if (comp.isUnknownLocation) {
+                layers.push("L:-");
+            }
+            else if (comp.spaceAnchor) {
+                // Generic / legacy anchor (adm:, planet:, etc.)
+                layers.push(comp.spaceAnchor);
+            }
+            else if (comp.ipv4) {
+                layers.push(`net:ip4:${comp.ipv4}`);
+            }
+            else if (comp.ipv6) {
+                layers.push(`net:ip6:${comp.ipv6}`);
+            }
+            else if (comp.nodeName) {
+                layers.push(`node:${comp.nodeName}`);
+            }
+            else if (comp.s2Cell) {
+                layers.push(`S2:${comp.s2Cell}`);
+            }
+            else if (comp.h3Cell) {
+                layers.push(`H3:${comp.h3Cell}`);
+            }
+            else if (comp.what3words) {
+                layers.push(`3W:${comp.what3words}`);
+            }
+            else if (comp.plusCode) {
+                layers.push(`plus:${comp.plusCode}`);
+            }
+            else if (comp.building) {
+                layers.push(`bldg:${comp.building}`);
+                if (comp.floor)
+                    layers.push(`floor:${comp.floor}`);
+                if (comp.room)
+                    layers.push(`room:${comp.room}`);
+                if (comp.door)
+                    layers.push(`door:${comp.door}`);
+                if (comp.zone)
+                    layers.push(`zone:${comp.zone}`);
+            }
+            else if (comp.latitude !== undefined && comp.longitude !== undefined) {
+                let gps = `L:${comp.latitude},${comp.longitude}`;
+                if (comp.altitude !== undefined)
+                    gps += `,${comp.altitude}m`;
+                layers.push(gps);
+            }
+            else {
+                layers.push("L:-"); // unknown fallback
+            }
+            // Place layer (P:) — appended after primary location
+            if (comp.placeCountryCode || comp.placeCountryName ||
+                comp.placeCityCode || comp.placeCityName) {
+                const pParts = [];
+                if (comp.placeCountryCode)
+                    pParts.push(`cc=${comp.placeCountryCode}`);
+                if (comp.placeCountryName)
+                    pParts.push(`cn=${comp.placeCountryName}`);
+                if (comp.placeCityCode)
+                    pParts.push(`ci=${comp.placeCityCode}`);
+                if (comp.placeCityName)
+                    pParts.push(`ct=${comp.placeCityName}`);
+                layers.push(`P:${pParts.join(",")}`);
+            }
+            const locationStr = layers.join(";");
+            // ── 2. Actor (/A:...) ─────────────────────────────────────────────────────
+            const actorPart = comp.actor ? `/A:${comp.actor}` : "";
+            // ── 3. Time (mandatory 9 tokens) ─────────────────────────────────────────
+            const timePart = buildTimePart(comp, opts);
+            // ── 4. Extensions (;KEY:val;...) ─────────────────────────────────────────
+            let extPart = "";
+            if (comp.extensions && Object.keys(comp.extensions).length > 0) {
+                const extStrings = Object.entries(comp.extensions).map(([k, v]) => {
+                    // Emit as KEY:val (preferred v0.6.0 style)
+                    return `${k.toUpperCase()}:${v}`;
+                });
+                extPart = `;${extStrings.join(";")}`;
+            }
+            // ── 5. Context (#C:key=val;...) ──────────────────────────────────────────
+            let contextPart = "";
+            if (comp.context && Object.keys(comp.context).length > 0) {
+                const ctxStrings = Object.entries(comp.context).map(([k, v]) => `${k}=${v}`);
+                contextPart = `#C:${ctxStrings.join(";")}`;
+            }
+            return `tps://${locationStr}${actorPart}@${timePart}${extPart}${contextPart}`;
+        }
+        /**
+         * CONVERTER: Creates a TPS Time Object string from a JavaScript Date.
+         * Supports plugin drivers for non-Gregorian calendars.
+         * @param date - The JS Date object (defaults to Now).
+         * @param calendar - The target calendar driver (default `"tps"`).
+         * @param opts - Optional parameters; for built-in calendars the only
+         *   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 = DefaultCalendars.TPS, opts) {
+            const normalizedCalendar = calendar.toLowerCase();
+            const driver = this.driverManager.get(normalizedCalendar);
+            if (driver) {
+                // when caller requested an explicit order we can bypass the driver's
+                // `fromDate` helper and instead generate components ourselves so that
+                // order is honoured even if the driver doesn't know about it.  This
+                // keeps behaviour identical to the old built-in implementation.
+                if (opts?.order || opts?.timeMode || opts?.indexedPrecision !== undefined) {
+                    const comp = driver.getComponentsFromDate(date);
+                    comp.calendar = normalizedCalendar;
+                    if (opts?.order)
+                        comp.order = opts.order;
+                    return buildTimePart(comp, opts);
+                }
+                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 === DefaultCalendars.UNIX) {
+                const s = (date.getTime() / 1000).toFixed(3);
+                comp.unixSeconds = parseFloat(s);
+                if (opts?.order)
+                    comp.order = opts.order;
+                return buildTimePart(comp, opts);
+            }
+            if (normalizedCalendar === DefaultCalendars.GREG) {
+                const fullYear = date.getUTCFullYear();
+                comp.millennium = Math.floor(fullYear / 1000) + 1;
+                comp.century = Math.floor((fullYear % 1000) / 100) + 1;
+                comp.year = fullYear % 100;
+                comp.month = date.getUTCMonth() + 1;
+                comp.day = date.getUTCDate();
+                comp.hour = date.getUTCHours();
+                comp.minute = date.getUTCMinutes();
+                comp.second = date.getUTCSeconds();
+                comp.millisecond = date.getUTCMilliseconds();
+                if (opts?.order)
+                    comp.order = opts.order;
+                return buildTimePart(comp, opts);
+            }
+            throw new Error(`Calendar driver '${normalizedCalendar}' not implemented. Register a driver.`);
+        }
+        /**
+         * CONVERTER: Converts a TPS string to a Date in a target calendar format.
+         * Uses plugin drivers for cross-calendar conversion.
+         * @param tpsString - The source TPS string (any calendar).
+         * @param targetCalendar - The target calendar code (e.g., 'hij').
+         * @returns A TPS string in the target calendar, or null if invalid.
+         */
+        static to(targetCalendar, tpsString) {
+            // 1. Parse to components and convert to Gregorian Date
+            const gregDate = this.toDate(tpsString);
+            if (!gregDate)
+                return null;
+            // 2. Convert Gregorian to target calendar using driver
+            return this.fromDate(gregDate, targetCalendar);
+        }
+        /**
+         * CONVERTER: Reconstructs a JavaScript Date object from a TPS string.
+         * Supports plugin drivers for non-Gregorian calendars.
+         * @param tpsString - The TPS string.
+         * @returns JS Date object or `null` if invalid.
+         */
+        static toDate(tpsString) {
+            const parsed = this.parse(tpsString);
+            if (!parsed)
+                return null;
+            const cal = parsed.calendar || DefaultCalendars.TPS;
+            const driver = this.driverManager.get(cal);
+            if (!driver) {
+                console.error(`Calendar driver '${cal}' not registered.`);
+                return null;
+            }
+            const date = driver.getDateFromComponents(parsed);
+            // If the URI has a ;tz= extension, the calendar date was expressed in local
+            // time. Convert from local → UTC using the timezone utility.
+            const tz = parsed.extensions?.["tz"];
+            if (tz && date) {
+                const localMs = date.getTime();
+                const utcMs = localToUtc(localMs, tz);
+                return new Date(utcMs);
+            }
+            return date;
+        }
+        static toDayIndex(input) {
+            const comp = this.toTpsNativeComponents(input);
+            return comp ? getTpsDayIndex(comp) : null;
+        }
+        static fromDayIndex(dayIndex, dayFraction = 0, opts) {
+            if (!Number.isSafeInteger(dayIndex) || dayIndex < 0) {
+                throw new Error("TPS.fromDayIndex: dayIndex must be a non-negative integer");
+            }
+            if (!Number.isFinite(dayFraction) || dayFraction < 0 || dayFraction >= 1) {
+                throw new Error("TPS.fromDayIndex: dayFraction must be in [0, 1)");
+            }
+            const comp = buildTpsComponentsFromDayIndex(dayIndex, dayFraction);
+            if (opts?.order)
+                comp.order = opts.order;
+            return buildTimePart(comp, opts);
+        }
+        static getDayFraction(input) {
+            const comp = this.toTpsNativeComponents(input);
+            return comp ? getTpsDayFraction(comp) : null;
+        }
+        static getSubDayMilliseconds(input) {
+            const comp = this.toTpsNativeComponents(input);
+            return comp ? getTpsSubDayMilliseconds(comp) : null;
+        }
+        static expandIndexedTime(input) {
+            const sanitized = this.sanitizeTimeInput(input);
+            const indexedMatch = sanitized.match(/(?:^T:|@T:)([a-z]{3,4})\.(i[^!;?#]+)/i);
+            if (!indexedMatch ||
+                indexedMatch[1].toLowerCase() !== DefaultCalendars.TPS ||
+                !isTpsIndexedToken(indexedMatch[2])) {
+                const parsed = this.parse(sanitized);
+                if (!parsed || parsed.calendar !== DefaultCalendars.TPS)
+                    return null;
+                return input.trim();
+            }
+            const comp = this.toTpsNativeComponents(sanitized);
+            if (!comp)
+                return null;
+            return this.renderTpsLikeInput(sanitized, comp);
+        }
+        static expandIndex(input) {
+            return this.expandIndexedTime(input);
+        }
+        static compactIndexedTime(input, opts) {
+            const comp = this.toTpsNativeComponents(input);
+            if (!comp)
+                return null;
+            return this.renderTpsLikeInput(input, comp, {
+                timeMode: "indexed-fraction",
+                indexedPrecision: opts?.precision,
+            });
+        }
+        static compact(input, opts) {
+            return this.compactIndexedTime(input, opts);
+        }
+        static toIndexedTime(input, opts) {
+            const comp = this.toTpsNativeComponents(input);
+            if (!comp)
+                return null;
+            return this.buildTimeString(comp, {
+                timeMode: "indexed-fraction",
+                indexedPrecision: opts?.precision,
+            });
+        }
+        static toIndexedURI(input, opts) {
+            const comp = this.toTpsNativeComponents(input);
+            if (!comp)
+                return null;
+            return this.toURI(comp, {
+                timeMode: "indexed-fraction",
+                indexedPrecision: opts?.precision,
+            });
+        }
+        // --- DRIVER CONVENIENCE METHODS ---
+        /**
+         * Parse a calendar-specific date string into TPS components.
+         * Requires the driver to implement `parseDate`.
+         *
+         * @param calendar - The calendar code (e.g., 'hij')
+         * @param dateString - Date string in calendar-native format (e.g., '1447-07-21')
+         * @param format - Optional format string (driver-specific)
+         * @returns TPS components or null if parsing fails
+         *
+         * @example
+         * ```ts
+         * const components = TPS.parseCalendarDate('hij', '1447-07-21');
+         * // { calendar: 'hij', year: 1447, month: 7, day: 21 }
+         *
+         * const uri = TPS.toURI({ ...components, latitude: 31.95, longitude: 35.91 });
+         * // "tps://31.95,35.91@T:hij.y1447.m07.d21"
+         * ```
+         */
+        static parseCalendarDate(calendar, dateString, format) {
+            const driver = this.driverManager.get(calendar);
+            if (!driver) {
+                throw new Error(`Calendar driver '${calendar}' not found. Register a driver first.`);
+            }
+            // parseDate is guaranteed by the interface, so we can call it directly.
+            return driver.parseDate(dateString, format);
+        }
+        /**
+         * Convert a calendar-specific date string directly to a TPS URI.
+         * This is a convenience method that combines parseDate + toURI.
+         *
+         * @param calendar - The calendar code (e.g., 'hij')
+         * @param dateString - Date string in calendar-native format
+         * @param location - Optional location (lat/lon/alt or privacy flag)
+         * @returns Full TPS URI string
+         *
+         * @example
+         * ```ts
+         * // With coordinates
+         * TPS.fromCalendarDate('hij', '1447-07-21', { latitude: 31.95, longitude: 35.91 });
+         * // "tps://31.95,35.91@T:hij.y1447.m07.d21"
+         *
+         * // With privacy flag
+         * TPS.fromCalendarDate('hij', '1447-07-21', { isHiddenLocation: true });
+         * // "tps://hidden@T:hij.y1447.m07.d21"
+         *
+         * // Without location
+         * TPS.fromCalendarDate('hij', '1447-07-21');
+         * // "tps://unknown@T:hij.y1447.m07.d21"
+         * ```
+         */
+        static fromCalendarDate(calendar, dateString, location) {
+            const components = this.parseCalendarDate(calendar, dateString);
+            if (!components) {
+                throw new Error(`Failed to parse date string: ${dateString}`);
+            }
+            // Merge with location
+            const fullComponents = {
+                calendar: calendar,
+                ...components,
+                ...location,
+            };
+            return this.toURI(fullComponents);
+        }
+        /**
+         * Format TPS components to a calendar-specific date string.
+         * Requires the driver to implement `format`.
+         *
+         * @param calendar - The calendar code
+         * @param components - TPS components to format
+         * @param format - Optional format string (driver-specific)
+         * @returns Formatted date string in calendar-native format
+         *
+         * @example
+         * ```ts
+         * const tps = TPS.parse('tps://unknown@T:hij.y1447.m07.d21');
+         * const formatted = TPS.formatCalendarDate('hij', tps);
+         * // "1447-07-21"
+         * ```
+         */
+        static formatCalendarDate(calendar, components, format) {
+            const driver = this.driverManager.get(calendar);
+            if (!driver) {
+                throw new Error(`Calendar driver '${calendar}' not found.`);
+            }
+            // format is guaranteed by the interface, so we can call it directly.
+            return driver.format(components, format);
+        }
+        // --- CONVENIENCE METHODS ---
+        /**
+         * Returns a TPS time string for the current moment.
+         * Shorthand for `TPS.fromDate(new Date(), calendar, opts)`.
+         *
+         * @param calendar - Calendar code. Defaults to 'greg'.
+         * @param opts - Optional `order` (ASC/DESC) parameter.
+         * @returns TPS time string.
+         *
+         * @example
+         * ```ts
+         * TPS.now(); // "T:greg.m3.c1.y26.m3.d4.h06.m30.s00.m0"
+         * TPS.now('hij'); // "T:hij.y1447.m09.d05.h06.m30.s00"
+         * ```
+         */
+        static now(calendar = DefaultCalendars.GREG, opts) {
+            return this.fromDate(new Date(), calendar, opts);
+        }
+        /**
+         * Returns the difference in milliseconds between two TPS strings.
+         * The result is `t2 - t1`; negative if t1 is after t2.
+         *
+         * @param t1 - First TPS string (subtracted from t2).
+         * @param t2 - Second TPS string.
+         * @returns Milliseconds between the two moments, or NaN on parse failure.
+         *
+         * @example
+         * ```ts
+         * const ms = TPS.diff('T:greg.m3.c1.y26.m1.d1.h0.m0.s0.m0',
+         *                       'T:greg.m3.c1.y26.m1.d2.h0.m0.s0.m0');
+         * // 86_400_000  (one day)
+         * ```
+         */
+        static diff(t1, t2) {
+            const d1 = this.toDate(t1);
+            const d2 = this.toDate(t2);
+            if (!d1 || !d2)
+                return NaN;
+            return d2.getTime() - d1.getTime();
+        }
+        /**
+         * Returns a new TPS string shifted by the given duration.
+         * The result is in the same calendar as the original string.
+         *
+         * @param tpsStr - Source TPS string.
+         * @param duration - Object with optional `days`, `hours`, `minutes`, `seconds`, `milliseconds`.
+         * @returns Shifted TPS string, or null if the input is invalid.
+         *
+         * @example
+         * ```ts
+         * const t = 'T:greg.m3.c1.y26.m1.d9.h14.m30.s25.m0';
+         * TPS.add(t, { days: 7 });   // one week later
+         * TPS.add(t, { hours: -2 }); // two hours earlier
+         * ```
+         */
+        static add(tpsStr, duration) {
+            const date = this.toDate(tpsStr);
+            if (!date)
+                return null;
+            const parsed = this.parse(tpsStr);
+            const calendar = parsed?.calendar ?? DefaultCalendars.GREG;
+            const order = parsed?.order;
+            const deltaMs = (duration.days ?? 0) * 86400000 +
+                (duration.hours ?? 0) * 3600000 +
+                (duration.minutes ?? 0) * 60000 +
+                (duration.seconds ?? 0) * 1000 +
+                (duration.milliseconds ?? 0);
+            const shifted = new Date(date.getTime() + deltaMs);
+            return this.fromDate(shifted, calendar, order ? { order } : undefined);
+        }
+        // --- INTERNAL HELPERS ---
+        static _mapGroupsToComponents(g) {
+            const components = {};
+            components.calendar = g.calendar;
+            // ── Signature ────────────────────────────────────────────────────────────
+            if (g.signature) {
+                components.signature = g.signature;
+            }
+            // ── Actor (/A:...) ────────────────────────────────────────────────────────
+            if (g.actor) {
+                components.actor = g.actor.trim();
+            }
+            // ── Location layers (v0.6.0: multi-layer, ;-separated) ───────────────────
+            if (g.location) {
+                this._parseLocationLayers(g.location, components);
+            }
+            // ── Extensions (;KEY:val or ;key=val after T: tokens) ────────────────────
+            if (g.extensions) {
+                const extObj = {};
+                g.extensions.split(";").forEach((part) => {
+                    part = part.trim();
+                    if (!part)
+                        return;
+                    const colonIdx = part.indexOf(":");
+                    const eqIdx = part.indexOf("=");
+                    if (colonIdx > 0 && (eqIdx < 0 || colonIdx < eqIdx)) {
+                        // KEY:val form (e.g. TZ:+03:00)
+                        const key = part.substring(0, colonIdx).toLowerCase();
+                        const val = part.substring(colonIdx + 1);
+                        if (key && val !== undefined)
+                            extObj[key] = val;
+                    }
+                    else if (eqIdx > 0) {
+                        // key=val form (e.g. tz=+03:00)
+                        const key = part.substring(0, eqIdx).toLowerCase();
+                        const val = part.substring(eqIdx + 1);
+                        if (key && val !== undefined)
+                            extObj[key] = val;
+                    }
+                });
+                if (Object.keys(extObj).length > 0)
+                    components.extensions = extObj;
+            }
+            // ── Context (#C:key=val;key=val) ─────────────────────────────────────────
+            if (g.context) {
+                const ctx = {};
+                g.context.split(";").forEach((part) => {
+                    part = part.trim();
+                    if (!part)
+                        return;
+                    const eqIdx = part.indexOf("=");
+                    if (eqIdx > 0) {
+                        ctx[part.substring(0, eqIdx)] = part.substring(eqIdx + 1);
+                    }
+                });
+                if (Object.keys(ctx).length > 0)
+                    components.context = ctx;
+            }
+            return components;
+        }
+        /**
+         * Parses a multi-layer location string (before @T:) into component fields.
+         * Layers are `;`-separated. Each layer is identified by its prefix token.
+         *
+         * Supported layers:
+         *   L:lat,lon[,altm]         — GPS
+         *   L:~|L:-|L:redacted       — Privacy markers
+         *   P:cc=JO,ci=AMM,...       — Place (country/city codes and names)
+         *   S2:token                 — S2 cell
+         *   H3:token                 — H3 cell
+         *   3W:word.word.word        — What3Words
+         *   plus:token               — Plus Code
+         *   net:ip4:x.x.x.x          — IPv4
+         *   net:ip6:x::x             — IPv6
+         *   node:name                — Logical node/host
+         *   bldg:name                — Building
+         *   floor:x                  — Floor
+         *   room:x                   — Room
+         *   door:x                   — Door
+         *   zone:x                   — Zone
+         */
+        static _parseLocationLayers(location, components) {
+            const layers = location.trim().split(";");
+            for (const layer of layers) {
+                const l = layer.trim();
+                if (!l)
+                    continue;
+                // Privacy shorthand
+                if (l === "L:~" || l === "L:hidden") {
+                    components.isHiddenLocation = true;
+                    continue;
+                }
+                if (l === "L:-" || l === "L:unknown") {
+                    components.isUnknownLocation = true;
+                    continue;
+                }
+                if (l === "L:redacted") {
+                    components.isRedactedLocation = true;
+                    continue;
+                }
+                // P: Place layer — P:cc=JO,ci=AMM,cn=Jordan,ct=Amman
+                if (l.startsWith("P:")) {
+                    l.slice(2).split(",").forEach((pair) => {
+                        const eq = pair.indexOf("=");
+                        if (eq < 1)
+                            return;
+                        const k = pair.substring(0, eq).toLowerCase();
+                        const v = pair.substring(eq + 1);
+                        if (k === "cc")
+                            components.placeCountryCode = v;
+                        else if (k === "cn")
+                            components.placeCountryName = v;
+                        else if (k === "ci")
+                            components.placeCityCode = v;
+                        else if (k === "ct")
+                            components.placeCityName = v;
+                    });
+                    continue;
+                }
+                // GPS coordinates (L:lat,lon[,alt])
+                if (l.startsWith("L:")) {
+                    const coords = l.slice(2);
+                    const m = coords.match(/^(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)(?:,(-?\d+(?:\.\d+)?)m?)?$/);
+                    if (m) {
+                        components.latitude = parseFloat(m[1]);
+                        components.longitude = parseFloat(m[2]);
+                        if (m[3])
+                            components.altitude = parseFloat(m[3]);
+                    }
+                    continue;
+                }
+                // Geospatial cells
+                if (/^S2:/i.test(l)) {
+                    components.s2Cell = l.slice(3);
+                    continue;
+                }
+                if (/^H3:/i.test(l)) {
+                    components.h3Cell = l.slice(3);
+                    continue;
+                }
+                if (/^3W:/i.test(l)) {
+                    components.what3words = l.slice(3);
+                    continue;
+                }
+                if (/^plus:/i.test(l)) {
+                    components.plusCode = l.slice(5);
+                    continue;
+                }
+                // Network
+                if (/^net:ip4:/i.test(l)) {
+                    components.ipv4 = l.slice(8);
+                    continue;
+                }
+                if (/^net:ip6:/i.test(l)) {
+                    components.ipv6 = l.slice(8);
+                    continue;
+                }
+                if (/^node:/i.test(l)) {
+                    components.nodeName = l.slice(5);
+                    continue;
+                }
+                // Structural
+                if (/^bldg:/i.test(l)) {
+                    components.building = l.slice(5);
+                    continue;
+                }
+                if (/^floor:/i.test(l)) {
+                    components.floor = l.slice(6);
+                    continue;
+                }
+                if (/^room:/i.test(l)) {
+                    components.room = l.slice(5);
+                    continue;
+                }
+                if (/^door:/i.test(l)) {
+                    components.door = l.slice(5);
+                    continue;
+                }
+                if (/^zone:/i.test(l)) {
+                    components.zone = l.slice(5);
+                    continue;
+                }
+                // Fallback: generic space anchor (adm:, planet:, legacy strings)
+                if (l) {
+                    components.spaceAnchor = components.spaceAnchor
+                        ? components.spaceAnchor + ";" + l
+                        : l;
+                }
+            }
+        }
+    }
+    // --- PLUGIN REGISTRY ---
+    /** Shared DriverManager instance — use TPS.driverManager for direct access. */
+    TPS.driverManager = new DriverManager();
+    // --- REGEX (v0.6.0) ---
+    // The URI and time regexes are intentionally permissive in the location &
+    // extension sections — detailed semantic parsing happens in
+    // _mapGroupsToComponents() and the layer parsers below.
+    //
+    // Structure:
+    //   tps://[location]/A:[actor]@T:[cal].[tokens];[ext];...#C:[ctx];...
+    //
+    // The `;` separator is used consistently:
+    //   - between location layers (before @T:)
+    //   - between extensions (after T: tokens, before #)
+    //   - between context key=val pairs (after #C:)
+    TPS.REGEX_URI = new RegExp("^tps://" +
+        // Location: everything up to optional /A: actor and then @T:
+        "(?<location>[^@]+?)" +
+        // Optional actor overlay
+        "(?:/A:(?<actor>[^@]+))?" +
+        // Time section
+        "@T:(?<calendar>[a-z]{3,4})" +
+        "(?<tokens>(?:\\.[a-z]-?[\\d.]+)*)" +
+        // Optional signature
+        "(?:!(?<signature>[^;#]+))?" +
+        // Optional extensions (;KEY:val;key=val;...)
+        "(?:;(?<extensions>[^#]+))?" +
+        // Optional context fragment (#C:key=val;...)
+        "(?:#C:(?<context>.+))?$");
+    TPS.REGEX_TIME = new RegExp("^T:(?<calendar>[a-z]{3,4})" +
+        "(?<tokens>(?:\\.[a-z]-?[\\d.]+)*)" +
+        "(?:!(?<signature>[^;#]+))?" +
+        "(?:;(?<extensions>[^#]+))?" +
+        "(?:#C:(?<context>.+))?$");
+    // register built-in drivers and set default
+    // (tps and gregorian provide canonical conversions before unix)
+    TPS.registerDriver(new TpsDriver());
+    TPS.registerDriver(new GregorianDriver());
+    TPS.registerDriver(new UnixDriver());
+    TPS.registerDriver(new PersianDriver());
+    TPS.registerDriver(new HijriDriver());
+    TPS.registerDriver(new JulianDriver());
+    TPS.registerDriver(new HoloceneDriver());
+    TPS.registerDriver(new ChineseDriver());
+    /**
+     * `TpsDate` is a Date-like wrapper with native TPS conversion helpers.
+     *
+     * It mirrors common JavaScript `Date` construction patterns:
+     * - `new TpsDate()`
+     * - `new TpsDate(ms)`
+     * - `new TpsDate(isoString)`
+     * - `new TpsDate(tpsString)`
+     * - `new TpsDate(year, monthIndex, day?, hour?, minute?, second?, ms?)`
+     */
+
+    exports.DefaultCalendars = DefaultCalendars;
+    exports.DriverManager = DriverManager;
+    exports.Env = Env;
+    exports.TPS = TPS;
+    exports.TPSUID7RB = TPSUID7RB;
+    exports.TpsDate = TpsDate;
+    exports.getOffsetString = getOffsetString;
+    exports.localToUtc = localToUtc;
+    exports.utcToLocal = utcToLocal;
+
+    return exports;
+
+})({});