@rowsncolumns/fast-formula-parser 6.2.37 → 6.2.38

package/dist/cjs/index.js

@@ -3883,6 +3883,80 @@ const IndexedColors = Object.freeze([
 
 const isSingleSectionElapsedTimePattern = (pattern) => !pattern.includes(";") &&
     /\[(?:h+|m+|s+)\]/i.test(pattern.replace(/\[\$[^\]]+\]/g, ""));
+const intlMonthNames = (locale, options) => {
+    const formatter = new Intl.DateTimeFormat(locale, {
+        ...options,
+        timeZone: "UTC",
+    });
+    return Array.from({ length: 12 }, (_, month) => formatter
+        .formatToParts(new Date(Date.UTC(2020, month, 1)))
+        .find((part) => part.type === "month")?.value ?? "");
+};
+const intlRegisteredLocales = new Set();
+/**
+ * numfmt ships name tables for a fixed set of languages; a tag it does not know
+ * (et, ms, nn, …) silently renders English month/weekday names and en-US
+ * separators. Excel and `Intl.DateTimeFormat` localize every locale, so an
+ * unknown tag gets a numfmt locale built from Intl on first use: separators
+ * from `Intl.NumberFormat`, the in-date month names (numfmt's single table is
+ * the form used beside a day number — see `getStandaloneMonthLocale`), the
+ * in-date weekday names (the form `dateStyle: "full"` shows) and the AM/PM
+ * designators. Tags Intl itself does not know keep numfmt's fallback.
+ */
+const ensureNumfmtLocale = (locale) => {
+    if (intlRegisteredLocales.has(locale))
+        return;
+    intlRegisteredLocales.add(locale);
+    try {
+        if (getLocale(locale))
+            return;
+        const canonical = Intl.DateTimeFormat.supportedLocalesOf([locale])[0];
+        if (!canonical)
+            return;
+        const numberParts = new Intl.NumberFormat(locale).formatToParts(1234567.5);
+        const part = (type) => numberParts.find((p) => p.type === type)?.value;
+        const weekdayNames = (weekday) => {
+            // 2024-01-07 was a Sunday; numfmt indexes `dddd[0]` as Sunday.
+            const fmt = new Intl.DateTimeFormat(locale, {
+                weekday,
+                day: "numeric",
+                month: "long",
+                year: "numeric",
+                timeZone: "UTC",
+            });
+            return Array.from({ length: 7 }, (_, i) => fmt
+                .formatToParts(new Date(Date.UTC(2024, 0, 7 + i)))
+                .find((p) => p.type === "weekday")?.value ?? "");
+        };
+        const dayPeriod = (hour) => new Intl.DateTimeFormat(locale, {
+            hour: "numeric",
+            hour12: true,
+            timeZone: "UTC",
+        })
+            .formatToParts(new Date(Date.UTC(2024, 0, 7, hour)))
+            .find((p) => p.type === "dayPeriod")?.value;
+        const dateParts = new Intl.DateTimeFormat(locale, {
+            timeZone: "UTC",
+        }).formatToParts(new Date(Date.UTC(2024, 0, 7)));
+        const monthIndex = dateParts.findIndex((p) => p.type === "month");
+        const dayIndex = dateParts.findIndex((p) => p.type === "day");
+        const am = dayPeriod(9);
+        const pm = dayPeriod(21);
+        addLocale({
+            group: part("group") ?? "\u00a0",
+            decimal: part("decimal") ?? ".",
+            mmmm: intlMonthNames(locale, { day: "numeric", month: "long" }),
+            mmm: intlMonthNames(locale, { day: "numeric", month: "short" }),
+            dddd: weekdayNames("long"),
+            ddd: weekdayNames("short"),
+            ...(am && pm && am !== pm ? { ampm: [am, pm] } : {}),
+            preferMDY: monthIndex >= 0 && dayIndex >= 0 && monthIndex < dayIndex,
+        }, locale);
+    }
+    catch {
+        // Malformed tag: numfmt keeps its own fallback.
+    }
+};
 const localeForPattern = (pattern, locale) => {
     return locale;
 };
@@ -4134,6 +4208,8 @@ const withWorkbookSeparatorsCached = (code, locale) => {
 };
 const ssfFormat = (pattern, value, locale) => {
     try {
+        if (locale)
+            ;
         let shortAmPm = shortAmPmPatternCache.get(pattern);
         if (shortAmPm === undefined && !shortAmPmPatternCache.has(pattern)) {
             shortAmPm = withShortAmPmMarker(pattern);
@@ -12588,7 +12664,10 @@ const forecastEtsPrep = (ys, xs, seasonality) => {
         if (typeof yv !== "number") continue;
         pairs.push([x, yv]);
     }
-    if (pairs.length < 4) throw FormulaError.NA;
+    // Excel fits from two pairs (there is no four-pair floor); fewer is
+    // #N/A, and two pairs on the same timeline point have no step (#NUM!
+    // below). rowsncolumns/spreadsheet#642 B-01.
+    if (pairs.length < 2) throw FormulaError.NA;
     pairs.sort((a, b) => a[0] - b[0]);
     const sortedX = pairs.map(p => p[0]);
     const y = pairs.map(p => p[1]);
@@ -12626,7 +12705,7 @@ const detectSeasonality = (y) => {
     const n = y.length;
     if (n < 4) return 1;
     const maxPeriod = Math.min(Math.floor(n / 2), 12);
-    const baseline = runHoltWinters(y, 1, 0.5, 0.1, 0, 0).sse;
+    const baseline = runHoltWinters(y, 1, 0.5, 0.1, 0).sse;
     let bestPeriod = 1;
     let bestSse = baseline;
     for (let m = 2; m <= maxPeriod; m++) {
@@ -12637,7 +12716,7 @@ const detectSeasonality = (y) => {
         for (const alpha of [0.3, 0.7]) {
             for (const beta of [0.1, 0.3]) {
                 for (const gamma of [0.3, 0.7]) {
-                    const sse = runHoltWinters(y, m, alpha, beta, gamma, 0).sse;
+                    const sse = runHoltWinters(y, m, alpha, beta, gamma).sse;
                     if (sse < mSse) mSse = sse;
                 }
             }
@@ -12653,11 +12732,10 @@ const detectSeasonality = (y) => {
 };
 
 // Fit Holt-Winters additive model with the supplied (or auto-fit) α,
-// β, γ smoothing parameters. Returns fitted in-sample values + the
-// `horizon`-step-ahead forecast. period=1 collapses to Holt linear
-// (no seasonal component).
-const fitHoltWinters = (y, period, horizon) => {
-    y.length;
+// β, γ smoothing parameters. Returns the fitted in-sample values and the
+// terminal state (`forecastAt(h)` extrapolates it to any horizon in O(1)).
+// period=1 collapses to Holt linear (no seasonal component).
+const fitHoltWinters = (y, period) => {
     // Grid search the smoothing params. The 5×5×5 grid is coarse but
     // close enough to the SSE-minimizing optimum that Excel's results
     // round-match within ~1% on the seasonal demo series.
@@ -12667,7 +12745,7 @@ const fitHoltWinters = (y, period, horizon) => {
     for (const alpha of grid) {
         for (const beta of grid) {
             for (const gamma of candidateGammas) {
-                const result = runHoltWinters(y, period, alpha, beta, gamma, horizon);
+                const result = runHoltWinters(y, period, alpha, beta, gamma);
                 if (best == null || result.sse < best.sse) {
                     best = { alpha, beta, gamma, ...result };
                 }
@@ -12677,7 +12755,25 @@ const fitHoltWinters = (y, period, horizon) => {
     return best;
 };
 
-const runHoltWinters = (y, period, alpha, beta, gamma, horizon) => {
+// The forecast `h` whole steps past the last observation from a run's
+// terminal state: level + h·trend + seasonal[(n + h - 1) mod m]. O(1) in
+// `h` — the old per-step forecast array made `FORECAST.ETS(1E15, …)`
+// hang the tab (and trapped the Rust engine's wasm with a capacity
+// overflow that poisoned the whole store). rowsncolumns/spreadsheet#642 B-06.
+const holtWintersForecastAt = ({ n, m, level, trend, seasonal }, h) => {
+    const seasonComp = m > 1 ? seasonal[(n + h - 1) % m] : 0;
+    return level + h * trend + seasonComp;
+};
+
+// One additive Holt-Winters pass with fixed smoothing parameters. The
+// initial level is the level one step *before* the series (first value
+// or first-cycle mean, minus the trend), so the one-step-ahead prediction
+// of the first observation is the observation itself and a perfectly
+// linear history has zero residual — an initial level *at* the first
+// value predicted y₀ + trend for y₀, and that spurious residual pulled
+// the grid search off the exact continuation (10,20,…,100 → 109.56
+// instead of Excel's 110). rowsncolumns/spreadsheet#642 B-01.
+const runHoltWinters = (y, period, alpha, beta, gamma) => {
     const n = y.length;
     const m = period;
     const fitted = new Array(n).fill(null);
@@ -12685,21 +12781,21 @@ const runHoltWinters = (y, period, alpha, beta, gamma, horizon) => {
     const seasonal = new Array(m).fill(0);
     if (m > 1 && n >= 2 * m) {
         // Initial seasonal indices = first-cycle deviations from the
-        // first-cycle mean. Initial level = mean of first cycle.
-        // Initial trend = average of per-step changes between first
-        // and second cycle, normalized by m.
+        // first-cycle mean. Initial trend = average of per-step changes
+        // between first and second cycle, normalized by m. Initial level
+        // = mean of first cycle, one trend step back.
         let sum1 = 0;
         for (let i = 0; i < m; i++) sum1 += y[i];
         const mean1 = sum1 / m;
-        level = mean1;
         let trendSum = 0;
         for (let i = 0; i < m; i++) trendSum += (y[i + m] - y[i]) / m;
         trend = trendSum / m;
+        level = mean1 - trend;
         for (let i = 0; i < m; i++) seasonal[i] = y[i] - mean1;
     } else {
-        // Holt linear initialization.
-        level = y[0];
+        // Holt linear initialization, one trend step back.
         trend = n > 1 ? y[1] - y[0] : 0;
+        level = y[0] - trend;
     }
     let sse = 0;
     let count = 0;
@@ -12718,12 +12814,12 @@ const runHoltWinters = (y, period, alpha, beta, gamma, horizon) => {
             seasonal[seasonIdx] = gamma * (y[t] - level) + (1 - gamma) * seasonComp;
         }
     }
-    const forecast = [];
-    for (let h = 1; h <= horizon; h++) {
-        const seasonComp = m > 1 ? seasonal[(n + h - 1) % m] : 0;
-        forecast.push(level + h * trend + seasonComp);
-    }
-    return { fitted, forecast, sse: count > 0 ? sse / count : Infinity };
+    const state = { n, m, level, trend, seasonal };
+    return {
+        fitted,
+        sse: count > 0 ? sse / count : Infinity,
+        forecastAt: (h) => holtWintersForecastAt(state, h),
+    };
 };
 
 const percentileInclusive = (values, k) => {
@@ -13508,9 +13604,11 @@ const DistributionFunctions = {
             throw FormulaError.NUM;
         }
         const horizon = Math.round((target - lastX) / step);
+        if (!Number.isFinite(horizon)) throw FormulaError.NUM;
         if (horizon < 1) return y[y.length - 1];
-        const { fitted: _f, forecast } = fitHoltWinters(y, period, horizon);
-        return forecast[horizon - 1];
+        const forecast = fitHoltWinters(y, period).forecastAt(horizon);
+        if (!Number.isFinite(forecast)) throw FormulaError.NUM;
+        return forecast;
     },
 
     'FORECAST.ETS.CONFINT': (targetDate, values, timeline, confidenceArg, seasonalityArg, dataCompletionArg, aggregationArg) => {
@@ -13526,7 +13624,8 @@ const DistributionFunctions = {
         const { y, lastX, step, period } = forecastEtsPrep(ys, xs, seasonality);
         if (target < lastX) throw FormulaError.NUM;
         const horizon = Math.max(1, Math.round((target - lastX) / step));
-        const { fitted, forecast: _fc } = fitHoltWinters(y, period, horizon);
+        if (!Number.isFinite(horizon)) throw FormulaError.NUM;
+        const { fitted } = fitHoltWinters(y, period);
         // RMSE of in-sample residuals — z-scaled to the requested
         // confidence level. Excel uses √(horizon) scaling on the
         // forecast variance.
@@ -13539,7 +13638,9 @@ const DistributionFunctions = {
         }
         const rmse = n > 0 ? Math.sqrt(sse / n) : 0;
         const z = jStat.normal.inv(1 - (1 - confidence) / 2, 0, 1);
-        return z * rmse * Math.sqrt(horizon);
+        const halfWidth = z * rmse * Math.sqrt(horizon);
+        if (!Number.isFinite(halfWidth)) throw FormulaError.NUM;
+        return halfWidth;
     },
 
     'FORECAST.ETS.SEASONALITY': (values, timeline, dataCompletionArg, aggregationArg) => {
@@ -13558,7 +13659,7 @@ const DistributionFunctions = {
         const seasonality = forecastEtsSeasonality(seasonalityArg);
         forecastEtsValidateOptions(dataCompletionArg, aggregationArg);
         const { y, period } = forecastEtsPrep(ys, xs, seasonality);
-        const { alpha, beta, gamma, fitted } = fitHoltWinters(y, period, 0);
+        const { alpha, beta, gamma, fitted } = fitHoltWinters(y, period);
         // Excel STAT codes:
         //   1: alpha   2: beta   3: gamma   4: MASE
         //   5: SMAPE   6: MAE    7: RMSE    8: detected step size
@@ -18019,6 +18120,11 @@ const applyToArray$1 = (value, checkFn) => {
  * Get the number of values that evaluate to true and false.
  * Cast Number and "TRUE", "FALSE" to boolean.
  * Ignore unrelated values.
+ * An error value — a direct argument (`AND(1/0, FALSE)`) or a cell inside a
+ * reference — is the result, whatever the other arguments decide: Excel never
+ * short-circuits AND/OR/XOR past an error, and the first one in argument order
+ * wins (rowsncolumns/spreadsheet#642 B-08). `flattenParams` only throws error
+ * values itself when a value type is requested.
  * @ignore
  * @param {any[]} params
  * @return {number[]}
@@ -18026,6 +18132,8 @@ const applyToArray$1 = (value, checkFn) => {
 function getNumLogicalValue(params) {
     let numTrue = 0, numFalse = 0;
     H$4.flattenParams(params, null, true, (val, info) => {
+        if (val instanceof FormulaError)
+            throw val;
         const type = typeof val;
         if (type === "string") {
             // Text inside a reference or array is ignored; a direct text