temporal-fmt 0.9.0 → 0.9.2

package/dist/chunk-JCIMP43G.js

@@ -1,602 +0,0 @@
-import {
-  MAX_FORMAT_LENGTH
-} from "./chunk-EDUFSRWJ.js";
-import {
-  FormatSyntaxError,
-  InvalidDurationError,
-  canonicalCacheKey
-} from "./chunk-O6GVMBLW.js";
-import {
-  asDateFieldView
-} from "./chunk-4ZBGVYLR.js";
-
-// src/rounding.ts
-var MS_PER_UNIT = {
-  day: 864e5,
-  hour: 36e5,
-  minute: 6e4,
-  second: 1e3,
-  millisecond: 1
-};
-function applyMode(ms, mode, increment) {
-  const sign = ms < 0 ? -1 : 1;
-  const abs = Math.abs(ms);
-  const stepped = abs / increment;
-  let rounded;
-  switch (mode) {
-    case "nearest":
-      rounded = Math.round(stepped);
-      break;
-    case "floor":
-      rounded = Math.floor(stepped);
-      break;
-    case "ceil":
-      rounded = Math.ceil(stepped);
-      break;
-    case "trunc":
-      rounded = Math.trunc(stepped);
-      break;
-  }
-  return sign * rounded * increment;
-}
-function toMs(v) {
-  const y = v.year, m = v.month, d = v.day;
-  const y2 = m <= 2 ? y - 1 : y;
-  const era = Math.floor((y2 >= 0 ? y2 : y2 - 399) / 400);
-  const yoe = y2 - era * 400;
-  const m2 = m > 2 ? m - 3 : m + 9;
-  const doy = Math.floor((153 * m2 + 2) / 5) + d - 1;
-  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
-  const days = era * 146097 + doe - 719468;
-  return days * MS_PER_UNIT.day + (v.hour ?? 0) * MS_PER_UNIT.hour + (v.minute ?? 0) * MS_PER_UNIT.minute + (v.second ?? 0) * MS_PER_UNIT.second + (v.millisecond ?? 0);
-}
-function fromMs(ms, base) {
-  const MS_PER_DAY = MS_PER_UNIT.day;
-  const totalDays = Math.floor(ms / MS_PER_DAY);
-  let withinDay = ms - totalDays * MS_PER_DAY;
-  if (withinDay < 0) withinDay += MS_PER_DAY;
-  const hour = Math.floor(withinDay / MS_PER_UNIT.hour);
-  const minute = Math.floor(withinDay % MS_PER_UNIT.hour / MS_PER_UNIT.minute);
-  const second = Math.floor(withinDay % MS_PER_UNIT.minute / MS_PER_UNIT.second);
-  const millisecond = withinDay % MS_PER_UNIT.second;
-  const z = totalDays + 719468;
-  const era = Math.floor((z >= 0 ? z : z - 146096) / 146097);
-  const doe = z - era * 146097;
-  const yoe = Math.floor((doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365);
-  const y2 = yoe + era * 400;
-  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
-  const mp = Math.floor((5 * doy + 2) / 153);
-  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;
-  const m = mp < 10 ? mp + 3 : mp - 9;
-  const year = m <= 2 ? y2 + 1 : y2;
-  return { ...base, year, month: m, day: d, hour, minute, second, millisecond };
-}
-function round(value, options) {
-  const base = asDateFieldView(value);
-  const mode = options.mode ?? "nearest";
-  const increment = (options.roundingIncrement ?? 1) * MS_PER_UNIT[options.unit];
-  if (increment <= 0) {
-    throw new Error(`temporal-fmt: round() requires a positive roundingIncrement (got ${options.roundingIncrement}).`);
-  }
-  const ms = toMs(base);
-  const rounded = applyMode(ms, mode, increment);
-  return fromMs(rounded, base);
-}
-function floor(value, unit, roundingIncrement = 1) {
-  return round(value, { unit, mode: "floor", roundingIncrement });
-}
-function ceil(value, unit, roundingIncrement = 1) {
-  return round(value, { unit, mode: "ceil", roundingIncrement });
-}
-function truncate(value, unit, roundingIncrement = 1) {
-  return round(value, { unit, mode: "trunc", roundingIncrement });
-}
-var DURATION_UNIT_TO_NS = {
-  years: 0n,
-  // calendar-bound, can't convert without relativeTo
-  months: 0n,
-  // same
-  weeks: 0n,
-  // same
-  days: 86400n * 1000000000n,
-  hours: 3600n * 1000000000n,
-  minutes: 60n * 1000000000n,
-  seconds: 1000000000n,
-  milliseconds: 1000000n,
-  microseconds: 1000n,
-  nanoseconds: 1n
-};
-function isCalendarBound(unit) {
-  return unit === "years" || unit === "months" || unit === "weeks";
-}
-function roundDuration(duration, options) {
-  const mode = options.mode ?? "nearest";
-  const increment = BigInt(options.roundingIncrement ?? 1);
-  if (increment <= 0n) {
-    throw new Error(`temporal-fmt: roundDuration() requires a positive roundingIncrement (got ${options.roundingIncrement}).`);
-  }
-  if (isCalendarBound(options.unit)) {
-    throw new Error(
-      `temporal-fmt: roundDuration() to "${options.unit}" requires a Temporal.Duration with a relativeTo \u2014 this helper operates on plain field bags without calendar context. Use Temporal.Duration.prototype.round() directly.`
-    );
-  }
-  let totalNs = 0n;
-  for (const u of ["days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"]) {
-    const v = duration[u] ?? 0;
-    totalNs += BigInt(v) * DURATION_UNIT_TO_NS[u];
-  }
-  const stepNs = increment * DURATION_UNIT_TO_NS[options.unit];
-  const sign = totalNs < 0n ? -1n : 1n;
-  const abs = totalNs < 0n ? -totalNs : totalNs;
-  const stepped = abs / stepNs;
-  const remainder = abs % stepNs;
-  let rounded;
-  switch (mode) {
-    case "nearest":
-      rounded = remainder * 2n >= stepNs ? stepped + 1n : stepped;
-      break;
-    case "floor":
-      rounded = stepped;
-      break;
-    case "ceil":
-      rounded = remainder > 0n ? stepped + 1n : stepped;
-      break;
-    case "trunc":
-      rounded = stepped;
-      break;
-  }
-  const newTotalNs = sign * rounded * stepNs;
-  const result = { ...duration };
-  let remaining = newTotalNs;
-  for (const u of ["days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"]) {
-    if (u === options.unit || isLargerUnit(u, options.unit) || u === options.unit) {
-    }
-    result[u] = 0;
-  }
-  const unitsInOrder = ["days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"];
-  const startIdx = unitsInOrder.indexOf(options.unit);
-  for (let i = 0; i <= startIdx; i++) {
-    const u = unitsInOrder[i];
-    const unitNs = DURATION_UNIT_TO_NS[u];
-    if (unitNs === 0n) continue;
-    const count = remaining / unitNs;
-    remaining -= count * unitNs;
-    if (count !== 0n) {
-      result[u] = Number(count);
-    }
-  }
-  return result;
-}
-function isLargerUnit(_a, _b) {
-  return false;
-}
-
-// src/formatDuration.ts
-var DURATION_UNITS = {
-  y: { longSingular: "year", longPlural: "years", shortSingular: "yr", shortPlural: "yrs", field: "years", intlUnit: "year" },
-  o: { longSingular: "month", longPlural: "months", shortSingular: "mo", shortPlural: "mos", field: "months", intlUnit: "month" },
-  w: { longSingular: "week", longPlural: "weeks", shortSingular: "wk", shortPlural: "wks", field: "weeks", intlUnit: "week" },
-  d: { longSingular: "day", longPlural: "days", shortSingular: "d", shortPlural: "d", field: "days", intlUnit: "day" },
-  h: { longSingular: "hour", longPlural: "hours", shortSingular: "h", shortPlural: "h", field: "hours", intlUnit: "hour" },
-  m: { longSingular: "minute", longPlural: "minutes", shortSingular: "m", shortPlural: "m", field: "minutes", intlUnit: "minute" },
-  s: { longSingular: "second", longPlural: "seconds", shortSingular: "s", shortPlural: "s", field: "seconds", intlUnit: "second" },
-  S: { longSingular: "millisecond", longPlural: "milliseconds", shortSingular: "ms", shortPlural: "ms", field: "milliseconds", intlUnit: "millisecond" }
-};
-var DURATION_TOKEN_STRINGS = Object.keys(DURATION_UNITS).flatMap((single) => [single + single + single, single + single, single]).sort((a, b) => b.length - a.length);
-function tokenizeDuration(format) {
-  const pieces = [];
-  let i = 0;
-  while (i < format.length) {
-    const ch = format[i];
-    if (ch === "'") {
-      if (format[i + 1] === "'") {
-        appendLiteral(pieces, "'");
-        i += 2;
-        continue;
-      }
-      let j = i + 1;
-      let literal = "";
-      let closed = false;
-      while (j < format.length) {
-        if (format[j] === "'") {
-          if (format[j + 1] === "'") {
-            literal += "'";
-            j += 2;
-            continue;
-          }
-          closed = true;
-          j += 1;
-          break;
-        }
-        literal += format[j];
-        j += 1;
-      }
-      if (!closed) {
-        throw new Error(`temporal-fmt: unterminated quote in duration format string "${format}"`);
-      }
-      appendLiteral(pieces, literal);
-      i = j;
-      continue;
-    }
-    const match = DURATION_TOKEN_STRINGS.find((tok) => format.startsWith(tok, i));
-    if (match) {
-      const unit = match[0];
-      const form = match.length === 1 ? "numeric" : match.length === 2 ? "short" : "long";
-      pieces.push({ kind: "token", value: match, unit, form });
-      i += match.length;
-      continue;
-    }
-    appendLiteral(pieces, ch);
-    i += 1;
-  }
-  return pieces;
-}
-function appendLiteral(pieces, value) {
-  const last = pieces[pieces.length - 1];
-  if (last && last.kind === "literal") {
-    last.value += value;
-  } else {
-    pieces.push({ kind: "literal", value });
-  }
-}
-function readUnit(duration, field) {
-  const value = duration[field];
-  if (value === void 0 || value === null) return 0;
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  const coerced = Number(value);
-  if (!Number.isFinite(coerced)) {
-    throw new Error(
-      `temporal-fmt: duration field "${field}" is not a finite number (got ${String(value)}).`
-    );
-  }
-  return coerced;
-}
-var unitFormatterCache = /* @__PURE__ */ new Map();
-var MAX_UNIT_FORMATTER_CACHE_SIZE = 200;
-function getUnitFormatter(locale, intlUnit, unitDisplay) {
-  const key = `${canonicalCacheKey(locale)}|${intlUnit}|${unitDisplay}`;
-  const cached = unitFormatterCache.get(key);
-  if (cached) return cached;
-  if (unitFormatterCache.size >= MAX_UNIT_FORMATTER_CACHE_SIZE) {
-    const oldestKey = unitFormatterCache.keys().next().value;
-    if (oldestKey !== void 0) unitFormatterCache.delete(oldestKey);
-  }
-  const formatter = new Intl.NumberFormat(locale, {
-    style: "unit",
-    unit: intlUnit,
-    unitDisplay
-  });
-  unitFormatterCache.set(key, formatter);
-  return formatter;
-}
-function formatDuration(duration, formatStr, options = {}) {
-  if (formatStr.length > MAX_FORMAT_LENGTH) {
-    throw new Error(
-      `temporal-fmt: duration format string exceeds maximum length of ${MAX_FORMAT_LENGTH} characters (got ${formatStr.length}).`
-    );
-  }
-  const showZeroes = options.showZeroValues === true;
-  const locale = options.locale;
-  const useIntl = locale !== void 0;
-  const pieces = tokenizeDuration(formatStr);
-  let result = "";
-  for (const piece of pieces) {
-    if (piece.kind === "literal") {
-      result += piece.value;
-      continue;
-    }
-    const unit = DURATION_UNITS[piece.unit];
-    if (!unit) {
-      throw new Error(`temporal-fmt: unknown duration token "${piece.value}"`);
-    }
-    const value = readUnit(duration, unit.field);
-    if (value === 0 && !showZeroes) {
-      continue;
-    }
-    if (piece.form === "numeric") {
-      result += String(value);
-      continue;
-    }
-    if (useIntl) {
-      const unitDisplay = piece.form === "short" ? "short" : "long";
-      const formatter = getUnitFormatter(locale, unit.intlUnit, unitDisplay);
-      result += formatter.format(value);
-      continue;
-    }
-    if (piece.form === "short") {
-      result += value + (value === 1 || value === -1 ? unit.shortSingular : unit.shortPlural);
-    } else {
-      result += value + " " + (value === 1 || value === -1 ? unit.longSingular : unit.longPlural);
-    }
-  }
-  return result;
-}
-
-// src/duration.ts
-function formatDurationToParts(duration, formatStr, options = {}) {
-  const full = formatDuration(duration, formatStr, options);
-  const tokens = tokenizeDurationFormat(formatStr);
-  const parts = [];
-  let pos = 0;
-  for (const tok of tokens) {
-    if (tok.kind === "literal") {
-      const lit = tok.value;
-      if (full.slice(pos, pos + lit.length) === lit) {
-        parts.push({ type: "literal", value: lit });
-        pos += lit.length;
-        /* c8 ignore start @preserve -- unreachable given current formatDuration(): every
-           literal is appended to `full` unconditionally regardless of adjacent
-           zero-value tokens, and pos tracking never desyncs from the true
-           literal position (verified via adversarial testing: duplicate
-           literals, skipped tokens before/after, ambiguous text — all still
-           found via indexOf as expected). Kept as a guard against a future
-           formatDuration() change that conditionally drops literals. */
-      } else {
-      }
-      /* c8 ignore stop @preserve */
-    } else {
-      const nextLiteralStart = findNextLiteralStart(tokens, tok, full, pos);
-      const value = full.slice(pos, nextLiteralStart);
-      parts.push({ type: "token", value, token: tok.value });
-      pos = nextLiteralStart;
-    }
-  }
-  return parts;
-}
-function tokenizeDurationFormat(formatStr) {
-  const DURATION_TOKEN_STRINGS2 = ["y", "o", "w", "d", "h", "m", "s", "S"].flatMap((single) => [single + single + single, single + single, single]).sort((a, b) => b.length - a.length);
-  const pieces = [];
-  let i = 0;
-  while (i < formatStr.length) {
-    const ch = formatStr[i];
-    if (ch === "'") {
-      if (formatStr[i + 1] === "'") {
-        appendLiteral2(pieces, "'");
-        i += 2;
-        continue;
-      }
-      let j = i + 1;
-      let literal = "";
-      let closed = false;
-      while (j < formatStr.length) {
-        if (formatStr[j] === "'") {
-          if (formatStr[j + 1] === "'") {
-            literal += "'";
-            j += 2;
-            continue;
-          }
-          closed = true;
-          j += 1;
-          break;
-        }
-        literal += formatStr[j];
-        j += 1;
-      }
-      if (!closed) throw new FormatSyntaxError({ format: formatStr, reason: "unterminated quote" });
-      appendLiteral2(pieces, literal);
-      i = j;
-      continue;
-    }
-    const match = DURATION_TOKEN_STRINGS2.find((tok) => formatStr.startsWith(tok, i));
-    if (match) {
-      pieces.push({ kind: "token", value: match, unit: match[0] });
-      i += match.length;
-      continue;
-    }
-    appendLiteral2(pieces, ch);
-    i += 1;
-  }
-  return pieces;
-}
-function appendLiteral2(pieces, value) {
-  const last = pieces[pieces.length - 1];
-  if (last && last.kind === "literal") {
-    last.value += value;
-  } else {
-    pieces.push({ kind: "literal", value });
-  }
-}
-function findNextLiteralStart(tokens, _currentTok, full, pos) {
-  const idx = tokens.indexOf(_currentTok);
-  for (let j = idx + 1; j < tokens.length; j++) {
-    const t = tokens[j];
-    if (t.kind === "literal") {
-      const found = full.indexOf(t.value, pos);
-      if (found >= 0) return found;
-    }
-  }
-  return full.length;
-}
-function parseISODuration(input) {
-  const re = /^P(?:(?:(\d+(?:\.\d+)?)Y)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
-  const m = re.exec(input);
-  if (!m) {
-    throw new InvalidDurationError({ input, reason: "does not match ISO 8601 duration grammar (P[n]Y[n]M[n]W[n]DT[n]H[n]M[n]S)" });
-  }
-  if (m.slice(1).every((g) => g === void 0)) {
-    throw new InvalidDurationError({ input, reason: 'duration has no fields (use "P0D" for zero duration)' });
-  }
-  const toNum = (s) => s === void 0 ? 0 : Number(s);
-  return {
-    years: toNum(m[1]),
-    months: toNum(m[2]),
-    weeks: toNum(m[3]),
-    days: toNum(m[4]),
-    hours: toNum(m[5]),
-    minutes: toNum(m[6]),
-    seconds: toNum(m[7])
-  };
-}
-function formatISODuration(duration) {
-  const parts = ["P"];
-  const years = duration.years ?? 0;
-  const months = duration.months ?? 0;
-  const weeks = duration.weeks ?? 0;
-  const days = duration.days ?? 0;
-  const hours = duration.hours ?? 0;
-  const minutes = duration.minutes ?? 0;
-  const seconds = duration.seconds ?? 0;
-  if (years) parts.push(`${years}Y`);
-  if (months) parts.push(`${months}M`);
-  if (weeks) parts.push(`${weeks}W`);
-  if (days) parts.push(`${days}D`);
-  if (hours || minutes || seconds) {
-    parts.push("T");
-    if (hours) parts.push(`${hours}H`);
-    if (minutes) parts.push(`${minutes}M`);
-    if (seconds) parts.push(`${seconds}S`);
-  }
-  if (parts.length === 1) parts.push("0D");
-  return parts.join("");
-}
-function parseDuration(input, formatStr, options = {}) {
-  const tokens = tokenizeDurationFormat(formatStr);
-  const fields = {};
-  const groupSpecs = [];
-  let regex = "";
-  for (const tok of tokens) {
-    if (tok.kind === "literal") {
-      regex += tok.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    } else {
-      const unit = tok.unit;
-      const form = tok.value.length === 1 ? "numeric" : tok.value.length === 2 ? "short" : "long";
-      /* c8 ignore start @preserve -- the final `: null` branch, and the
-         `if (key === null)` throw it feeds, are both unreachable: tok.unit
-         is always one of the 8 letters in DURATION_TOKEN_STRINGS (the same
-         source set this ternary checks against), so `null` can't be
-         produced by any token the tokenizer emits. Kept as a guard against
-         a future letter being added to one set without the other. */
-      const key = unit === "y" ? "years" : unit === "o" ? "months" : unit === "w" ? "weeks" : unit === "d" ? "days" : unit === "h" ? "hours" : unit === "m" ? "minutes" : unit === "s" ? "seconds" : unit === "S" ? "milliseconds" : null;
-      if (key === null) {
-        throw new FormatSyntaxError({ format: formatStr, token: tok.value, reason: "unknown duration token" });
-      }
-      /* c8 ignore stop @preserve */
-      if (form === "numeric") {
-        regex += "(-?\\d+)";
-      } else {
-        regex += "(\\d+)\\s*\\w*";
-      }
-      groupSpecs.push({ unit: key, form });
-    }
-  }
-  const re = new RegExp(`^${regex}$`, "u");
-  const m = re.exec(input);
-  if (!m) {
-    throw new FormatSyntaxError({ input, format: formatStr, reason: "does not match duration format" });
-  }
-  groupSpecs.forEach((spec, i) => {
-    const raw = m[i + 1];
-    const value = Number(raw);
-    if (!Number.isFinite(value)) {
-      throw new InvalidDurationError({ input, reason: `token for ${spec.unit} matched "${raw}" but isn't a finite number` });
-    }
-    fields[spec.unit] = value;
-  });
-  return fields;
-}
-function balanceDuration(duration) {
-  const NS_PER = [
-    ["days", 86400n * 1000000000n],
-    ["hours", 3600n * 1000000000n],
-    ["minutes", 60n * 1000000000n],
-    ["seconds", 1000000000n],
-    ["milliseconds", 1000000n],
-    ["microseconds", 1000n],
-    ["nanoseconds", 1n]
-  ];
-  let totalNs = 0n;
-  for (const [k, nsPer] of NS_PER) {
-    const v = duration[k];
-    if (typeof v === "number") totalNs += BigInt(v) * nsPer;
-  }
-  const result = { ...duration };
-  let remaining = totalNs;
-  for (const [k, nsPer] of NS_PER) {
-    const count = remaining / nsPer;
-    remaining -= count * nsPer;
-    result[k] = Number(count);
-  }
-  return result;
-}
-function totalDuration(duration, unit) {
-  const NS_PER = {
-    days: 86400n * 1000000000n,
-    hours: 3600n * 1000000000n,
-    minutes: 60n * 1000000000n,
-    seconds: 1000000000n,
-    milliseconds: 1000000n,
-    microseconds: 1000n,
-    nanoseconds: 1n
-  };
-  let totalNs = 0n;
-  for (const k of Object.keys(NS_PER)) {
-    const v = duration[k];
-    if (typeof v === "number") totalNs += BigInt(v) * NS_PER[k];
-  }
-  const divisor = NS_PER[unit];
-  if (!divisor) {
-    throw new InvalidDurationError({ reason: `totalDuration() does not support unit "${unit}" (calendar-bound units need a relativeTo)` });
-  }
-  return Number(totalNs) / Number(divisor);
-}
-function compareDuration(a, b) {
-  const aNs = totalDurationNs(a);
-  const bNs = totalDurationNs(b);
-  if (aNs < bNs) return -1;
-  if (aNs > bNs) return 1;
-  return 0;
-}
-function totalDurationNs(d) {
-  const NS_PER = {
-    days: 86400n * 1000000000n,
-    hours: 3600n * 1000000000n,
-    minutes: 60n * 1000000000n,
-    seconds: 1000000000n,
-    milliseconds: 1000000n,
-    microseconds: 1000n,
-    nanoseconds: 1n
-  };
-  let total = 0n;
-  for (const k of Object.keys(NS_PER)) {
-    const v = d[k];
-    if (typeof v === "number") total += BigInt(v) * NS_PER[k];
-  }
-  return total;
-}
-function addDuration(a, b) {
-  const keys = ["years", "months", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"];
-  const result = {};
-  for (const k of keys) {
-    result[k] = (a[k] ?? 0) + (b[k] ?? 0);
-  }
-  return result;
-}
-function subtractDuration(a, b) {
-  return addDuration(a, negateDuration(b));
-}
-function negateDuration(d) {
-  const result = {};
-  for (const k of Object.keys(d)) {
-    result[k] = -(d[k] ?? 0);
-  }
-  return result;
-}
-
-export {
-  round,
-  floor,
-  ceil,
-  truncate,
-  roundDuration,
-  formatDuration,
-  formatDurationToParts,
-  parseISODuration,
-  formatISODuration,
-  parseDuration,
-  balanceDuration,
-  totalDuration,
-  compareDuration,
-  addDuration,
-  subtractDuration
-};
-//# sourceMappingURL=chunk-JCIMP43G.js.map