@rowsncolumns/fast-formula-parser 6.2.44 → 6.2.46

package/dist/esm/index.js

@@ -701,7 +701,9 @@ const excelNumberPrePass = (pattern, value, l10n, render) => {
     if (!info)
         return { value };
     if (info.kind === "date") {
-        if (info.isElapsed && sections.length === 1)
+        // A negative date or time — an elapsed `[h]:mm` duration included —
+        // shows `#######` in Excel's 1900 date system.
+        if (info.isElapsed && sections.length === 1 && value >= 0)
             return { value };
         if (value < 0 || value >= MAX_DATE_SERIAL_EXCLUSIVE) {
             return { text: DATE_OVERFLOW_DISPLAY, value };
@@ -716,6 +718,16 @@ const excelNumberPrePass = (pattern, value, l10n, render) => {
     if (index === 1 && value < 0 && pre.text === undefined && pre.value === 0) {
         return { text: render(sections[index], 0), value };
     }
+    // A one-section format keeps the minus of a negative that rounds to zero:
+    // Excel shows -0.4 in `0` as `-0` (and -0.004 in `0.00` as `-0.00`).
+    if (index === 0 &&
+        implicitSign &&
+        value < 0 &&
+        info.kind === "number" &&
+        pre.text === undefined &&
+        pre.value === 0) {
+        return { text: `-${render(sections[0], 0)}`, value };
+    }
     return pre;
 };
 
@@ -3801,6 +3813,500 @@ function isDateFormat (pattern) {
   return isDate(data.partitions);
 }
 
+/**
+ * East Asian number-format tokens `numfmt` does not render: the `[DBNum1]`–`[DBNum4]` numeral
+ * systems, the Japanese emperor-era tokens (`g`/`gg`/`ggg`, and `e`/`ee` under a Japanese locale)
+ * and the `aaa`/`aaaa` weekday tokens. TypeScript twin of the engine's Rust
+ * `rnc-cellmodel/src/cjk_format.rs` — keep the two in step.
+ *
+ * {@link prepareCjkNumberFormat} rewrites a format code so the base formatter can render it (era
+ * names, era years and weekday names become quoted literals computed from the date serial,
+ * `[DBNumN]` is removed, and under `[DBNumN]` a date's year becomes a quoted literal in that numeral
+ * system); `finish` then turns the remaining ASCII digits into the numeral system:
+ *
+ * - `General` and date fields read as a number with units (`123` → `百二十三`, `15日` → `十五日`);
+ * - digit placeholders (`0`, `#`) and years read digit by digit (`[DBNum1]0` → `一二三`).
+ *
+ * The language comes from the code's `[$-LCID]` / `[$-tag]` token, then the workbook locale, and
+ * defaults to Japanese.
+ */
+const DBNUM_TOKEN = /^\[dbnum([1-4])\]$/i;
+/** Cheap pre-filter: a `DBNum` token, a `g` (era name or `General`), `aaa`, or an `e` beside a locale token. */
+const mightContainTokens = (code) => /[gG]|dbnum|aaa/i.test(code) || (/[eE]/.test(code) && code.includes("[$"));
+const prepareCjkNumberFormat = (code, value, workbookLocale) => {
+    if (!mightContainTokens(code))
+        return undefined;
+    const tag = localeTag(code);
+    const tagLang = tag ? cjkLangOfTag(tag) : undefined;
+    const lang = tagLang ??
+        (workbookLocale ? cjkLangOfTag(workbookLocale) : undefined) ??
+        "ja";
+    const gannen = !!tag && tag.toLowerCase().includes("-x-gannen");
+    const date = serialToDate(value);
+    const sections = splitFormatSections(code);
+    const rewritten = [];
+    const levels = [];
+    const dated = [];
+    let changed = false;
+    for (const section of sections) {
+        const level = dbnumLevel(section);
+        const result = rewriteSection(section, {
+            dbnum: level === undefined ? undefined : { level, lang },
+            weekdayLang: lang,
+            eraYears: tagLang === "ja" || hasEraNameToken(section),
+            gannen,
+            date,
+        });
+        changed ||= result.changed || level !== undefined;
+        rewritten.push(result.text);
+        levels.push(level);
+        dated.push(result.dateToken);
+    }
+    if (!changed)
+        return undefined;
+    const anyCondition = sections.some((s) => analyzeFormatSection(s).hasCondition);
+    const index = anyCondition
+        ? 0
+        : Math.min(pickNumberSection(sections.length, value).index, sections.length - 1);
+    const level = levels[index];
+    const dbnum = level !== undefined && (level <= 3 || (level === 4 && lang === "ko"))
+        ? { level, lang }
+        : undefined;
+    let mode;
+    if (dated[index]) {
+        mode = "date";
+    }
+    else {
+        switch (analyzeFormatSection(stripDbNum(sections[index])).kind) {
+            case "general":
+                mode = "general";
+                break;
+            case "date":
+                mode = "date";
+                break;
+            case "number":
+            case "other":
+                mode = "digits";
+                break;
+            default:
+                mode = "unchanged";
+        }
+    }
+    return {
+        code: rewritten.join(";"),
+        finish: (out) => dbnum && mode !== "unchanged" ? convertDigits(out, dbnum, mode) : out,
+    };
+};
+const runLength = (chars, from, letter) => {
+    let n = 0;
+    while (from + n < chars.length && chars[from + n].toLowerCase() === letter)
+        n += 1;
+    return n;
+};
+const startsWithCi = (chars, from, word) => chars
+    .slice(from, from + word.length)
+    .join("")
+    .toLowerCase() === word;
+const quote = (text) => `"${text}"`;
+const rewriteSection = (section, ctx) => {
+    const chars = Array.from(section);
+    let out = "";
+    let changed = false;
+    let dateToken = false;
+    let i = 0;
+    while (i < chars.length) {
+        const c = chars[i];
+        const lower = c.toLowerCase();
+        if (c === '"') {
+            const close = chars.indexOf('"', i + 1);
+            const end = close === -1 ? chars.length : close + 1;
+            out += chars.slice(i, end).join("");
+            i = end;
+        }
+        else if (c === "\\" || c === "_" || c === "*") {
+            out += chars.slice(i, i + 2).join("");
+            i += 2;
+        }
+        else if (c === "[") {
+            const close = chars.indexOf("]", i);
+            const end = close === -1 ? chars.length : close + 1;
+            const token = chars.slice(i, end).join("");
+            if (DBNUM_TOKEN.test(token))
+                changed = true;
+            else
+                out += token;
+            i = end;
+        }
+        else if (lower === "g" && startsWithCi(chars, i, "general")) {
+            out += chars.slice(i, i + 7).join("");
+            i += 7;
+        }
+        else if (lower === "g") {
+            const run = runLength(chars, i, "g");
+            if (ctx.date) {
+                const era = eraOf(ctx.date);
+                out += quote(run === 1 ? era.letter : run === 2 ? era.short : era.name);
+            }
+            changed = true;
+            dateToken = true;
+            i += run;
+        }
+        else if (lower === "e" && chars[i + 1] !== "+" && chars[i + 1] !== "-") {
+            const run = runLength(chars, i, "e");
+            if (ctx.date && ctx.eraYears) {
+                const eraYear = ctx.date.year - eraOf(ctx.date).start[0] + 1;
+                const text = eraYear === 1 && ctx.gannen
+                    ? "元"
+                    : run >= 2
+                        ? String(eraYear).padStart(2, "0")
+                        : String(eraYear);
+                out += quote(text);
+                changed = true;
+                dateToken = true;
+            }
+            else if (ctx.date && ctx.dbnum) {
+                out += quote(perDigit(String(ctx.date.year), ctx.dbnum));
+                changed = true;
+                dateToken = true;
+            }
+            else {
+                out += chars.slice(i, i + run).join("");
+            }
+            i += run;
+        }
+        else if (lower === "a" && startsWithCi(chars, i, "am/pm")) {
+            out += chars.slice(i, i + 5).join("");
+            i += 5;
+        }
+        else if (lower === "a" && startsWithCi(chars, i, "a/p")) {
+            out += chars.slice(i, i + 3).join("");
+            i += 3;
+        }
+        else if (lower === "a" && runLength(chars, i, "a") >= 3) {
+            const run = runLength(chars, i, "a");
+            if (ctx.date)
+                out += quote(weekdayName(ctx.weekdayLang, ctx.date.weekday, run >= 4));
+            changed = true;
+            dateToken = true;
+            i += run;
+        }
+        else if (lower === "y" && ctx.dbnum && ctx.date) {
+            const run = runLength(chars, i, "y");
+            const digits = run <= 2
+                ? String(ctx.date.year % 100).padStart(2, "0")
+                : String(ctx.date.year);
+            out += quote(perDigit(digits, ctx.dbnum));
+            changed = true;
+            dateToken = true;
+            i += run;
+        }
+        else {
+            out += c;
+            i += 1;
+        }
+    }
+    return { text: out, changed, dateToken };
+};
+/** `[...]` tokens outside quoted literals and escapes. */
+const bracketTokens = (section) => {
+    const tokens = [];
+    let inQuotes = false;
+    for (let i = 0; i < section.length; i += 1) {
+        const c = section[i];
+        if (c === '"')
+            inQuotes = !inQuotes;
+        else if (!inQuotes && (c === "\\" || c === "_" || c === "*"))
+            i += 1;
+        else if (!inQuotes && c === "[") {
+            const end = section.indexOf("]", i);
+            if (end !== -1) {
+                tokens.push(section.slice(i, end + 1));
+                i = end;
+            }
+        }
+    }
+    return tokens;
+};
+const dbnumLevel = (section) => {
+    for (const token of bracketTokens(section)) {
+        const m = DBNUM_TOKEN.exec(token);
+        if (m)
+            return Number(m[1]);
+    }
+    return undefined;
+};
+const stripDbNum = (section) => bracketTokens(section)
+    .filter((t) => DBNUM_TOKEN.test(t))
+    .reduce((s, t) => s.replace(t, ""), section);
+/** Whether a section names an era (`g`) outside quotes, brackets and `General`. */
+const hasEraNameToken = (section) => {
+    let inQuotes = false;
+    let inBrackets = false;
+    for (let i = 0; i < section.length; i += 1) {
+        const c = section[i];
+        if (inQuotes)
+            inQuotes = c !== '"';
+        else if (inBrackets)
+            inBrackets = c !== "]";
+        else if (c === '"')
+            inQuotes = true;
+        else if (c === "[")
+            inBrackets = true;
+        else if (c === "\\" || c === "_" || c === "*")
+            i += 1;
+        else if (c.toLowerCase() === "g") {
+            if (section.slice(i, i + 7).toLowerCase() === "general")
+                i += 6;
+            else
+                return true;
+        }
+    }
+    return false;
+};
+/** The locale spec of the code's first `[$…-spec]` token (`411`, `ja-JP`, `ja-JP-x-gannen`). */
+const localeTag = (code) => {
+    const start = code.indexOf("[$");
+    if (start === -1)
+        return undefined;
+    const end = code.indexOf("]", start);
+    if (end === -1)
+        return undefined;
+    const inner = code.slice(start + 2, end);
+    const dash = inner.indexOf("-");
+    if (dash === -1)
+        return undefined;
+    const spec = inner.slice(dash + 1);
+    return spec || undefined;
+};
+/** Language of an LCID (hex, low 16 bits) or a BCP-47 tag, for the CJK locales. */
+const cjkLangOfTag = (input) => {
+    const spec = input.split(",")[0].trim();
+    if (/^[0-9a-f]+$/i.test(spec)) {
+        switch (parseInt(spec, 16) & 0xffff) {
+            case 0x0411:
+                return "ja";
+            case 0x0804:
+            case 0x1004:
+                return "zh-Hans";
+            case 0x0404:
+            case 0x0c04:
+            case 0x1404:
+                return "zh-Hant";
+            case 0x0412:
+                return "ko";
+            default:
+                return undefined;
+        }
+    }
+    const [primary, ...rest] = spec.toLowerCase().split(/[-_]/);
+    if (primary === "ja")
+        return "ja";
+    if (primary === "ko")
+        return "ko";
+    if (primary === "zh") {
+        return rest.some((p) => p === "hant" || p === "tw" || p === "hk" || p === "mo")
+            ? "zh-Hant"
+            : "zh-Hans";
+    }
+    return undefined;
+};
+// ---- dates ------------------------------------------------------------------------------------
+/**
+ * Excel 1900-system serial → calendar date, keeping Excel's fictitious 1900-02-29 (serial 60)
+ * and its weekday numbering (serial 1 is a Sunday). The time of day rounds to the nearest second.
+ */
+const serialToDate = (value) => {
+    if (!Number.isFinite(value) || value < 0 || value >= 2958466)
+        return undefined;
+    const days = Math.floor(Math.round(value * 86400) / 86400);
+    const weekday = (days + 6) % 7;
+    if (days === 60)
+        return { year: 1900, month: 2, day: 29, weekday };
+    const offset = days < 60 ? days : days - 1;
+    const d = new Date(Date.UTC(1899, 11, 31) + offset * 86400000);
+    return {
+        year: d.getUTCFullYear(),
+        month: d.getUTCMonth() + 1,
+        day: d.getUTCDate(),
+        weekday,
+    };
+};
+/** Japanese eras with the start dates Windows' Japanese calendar (and so Excel) uses. */
+const ERAS = [
+    { start: [1868, 1, 1], letter: "M", short: "明", name: "明治" },
+    { start: [1912, 7, 30], letter: "T", short: "大", name: "大正" },
+    { start: [1926, 12, 25], letter: "S", short: "昭", name: "昭和" },
+    { start: [1989, 1, 8], letter: "H", short: "平", name: "平成" },
+    { start: [2019, 5, 1], letter: "R", short: "令", name: "令和" },
+];
+const eraOf = (date) => {
+    const key = date.year * 10000 + date.month * 100 + date.day;
+    for (let i = ERAS.length - 1; i >= 0; i -= 1) {
+        const [y, m, d] = ERAS[i].start;
+        if (key >= y * 10000 + m * 100 + d)
+            return ERAS[i];
+    }
+    return ERAS[0];
+};
+const weekdayName = (lang, weekday, long) => {
+    const w = weekday % 7;
+    switch (lang) {
+        case "ja": {
+            const short = "日月火水木金土"[w];
+            return long ? `${short}曜日` : short;
+        }
+        case "ko": {
+            const short = "일월화수목금토"[w];
+            return long ? `${short}요일` : short;
+        }
+        default: {
+            const short = "日一二三四五六"[w];
+            return long ? `星期${short}` : short;
+        }
+    }
+};
+const KANJI = Array.from("〇一二三四五六七八九");
+const FULL_WIDTH = Array.from("０１２３４５６７８９");
+const BIG_HANS = ["万", "亿", "兆"];
+const BIG_TRAD = ["萬", "億", "兆"];
+const BIG_JA = ["万", "億", "兆"];
+const numerals = ({ level, lang }) => {
+    const zh = lang === "zh-Hans" || lang === "zh-Hant";
+    const level1Big = lang === "ja" ? BIG_JA : lang === "zh-Hans" ? BIG_HANS : BIG_TRAD;
+    if (level === 2) {
+        switch (lang) {
+            case "ja":
+                return {
+                    digits: Array.from("〇壱弐参四伍六七八九"),
+                    small: ["拾", "百", "阡"],
+                    big: BIG_TRAD,
+                    omitOne: false,
+                    fillZero: false,
+                };
+            case "zh-Hans":
+                return {
+                    digits: Array.from("零壹贰叁肆伍陆柒捌玖"),
+                    small: ["拾", "佰", "仟"],
+                    big: BIG_HANS,
+                    omitOne: false,
+                    fillZero: true,
+                };
+            case "zh-Hant":
+                return {
+                    digits: Array.from("零壹貳參肆伍陸柒捌玖"),
+                    small: ["拾", "佰", "仟"],
+                    big: BIG_TRAD,
+                    omitOne: false,
+                    fillZero: true,
+                };
+            case "ko":
+                return {
+                    digits: Array.from("零壹貳參四伍六七八九"),
+                    small: ["拾", "百", "阡"],
+                    big: BIG_TRAD,
+                    omitOne: false,
+                    fillZero: false,
+                };
+        }
+    }
+    if (level === 3) {
+        return {
+            digits: FULL_WIDTH,
+            small: ["十", "百", "千"],
+            big: level1Big,
+            omitOne: false,
+            fillZero: zh,
+        };
+    }
+    if (level === 4 && lang === "ko") {
+        return {
+            digits: Array.from("영일이삼사오육칠팔구"),
+            small: ["십", "백", "천"],
+            big: ["만", "억", "조"],
+            omitOne: true,
+            fillZero: false,
+        };
+    }
+    return {
+        digits: KANJI,
+        small: ["十", "百", "千"],
+        big: level1Big,
+        omitOne: !zh,
+        fillZero: zh,
+    };
+};
+const perDigit = (digits, dbnum) => {
+    const table = numerals(dbnum).digits;
+    return Array.from(digits)
+        .map((c) => (c >= "0" && c <= "9" ? table[Number(c)] : c))
+        .join("");
+};
+/** `digits` read as a number with units; past 兆 (≥ 10^16) digit by digit. */
+const withUnits = (digits, dbnum) => {
+    const n = numerals(dbnum);
+    const trimmed = digits.replace(/^0+/, "");
+    if (!trimmed)
+        return n.digits[0];
+    if (trimmed.length > 16)
+        return perDigit(digits, dbnum);
+    const values = Array.from(trimmed, Number);
+    const groups = Math.ceil(values.length / 4);
+    let out = "";
+    let pendingZero = false;
+    for (let g = 0; g < groups; g += 1) {
+        const groupIndex = groups - 1 - g;
+        const end = values.length - groupIndex * 4;
+        const group = values.slice(Math.max(0, end - 4), end);
+        let wrote = false;
+        group.forEach((d, k) => {
+            const pos = group.length - 1 - k;
+            if (d === 0) {
+                pendingZero ||= out.length > 0 || wrote;
+                return;
+            }
+            if (pendingZero && n.fillZero)
+                out += "零";
+            pendingZero = false;
+            if (!(d === 1 && pos > 0 && n.omitOne))
+                out += n.digits[d];
+            if (pos > 0)
+                out += n.small[pos - 1];
+            wrote = true;
+        });
+        if (wrote && groupIndex > 0)
+            out += n.big[groupIndex - 1];
+    }
+    return out;
+};
+const isAsciiDigit = (c) => !!c && c >= "0" && c <= "9";
+const convertDigits = (text, dbnum, mode) => {
+    const chars = Array.from(text);
+    let out = "";
+    let i = 0;
+    while (i < chars.length) {
+        if (!isAsciiDigit(chars[i])) {
+            out += chars[i];
+            i += 1;
+            continue;
+        }
+        let end = i;
+        while (end < chars.length && isAsciiDigit(chars[end]))
+            end += 1;
+        const run = chars.slice(i, end).join("");
+        const fraction = i >= 2 &&
+            (chars[i - 1] === "." || chars[i - 1] === ",") &&
+            isAsciiDigit(chars[i - 2]);
+        const units = mode === "date"
+            ? dbnum.level !== 3
+            : mode === "general"
+                ? !fraction
+                : false;
+        out += units ? withUnits(run, dbnum) : perDigit(run, dbnum);
+        i = end;
+    }
+    return out;
+};
+
 // Excel indexed colors mapping used for legacy color references
 const IndexedColors = Object.freeze([
     // 0-7
@@ -3877,35 +4383,44 @@ const IndexedColors = Object.freeze([
     "#333333",
 ]);
 
-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 names = Array.from({ length: 12 }, (_, month) => {
+        const parts = formatter.formatToParts(new Date(Date.UTC(2020, month, 1)));
+        const index = parts.findIndex((part) => part.type === "month");
+        const name = parts[index]?.value ?? "";
+        // A numeric month comes split from its counter ("1" + "月"); the CLDR
+        // name on its own (what the Rust engine renders) is "1月".
+        const next = parts[index + 1];
+        return /^\d+$/.test(name) && next?.type === "literal" && !/\d/.test(next.value)
+            ? name + next.value.trim()
+            : name;
+    });
+    // Beside a day, zh/ja write the month as a number ("3月15日") even where
+    // CLDR's `MMMM` on its own is a word (zh "三月"): take the standalone name.
+    if (options.day && names.every((name) => /^\d/.test(name))) {
+        return intlMonthNames(locale, { month: options.month });
+    }
+    return names;
 };
 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.
+ * Every locale renders from a numfmt locale built from Intl (CLDR) the way the
+ * Rust engine (the Excel reference, `rnc_cellmodel::locale_data`) builds its
+ * own: separators from `Intl.NumberFormat`, the in-date month and weekday
+ * names, and English `AM`/`PM` and `TRUE`/`FALSE` (numfmt's defaults), not
+ * numfmt's shipped tables (de `WAHR`, ja `午前`, en-GB `Sep`). A month shown
+ * without a day takes the standalone names (`getStandaloneMonthLocale`). Tags
+ * Intl 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;
@@ -3924,20 +4439,11 @@ const ensureNumfmtLocale = (locale) => {
                 .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") ?? ".",
@@ -3945,7 +4451,6 @@ const ensureNumfmtLocale = (locale) => {
             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);
     }
@@ -3953,6 +4458,31 @@ const ensureNumfmtLocale = (locale) => {
         // Malformed tag: numfmt keeps its own fallback.
     }
 };
+const scientificLocales = new Map();
+/**
+ * The Rust engine (ssfmt) renders a scientific mantissa with `.` in every
+ * locale (`1.00E+03` in de-DE), so an exponent section renders under a
+ * companion locale whose decimal separator is `.`.
+ */
+const getScientificLocale = (locale) => {
+    const cached = scientificLocales.get(locale);
+    if (cached !== undefined)
+        return cached;
+    let overlay = locale;
+    try {
+        const base = getLocale(locale);
+        if (base && base.decimal !== ".") {
+            overlay = `sci_${locale.replace(/[^a-z\d]/gi, "")}`;
+            addLocale({ ...base, decimal: "." }, overlay);
+        }
+    }
+    catch {
+        overlay = locale;
+    }
+    scientificLocales.set(locale, overlay);
+    return overlay;
+};
+const SCIENTIFIC_SECTION = /^(?:"[^"]*"|\[[^\]]*\]|\\.|[^"\[\\eE])*[eE][+-]/;
 const localeForPattern = (pattern, locale) => {
     return locale;
 };
@@ -4203,6 +4733,17 @@ const withWorkbookSeparatorsCached = (code, locale) => {
     return rewritten;
 };
 const ssfFormat = (pattern, value, locale) => {
+    // East Asian tokens numfmt does not render (`[DBNumN]`, Japanese era `g`/`e`,
+    // `aaa` weekdays): rewrite the code to plain literals, then convert the
+    // rendered digits to the `[DBNumN]` numeral system (see cjk-number-format).
+    if (typeof value === "number") {
+        const cjk = prepareCjkNumberFormat(pattern, value, locale);
+        if (cjk)
+            return cjk.finish(ssfFormatBase(cjk.code, value, locale));
+    }
+    return ssfFormatBase(pattern, value, locale);
+};
+function ssfFormatBase(pattern, value, locale, layout) {
     try {
         if (locale)
             ;
@@ -4211,12 +4752,25 @@ const ssfFormat = (pattern, value, locale) => {
             shortAmPm = withShortAmPmMarker(pattern);
             shortAmPmPatternCache.set(pattern, shortAmPm);
         }
-        const code = withWorkbookSeparatorsCached(shortAmPm ?? pattern, locale);
+        const baseCode = withWorkbookSeparatorsCached(shortAmPm ?? pattern, locale);
+        const code = layout ? layout.transform(baseCode) : baseCode;
         let patternLocale = localeForPattern(pattern, locale);
+        if (patternLocale && SCIENTIFIC_SECTION.test(pattern)) {
+            patternLocale = getScientificLocale(patternLocale);
+        }
         if (shortAmPm !== undefined && patternLocale) {
             patternLocale = getShortAmPmLocale(patternLocale);
         }
-        const options = { locale: patternLocale };
+        // numfmt types `fillChar` / `skipChar` as booleans; at runtime they are
+        // the marker strings it emits ahead of the fill / skip character.
+        const options = layout
+            ? {
+                locale: patternLocale,
+                nbsp: layout.nbsp,
+                fillChar: layout.fillChar,
+                skipChar: layout.skipChar,
+            }
+            : { locale: patternLocale };
         if (typeof value === "number") {
             // Excel decides rounding, `General`, huge magnitudes and conditional
             // sections from the 15-significant-digit decimal, not the binary
@@ -4227,16 +4781,12 @@ const ssfFormat = (pattern, value, locale) => {
             }
             value = pre.value;
         }
-        const isNegativeElapsedTime = typeof value === "number" &&
-            value < 0 &&
-            isSingleSectionElapsedTimePattern(pattern);
-        const formatted = format(code, isNegativeElapsedTime ? Math.abs(value) : value, options);
-        return isNegativeElapsedTime ? `-${formatted}` : formatted;
+        return format(code, value, options);
     }
     catch (err) {
-        return String(value);
+        return layout ? undefined : String(value);
     }
-};
+}
 for (let n = 1; n <= 56; n++) {
     IndexedColors[n + 7];
 }
@@ -4429,6 +4979,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "ZWEIFAKULTÄT",
             "FALSE": "FALSCH",
             "FDIST": "FVERT",
+            "FIELDVALUE": "FELDWERT",
             "FILTER": "FILTER",
             "FILTERXML": "XMLFILTERN",
             "FIND": "FINDEN",
@@ -4492,6 +5043,8 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "IMLN",
             "IMLOG10": "IMLOG10",
             "IMLOG2": "IMLOG2",
+            "IMPORTCSV": "IMPORTCSV",
+            "IMPORTTEXT": "IMPORTTEXT",
             "IMPOWER": "IMAPOTENZ",
             "IMPRODUCT": "IMPRODUKT",
             "IMREAL": "IMREALTEIL",
@@ -4629,6 +5182,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "PRODUKT",
             "PROPER": "GROSS2",
             "PV": "BW",
+            "PY": "PY",
             "QUARTILE": "QUARTILE",
             "QUARTILE.EXC": "QUARTILE.EXKL",
             "QUARTILE.INC": "QUARTILE.INKL",
@@ -4998,6 +5552,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "FACT.DOBLE",
             "FALSE": "FALSO",
             "FDIST": "DISTR.F",
+            "FIELDVALUE": "VALORCAMPO",
             "FILTER": "FILTRAR",
             "FILTERXML": "XMLFILTRO",
             "FIND": "ENCONTRAR",
@@ -5062,6 +5617,8 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "IM.LN",
             "IMLOG10": "IM.LOG10",
             "IMLOG2": "IM.LOG2",
+            "IMPORTCSV": "IMPORTCSV",
+            "IMPORTTEXT": "IMPORTTEXT",
             "IMPOWER": "IM.POT",
             "IMPRODUCT": "IM.PRODUCT",
             "IMREAL": "IM.REAL",
@@ -5199,6 +5756,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "PRODUCTO",
             "PROPER": "NOMPROPIO",
             "PV": "VA",
+            "PY": "PY",
             "QUARTILE": "CUARTIL",
             "QUARTILE.EXC": "CUARTIL.EXC",
             "QUARTILE.INC": "CUARTIL.INC",
@@ -5551,6 +6109,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "FACTDOUBLE",
             "FALSE": "FAUX",
             "FDIST": "LOI.F",
+            "FIELDVALUE": "VALEURCHAMP",
             "FILTER": "FILTRE",
             "FILTERXML": "FILTRE.XML",
             "FIND": "TROUVE",
@@ -5615,6 +6174,8 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "COMPLEXE.LN",
             "IMLOG10": "COMPLEXE.LOG10",
             "IMLOG2": "COMPLEXE.LOG2",
+            "IMPORTCSV": "IMPORTCSV",
+            "IMPORTTEXT": "IMPORTTEXT",
             "IMPOWER": "COMPLEXE.PUISSANCE",
             "IMPRODUCT": "COMPLEXE.PRODUIT",
             "IMREAL": "COMPLEXE.REEL",
@@ -5750,6 +6311,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "PRODUIT",
             "PROPER": "NOMPROPRE",
             "PV": "VA",
+            "PY": "PY",
             "QUARTILE": "QUARTILE",
             "QUARTILE.EXC": "QUARTILE.EXCLURE",
             "QUARTILE.INC": "QUARTILE.INCLURE",
@@ -6101,6 +6663,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "FATT.DOPPIO",
             "FALSE": "FALSO",
             "FDIST": "DISTRIB.F",
+            "FIELDVALUE": "VALORECAMPO",
             "FILTER": "FILTER",
             "FILTERXML": "FILTRO.XML",
             "FIND": "TROVA",
@@ -6165,6 +6728,7 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "COMP.LN",
             "IMLOG10": "COMP.LOG10",
             "IMLOG2": "COMP.LOG2",
+            "IMPORTTEXT": "IMPORTTEXT",
             "IMPOWER": "COMP.POTENZA",
             "IMPRODUCT": "COMP.PRODOTTO",
             "IMREAL": "COMP.PARTE.REALE",
@@ -6302,6 +6866,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "PRODOTTO",
             "PROPER": "MAIUSC.INIZ",
             "PV": "VA",
+            "PY": "PY",
             "QUARTILE": "QUARTILE",
             "QUARTILE.EXC": "ESC.QUARTILE",
             "QUARTILE.INC": "INC.QUARTILE",
@@ -6460,6 +7025,7 @@ const FORMULA_LOCALE_DATA = {
         },
         "uncertain": [
             "FINDB",
+            "IMPORTCSV",
             "JIS",
             "LEFTB",
             "LENB",
@@ -6662,6 +7228,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "DUBBELE.FACULTEIT",
             "FALSE": "ONWAAR",
             "FDIST": "F.VERDELING",
+            "FIELDVALUE": "VELDWAARDE",
             "FILTER": "FILTER",
             "FILTERXML": "XML.FILTEREN",
             "FIND": "VIND.ALLES",
@@ -6726,6 +7293,7 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "C.LN",
             "IMLOG10": "C.LOG10",
             "IMLOG2": "C.LOG2",
+            "IMPORTCSV": "IMPORTCSV",
             "IMPOWER": "C.MACHT",
             "IMPRODUCT": "C.PRODUCT",
             "IMREAL": "C.REEEL.DEEL",
@@ -6863,6 +7431,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "PRODUCT",
             "PROPER": "BEGINLETTERS",
             "PV": "HW",
+            "PY": "PY",
             "QUARTILE": "KWARTIEL",
             "QUARTILE.EXC": "KWARTIEL.EXC",
             "QUARTILE.INC": "KWARTIEL.INC",
@@ -7024,6 +7593,7 @@ const FORMULA_LOCALE_DATA = {
         },
         "uncertain": [
             "FINDB",
+            "IMPORTTEXT",
             "JIS",
             "LEFTB",
             "LENB",
@@ -7216,6 +7786,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "SILNIA.DWUKR",
             "FALSE": "FAŁSZ",
             "FDIST": "ROZKŁAD.F",
+            "FIELDVALUE": "POLE.WARTOŚĆ",
             "FILTER": "FILTER",
             "FILTERXML": "FILTERXML",
             "FIND": "ZNAJDŹ",
@@ -7280,6 +7851,7 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "LN.LICZBY.ZESP",
             "IMLOG10": "LOG10.LICZBY.ZESP",
             "IMLOG2": "LOG2.LICZBY.ZESP",
+            "IMPORTCSV": "IMPORTCSV",
             "IMPOWER": "POTĘGA.LICZBY.ZESP",
             "IMPRODUCT": "ILOCZYN.LICZB.ZESP",
             "IMREAL": "CZ.RZECZ.LICZBY.ZESP",
@@ -7418,6 +7990,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "ILOCZYN",
             "PROPER": "Z.WIELKIEJ.LITERY",
             "PV": "PV",
+            "PY": "PY",
             "QUARTILE": "KWARTYL",
             "QUARTILE.EXC": "KWARTYL.PRZEDZ.OTW",
             "QUARTILE.INC": "KWARTYL.PRZEDZ.ZAMK",
@@ -7579,6 +8152,7 @@ const FORMULA_LOCALE_DATA = {
         },
         "uncertain": [
             "FINDB",
+            "IMPORTTEXT",
             "LEFTB",
             "LENB",
             "MIDB",
@@ -7770,6 +8344,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "FATDUPLO",
             "FALSE": "FALSO",
             "FDIST": "DISTF",
+            "FIELDVALUE": "VALORDOCAMPO",
             "FILTER": "FILTRAR",
             "FILTERXML": "FILTRARXML",
             "FIND": "LOCALIZAR",
@@ -7834,6 +8409,7 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "IMLN",
             "IMLOG10": "IMLOG10",
             "IMLOG2": "IMLOG2",
+            "IMPORTCSV": "IMPORTCSV",
             "IMPOWER": "IMPOT",
             "IMPRODUCT": "IMPROD",
             "IMREAL": "IMREAL",
@@ -7971,6 +8547,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "PRODUTO",
             "PROPER": "INICIAL.MAIÚSCULA",
             "PV": "VA",
+            "PY": "PY",
             "QUARTILE": "QUARTIL",
             "QUARTILE.EXC": "QUARTIL.EXC",
             "QUARTILE.INC": "QUARTIL.INC",
@@ -8130,6 +8707,7 @@ const FORMULA_LOCALE_DATA = {
         },
         "uncertain": [
             "FINDB",
+            "IMPORTTEXT",
             "JIS",
             "LEFTB",
             "LENB",
@@ -8322,6 +8900,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "FATDUPLO",
             "FALSE": "FALSO",
             "FDIST": "DISTF",
+            "FIELDVALUE": "VALORCAMPO",
             "FILTER": "FILTRO",
             "FILTERXML": "FILTROXML",
             "FIND": "PROCURAR",
@@ -8386,6 +8965,8 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "IMLN",
             "IMLOG10": "IMLOG10",
             "IMLOG2": "IMLOG2",
+            "IMPORTCSV": "IMPORTCSV",
+            "IMPORTTEXT": "IMPORTTEXT",
             "IMPOWER": "IMPOT",
             "IMPRODUCT": "IMPROD",
             "IMREAL": "IMREAL",
@@ -8522,6 +9103,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "MULT",
             "PROPER": "PRI.MAIÚSCULA",
             "PV": "VP",
+            "PY": "PY",
             "QUARTILE": "QUARTIL",
             "QUARTILE.EXC": "QUARTIL.EXC",
             "QUARTILE.INC": "QUARTIL.INC",
@@ -8864,6 +9446,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "ДВФАКТР",
             "FALSE": "ЛОЖЬ",
             "FDIST": "FРАСП",
+            "FIELDVALUE": "ЗНАЧПОЛЯ",
             "FILTER": "ФИЛЬТР",
             "FILTERXML": "ФИЛЬТР.XML",
             "FIND": "НАЙТИ",
@@ -8929,6 +9512,7 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "МНИМ.LN",
             "IMLOG10": "МНИМ.LOG10",
             "IMLOG2": "МНИМ.LOG2",
+            "IMPORTCSV": "IMPORTCSV",
             "IMPOWER": "МНИМ.СТЕПЕНЬ",
             "IMPRODUCT": "МНИМ.ПРОИЗВЕД",
             "IMREAL": "МНИМ.ВЕЩ",
@@ -9070,6 +9654,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "ПРОИЗВЕД",
             "PROPER": "ПРОПНАЧ",
             "PV": "ПС",
+            "PY": "PY",
             "QUARTILE": "КВАРТИЛЬ",
             "QUARTILE.EXC": "КВАРТИЛЬ.ИСКЛ",
             "QUARTILE.INC": "КВАРТИЛЬ.ВКЛ",
@@ -9234,6 +9819,7 @@ const FORMULA_LOCALE_DATA = {
             "#VALUE!": "#ЗНАЧ!"
         },
         "uncertain": [
+            "IMPORTTEXT",
             "SINGLE"
         ]
     },
@@ -9419,6 +10005,7 @@ const FORMULA_LOCALE_DATA = {
             "FACTDOUBLE": "ÇİFTFAKTÖR",
             "FALSE": "YANLIŞ",
             "FDIST": "FDAĞ",
+            "FIELDVALUE": "FIELDVALUE",
             "FILTER": "FİLTRE",
             "FILTERXML": "XMLFİLTRELE",
             "FIND": "BUL",
@@ -9483,6 +10070,7 @@ const FORMULA_LOCALE_DATA = {
             "IMLN": "SANLN",
             "IMLOG10": "SANLOG10",
             "IMLOG2": "SANLOG2",
+            "IMPORTCSV": "IMPORTCSV",
             "IMPOWER": "SANKUVVET",
             "IMPRODUCT": "SANÇARP",
             "IMREAL": "SANGERÇEK",
@@ -9621,6 +10209,7 @@ const FORMULA_LOCALE_DATA = {
             "PRODUCT": "ÇARPIM",
             "PROPER": "YAZIM.DÜZENİ",
             "PV": "BD",
+            "PY": "PY",
             "QUARTILE": "DÖRTTEBİRLİK",
             "QUARTILE.EXC": "DÖRTTEBİRLİK.HRC",
             "QUARTILE.INC": "DÖRTTEBİRLİK.DHL",
@@ -9781,6 +10370,7 @@ const FORMULA_LOCALE_DATA = {
         },
         "uncertain": [
             "FINDB",
+            "IMPORTTEXT",
             "LEFTB",
             "LENB",
             "MIDB",
@@ -31546,6 +32136,19 @@ const unavailable = () => {
   throw FormulaError.NA;
 };
 
+// The file imports (IMPORTTEXT, IMPORTCSV) and Python in Excel (PY) need a capability this engine
+// blocks (local files, a Python runtime): Excel reports that as #BLOCKED!. Linked data type fields
+// (FIELDVALUE, and `_FV` — `A1.Price` as a workbook file stores it) have no linked data types to
+// read here: #FIELD!, as Excel answers for a field the value does not have. Same answers as the
+// rnc engine (formualizer `builtins/external.rs`), so these are never #NAME? on either engine
+// (demo-app-monorepo#49969 FX-15).
+const blocked = () => {
+  throw FormulaError.BLOCKED;
+};
+const noField = () => {
+  throw FormulaError.FIELD;
+};
+
 const ExternalFunctions = {
   CUBEKPIMEMBER: unavailable,
   CUBEMEMBER: unavailable,
@@ -31562,6 +32165,11 @@ const ExternalFunctions = {
   TRANSLATE: unavailable,
   DETECTLANGUAGE: unavailable,
   QUERY: unavailable,
+  IMPORTTEXT: blocked,
+  IMPORTCSV: blocked,
+  PY: blocked,
+  FIELDVALUE: noField,
+  _FV: noField,
 };
 
 var api$3 = {};
@@ -53227,6 +53835,11 @@ class FormulaParser {
     );
     this.onRange = config.onRange;
     this.onCell = config.onCell;
+    // Observer of every cell / range the evaluation actually reads, with the
+    // cell being evaluated. `INDIRECT` / `OFFSET` targets only exist at run
+    // time, so this is how a host learns the dynamic precedents of a formula
+    // (the dependency parser cannot see them).
+    this.onReferenceResolved = config.onReferenceResolved;
     // Optional host callback reporting row visibility for SUBTOTAL:
     // ({sheet, row}) => {hiddenByFilter?: boolean, hiddenByUser?: boolean}
     this.onRowHidden = config.onRowHidden;
@@ -53376,18 +53989,36 @@ class FormulaParser {
         const bounds = this.onSpilledRange(ref);
         if (bounds instanceof FormulaError) return bounds;
         if (bounds && bounds.from && bounds.to) {
-          return this.onRange({
+          const spilled = {
             from: bounds.from,
             to: bounds.to,
             sheet: bounds.sheet ?? ref.sheet,
-          });
+          };
+          this.noteReferenceResolved("range", spilled, finalPosition);
+          return this.onRange(spilled);
         }
       }
       return FormulaError.REF;
     }
+    this.noteReferenceResolved("cell", ref, finalPosition);
     return this.onCell(ref);
   }
 
+  /**
+   * Tell the host which reference an evaluation is about to read.
+   * @param {"cell"|"range"} kind
+   * @param ref - the resolved reference (sheet already defaulted)
+   * @param position - the cell being evaluated, when known
+   */
+  noteReferenceResolved(kind, ref, position) {
+    if (typeof this.onReferenceResolved !== "function") return;
+    try {
+      this.onReferenceResolved({ kind, ref, position });
+    } catch {
+      // An observer must never break the evaluation.
+    }
+  }
+
   /**
    * Get values from the range reference.
    * @param ref
@@ -53402,6 +54033,7 @@ class FormulaParser {
     if (ref.sheetEnd != null) {
       return this.get3DRange(ref, true);
     }
+    this.noteReferenceResolved("range", ref, finalPosition);
     return this.onRange(ref);
   }
 
@@ -53438,6 +54070,11 @@ class FormulaParser {
     for (const sheet of sheets) {
       const { sheetEnd: _ignored, ...perSheet } = ref;
       perSheet.sheet = sheet;
+      this.noteReferenceResolved(
+        isRange ? "range" : "cell",
+        perSheet,
+        this.position,
+      );
       const value = isRange ? this.onRange(perSheet) : this.onCell(perSheet);
       if (value instanceof FormulaError) return value;
       if (Array.isArray(value)) {