react-semaphor 0.1.449 → 0.1.454

package/dist/chunks/temporal-bucket-5UYEotyQ.js

@@ -0,0 +1,810 @@
+var x = Object.defineProperty;
+var Y = (e, r, t) => r in e ? x(e, r, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[r] = t;
+var T = (e, r, t) => Y(e, typeof r != "symbol" ? r + "" : r, t);
+import { j as L, al as O, e as R, d as U } from "./validators-DEmd8Sin.js";
+import { canonicalizeSupportedLocale as I } from "../value-format-preferences/index.js";
+const q = "higher_is_better", fe = {
+  displayMode: "difference",
+  showComparison: !0,
+  indicatorStyle: "arrow_badge",
+  showColor: !0,
+  conditionalLabel: !1
+};
+function G(e) {
+  return L(e) !== null;
+}
+function pe(e) {
+  var r, t, o, n;
+  if (((r = e.metricComparison) == null ? void 0 : r.mode) !== "off") {
+    if (((t = e.metricComparison) == null ? void 0 : t.mode) === "explicit")
+      return { source: "explicit", spec: e.metricComparison.spec };
+    if (!((e.inheritGlobalComparison ?? ((o = e.globalDateComparison) == null ? void 0 : o.inheritGlobalComparison)) === !1 || ((n = e.globalDateComparison) == null ? void 0 : n.selection.mode) !== "period"))
+      return {
+        source: "inherited",
+        spec: e.globalDateComparison.selection.spec,
+        ...e.globalDateComparison.owner ? { owner: e.globalDateComparison.owner } : {}
+      };
+  }
+}
+function be(e) {
+  if (e.alias) return e.alias;
+  const r = e.entityName && e.entityName !== "SEMAPHOR_CALCULATED_FIELD" ? e.entityName : void 0, t = r && r !== e.name ? `${r}_` : "";
+  if (e.role !== "metric") return `${t}${e.name}`;
+  let o = e.aggregate || "metric";
+  if (e.expression) {
+    const n = e.expression.match(
+      /^(COUNT|SUM|AVG|MIN|MAX|MEDIAN|DISTINCT)\s*\(/i
+    );
+    o = n ? n[1].toLowerCase() : "expr";
+  } else
+    o = o.toLowerCase();
+  return `${t}${e.name}_${o}`;
+}
+function i(e, r, t) {
+  return t ? { code: e, message: r, path: t } : { code: e, message: r };
+}
+function d(e) {
+  return !!e && typeof e == "object" && !Array.isArray(e);
+}
+function u(e, r, t, o) {
+  Object.keys(e).forEach((n) => {
+    r.includes(n) || o.push(
+      i(
+        "invalid_comparison_spec",
+        `Comparison kind does not accept field "${n}".`,
+        `${t}.${n}`
+      )
+    );
+  });
+}
+function M(e, r, t) {
+  e.alignment !== void 0 && e.alignment !== "calendar" && e.alignment !== "weekday" && t.push(
+    i(
+      "invalid_comparison_spec",
+      'Comparison alignment must be "calendar" or "weekday".',
+      `${r}.alignment`
+    )
+  ), e.toDate !== void 0 && typeof e.toDate != "boolean" && t.push(
+    i(
+      "invalid_comparison_spec",
+      "Comparison toDate must be a boolean.",
+      `${r}.toDate`
+    )
+  );
+}
+function D(e, r, t) {
+  e !== void 0 && (typeof e != "number" || !Number.isSafeInteger(e) || e <= 0) && t.push(
+    i(
+      "invalid_comparison_spec",
+      "Comparison offset must be a positive safe integer.",
+      r
+    )
+  );
+}
+function P(e, r = "comparison") {
+  const t = [];
+  return d(e) ? (e.kind === "previous_period" ? (u(
+    e,
+    ["kind", "offsetPeriods", "alignment", "toDate"],
+    r,
+    t
+  ), D(e.offsetPeriods, `${r}.offsetPeriods`, t), M(e, r, t)) : e.kind === "previous_year" ? (u(
+    e,
+    ["kind", "offsetYears", "alignment", "toDate"],
+    r,
+    t
+  ), D(e.offsetYears, `${r}.offsetYears`, t), M(e, r, t)) : e.kind === "target" ? (u(e, ["kind", "targetValue"], r, t), (typeof e.targetValue != "number" || !Number.isFinite(e.targetValue)) && t.push(
+    i(
+      "invalid_comparison_spec",
+      "Target comparison requires a finite targetValue.",
+      `${r}.targetValue`
+    )
+  )) : t.push(
+    i(
+      "invalid_comparison_spec",
+      "Comparison kind must be previous_period, previous_year, or target.",
+      `${r}.kind`
+    )
+  ), { ok: t.length === 0, errors: t, warnings: [] }) : {
+    ok: !1,
+    errors: [
+      i(
+        "invalid_comparison_spec",
+        "Comparison spec must be an object.",
+        r
+      )
+    ],
+    warnings: []
+  };
+}
+function ge(e, r = "comparison") {
+  if (!d(e))
+    return {
+      ok: !1,
+      errors: [
+        i(
+          "invalid_comparison_config",
+          "Comparison config must be an object.",
+          r
+        )
+      ],
+      warnings: []
+    };
+  const t = [];
+  return e.mode === "off" ? u(e, ["mode"], r, t) : e.mode === "explicit" ? (u(e, ["mode", "spec"], r, t), t.push(...P(e.spec, `${r}.spec`).errors)) : t.push(
+    i(
+      "invalid_comparison_config",
+      "Comparison mode must be off or explicit.",
+      `${r}.mode`
+    )
+  ), { ok: t.length === 0, errors: t, warnings: [] };
+}
+function V(e, r = "comparisonSelection") {
+  if (!d(e))
+    return {
+      ok: !1,
+      errors: [
+        i(
+          "invalid_global_date_comparison",
+          "Global Date comparison selection must be an object.",
+          r
+        )
+      ],
+      warnings: []
+    };
+  const t = [];
+  if (e.mode === "off")
+    u(e, ["mode"], r, t);
+  else if (e.mode === "period") {
+    u(e, ["mode", "spec"], r, t);
+    const o = P(e.spec, `${r}.spec`);
+    t.push(...o.errors), d(e.spec) && e.spec.kind === "target" && t.push(
+      i(
+        "invalid_global_date_comparison",
+        "Global Date comparison supports previous_period or previous_year, not target.",
+        `${r}.spec.kind`
+      )
+    );
+  } else
+    t.push(
+      i(
+        "invalid_global_date_comparison",
+        "Global Date comparison mode must be off or period.",
+        `${r}.mode`
+      )
+    );
+  return { ok: t.length === 0, errors: t, warnings: [] };
+}
+function ye(e, r = "globalDateComparison") {
+  if (!d(e))
+    return {
+      ok: !1,
+      errors: [
+        i(
+          "invalid_global_date_comparison",
+          "Global Date comparison context must be an object.",
+          r
+        )
+      ],
+      warnings: []
+    };
+  const t = [];
+  return u(
+    e,
+    ["selection", "inheritGlobalComparison", "owner", "referenceTime"],
+    r,
+    t
+  ), t.push(
+    ...V(
+      e.selection,
+      `${r}.selection`
+    ).errors
+  ), e.inheritGlobalComparison !== void 0 && e.inheritGlobalComparison !== !1 && t.push(
+    i(
+      "invalid_global_date_comparison",
+      "inheritGlobalComparison may only be false when present.",
+      `${r}.inheritGlobalComparison`
+    )
+  ), e.owner !== void 0 && (d(e.owner) ? e.owner.kind === "global_date" ? u(e.owner, ["kind"], `${r}.owner`, t) : e.owner.kind === "field_date" ? (u(
+    e.owner,
+    ["kind", "filterId", "label"],
+    `${r}.owner`,
+    t
+  ), (typeof e.owner.filterId != "string" || !e.owner.filterId.trim()) && t.push(
+    i(
+      "invalid_global_date_comparison",
+      "Field Date comparison owner requires a non-empty filterId.",
+      `${r}.owner.filterId`
+    )
+  ), (typeof e.owner.label != "string" || !e.owner.label.trim()) && t.push(
+    i(
+      "invalid_global_date_comparison",
+      "Field Date comparison owner requires a non-empty label.",
+      `${r}.owner.label`
+    )
+  )) : t.push(
+    i(
+      "invalid_global_date_comparison",
+      "Comparison owner kind must be global_date or field_date.",
+      `${r}.owner.kind`
+    )
+  ) : t.push(
+    i(
+      "invalid_global_date_comparison",
+      "Comparison owner must be an object.",
+      `${r}.owner`
+    )
+  )), e.referenceTime !== void 0 && (typeof e.referenceTime != "string" || !G(e.referenceTime)) && t.push(
+    i(
+      "invalid_global_date_comparison",
+      "referenceTime must be a valid ISO date-time string when present.",
+      `${r}.referenceTime`
+    )
+  ), { ok: t.length === 0, errors: t, warnings: [] };
+}
+function _e(e, r = "comparisonPolarity") {
+  return e === "higher_is_better" || e === "lower_is_better" || e === "neutral" ? { ok: !0, errors: [], warnings: [] } : {
+    ok: !1,
+    errors: [
+      i(
+        "invalid_comparison_polarity",
+        "Comparison polarity must be higher_is_better, lower_is_better, or neutral.",
+        r
+      )
+    ],
+    warnings: []
+  };
+}
+function he(e, r = "comparisonPresentation") {
+  if (!d(e))
+    return {
+      ok: !1,
+      errors: [
+        i(
+          "invalid_comparison_presentation",
+          "Comparison presentation must be an object.",
+          r
+        )
+      ],
+      warnings: []
+    };
+  const t = [], o = [
+    "displayMode",
+    "showComparison",
+    "precision",
+    "indicatorStyle",
+    "showColor",
+    "position",
+    "conditionalLabel",
+    "labelName",
+    "conditionalLabels",
+    "colors"
+  ];
+  return Object.keys(e).forEach((a) => {
+    o.includes(a) || t.push(
+      i(
+        "invalid_comparison_presentation",
+        `Comparison presentation does not accept field "${a}".`,
+        `${r}.${a}`
+      )
+    );
+  }), [
+    ["displayMode", ["difference", "percent_change", "both", "ratio"]],
+    ["indicatorStyle", ["arrow_badge", "arrow", "badge", "none"]],
+    ["position", ["left", "right", "top"]]
+  ].forEach(([a, s]) => {
+    e[a] !== void 0 && !s.includes(e[a]) && t.push(
+      i(
+        "invalid_comparison_presentation",
+        `Comparison presentation ${a} is invalid.`,
+        `${r}.${a}`
+      )
+    );
+  }), ["showComparison", "showColor", "conditionalLabel"].forEach((a) => {
+    e[a] !== void 0 && typeof e[a] != "boolean" && t.push(
+      i(
+        "invalid_comparison_presentation",
+        `Comparison presentation ${a} must be a boolean.`,
+        `${r}.${a}`
+      )
+    );
+  }), e.precision !== void 0 && (typeof e.precision != "number" || !Number.isInteger(e.precision) || e.precision < 0 || e.precision > 6) && t.push(
+    i(
+      "invalid_comparison_presentation",
+      "Comparison presentation precision must be an integer from 0 through 6.",
+      `${r}.precision`
+    )
+  ), e.labelName !== void 0 && typeof e.labelName != "string" && t.push(
+    i(
+      "invalid_comparison_presentation",
+      "Comparison presentation labelName must be a string.",
+      `${r}.labelName`
+    )
+  ), ["conditionalLabels", "colors"].forEach((a) => {
+    const s = e[a];
+    if (s !== void 0) {
+      if (!d(s)) {
+        t.push(
+          i(
+            "invalid_comparison_presentation",
+            `Comparison presentation ${a} must be an object.`,
+            `${r}.${a}`
+          )
+        );
+        return;
+      }
+      Object.keys(s).forEach((l) => {
+        ["increase", "decrease", "neutral"].includes(l) || t.push(
+          i(
+            "invalid_comparison_presentation",
+            `Comparison presentation ${a} does not accept field "${l}".`,
+            `${r}.${a}.${l}`
+          )
+        );
+      }), Object.entries(s).forEach(([l, c]) => {
+        c !== void 0 && typeof c != "string" && t.push(
+          i(
+            "invalid_comparison_presentation",
+            `Comparison presentation ${a}.${l} must be a string.`,
+            `${r}.${a}.${l}`
+          )
+        );
+      });
+    }
+  }), { ok: t.length === 0, errors: t, warnings: [] };
+}
+function B(e) {
+  return e === null ? "unknown" : e > 0 ? "increase" : e < 0 ? "decrease" : "no_change";
+}
+function H(e, r) {
+  return e === "unknown" || e === "no_change" || r === "neutral" ? "neutral" : r === "higher_is_better" && e === "increase" || r === "lower_is_better" && e === "decrease" ? "favorable" : "unfavorable";
+}
+function we(e) {
+  const {
+    currentValue: r,
+    comparisonValue: t,
+    polarity: o = q
+  } = e, a = r !== null && t !== null ? r - t : null, s = a !== null && t !== null && t !== 0 ? a / Math.abs(t) : null, l = r !== null && t !== null && t !== 0 ? r / t : null, c = B(a);
+  return {
+    status: t === null ? "insufficient_history" : "available",
+    currentValue: r,
+    comparisonValue: t,
+    delta: a,
+    percentChange: s,
+    ratio: l,
+    direction: c,
+    sentiment: H(c, o)
+  };
+}
+function g(e) {
+  if (e === null || typeof e != "object" || Array.isArray(e))
+    return !1;
+  const r = Object.getPrototypeOf(e);
+  if (r === null || r === Object.prototype) return !0;
+  const t = Object.prototype.hasOwnProperty.call(
+    r,
+    "constructor"
+  ) ? r.constructor : void 0;
+  return typeof t == "function" && Function.prototype.toString.call(t) === Function.prototype.toString.call(Object);
+}
+const J = {
+  dateStyle: "short",
+  dateTime: { dateStyle: "short", timeStyle: "short" }
+};
+class _ extends Error {
+  constructor(t, o) {
+    super(o);
+    T(this, "code");
+    this.name = "TemporalBucketContractError", this.code = t;
+  }
+}
+const Z = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+], z = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+function $(e) {
+  return {
+    ok: !1,
+    error: { code: "invalid_temporal_bucket_value", message: e }
+  };
+}
+function Q(e) {
+  return e % 4 === 0 && (e % 100 !== 0 || e % 400 === 0);
+}
+function W(e, r) {
+  return r === 2 ? Q(e) ? 29 : 28 : [4, 6, 9, 11].includes(r) ? 30 : 31;
+}
+function K(e, r, t) {
+  const o = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4], n = r < 3 ? e - 1 : e;
+  return (n + Math.floor(n / 4) - Math.floor(n / 100) + Math.floor(n / 400) + o[r - 1] + t) % 7;
+}
+function S(e) {
+  var r;
+  return (r = e.calendar.fiscalCalendar) == null ? void 0 : r.yearStartMonth;
+}
+function X(e, r) {
+  return (e - r + 12) % 12 % 3 === 0;
+}
+function ee(e, r) {
+  const { granularity: t } = r, o = S(r) ?? 1;
+  switch (t) {
+    case "second":
+      return !0;
+    case "minute":
+      return e.second === 0;
+    case "hour":
+      return e.minute === 0 && e.second === 0;
+    case "day":
+      return !0;
+    case "week":
+      return K(e.year, e.month, e.day) === r.calendar.weekStart;
+    case "month":
+      return e.day === 1;
+    case "quarter":
+      return e.day === 1 && X(e.month, o);
+    case "year":
+      return e.day === 1 && e.month === o;
+  }
+}
+function re(e, r) {
+  if (e === null) return { ok: !0, value: null };
+  const t = r.granularity === "second" || r.granularity === "minute" || r.granularity === "hour", o = t ? /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})$/.exec(e) : /^(\d{4})-(\d{2})-(\d{2})$/.exec(e);
+  if (!o)
+    return $(
+      `Expected ${t ? "YYYY-MM-DDTHH:mm:ss" : "YYYY-MM-DD"} for ${r.granularity} granularity.`
+    );
+  const n = {
+    year: Number(o[1]),
+    month: Number(o[2]),
+    day: Number(o[3]),
+    hour: t ? Number(o[4]) : 0,
+    minute: t ? Number(o[5]) : 0,
+    second: t ? Number(o[6]) : 0
+  };
+  return n.year < 1 || n.month < 1 || n.month > 12 || n.day < 1 || n.day > W(n.year, n.month) || n.hour > 23 || n.minute > 59 || n.second > 59 ? $(`Invalid canonical ${r.granularity} bucket value ${e}.`) : ee(n, r) ? { ok: !0, value: n } : $(
+    `Canonical value ${e} is not aligned to ${r.granularity} granularity and its governed Calendar.`
+  );
+}
+function te(e) {
+  if (!g(e))
+    return {
+      ok: !1,
+      issues: [{ path: "$", message: "Resolved temporal bucket format must be an object." }]
+    };
+  const r = [], t = /* @__PURE__ */ new Set(["type", "presentation", "locale"]);
+  for (const s of Object.keys(e))
+    t.has(s) || r.push({ path: s, message: `Unknown property "${s}".` });
+  e.type !== "temporal_bucket" && r.push({ path: "type", message: "Expected temporal_bucket." });
+  const o = e.presentation;
+  if (!g(o))
+    r.push({ path: "presentation", message: "Expected a presentation object." });
+  else {
+    const s = o.mode, l = s === "preset" ? /* @__PURE__ */ new Set(["mode", "preset"]) : s === "pattern" ? /* @__PURE__ */ new Set(["mode", "pattern"]) : s === "auto" ? /* @__PURE__ */ new Set(["mode", "styles"]) : /* @__PURE__ */ new Set(["mode"]);
+    for (const c of Object.keys(o))
+      l.has(c) || r.push({
+        path: `presentation.${c}`,
+        message: `Unknown property "${c}".`
+      });
+    if (s === "preset")
+      R(o.preset) || r.push({ path: "presentation.preset", message: "Expected a supported preset." });
+    else if (s === "pattern")
+      if (typeof o.pattern != "string" || !o.pattern)
+        r.push({ path: "presentation.pattern", message: "Expected a non-empty pattern." });
+      else {
+        const c = O(o.pattern);
+        c.ok || r.push({
+          path: "presentation.pattern",
+          message: c.message
+        });
+      }
+    else if (s === "auto") {
+      const c = o.styles;
+      (!g(c) || !["short", "medium", "long"].includes(String(c.dateStyle)) || !g(c.dateTime) || !["short", "medium", "long"].includes(
+        String(c.dateTime.dateStyle)
+      ) || !["short", "medium", "long"].includes(
+        String(c.dateTime.timeStyle)
+      ) || Object.keys(c).some(
+        (m) => m !== "dateStyle" && m !== "dateTime"
+      ) || Object.keys(c.dateTime).some(
+        (m) => m !== "dateStyle" && m !== "timeStyle"
+      )) && r.push({
+        path: "presentation.styles",
+        message: "Expected complete resolved date and datetime styles."
+      });
+    } else
+      r.push({ path: "presentation.mode", message: "Expected auto, preset, or pattern." });
+  }
+  const n = I(e.locale);
+  if (n || r.push({ path: "locale", message: "Expected a supported base BCP 47 locale." }), r.length > 0 || !n || !g(o))
+    return { ok: !1, issues: r };
+  if (o.mode === "auto") {
+    const s = o.styles;
+    return {
+      ok: !0,
+      value: {
+        type: "temporal_bucket",
+        locale: n,
+        presentation: {
+          mode: "auto",
+          styles: {
+            dateStyle: s.dateStyle,
+            dateTime: {
+              dateStyle: s.dateTime.dateStyle,
+              timeStyle: s.dateTime.timeStyle
+            }
+          }
+        }
+      }
+    };
+  }
+  return {
+    ok: !0,
+    value: {
+      type: "temporal_bucket",
+      presentation: o.mode === "preset" ? {
+        mode: "preset",
+        preset: o.preset
+      } : {
+        mode: "pattern",
+        pattern: o.pattern
+      },
+      locale: n
+    }
+  };
+}
+function oe(e, r) {
+  const t = !!r.calendar.fiscalCalendar;
+  return e === "fiscal_quarter_short" || e === "fiscal_year" ? t : e === "quarter_short" || e === "quarter_long" ? !t : !0;
+}
+function F(e, r) {
+  return U(e, r.granularity).ok ? e.presentation.mode === "preset" ? oe(e.presentation.preset, r) : !(e.presentation.mode === "pattern" && r.calendar.fiscalCalendar && (r.granularity === "quarter" || r.granularity === "year")) : !1;
+}
+function v(e, r) {
+  if (!(!e || e.presentation.mode === "auto"))
+    return F(e, r) ? { type: "temporal_bucket", presentation: e.presentation } : void 0;
+}
+function Ce(e) {
+  var n;
+  const r = I(e.locale);
+  if (!r)
+    throw new _(
+      "invalid_temporal_bucket_format",
+      "Temporal bucket locale must be a supported base BCP 47 locale."
+    );
+  const t = v(e.cardFormat, e.metadata);
+  if (t)
+    return { format: { ...t, locale: r }, source: "card" };
+  const o = ((n = e.semanticFormat) == null ? void 0 : n.granularity) === e.metadata.granularity ? v(e.semanticFormat.format, e.metadata) : void 0;
+  return o ? { format: { ...o, locale: r }, source: "semantic" } : {
+    format: {
+      type: "temporal_bucket",
+      locale: r,
+      presentation: {
+        mode: "auto",
+        styles: e.styles ?? J
+      }
+    },
+    source: "automatic"
+  };
+}
+function p(e, r = 2) {
+  return String(e).padStart(r, "0");
+}
+function h(e, r, t) {
+  if (r === "en-US")
+    return (t === "short" ? Z : z)[e - 1];
+  const o = new Date(Date.UTC(2e3, e - 1, 15));
+  return new Intl.DateTimeFormat(r, {
+    calendar: "gregory",
+    month: t,
+    timeZone: "UTC"
+  }).format(o);
+}
+function ne(e, r, t) {
+  return r.map((o) => {
+    if (o.kind === "literal") return o.value;
+    switch (o.value) {
+      case "YYYY":
+        return p(e.year, 4);
+      case "YY":
+        return p(e.year % 100);
+      case "MMMM":
+        return h(e.month, t, "long");
+      case "MMM":
+        return h(e.month, t, "short");
+      case "MM":
+        return p(e.month);
+      case "DD":
+        return p(e.day);
+      case "HH":
+        return p(e.hour);
+      case "mm":
+        return p(e.minute);
+      case "ss":
+        return p(e.second);
+    }
+  }).join("");
+}
+const N = /* @__PURE__ */ new Map();
+function y(e, r) {
+  const t = `${e}:${JSON.stringify(r)}`, o = N.get(t);
+  if (o) return o;
+  const n = new Intl.DateTimeFormat(e, r);
+  return N.set(t, n), n;
+}
+function w(e) {
+  const r = /* @__PURE__ */ new Date(0);
+  return r.setUTCFullYear(e.year, e.month - 1, e.day), r.setUTCHours(e.hour, e.minute, e.second, 0), r;
+}
+function A(e, r, t) {
+  return y(r, {
+    calendar: "gregory",
+    dateStyle: t,
+    timeZone: "UTC"
+  }).format(w(e));
+}
+function ae(e, r, t) {
+  return y(r, {
+    calendar: "gregory",
+    dateStyle: t.dateStyle,
+    // Grouped buckets are civil values, not instants. Long time styles would
+    // append a zone label that the canonical value does not semantically own.
+    timeStyle: t.timeStyle === "long" ? "medium" : t.timeStyle,
+    timeZone: "UTC"
+  }).format(w(e));
+}
+function ie(e, r, t) {
+  var n;
+  if (t === "short") {
+    const a = w(e), s = y(r, {
+      calendar: "gregory",
+      dateStyle: "short",
+      timeZone: "UTC"
+    }).formatToParts(a), l = s.findIndex((f) => f.type === "month"), c = s.findIndex((f) => f.type === "year"), m = (n = y(r, {
+      calendar: "gregory",
+      timeZone: "UTC",
+      year: "numeric"
+    }).formatToParts(a).find((f) => f.type === "year")) == null ? void 0 : n.value;
+    if (l >= 0 && c >= 0 && m) {
+      const f = Math.min(l, c), j = Math.max(l, c);
+      let C = !1;
+      return s.slice(f, j + 1).filter((b) => b.type === "day" ? (C = !0, !1) : C && b.type === "literal" ? (C = !1, !1) : !0).map((b) => b.type === "year" ? m : b.value).join("");
+    }
+  }
+  return y(r, {
+    calendar: "gregory",
+    month: t === "short" ? "numeric" : t === "medium" ? "short" : "long",
+    timeZone: "UTC",
+    year: "numeric"
+  }).format(w(e));
+}
+function se(e, r) {
+  return Math.floor((e.month - r + 12) % 12 / 3) + 1;
+}
+function E(e, r) {
+  return r === 1 || e.month < r ? e.year : e.year + 1;
+}
+function ce(e) {
+  return e === 1 ? "1st" : e === 2 ? "2nd" : e === 3 ? "3rd" : `${e}th`;
+}
+function k(e, r, t, o) {
+  const n = S(o) ?? 1, a = se(e, n);
+  switch (r) {
+    case "week_of_short":
+      return `Week of ${h(e.month, t, "short")} ${e.day}, ${e.year}`;
+    case "week_of_long":
+      return `Week of ${h(e.month, t, "long")} ${e.day}, ${e.year}`;
+    case "quarter_short":
+      return `Q${a} ${e.year}`;
+    case "quarter_long":
+      return `${ce(a)} Quarter ${e.year}`;
+    case "fiscal_quarter_short":
+      return `Q${a} FY${E(e, n)}`;
+    case "fiscal_year":
+      return `FY${E(e, n)}`;
+  }
+}
+function le(e, r, t, o) {
+  const n = S(r);
+  switch (r.granularity) {
+    case "second":
+    case "minute":
+    case "hour":
+      return ae(e, t, o.dateTime);
+    case "day":
+      return A(e, t, o.dateStyle);
+    case "week":
+      return `Week of ${A(e, t, o.dateStyle)}`;
+    case "month":
+      return ie(e, t, o.dateStyle);
+    case "quarter":
+      return k(
+        e,
+        n ? "fiscal_quarter_short" : "quarter_short",
+        t,
+        r
+      );
+    case "year":
+      return n ? k(e, "fiscal_year", t, r) : String(e.year);
+  }
+}
+function $e(e) {
+  const r = te(e.format);
+  if (!r.ok || !F(r.value, e.metadata))
+    throw new _(
+      "invalid_temporal_bucket_format",
+      "Resolved temporal bucket format is invalid or inapplicable to its metadata."
+    );
+  const t = re(e.value, e.metadata);
+  if (!t.ok)
+    throw new _(
+      t.error.code,
+      t.error.message
+    );
+  if (t.value === null) return "(Blank)";
+  const { presentation: o, locale: n } = r.value;
+  if (o.mode === "auto")
+    return le(
+      t.value,
+      e.metadata,
+      n,
+      o.styles
+    );
+  if (o.mode === "preset")
+    return k(
+      t.value,
+      o.preset,
+      n,
+      e.metadata
+    );
+  const a = O(o.pattern);
+  if (!a.ok)
+    throw new _(
+      "invalid_temporal_bucket_format",
+      a.message
+    );
+  return ne(t.value, a.segments, n);
+}
+export {
+  fe as C,
+  q as D,
+  _ as T,
+  be as a,
+  ge as b,
+  V as c,
+  ye as d,
+  _e as e,
+  $e as f,
+  he as g,
+  we as h,
+  J as i,
+  te as j,
+  Ce as k,
+  g as l,
+  re as p,
+  pe as r,
+  P as v
+};