mmntjs-timezone 0.0.1

package/dist/logic.cjs

@@ -0,0 +1,958 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/logic.ts
+var logic_exports = {};
+__export(logic_exports, {
+  default: () => logic_default,
+  tz: () => tz
+});
+module.exports = __toCommonJS(logic_exports);
+var mmntjs = __toESM(require("mmntjs"), 1);
+
+// src/install.ts
+var offsetCache = /* @__PURE__ */ new Map();
+var MAX_DOMAIN_CACHE_SIZE = 1e3;
+var ABBR_LOCALES = [
+  "en-US",
+  "en-GB",
+  "ja-JP",
+  "en-AU",
+  "en-SG",
+  "en-HK",
+  "af-ZA",
+  "es-AR",
+  "pt-BR",
+  "ko-KR",
+  "en-IN",
+  "zh-CN"
+];
+var ZONE_ALIAS = {
+  "Asia/Calcutta": "Asia/Kolkata"
+};
+function normalizeName(name) {
+  return name.toLowerCase().replace(/\//g, "_");
+}
+function normalizeTz(tz2) {
+  const u = tz2.toUpperCase();
+  if (u === "UTC" || u === "GMT") {
+    return u;
+  }
+  return ZONE_ALIAS[tz2] ?? tz2;
+}
+function charCodeToInt(charCode) {
+  if (charCode > 96) {
+    return charCode - 87;
+  }
+  if (charCode > 64) {
+    return charCode - 29;
+  }
+  return charCode - 48;
+}
+function unpackBase60(input) {
+  let i = 0;
+  const parts = input.split(".");
+  const whole = parts[0] ?? "";
+  const fractional = parts[1] ?? "";
+  let multiplier = 1;
+  let out = 0;
+  let sign = 1;
+  if (input.charCodeAt(0) === 45) {
+    i = 1;
+    sign = -1;
+  }
+  for (; i < whole.length; i++) {
+    out = 60 * out + charCodeToInt(whole.charCodeAt(i));
+  }
+  for (i = 0; i < fractional.length; i++) {
+    multiplier /= 60;
+    out += charCodeToInt(fractional.charCodeAt(i)) * multiplier;
+  }
+  return out * sign;
+}
+function arrayToInt(values) {
+  return values.map((value) => unpackBase60(value));
+}
+function mapIndices(source, indices) {
+  const out = new Array(indices.length);
+  for (let i = 0; i < indices.length; i++) {
+    out[i] = source[indices[i]];
+  }
+  return out;
+}
+function decodeIndicesCodec(encoded) {
+  if (encoded[0] !== "!") {
+    return arrayToInt(encoded.split(""));
+  }
+  const indices = [];
+  let pos = 1;
+  const len = encoded.length;
+  while (pos < len) {
+    const ch = encoded[pos];
+    if (ch === "^" && pos + 4 <= len) {
+      const a = charCodeToInt(encoded.charCodeAt(pos + 1));
+      const b = charCodeToInt(encoded.charCodeAt(pos + 2));
+      const count = charCodeToInt(encoded.charCodeAt(pos + 3)) + 1;
+      for (let i = 0; i < count; i++) {
+        indices.push(a, b);
+      }
+      pos += 4;
+    } else if (ch === "~" && pos + 3 <= len) {
+      const a = charCodeToInt(encoded.charCodeAt(pos + 1));
+      const count = charCodeToInt(encoded.charCodeAt(pos + 2)) + 1;
+      for (let i = 0; i < count; i++) {
+        indices.push(a);
+      }
+      pos += 3;
+    } else if (ch === "@" && pos + 3 <= len) {
+      const start = charCodeToInt(encoded.charCodeAt(pos + 1));
+      const count = charCodeToInt(encoded.charCodeAt(pos + 2)) + 1;
+      const abbrCount = 62;
+      for (let i = 0; i < count; i++) {
+        indices.push((start + i) % abbrCount);
+      }
+      pos += 3;
+    } else {
+      indices.push(charCodeToInt(encoded.charCodeAt(pos)));
+      pos++;
+    }
+  }
+  return indices;
+}
+function parseDeltas(raw) {
+  const tokens = raw.split(" ");
+  if (_deltaDict.length > 0 && tokens.length > 0) {
+    return tokens.map((t) => {
+      if (t === "") return 0;
+      return _deltaDict[unpackBase60(t)] ?? 0;
+    });
+  }
+  return arrayToInt(tokens);
+}
+function unpack(packed) {
+  const data = packed.split("|");
+  const offsets = arrayToInt((data[2] ?? "").split(" "));
+  const indices = decodeIndicesCodec(data[3] ?? "");
+  const untils = parseDeltas(data[4] ?? "");
+  for (let i = 0; i < indices.length; i++) {
+    untils[i] = Math.round((untils[i - 1] || 0) + untils[i] * 6e4);
+  }
+  untils[indices.length - 1] = Number.POSITIVE_INFINITY;
+  return {
+    name: data[0] ?? "",
+    abbrs: mapIndices((data[1] ?? "").split(" "), indices),
+    offsets: mapIndices(offsets, indices),
+    untils,
+    population: Number(data[5] ?? 0) | 0
+  };
+}
+function closest(num, arr) {
+  const len = arr.length;
+  if (len === 0) {
+    return -1;
+  }
+  if (num < arr[0]) {
+    return 0;
+  }
+  if (len > 1 && arr[len - 1] === Number.POSITIVE_INFINITY && num >= (arr[len - 2] ?? 0)) {
+    return len - 1;
+  }
+  if (num >= (arr[len - 1] ?? 0)) {
+    return -1;
+  }
+  let lo = 0;
+  let hi = len - 1;
+  while (hi - lo > 1) {
+    const mid = Math.floor((lo + hi) / 2);
+    if ((arr[mid] ?? 0) <= num) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  return hi;
+}
+var InternalZone = class {
+  constructor(name, canonicalKey) {
+    this.lastIndex = -1;
+    this.lastStart = Number.NEGATIVE_INFINITY;
+    this.lastEnd = Number.POSITIVE_INFINITY;
+    this.name = name;
+    this.canonicalKey = canonicalKey;
+  }
+  _index(timestamp) {
+    const target = +timestamp;
+    if (this.lastIndex >= 0 && target >= this.lastStart && target < this.lastEnd) {
+      return this.lastIndex;
+    }
+    const untils = getDecodedZonePayload(this.canonicalKey).untils;
+    const idx = closest(target, untils);
+    if (idx >= 0) {
+      this.lastIndex = idx;
+      this.lastStart = idx > 0 ? untils[idx - 1] ?? Number.NEGATIVE_INFINITY : Number.NEGATIVE_INFINITY;
+      this.lastEnd = untils[idx] ?? Number.POSITIVE_INFINITY;
+    }
+    return idx;
+  }
+  countries() {
+    const out = [];
+    for (const [code, country] of Object.entries(countryStore)) {
+      if (country.zones.includes(this.name)) {
+        out.push(code);
+      }
+    }
+    return out;
+  }
+  parse(timestamp) {
+    const payload = getDecodedZonePayload(this.canonicalKey);
+    const target = +timestamp;
+    const max = payload.untils.length - 1;
+    for (let i = 0; i < max; i++) {
+      let offset = payload.offsets[i] ?? 0;
+      const offsetNext = payload.offsets[i + 1] ?? offset;
+      const offsetPrev = payload.offsets[i ? i - 1 : i] ?? offset;
+      if (offset < offsetNext && timezoneFlags.moveAmbiguousForward) {
+        offset = offsetNext;
+      } else if (offset > offsetPrev && timezoneFlags.moveInvalidForward) {
+        offset = offsetPrev;
+      }
+      if (target < (payload.untils[i] ?? Number.POSITIVE_INFINITY) - offset * 6e4) {
+        return payload.offsets[i] ?? 0;
+      }
+    }
+    return payload.offsets[max] ?? 0;
+  }
+  abbr(ts) {
+    const idx = this._index(ts);
+    const payload = getDecodedZonePayload(this.canonicalKey);
+    return idx >= 0 ? payload.abbrs[idx] ?? "" : "";
+  }
+  offset(ts) {
+    return this.utcOffset(ts);
+  }
+  utcOffset(ts) {
+    const idx = this._index(ts);
+    const payload = getDecodedZonePayload(this.canonicalKey);
+    return idx >= 0 ? payload.offsets[idx] ?? 0 : 0;
+  }
+};
+var CompatZone = class {
+  constructor(packedString) {
+    this.li = -1;
+    this.ls = Number.NEGATIVE_INFINITY;
+    this.le = Number.POSITIVE_INFINITY;
+    const u = unpack(packedString ?? "||0|0||0");
+    this.name = u.name;
+    this.p = createDecodedZonePayload(u);
+  }
+  _i(ts) {
+    const t = +ts;
+    if (this.li >= 0 && t >= this.ls && t < this.le) {
+      return this.li;
+    }
+    const idx = closest(t, this.p.untils);
+    if (idx >= 0) {
+      this.li = idx;
+      this.ls = idx > 0 ? this.p.untils[idx - 1] : Number.NEGATIVE_INFINITY;
+      this.le = this.p.untils[idx];
+    }
+    return idx;
+  }
+  countries() {
+    return [];
+  }
+  abbr(ts) {
+    const i = this._i(ts);
+    return i >= 0 ? this.p.abbrs[i] : "";
+  }
+  offset(ts) {
+    return this.utcOffset(ts);
+  }
+  utcOffset(ts) {
+    const i = this._i(ts);
+    return i >= 0 ? this.p.offsets[i] : 0;
+  }
+  parse(ts) {
+    const target = +ts;
+    const max = this.p.untils.length - 1;
+    for (let i = 0; i < max; i++) {
+      let off = this.p.offsets[i];
+      const nxt = this.p.offsets[i + 1] ?? off;
+      const prv = this.p.offsets[i ? i - 1 : i] ?? off;
+      if (off < nxt && timezoneFlags.moveAmbiguousForward) {
+        off = nxt;
+      } else if (off > prv && timezoneFlags.moveInvalidForward) {
+        off = prv;
+      }
+      if (target < this.p.untils[i] - off * 6e4) {
+        return this.p.offsets[i];
+      }
+    }
+    return this.p.offsets[max];
+  }
+};
+var _deltaDict = [];
+var zoneStore = /* @__PURE__ */ Object.create(
+  null
+);
+var linkStore = /* @__PURE__ */ Object.create(null);
+var nameStore = /* @__PURE__ */ Object.create(null);
+var countryStore = /* @__PURE__ */ Object.create(
+  null
+);
+var zoneWrapperCache = /* @__PURE__ */ new Map();
+var decodedZonePayloadCache = /* @__PURE__ */ new Map();
+var abbrInternPool = /* @__PURE__ */ new Map();
+var timezoneFlags = {
+  moveInvalidForward: true,
+  moveAmbiguousForward: false
+};
+var builtinZoneDataLoaded = false;
+var indexBuilt = false;
+var sortedZoneNamesCache = null;
+var _zonesBlob = "";
+var _linksBlob = "";
+var _countriesBlob = "";
+var _nameTable = [];
+var _zoneIdx = /* @__PURE__ */ new Map();
+var _linkIdx = /* @__PURE__ */ new Map();
+var _linkNameIdx = /* @__PURE__ */ new Map();
+var _countryIdx = /* @__PURE__ */ new Map();
+function internString(value) {
+  const cached = abbrInternPool.get(value);
+  if (cached) {
+    return cached;
+  }
+  abbrInternPool.set(value, value);
+  return value;
+}
+function createDecodedZonePayload(unpacked) {
+  const offsets = unpacked.offsets.some((value) => value > 32767 || value < -32768) ? Int32Array.from(unpacked.offsets) : Int16Array.from(unpacked.offsets);
+  return {
+    abbrs: unpacked.abbrs.map((abbr) => internString(abbr)),
+    offsets,
+    untils: Float64Array.from(unpacked.untils),
+    population: unpacked.population
+  };
+}
+function getDecodedZonePayload(canonicalKey) {
+  const cached = decodedZonePayloadCache.get(canonicalKey);
+  if (cached) {
+    return cached;
+  }
+  const source = zoneStore[canonicalKey];
+  if (!source) {
+    throw new Error(`Missing timezone payload for ${canonicalKey}`);
+  }
+  let payload;
+  if (typeof source === "string") {
+    payload = createDecodedZonePayload(unpack(source));
+  } else if ("ut" in source) {
+    const prebuilt = source;
+    const untils = [prebuilt.ut];
+    for (let i = 0; i < prebuilt.ud.length; i++) {
+      untils.push(untils[i] + prebuilt.ud[i]);
+    }
+    untils[untils.length - 1] = Number.POSITIVE_INFINITY;
+    payload = createDecodedZonePayload({
+      name: "",
+      abbrs: prebuilt.abbrs,
+      offsets: prebuilt.offsets,
+      untils,
+      population: prebuilt.pop
+    });
+  } else {
+    payload = source;
+  }
+  zoneStore[canonicalKey] = payload;
+  decodedZonePayloadCache.set(canonicalKey, payload);
+  return payload;
+}
+function addPackedZoneEntry(name, value) {
+  const normalized = normalizeName(name);
+  zoneStore[normalized] = value;
+  nameStore[normalized] = name;
+  zoneWrapperCache.delete(name);
+  decodedZonePayloadCache.delete(normalized);
+  sortedZoneNamesCache = null;
+}
+function addZone(packed) {
+  if (typeof packed === "string") {
+    const split = packed.split("|");
+    addPackedZoneEntry(split[0] ?? "", packed);
+    return;
+  }
+  if (Array.isArray(packed)) {
+    for (const item of packed) {
+      addZone(item);
+    }
+    return;
+  }
+  if (packed && typeof packed === "object") {
+    for (const [name, value] of Object.entries(packed)) {
+      if (typeof value === "string") {
+        addZone(value);
+        continue;
+      }
+      if (value && typeof value === "object") {
+        if ("ut" in value) {
+          addPackedZoneEntry(name, value);
+        } else {
+          const entry = value;
+          addPackedZoneEntry(
+            name,
+            createDecodedZonePayload({
+              name,
+              abbrs: [...entry.abbrs ?? []],
+              offsets: [...entry.offsets ?? []],
+              untils: [...entry.untils ?? []],
+              population: entry.population ?? 0
+            })
+          );
+        }
+      }
+    }
+  }
+}
+function addLink(links) {
+  const linkList = [];
+  if (typeof links === "string") {
+    linkList.push(links);
+  } else if (Array.isArray(links)) {
+    for (const entry of links) {
+      if (typeof entry === "string") {
+        linkList.push(entry);
+      }
+    }
+  } else if (links && typeof links === "object") {
+    for (const [alias, target] of Object.entries(links)) {
+      if (typeof target === "string") {
+        linkList.push(`${alias}|${target}`);
+      }
+    }
+  }
+  for (const aliasEntry of linkList) {
+    const alias = aliasEntry.split("|");
+    const name0 = alias[0];
+    const name1 = alias[1];
+    if (!name0 || !name1) {
+      continue;
+    }
+    const normal0 = normalizeName(name0);
+    const normal1 = normalizeName(name1);
+    linkStore[normal0] = normal1;
+    nameStore[normal0] = name0;
+    linkStore[normal1] = normal0;
+    nameStore[normal1] = name1;
+    sortedZoneNamesCache = null;
+  }
+}
+function addCountries(data) {
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (typeof item !== "string") {
+        continue;
+      }
+      const split = item.split("|");
+      const code = (split[0] ?? "").toUpperCase();
+      const zones = (split[1] ?? "").split(" ").filter(Boolean);
+      if (code) {
+        countryStore[code] = { name: code, zones };
+      }
+    }
+    return;
+  }
+  if (data && typeof data === "object") {
+    for (const [codeKey, value] of Object.entries(data)) {
+      const code = codeKey.toUpperCase();
+      if (Array.isArray(value)) {
+        countryStore[code] = {
+          name: code,
+          zones: value.filter((v) => typeof v === "string")
+        };
+        continue;
+      }
+      if (value && typeof value === "object") {
+        const zones = value.zones;
+        if (Array.isArray(zones)) {
+          countryStore[code] = {
+            name: code,
+            zones: zones.filter((v) => typeof v === "string")
+          };
+        }
+      }
+    }
+  }
+}
+function getZoneRecord(name, caller) {
+  ensureIndexBuilt();
+  const normalized = normalizeName(normalizeTz(name));
+  const cached = zoneWrapperCache.get(name);
+  if (cached instanceof InternalZone) return cached;
+  if (normalized in zoneStore || materializeZone(normalized)) {
+    const r = new InternalZone(nameStore[normalized] ?? name, normalized);
+    zoneWrapperCache.set(name, r);
+    return r;
+  }
+  const linkTarget = resolveLink(normalized);
+  if (linkTarget && caller !== getZoneRecord) {
+    const target = getZoneRecord(linkTarget, getZoneRecord);
+    if (target) {
+      const alias = new InternalZone(nameStore[normalized] ?? name, normalizeName(target.name));
+      zoneWrapperCache.set(name, alias);
+      return alias;
+    }
+  }
+  return null;
+}
+function getZone(name) {
+  return getZoneRecord(name);
+}
+function getAbbr(tz2, ts) {
+  if (tz2 === "UTC") {
+    return "UTC";
+  }
+  if (tz2 === "GMT") {
+    return "GMT";
+  }
+  const d = new Date(ts);
+  for (const loc of ABBR_LOCALES) {
+    try {
+      const full = d.toLocaleString(loc, { timeZone: tz2, timeZoneName: "short" });
+      const m = full.match(/\s(\S+)$/);
+      if (m) {
+        const abbr = m[1] ?? "";
+        if (/^[A-Z]{2,5}$/.test(abbr) && abbr !== "Time") {
+          return abbr;
+        }
+      }
+    } catch {
+    }
+  }
+  const offset = getOffset(tz2, ts);
+  const abs = Math.abs(offset);
+  const hrs = Math.floor(abs / 60);
+  const min = abs % 60;
+  const sign = offset >= 0 ? "+" : "-";
+  return `${sign}${String(hrs).padStart(2, "0")}${min ? String(min).padStart(2, "0") : "00"}`;
+}
+function getOffset(tz2, timestamp) {
+  tz2 = normalizeTz(tz2);
+  let domain = offsetCache.get(tz2);
+  if (!domain) {
+    domain = /* @__PURE__ */ new Map();
+    offsetCache.set(tz2, domain);
+  }
+  const cached = domain.get(timestamp);
+  if (cached !== void 0) {
+    return cached;
+  }
+  if (domain.size >= MAX_DOMAIN_CACHE_SIZE) {
+    const first = domain.keys().next().value;
+    if (first !== void 0) {
+      domain.delete(first);
+    }
+  }
+  const d = new Date(timestamp);
+  const parts = d.toLocaleString("en-US", {
+    timeZone: tz2,
+    timeZoneName: "longOffset"
+  });
+  const m = parts.match(/GMT([+-]\d{1,2})(?::(\d{2}))?/);
+  let offset = 0;
+  if (m) {
+    const hrs = parseInt(m[1] ?? "0", 10);
+    const min = m[2] ? parseInt(m[2], 10) : 0;
+    const s = hrs >= 0 ? 1 : -1;
+    offset = hrs * 60 + s * min;
+  }
+  domain.set(timestamp, offset);
+  return offset;
+}
+function hasExplicitOffset(input) {
+  return /(Z|[+-]\d{2}:?\d{2})\s*$/.test(input.trim());
+}
+function getNames() {
+  ensureIndexBuilt();
+  if (sortedZoneNamesCache) return [...sortedZoneNamesCache];
+  const out = /* @__PURE__ */ new Set();
+  for (const [, entry] of _zoneIdx) out.add(entry.name);
+  for (const [, name] of _linkNameIdx) out.add(name);
+  for (const key of Object.keys(nameStore)) {
+    if (nameStore[key] && (zoneStore[key] || resolveLink(key))) out.add(nameStore[key]);
+  }
+  for (const name of Object.keys(ZONE_ALIAS)) {
+    out.add(name);
+    out.add(ZONE_ALIAS[name]);
+  }
+  sortedZoneNamesCache = [...out].sort();
+  return [...sortedZoneNamesCache];
+}
+function getCountryNames() {
+  ensureIndexBuilt();
+  const out = /* @__PURE__ */ new Set([..._countryIdx.keys()]);
+  for (const key of Object.keys(countryStore)) out.add(key);
+  return [...out].sort();
+}
+function zonesForCountry(code, withOffset) {
+  var _a;
+  ensureIndexBuilt();
+  const upper = code.toUpperCase();
+  let zones = ((_a = countryStore[upper]) == null ? void 0 : _a.zones) ?? _countryIdx.get(upper);
+  if (!zones) return null;
+  const sorted = [...zones].sort();
+  if (withOffset) {
+    const now = Date.now();
+    return sorted.map((name) => {
+      const z = getZone(name);
+      return z ? { name, offset: z.utcOffset(now) } : null;
+    }).filter((e) => e !== null);
+  }
+  return sorted;
+}
+function isZoneName(s) {
+  const u = s.toUpperCase();
+  if (u === "UTC" || u === "GMT") return true;
+  ensureIndexBuilt();
+  const n = normalizeName(normalizeTz(s));
+  return n in zoneStore || _zoneIdx.has(n) || !!resolveLink(n);
+}
+function ensureIndexBuilt() {
+  if (indexBuilt || !builtinZoneDataLoaded) return;
+  indexBuilt = true;
+  const nt = _nameTable;
+  let pos = 0;
+  if (_zonesBlob.charCodeAt(0) === 33 && _zonesBlob.charCodeAt(1) === 68 && _zonesBlob.charCodeAt(2) === 124) {
+    const nl = _zonesBlob.indexOf("\n", 0);
+    if (nl >= 0) {
+      const header = _zonesBlob.slice(0, nl);
+      const dp = header.split("|");
+      if (dp[0] === "!D") {
+        _deltaDict = (dp[1] ?? "").split(" ").filter(Boolean).map(unpackBase60);
+      }
+      pos = nl + 1;
+    }
+  }
+  while (pos < _zonesBlob.length) {
+    const start = pos;
+    const nl = _zonesBlob.indexOf("\n", pos);
+    const end = nl >= 0 ? nl : _zonesBlob.length;
+    pos = nl >= 0 ? nl + 1 : _zonesBlob.length;
+    if (start === end) continue;
+    const pipe = _zonesBlob.indexOf("|", start);
+    if (pipe < 0 || pipe >= end) continue;
+    const idStr = _zonesBlob.slice(start, pipe);
+    const id = charCodeToInt(idStr.charCodeAt(0)) * 60 + charCodeToInt(idStr.charCodeAt(1));
+    const name = nt[id] ?? "";
+    if (name) _zoneIdx.set(normalizeName(name), { name, start, end });
+  }
+  pos = 0;
+  while (pos < _linksBlob.length) {
+    const nl = _linksBlob.indexOf("\n", pos);
+    const line = nl >= 0 ? _linksBlob.slice(pos, nl) : _linksBlob.slice(pos);
+    pos = nl >= 0 ? nl + 1 : _linksBlob.length;
+    if (!line) continue;
+    const pipe = line.indexOf("|");
+    if (pipe < 0) continue;
+    const fromId = line.slice(0, pipe), toId = line.slice(pipe + 1);
+    if (fromId && toId) {
+      const fi = charCodeToInt(fromId.charCodeAt(0)) * 60 + charCodeToInt(fromId.charCodeAt(1));
+      const ti = charCodeToInt(toId.charCodeAt(0)) * 60 + charCodeToInt(toId.charCodeAt(1));
+      const from = nt[fi] ?? "", to = nt[ti] ?? "";
+      if (from && to) {
+        const nf = normalizeName(from), ntNorm = normalizeName(to);
+        _linkIdx.set(nf, ntNorm);
+        _linkIdx.set(ntNorm, nf);
+        _linkNameIdx.set(nf, from);
+        _linkNameIdx.set(ntNorm, to);
+      }
+    }
+  }
+  pos = 0;
+  while (pos < _countriesBlob.length) {
+    const nl = _countriesBlob.indexOf("\n", pos);
+    const line = nl >= 0 ? _countriesBlob.slice(pos, nl) : _countriesBlob.slice(pos);
+    pos = nl >= 0 ? nl + 1 : _countriesBlob.length;
+    if (!line) continue;
+    const pipe = line.indexOf("|");
+    if (pipe < 0) continue;
+    const code = line.slice(0, pipe).toUpperCase();
+    const zones = line.slice(pipe + 1).split(" ").filter(Boolean).map((idStr) => nt[parseInt(idStr, 10)] ?? "").filter(Boolean);
+    if (code && zones.length > 0) _countryIdx.set(code, zones);
+  }
+}
+function materializeZone(normalized) {
+  const entry = _zoneIdx.get(normalized);
+  if (!entry) return false;
+  if (normalized in zoneStore) return true;
+  const line = _zonesBlob.slice(entry.start, entry.end);
+  const pipe = line.indexOf("|");
+  addPackedZoneEntry(entry.name, entry.name + line.slice(pipe));
+  getDecodedZonePayload(normalized);
+  return true;
+}
+function resolveLink(normalized) {
+  return linkStore[normalized] ?? _linkIdx.get(normalized);
+}
+function loadData(data) {
+  addZone(data.zones);
+  addLink(data.links);
+  addCountries(data.countries);
+}
+function ensureBuiltinZoneData(moment2, data) {
+  if (builtinZoneDataLoaded || !data) {
+    return;
+  }
+  _zonesBlob = data.zonesBlob;
+  _linksBlob = data.linksBlob;
+  _countriesBlob = data.countriesBlob;
+  if (data.namesBlob) _nameTable = data.namesBlob.split("\n");
+  if (moment2 == null ? void 0 : moment2.tz) {
+    moment2.tz.dataVersion = data.version;
+    if (data.tzVersion) {
+      moment2.tz.version = data.tzVersion;
+    }
+  }
+  builtinZoneDataLoaded = true;
+}
+function installTimezone(moment2, data) {
+  if (moment2.tz) {
+    return moment2;
+  }
+  ensureBuiltinZoneData(moment2, data);
+  moment2.momentProperties.push("_z");
+  function parseInZone(input, zone, format) {
+    const parsed = format ? moment2.utc(input, format) : moment2.utc(input);
+    if (!parsed.isValid()) {
+      return parsed;
+    }
+    const y = parsed.year(), M = parsed.month(), d = parsed.date();
+    const h = parsed.hour(), min = parsed.minute(), s = parsed.second(), ms = parsed.millisecond();
+    const zoneInfo = getZone(zone);
+    if (zoneInfo instanceof InternalZone) {
+      const base = Date.UTC(y, M, d, h, min, s, ms);
+      const offset = zoneInfo.parse(base);
+      const result2 = moment2(base + offset * 6e4);
+      const ro = zoneInfo.utcOffset(result2.valueOf());
+      result2.utcOffset(ro ? -ro : 0, false);
+      result2._z = zoneInfo;
+      return result2;
+    }
+    const guess = Date.UTC(y, M, d, h, min, s, ms);
+    const offsets = new Set(
+      [guess, Date.UTC(y, M, d), Date.UTC(y, M, d, 12), Date.UTC(y, M, d - 1, 12)].map(
+        (r) => getOffset(zone, r)
+      )
+    );
+    for (const o of [...offsets]) {
+      offsets.add(o + 30);
+      offsets.add(o - 30);
+    }
+    const sorted = [...offsets].sort((a, b) => b - a);
+    let bestTs = guess, bestOff = sorted[0] ?? 0, found = false;
+    for (const off of sorted) {
+      const ct = guess - off * 6e4;
+      if (getOffset(zone, ct) !== off) {
+        continue;
+      }
+      try {
+        const wp = new Date(ct).toLocaleString("en-US", {
+          timeZone: zone,
+          hour12: false,
+          hour: "2-digit",
+          minute: "2-digit",
+          second: "2-digit"
+        });
+        const p = wp.match(/^(\d{2}):(\d{2}):(\d{2})$/);
+        if (p && +p[1] === h && +p[2] === min && +p[3] === s) {
+          bestTs = ct;
+          bestOff = off;
+          found = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!found) {
+      const offA = getOffset(zone, guess);
+      const offB = getOffset(zone, guess - offA * 6e4);
+      bestOff = Math.max(offA, offB);
+      bestTs = guess + Math.abs(offB - offA) * 6e4 - bestOff * 6e4;
+    }
+    const result = moment2(bestTs);
+    result.utcOffset(bestOff, false);
+    result._z = zoneInfo ?? {
+      name: zone,
+      abbr: (t) => getAbbr(zone, t),
+      offset: () => -bestOff,
+      utcOffset: () => -bestOff,
+      parse: () => -bestOff
+    };
+    return result;
+  }
+  function momentTz(input, foz, zos, fourth) {
+    if (typeof foz === "string") {
+      if (isZoneName(foz)) {
+        const tz2 = normalizeTz(foz);
+        if (input == null) {
+          return moment2().tz(tz2);
+        }
+        if (typeof input === "string" && !hasExplicitOffset(input)) {
+          return parseInZone(input, tz2);
+        }
+        return moment2(input).tz(tz2);
+      }
+      if (typeof input === "string") {
+        if (typeof zos === "string" && isZoneName(zos)) {
+          return parseInZone(input, normalizeTz(zos), foz);
+        }
+        if (typeof zos === "boolean" && typeof fourth === "string" && isZoneName(fourth)) {
+          return parseInZone(input, normalizeTz(fourth), foz);
+        }
+        return moment2(input, foz);
+      }
+    }
+    if (typeof input === "string") {
+      return moment2().tz(input);
+    }
+    return input != null ? moment2(input) : moment2();
+  }
+  function fnTz(tz2, keepTime) {
+    if (tz2 === void 0) {
+      return this._z ? this._z.name : Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    const zi = getZone(normalizeTz(tz2));
+    if (!zi) {
+      return this.clone();
+    }
+    const m = this.clone();
+    m._z = zi;
+    const to = -zi.utcOffset(m.valueOf());
+    m.utcOffset(to ? to : 0, keepTime);
+    return m;
+  }
+  moment2.tz = momentTz;
+  moment2.fn.tz = fnTz;
+  moment2.defaultZone = null;
+  moment2.tz.version = (data == null ? void 0 : data.tzVersion) || "0.6.2";
+  moment2.tz.dataVersion = (data == null ? void 0 : data.version) || "";
+  moment2.tz.Zone = CompatZone;
+  moment2.tz._zones = zoneStore;
+  moment2.tz._links = linkStore;
+  moment2.tz._names = nameStore;
+  moment2.tz._countries = countryStore;
+  moment2.tz.unpack = unpack;
+  moment2.tz.unpackBase60 = unpackBase60;
+  moment2.tz.load = function(bundle) {
+    loadData(bundle);
+    moment2.tz.dataVersion = bundle.version ?? "";
+  };
+  moment2.tz.add = function(zoneData) {
+    addZone(zoneData);
+  };
+  moment2.tz.link = function(links) {
+    addLink(links);
+  };
+  moment2.tz.zone = function(name) {
+    return getZone(name);
+  };
+  moment2.tz.zoneExists = function(name) {
+    return !!getZone(name);
+  };
+  moment2.tz.guess = function(_preferCache) {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  };
+  moment2.tz.names = function() {
+    return getNames();
+  };
+  moment2.tz.countries = function() {
+    return getCountryNames();
+  };
+  moment2.tz.zonesForCountry = function(code, withOffset) {
+    return zonesForCountry(code, withOffset);
+  };
+  moment2.tz.setDefault = function(tz2) {
+    moment2.defaultZone = tz2 ? normalizeTz(tz2) : void 0;
+    return moment2;
+  };
+  Object.defineProperty(moment2.tz, "moveInvalidForward", {
+    get() {
+      return timezoneFlags.moveInvalidForward;
+    },
+    set(value) {
+      timezoneFlags.moveInvalidForward = !!value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(moment2.tz, "moveAmbiguousForward", {
+    get() {
+      return timezoneFlags.moveAmbiguousForward;
+    },
+    set(value) {
+      timezoneFlags.moveAmbiguousForward = !!value;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  const _zn = moment2.fn.zoneName;
+  const _za = moment2.fn.zoneAbbr;
+  moment2.fn.isDST = function() {
+    const z = this._z;
+    if (!z) {
+      return false;
+    }
+    const ts = this.valueOf();
+    const y = new Date(ts).getUTCFullYear();
+    const jan = Date.UTC(y, 0, 1);
+    const jul = Date.UTC(y, 6, 1);
+    if (z instanceof InternalZone) {
+      return z.utcOffset(ts) !== Math.max(z.utcOffset(jan), z.utcOffset(jul));
+    }
+    return getOffset(z.name, ts) !== Math.min(getOffset(z.name, jan), getOffset(z.name, jul));
+  };
+  moment2.fn.zoneName = function() {
+    return this._z ? this._z.abbr(this.valueOf()) : _zn ? _zn.call(this) : "";
+  };
+  moment2.fn.zoneAbbr = function() {
+    return this._z ? this._z.abbr(this.valueOf()) : _za ? _za.call(this) : "";
+  };
+  return moment2;
+}
+
+// src/logic.ts
+var momentFactory = mmntjs.moment ?? mmntjs.default ?? mmntjs;
+installTimezone(momentFactory);
+var logic_default = momentFactory;
+var tz = momentFactory.tz;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  tz
+});
+//# sourceMappingURL=logic.cjs.map