impact-nova 2.5.6 → 2.5.8

package/dist/lib/fiscal-calendar/build-year.d.ts

@@ -0,0 +1,8 @@
+import { CivilDate, FiscalCalendarConfig, FiscalMonthPattern, FiscalYearModel, FyLabelStyle, RetailPatternId } from './types';
+export declare function configKey(config: FiscalCalendarConfig): string;
+export declare function clearFiscalYearCache(): void;
+export declare function resolvePattern(pattern: RetailPatternId | FiscalMonthPattern): FiscalMonthPattern;
+export declare function quarterForPeriod(period: number): 1 | 2 | 3 | 4;
+export declare function buildFiscalYear(config: FiscalCalendarConfig, fy: number): FiscalYearModel;
+export declare function formatFyLabel(fy: number, style?: FyLabelStyle, model?: FiscalYearModel): string;
+export declare function shiftedFyForDate(iso: CivilDate, fyStartMonth: number, fyStartDay?: number): number;

package/dist/lib/fiscal-calendar/build-year.js

@@ -0,0 +1,173 @@
+import { diffDays as w, addDays as l, compareCivil as S, parseCivilDate as f, lastDayOfMonth as P, weekStart as b, formatCivilRange as $, toCivilDate as m, minCivil as E, maxCivil as D } from "./civil-date.js";
+import { DEFAULT_FY_LABEL as O, DEFAULT_LEAP_WEEK_POLICY as v, FISCAL_PATTERNS as A } from "./types.js";
+const F = /* @__PURE__ */ new Map();
+function L(t) {
+  return JSON.stringify(t);
+}
+function W() {
+  F.clear();
+}
+function M(t) {
+  return typeof t == "string" ? A[t] : t;
+}
+function q(t) {
+  return t <= 3 ? 1 : t <= 6 ? 2 : t <= 9 ? 3 : 4;
+}
+function x(t, e) {
+  const r = f(t), n = f(e), s = [];
+  let o = r.y, a = r.m;
+  for (; o < n.y || o === n.y && a <= n.m; )
+    s.push({ year: o, month: a - 1 }), a += 1, a > 12 && (a = 1, o += 1);
+  return s;
+}
+function g(t, e, r, n, s) {
+  return {
+    fy: t,
+    period: e,
+    label: `Period ${e}`,
+    displayLabel: `Period ${e} (${$(r, n)})`,
+    start: r,
+    end: n,
+    weekCount: s,
+    quarter: q(e),
+    gregorianMonthSpan: x(r, n)
+  };
+}
+function _(t, e, r) {
+  const n = [];
+  let s = 1;
+  for (const o of e) {
+    let a = b(o.start, r);
+    for (S(a, o.start) < 0 && (a = o.start); S(a, o.end) <= 0; ) {
+      const i = l(a, 6), c = E(i, o.end), d = D(a, o.start);
+      n.push({
+        fy: t,
+        week: s,
+        start: d,
+        end: c,
+        period: o.period,
+        quarter: o.quarter
+      }), s += 1, a = l(c, 1);
+    }
+  }
+  return n;
+}
+function y(t, e) {
+  const r = /* @__PURE__ */ new Map();
+  for (const n of e) {
+    const s = r.get(n.quarter) ?? [];
+    s.push(n), r.set(n.quarter, s);
+  }
+  return [1, 2, 3, 4].flatMap((n) => {
+    const s = r.get(n);
+    return !s || s.length === 0 ? [] : [{
+      fy: t,
+      quarter: n,
+      start: s[0].start,
+      end: s[s.length - 1].end,
+      periods: s.map((a) => a.period)
+    }];
+  });
+}
+function C(t, e, r) {
+  const n = _(t, e, r);
+  return {
+    fy: t,
+    start: e[0].start,
+    end: e[e.length - 1].end,
+    weekCount: n.length === 53 ? 53 : 52,
+    periodCount: e.length === 13 ? 13 : 12,
+    weeks: n,
+    periods: e,
+    quarters: y(t, e)
+  };
+}
+function R(t, e, r) {
+  return m(t, e, r);
+}
+function Y(t, e, r) {
+  const n = R(t, r.month, r.day), s = b(n, e);
+  if (r.rule === "on-or-before") return s;
+  const o = l(s, 7), a = Math.abs(w(n, s));
+  return Math.abs(w(o, n)) < a ? o : s;
+}
+function T(t, e) {
+  const r = M(t.pattern);
+  if (r.length !== 12)
+    throw new Error(`retail pattern must have 12 entries, got ${r.length}`);
+  const n = t.weekStartsOn, s = Y(e, n, t.fyAnchor), o = Y(e + 1, n, t.fyAnchor), i = w(o, s) >= 371, c = t.leapWeekPolicy ?? v, d = [];
+  let h = s;
+  for (let u = 0; u < 12; u++) {
+    let p = r[u];
+    i && c === "append-last-period" && u === 11 && (p += 1);
+    const k = l(h, p * 7 - 1);
+    d.push(g(e, u + 1, h, k, p)), h = l(k, 1);
+  }
+  if (i && c === "period-13") {
+    const u = l(h, 6);
+    d.push(g(e, 13, h, u, 1));
+  }
+  return C(e, d, n);
+}
+function B(t, e, r) {
+  if (e === 1 && r === 1)
+    return { start: m(t, 1, 1), end: m(t, 12, 31) };
+  const n = m(t - 1, e, r), s = m(t, e, r);
+  return { start: n, end: l(s, -1) };
+}
+function N(t, e) {
+  const r = t.fyStartDay ?? 1, { start: n, end: s } = B(e, t.fyStartMonth, r), o = t.weekStartsOn ?? 1, a = [];
+  let i = n, c = 1;
+  for (; S(i, s) <= 0; ) {
+    const { y: d, m: h } = f(i), u = P(d, h), p = E(u, s), k = Math.max(1, Math.ceil((w(p, i) + 1) / 7));
+    a.push(g(e, c, i, p, k)), i = l(p, 1), c += 1;
+  }
+  return C(e, a, o);
+}
+function I(t, e) {
+  const r = t.periods.filter((o) => o.fy === e).sort((o, a) => o.period - a.period);
+  if (r.length === 0)
+    throw new Error(`custom-table has no periods for FY ${e}`);
+  for (let o = 1; o < r.length; o++)
+    if (S(r[o].start, r[o - 1].end) <= 0)
+      throw new Error(`custom-table periods overlap in FY ${e}`);
+  const n = t.weekStartsOn ?? 1, s = r.map(
+    (o) => g(
+      e,
+      o.period,
+      o.start,
+      o.end,
+      Math.max(1, Math.ceil((w(o.end, o.start) + 1) / 7))
+    )
+  );
+  return C(e, s, n);
+}
+function J(t, e) {
+  const r = `${L(t)}:${e}`, n = F.get(r);
+  if (n) return n;
+  let s;
+  return t.kind === "retail" ? s = T(t, e) : t.kind === "shifted-year" ? s = N(t, e) : s = I(t, e), F.set(r, s), s;
+}
+function j(t, e = O, r) {
+  if (e === "fy-long") return `FY ${t}`;
+  if (e === "fy-short") return `FY${String(t).slice(-2)}`;
+  if (e === "ending-year") {
+    const o = r ? f(r.end).y : t;
+    return String(o);
+  }
+  const n = r ? f(r.start).y : t - 1, s = r ? f(r.end).y : t;
+  return `${String(n).slice(-2)}–${String(s).slice(-2)}`;
+}
+function z(t, e, r = 1) {
+  const { y: n, m: s, d: o } = f(t);
+  return e === 1 && r === 1 ? n : s > e || s === e && o >= r ? n + 1 : n;
+}
+export {
+  J as buildFiscalYear,
+  W as clearFiscalYearCache,
+  L as configKey,
+  j as formatFyLabel,
+  q as quarterForPeriod,
+  M as resolvePattern,
+  z as shiftedFyForDate
+};

package/dist/lib/fiscal-calendar/civil-date.d.ts

@@ -0,0 +1,21 @@
+import { CivilDate, Weekday } from './types';
+export declare function parseCivilDate(iso: CivilDate): {
+    y: number;
+    m: number;
+    d: number;
+};
+export declare function toCivilDate(y: number, m: number, d: number): CivilDate;
+export declare function addDays(iso: CivilDate, n: number): CivilDate;
+export declare function diffDays(a: CivilDate, b: CivilDate): number;
+export declare function compareCivil(a: CivilDate, b: CivilDate): number;
+export declare function minCivil(a: CivilDate, b: CivilDate): CivilDate;
+export declare function maxCivil(a: CivilDate, b: CivilDate): CivilDate;
+/** 0 = Sunday … 6 = Saturday. Sakamoto; no Date. */
+export declare function weekday(iso: CivilDate): Weekday;
+export declare function weekStart(iso: CivilDate, weekStartsOn: Weekday): CivilDate;
+export declare function daysInMonth(y: number, m: number): number;
+export declare function lastDayOfMonth(y: number, m: number): CivilDate;
+export declare function civilFromLocalDate(date: Date): CivilDate;
+export declare function localDateFromCivil(iso: CivilDate): Date;
+export declare const MONTH_SHORT: readonly ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+export declare function formatCivilRange(start: CivilDate, end: CivilDate): string;

package/dist/lib/fiscal-calendar/civil-date.js

@@ -0,0 +1,94 @@
+const h = /^(\d{4})-(\d{2})-(\d{2})$/;
+function c(t) {
+  const n = h.exec(t);
+  if (!n)
+    throw new Error(`Invalid civil date: ${t}`);
+  const o = Number(n[1]), r = Number(n[2]), a = Number(n[3]);
+  if (r < 1 || r > 12 || a < 1 || a > 31)
+    throw new Error(`Invalid civil date: ${t}`);
+  return { y: o, m: r, d: a };
+}
+function l(t, n, o) {
+  return `${String(t).padStart(4, "0")}-${String(n).padStart(2, "0")}-${String(o).padStart(2, "0")}`;
+}
+function u(t, n, o) {
+  const r = Math.floor((14 - n) / 12), a = t + 4800 - r, e = n + 12 * r - 3;
+  return o + Math.floor((153 * e + 2) / 5) + 365 * a + Math.floor(a / 4) - Math.floor(a / 100) + Math.floor(a / 400) - 32045;
+}
+function y(t) {
+  const n = t + 32044, o = Math.floor((4 * n + 3) / 146097), r = n - Math.floor(146097 * o / 4), a = Math.floor((4 * r + 3) / 1461), e = r - Math.floor(1461 * a / 4), f = Math.floor((5 * e + 2) / 153), d = e - Math.floor((153 * f + 2) / 5) + 1, m = f + 3 - 12 * Math.floor(f / 10);
+  return { y: 100 * o + a - 4800 + Math.floor(f / 10), m, d };
+}
+function M(t, n) {
+  const { y: o, m: r, d: a } = c(t), e = y(u(o, r, a) + n);
+  return l(e.y, e.m, e.d);
+}
+function D(t, n) {
+  const o = c(t), r = c(n);
+  return u(o.y, o.m, o.d) - u(r.y, r.m, r.d);
+}
+function s(t, n) {
+  return t === n ? 0 : t < n ? -1 : 1;
+}
+function g(t, n) {
+  return s(t, n) <= 0 ? t : n;
+}
+function S(t, n) {
+  return s(t, n) >= 0 ? t : n;
+}
+function $(t) {
+  const { y: n, m: o, d: r } = c(t), a = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4], e = o < 3 ? n - 1 : n;
+  return (e + Math.floor(e / 4) - Math.floor(e / 100) + Math.floor(e / 400) + a[o - 1] + r) % 7;
+}
+function C(t, n) {
+  const r = ($(t) + 7 - n) % 7;
+  return M(t, -r);
+}
+function v(t, n) {
+  return n === 2 ? t % 4 === 0 && t % 100 !== 0 || t % 400 === 0 ? 29 : 28 : [31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][n - 1];
+}
+function w(t, n) {
+  return l(t, n, v(t, n));
+}
+function I(t) {
+  return l(t.getFullYear(), t.getMonth() + 1, t.getDate());
+}
+function J(t) {
+  const { y: n, m: o, d: r } = c(t);
+  return new Date(n, o - 1, r);
+}
+const i = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+function N(t, n) {
+  const o = c(t), r = c(n);
+  return o.y === r.y && o.m === r.m ? `${i[o.m - 1]} ${o.d} – ${r.d}` : o.y === r.y ? `${i[o.m - 1]} ${o.d} – ${i[r.m - 1]} ${r.d}` : `${i[o.m - 1]} ${o.d} ${o.y} – ${i[r.m - 1]} ${r.d} ${r.y}`;
+}
+export {
+  i as MONTH_SHORT,
+  M as addDays,
+  I as civilFromLocalDate,
+  s as compareCivil,
+  v as daysInMonth,
+  D as diffDays,
+  N as formatCivilRange,
+  w as lastDayOfMonth,
+  J as localDateFromCivil,
+  S as maxCivil,
+  g as minCivil,
+  c as parseCivilDate,
+  l as toCivilDate,
+  C as weekStart,
+  $ as weekday
+};

package/dist/lib/fiscal-calendar/index.d.ts

@@ -0,0 +1,10 @@
+export type { CalendarInterval, CalendarKind, CalendarSelection, CalendarSelectionMode, CivilDate, DateCellMeta, FiscalCalendarConfig, FiscalMode, FiscalMonth, FiscalMonthPattern, FiscalPeriod, FiscalQuarter, FiscalWeek, FiscalYearModel, FyLabelStyle, Granularity, LeapWeekPolicy, RetailPatternId, WeekSelection, Weekday, } from './types';
+export { DEFAULT_FY_LABEL, DEFAULT_LEAP_WEEK_POLICY, FISCAL_PATTERNS, } from './types';
+export { addDays, civilFromLocalDate, compareCivil, diffDays, formatCivilRange, lastDayOfMonth, localDateFromCivil, parseCivilDate, toCivilDate, weekStart, weekday, } from './civil-date';
+export { buildFiscalYear, clearFiscalYearCache, formatFyLabel, resolvePattern, shiftedFyForDate, } from './build-year';
+export { getCellMeta, getFiscalYearForDate, clearFiscalLookupCache } from './lookup';
+export { getFiscalPresets } from './presets';
+export type { FiscalPreset } from './presets';
+export { isSameInterval, nextIntervalSelection } from './selection';
+export { buildFiscalMonthCalendar, getCalendarWeekSelection, getFiscalMonthSelection, getFiscalWeekSelection, resolveWeekSelection, toFiscalCalendarConfig, } from './week-selection';
+export type { ResolveWeekSelectionOptions } from './week-selection';

package/dist/lib/fiscal-calendar/index.js

@@ -0,0 +1,40 @@
+import { DEFAULT_FY_LABEL as t, DEFAULT_LEAP_WEEK_POLICY as l, FISCAL_PATTERNS as o } from "./types.js";
+import { addDays as i, civilFromLocalDate as c, compareCivil as s, diffDays as F, formatCivilRange as n, lastDayOfMonth as f, localDateFromCivil as C, parseCivilDate as m, toCivilDate as D, weekStart as d, weekday as p } from "./civil-date.js";
+import { buildFiscalYear as L, clearFiscalYearCache as S, formatFyLabel as g, resolvePattern as x, shiftedFyForDate as E } from "./build-year.js";
+import { clearFiscalLookupCache as k, getCellMeta as y, getFiscalYearForDate as A } from "./lookup.js";
+import { getFiscalPresets as P } from "./presets.js";
+import { isSameInterval as I, nextIntervalSelection as M } from "./selection.js";
+import { buildFiscalMonthCalendar as W, getCalendarWeekSelection as b, getFiscalMonthSelection as u, getFiscalWeekSelection as w, resolveWeekSelection as O, toFiscalCalendarConfig as R } from "./week-selection.js";
+export {
+  t as DEFAULT_FY_LABEL,
+  l as DEFAULT_LEAP_WEEK_POLICY,
+  o as FISCAL_PATTERNS,
+  i as addDays,
+  W as buildFiscalMonthCalendar,
+  L as buildFiscalYear,
+  c as civilFromLocalDate,
+  k as clearFiscalLookupCache,
+  S as clearFiscalYearCache,
+  s as compareCivil,
+  F as diffDays,
+  n as formatCivilRange,
+  g as formatFyLabel,
+  b as getCalendarWeekSelection,
+  y as getCellMeta,
+  u as getFiscalMonthSelection,
+  P as getFiscalPresets,
+  w as getFiscalWeekSelection,
+  A as getFiscalYearForDate,
+  I as isSameInterval,
+  f as lastDayOfMonth,
+  C as localDateFromCivil,
+  M as nextIntervalSelection,
+  m as parseCivilDate,
+  x as resolvePattern,
+  O as resolveWeekSelection,
+  E as shiftedFyForDate,
+  D as toCivilDate,
+  R as toFiscalCalendarConfig,
+  d as weekStart,
+  p as weekday
+};

package/dist/lib/fiscal-calendar/lookup.d.ts

@@ -0,0 +1,4 @@
+import { CivilDate, DateCellMeta, FiscalCalendarConfig, FiscalYearModel } from './types';
+export declare function clearFiscalLookupCache(): void;
+export declare function getCellMeta(config: FiscalCalendarConfig, iso: CivilDate): DateCellMeta | undefined;
+export declare function getFiscalYearForDate(config: FiscalCalendarConfig, iso: CivilDate): FiscalYearModel | undefined;

package/dist/lib/fiscal-calendar/lookup.js

@@ -0,0 +1,70 @@
+import { parseCivilDate as c, compareCivil as f, addDays as l } from "./civil-date.js";
+import { buildFiscalYear as u, shiftedFyForDate as h, configKey as p } from "./build-year.js";
+const y = /* @__PURE__ */ new Map();
+function M() {
+  y.clear();
+}
+function m(e) {
+  const r = /* @__PURE__ */ new Map();
+  for (const t of e.weeks) {
+    let n = t.start;
+    for (; f(n, t.end) <= 0; ) {
+      const { y: o, m: i, d } = c(n), a = e.periods.find((s) => s.period === t.period);
+      r.set(n, {
+        iso: n,
+        gregorian: { year: o, month: i, day: d },
+        fy: e.fy,
+        fiscalWeek: t.week,
+        fiscalPeriod: t.period,
+        fiscalQuarter: t.quarter,
+        isPeriodStart: a ? n === a.start : !1,
+        isPeriodEnd: a ? n === a.end : !1,
+        isFyStart: n === e.start,
+        isFyEnd: n === e.end,
+        crossesGregorianMonth: a ? a.gregorianMonthSpan.length > 1 : !1
+      }), n = l(n, 1);
+    }
+  }
+  return r;
+}
+function F(e, r) {
+  if (e.kind === "shifted-year")
+    return h(r, e.fyStartMonth, e.fyStartDay ?? 1);
+  if (e.kind === "custom-table") {
+    const t = e.periods.find(
+      (n) => f(r, n.start) >= 0 && f(r, n.end) <= 0
+    );
+    return t ? t.fy : c(r).y;
+  }
+  return c(r).y;
+}
+function k(e, r) {
+  const t = `${p(e)}:${r}`, n = y.get(t);
+  if (n) return n;
+  const o = u(e, r), i = m(o);
+  return y.set(t, i), i;
+}
+function g(e, r) {
+  const t = F(e, r);
+  for (const d of [t, t - 1, t + 1])
+    try {
+      const s = k(e, d).get(r);
+      if (s) return s;
+    } catch {
+    }
+  const { y: n, m: o, d: i } = c(r);
+  return {
+    iso: r,
+    gregorian: { year: n, month: o, day: i }
+  };
+}
+function C(e, r) {
+  const t = g(e, r);
+  if (t?.fy != null)
+    return u(e, t.fy);
+}
+export {
+  M as clearFiscalLookupCache,
+  g as getCellMeta,
+  C as getFiscalYearForDate
+};

package/dist/lib/fiscal-calendar/presets.d.ts

@@ -0,0 +1,8 @@
+import { CalendarInterval, CivilDate, FiscalCalendarConfig } from './types';
+export interface FiscalPreset {
+    id: string;
+    label: string;
+    interval: CalendarInterval;
+    comparison?: CalendarInterval;
+}
+export declare function getFiscalPresets(config: FiscalCalendarConfig, now: CivilDate): FiscalPreset[];

package/dist/lib/fiscal-calendar/presets.js

@@ -0,0 +1,99 @@
+import { minCivil as y, compareCivil as h, addDays as c } from "./civil-date.js";
+import { buildFiscalYear as q } from "./build-year.js";
+import { getCellMeta as v, getFiscalYearForDate as b } from "./lookup.js";
+function a(l, s, p, r = {}) {
+  return { start: l, end: s, granularity: p, ...r };
+}
+function Y(l, s) {
+  const p = v(l, s), r = b(l, s);
+  if (!p?.fy || !r) return [];
+  const i = r.periods.find((e) => e.period === p.fiscalPeriod), o = r.quarters.find((e) => e.quarter === p.fiscalQuarter), n = i && i.period > 1 ? r.periods.find((e) => e.period === i.period - 1) : void 0;
+  let t;
+  try {
+    t = q(l, r.fy - 1);
+  } catch {
+    t = void 0;
+  }
+  const f = o && o.quarter > 1 ? r.quarters.find((e) => e.quarter === o.quarter - 1) : t?.quarters[t.quarters.length - 1], d = [
+    {
+      id: "this-fy",
+      label: "This FY",
+      interval: a(r.start, r.end, "year", { fy: r.fy })
+    }
+  ];
+  if (t && d.push({
+    id: "last-fy",
+    label: "Last FY",
+    interval: a(t.start, t.end, "year", { fy: t.fy })
+  }), i && (d.push({
+    id: "this-period",
+    label: "This Period",
+    interval: a(i.start, i.end, "period", {
+      fy: r.fy,
+      period: i.period
+    })
+  }), d.push({
+    id: "period-to-date",
+    label: "Period to date",
+    interval: a(i.start, y(s, i.end), "period", {
+      fy: r.fy,
+      period: i.period
+    })
+  })), n)
+    d.push({
+      id: "last-period",
+      label: "Last Period",
+      interval: a(n.start, n.end, "period", {
+        fy: r.fy,
+        period: n.period
+      })
+    });
+  else if (t) {
+    const e = t.periods[t.periods.length - 1];
+    d.push({
+      id: "last-period",
+      label: "Last Period",
+      interval: a(e.start, e.end, "period", {
+        fy: t.fy,
+        period: e.period
+      })
+    });
+  }
+  if (d.push({
+    id: "this-fytd",
+    label: "This FYTD",
+    interval: a(r.start, y(s, r.end), "year", { fy: r.fy })
+  }), o && d.push({
+    id: "this-fq",
+    label: "This FQ",
+    interval: a(o.start, o.end, "quarter", {
+      fy: r.fy,
+      quarter: o.quarter
+    })
+  }), f && d.push({
+    id: "last-fq",
+    label: "Last FQ",
+    interval: a(f.start, f.end, "quarter", {
+      fy: f.fy,
+      quarter: f.quarter
+    })
+  }), i && t) {
+    const e = t.periods.find((u) => u.period === i.period);
+    e && d.push({
+      id: "yoy-period",
+      label: "YoY same period",
+      interval: a(i.start, i.end, "period", {
+        fy: r.fy,
+        period: i.period
+      }),
+      comparison: a(e.start, e.end, "period", {
+        fy: t.fy,
+        period: e.period
+      })
+    });
+  }
+  return d.filter((e) => h(e.interval.start, c(s, 1)) < 0);
+}
+export {
+  Y as getFiscalPresets
+};

package/dist/lib/fiscal-calendar/selection.d.ts

@@ -0,0 +1,18 @@
+import { CalendarInterval, CalendarSelectionMode } from './types';
+export declare function isSameInterval(a: CalendarInterval, b: CalendarInterval): boolean;
+export declare function nextIntervalSelection(interval: CalendarInterval, prev: CalendarInterval | CalendarInterval[] | {
+    from: CalendarInterval;
+    to?: CalendarInterval;
+} | Array<{
+    from: CalendarInterval;
+    to?: CalendarInterval;
+}> | {
+    from: CalendarInterval;
+    to?: CalendarInterval;
+} | null | undefined, mode: CalendarSelectionMode): CalendarInterval | CalendarInterval[] | {
+    from: CalendarInterval;
+    to?: CalendarInterval;
+} | Array<{
+    from: CalendarInterval;
+    to?: CalendarInterval;
+}> | undefined;

package/dist/lib/fiscal-calendar/selection.js

@@ -0,0 +1,32 @@
+import { compareCivil as u } from "./civil-date.js";
+function m(o, r) {
+  return o.start === r.start && o.end === r.end && o.granularity === r.granularity;
+}
+function i(o, r) {
+  return u(o.start, r.start) || u(o.end, r.end);
+}
+function g(o, r, c) {
+  if (c === "single") return o;
+  if (c === "multiple") {
+    const t = Array.isArray(r) && (r.length === 0 || !("from" in r[0])) ? r : [];
+    return t.some((e) => m(e, o)) ? t.filter((e) => !m(e, o)) : [...t, o];
+  }
+  if (c === "multi-range") {
+    const t = Array.isArray(r) ? r.filter(
+      (s) => s && typeof s == "object" && "from" in s
+    ) : r && typeof r == "object" && "from" in r ? [r] : [], n = t[t.length - 1];
+    if (!n || n.to)
+      return [...t.filter(
+        (l) => !!l.to
+      ), { from: o }];
+    if (m(o, n.from)) return t;
+    const e = i(o, n.from) < 0 ? { from: o, to: n.from } : { from: n.from, to: o };
+    return [...t.slice(0, -1), e];
+  }
+  const f = r;
+  return !f?.from || f.to ? { from: o } : m(o, f.from) ? f : i(o, f.from) < 0 ? { from: o, to: f.from } : { from: f.from, to: o };
+}
+export {
+  m as isSameInterval,
+  g as nextIntervalSelection
+};