@rowsncolumns/utils 9.2.39 → 9.2.41

package/dist/esm/formatter.js

@@ -1,5 +1,6 @@
 import { addLocale, format, formatColor, getFormatDateInfo, getLocale, isDateFormat, isTextFormat, } from "numfmt";
 import { IndexedColors } from "./colors";
+import { excelNumberPrePass, splitFormatSections, } from "./excel-number-format";
 /**
  * Pattern-based type inference (Excel parity). xlsx files routinely carry
  * a `numberFormat.pattern` without an accompanying `type` field — these
@@ -177,12 +178,287 @@ const localeForPattern = (pattern, locale) => {
     }
     return standalone ? (getStandaloneMonthLocale(locale) ?? locale) : locale;
 };
+const shortAmPmLocales = new Map();
+/**
+ * Excel's `A/P` renders one letter (`6:00 P`) in every locale, but numfmt
+ * honours the short form only when no locale is passed — under a locale it
+ * emits that locale's full designator (`6:00 PM`). Patterns with `A/P` render
+ * under a companion locale whose AM/PM designators are `A`/`P`. `locale` is a
+ * BCP 47 tag or an Excel LCID (`409`), as numfmt accepts both.
+ */
+const getShortAmPmLocale = (locale) => {
+    const cached = shortAmPmLocales.get(locale);
+    if (cached !== undefined)
+        return cached;
+    let overlay = locale;
+    try {
+        overlay = `ampm_${locale.replace(/[^a-z\d]/gi, "")}`;
+        addLocale({ ...(getLocale(locale) ?? {}), ampm: ["A", "P"] }, overlay);
+    }
+    catch {
+        overlay = locale;
+    }
+    shortAmPmLocales.set(locale, overlay);
+    return overlay;
+};
+/**
+ * An Excel `[$-LCID]` / `[$symbol-LCID]` token pins the section's locale, and
+ * numfmt resolves it to that LCID's own table — ahead of the companion locale
+ * `ssfFormat` passes, so `[$-409]h:mm A/P` would still render `6:00 PM`.
+ * Re-point a known LCID or tag at its companion (`$-409` → `$-ampm_409`); an
+ * LCID numfmt does not know (`F400`) or one carrying calendar bits stays as
+ * written.
+ */
+const shortAmPmLocaleToken = (token) => {
+    const dash = token.indexOf("-");
+    if (dash < 0)
+        return token;
+    const code = token.slice(dash + 1);
+    const wincode = Number.parseInt(code, 16);
+    if (Number.isFinite(wincode) && wincode & 0xff0000)
+        return token;
+    if (!getLocale(code))
+        return token;
+    return `${token.slice(0, dash + 1)}${getShortAmPmLocale(code)}`;
+};
+/**
+ * Does the pattern carry Excel's short `A/P` marker outside quoted literals,
+ * bracket directives and escapes? Returns the pattern with the marker
+ * upper-cased (Excel accepts `a/p` and renders it `A`/`P`; numfmt only
+ * tokenizes `A/P`) and its `[$-LCID]` tokens re-pointed at the companion
+ * `A`/`P` locale, or `undefined` when there is none.
+ */
+export const withShortAmPmMarker = (pattern) => {
+    const chunks = [];
+    const localeChunks = [];
+    let found = false;
+    let inQuotes = false;
+    let inBrackets = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (inQuotes) {
+            inQuotes = char !== '"';
+        }
+        else if (inBrackets) {
+            inBrackets = char !== "]";
+        }
+        else if (char === '"') {
+            inQuotes = true;
+        }
+        else if (char === "[") {
+            const end = pattern[i + 1] === "$" ? pattern.indexOf("]", i) : -1;
+            if (end > 0) {
+                localeChunks.push(chunks.length);
+                chunks.push(pattern.slice(i + 1, end));
+                i = end;
+                continue;
+            }
+            inBrackets = true;
+        }
+        else if (char === "\\" || char === "_" || char === "*") {
+            chunks.push(char + (pattern[i + 1] ?? ""));
+            i++;
+            continue;
+        }
+        else if ((char === "A" || char === "a") &&
+            pattern[i + 1] === "/" &&
+            (pattern[i + 2] === "P" || pattern[i + 2] === "p")) {
+            chunks.push("A/P");
+            found = true;
+            i += 2;
+            continue;
+        }
+        chunks.push(char);
+    }
+    if (!found)
+        return undefined;
+    for (const index of localeChunks) {
+        chunks[index] = `[${shortAmPmLocaleToken(chunks[index])}]`;
+    }
+    return chunks.join("");
+};
+const shortAmPmPatternCache = new Map();
+const DEFAULT_SEPARATORS = { decimal: ".", group: "," };
+const separatorsFor = (locale) => {
+    if (!locale)
+        return DEFAULT_SEPARATORS;
+    const l10n = getLocale(locale);
+    if (!l10n)
+        return DEFAULT_SEPARATORS;
+    return {
+        decimal: l10n.decimal ?? ".",
+        group: l10n.group ?? ",",
+    };
+};
+/**
+ * Rewrite the `[$symbol-LCID]` tokens of one section through `rewrite`,
+ * which receives the bracket content (`€-407`) and returns the new content,
+ * or an empty string to drop the token. Quoted literals, escapes and other
+ * bracket directives are left as written.
+ */
+const rewriteSectionLocaleTokens = (section, rewrite) => {
+    let out = "";
+    let inQuotes = false;
+    let inBrackets = false;
+    for (let i = 0; i < section.length; i++) {
+        const char = section[i];
+        if (inQuotes) {
+            inQuotes = char !== '"';
+        }
+        else if (inBrackets) {
+            inBrackets = char !== "]";
+        }
+        else if (char === '"') {
+            inQuotes = true;
+        }
+        else if (char === "[") {
+            const end = section[i + 1] === "$" ? section.indexOf("]", i) : -1;
+            if (end > 0) {
+                const token = rewrite(section.slice(i + 1, end));
+                if (token)
+                    out += `[${token}]`;
+                i = end;
+                continue;
+            }
+            inBrackets = true;
+        }
+        else if (char === "\\" || char === "_" || char === "*") {
+            out += char + (section[i + 1] ?? "");
+            i++;
+            continue;
+        }
+        out += char;
+    }
+    return out;
+};
+/** `[$€-407]` → `[$€]`; a bare `[$-407]` goes away. */
+const currencySymbolOnly = (token) => {
+    const dash = token.indexOf("-");
+    const symbol = dash < 0 ? token : token.slice(0, dash);
+    return symbol.length > 1 ? symbol : "";
+};
+const separatorLocales = new Map();
+/**
+ * Companion numfmt locale carrying `locale`'s calendar names and AM/PM with
+ * the workbook's decimal / group separators, so a date section pinned to
+ * `[$-407]` renders German names but a workbook decimal mark in `ss.00`.
+ * Returns `locale` itself when its separators already match.
+ */
+const getWorkbookSeparatorLocale = (locale, separators) => {
+    const key = `${locale}\u0000${separators.decimal}\u0000${separators.group}`;
+    const cached = separatorLocales.get(key);
+    if (cached !== undefined)
+        return cached;
+    let overlay = locale;
+    try {
+        const base = getLocale(locale);
+        if (base &&
+            (base.decimal !== separators.decimal || base.group !== separators.group)) {
+            // numfmt locale ids are `[a-z\d]+` with one optional `_` part.
+            const hex = (text) => [...text].map((c) => c.codePointAt(0).toString(16)).join("x");
+            overlay = `sep${hex(separators.decimal)}x${hex(separators.group)}_${locale.replace(/[^a-z\d]/gi, "")}`;
+            addLocale({ ...base, decimal: separators.decimal, group: separators.group }, overlay);
+        }
+    }
+    catch {
+        overlay = locale;
+    }
+    separatorLocales.set(key, overlay);
+    return overlay;
+};
+/**
+ * Re-point a date section's `[$symbol-LCID]` token at the companion locale
+ * with the workbook's separators (`$-407` → `$-sep2ex2c_407`). An LCID numfmt
+ * does not know or one carrying calendar bits stays as written.
+ */
+const workbookSeparatorLocaleToken = (separators) => (token) => {
+    const dash = token.indexOf("-");
+    if (dash < 0)
+        return token;
+    const code = token.slice(dash + 1);
+    const wincode = Number.parseInt(code, 16);
+    if (Number.isFinite(wincode) && wincode & 0xff0000)
+        return token;
+    if (!getLocale(code))
+        return token;
+    return `${token.slice(0, dash + 1)}${getWorkbookSeparatorLocale(code, separators)}`;
+};
+const isDateSection = (section) => {
+    try {
+        return isDateFormat(section);
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Excel's `[$symbol-LCID]` token selects the currency symbol and the
+ * language of day/month names and AM/PM; digit grouping and the decimal
+ * separator follow the workbook locale (`[$€-407] #,##0.00` is
+ * `€ 1,234.50` on a US host). numfmt applies the token's locale to the whole
+ * section, separators included, so the locale part is dropped from every
+ * section that is not a date (number, scientific, fraction, text, …); a
+ * date section keeps the token for its names, re-pointed at a companion
+ * locale that carries the workbook's separators for fractional seconds.
+ * Returns `undefined` when nothing had to change.
+ */
+export const withWorkbookSeparators = (pattern, locale) => {
+    if (!pattern.includes("[$"))
+        return undefined;
+    const sections = splitFormatSections(pattern);
+    let changed = false;
+    let dateTokens;
+    const rewritten = sections.map((section) => {
+        if (!section.includes("[$"))
+            return section;
+        let rewrite = currencySymbolOnly;
+        if (isDateSection(section)) {
+            dateTokens ??= workbookSeparatorLocaleToken(separatorsFor(locale));
+            rewrite = dateTokens;
+        }
+        const stripped = rewriteSectionLocaleTokens(section, rewrite);
+        changed ||= stripped !== section;
+        return stripped;
+    });
+    return changed ? rewritten.join(";") : undefined;
+};
+const workbookSeparatorPatternCache = new Map();
+const withWorkbookSeparatorsCached = (code, locale) => {
+    const key = `${locale ?? ""}\u0000${code}`;
+    let rewritten = workbookSeparatorPatternCache.get(key);
+    if (rewritten === undefined) {
+        rewritten = withWorkbookSeparators(code, locale) ?? code;
+        workbookSeparatorPatternCache.set(key, rewritten);
+    }
+    return rewritten;
+};
 export const ssfFormat = (pattern, value, locale) => {
     try {
+        let shortAmPm = shortAmPmPatternCache.get(pattern);
+        if (shortAmPm === undefined && !shortAmPmPatternCache.has(pattern)) {
+            shortAmPm = withShortAmPmMarker(pattern);
+            shortAmPmPatternCache.set(pattern, shortAmPm);
+        }
+        const code = withWorkbookSeparatorsCached(shortAmPm ?? pattern, locale);
+        let patternLocale = localeForPattern(pattern, locale);
+        if (shortAmPm !== undefined && patternLocale) {
+            patternLocale = getShortAmPmLocale(patternLocale);
+        }
+        const options = { locale: patternLocale };
+        if (typeof value === "number") {
+            // Excel decides rounding, `General`, huge magnitudes and conditional
+            // sections from the 15-significant-digit decimal, not the binary
+            // double (#546 U8 / U21).
+            const pre = excelNumberPrePass(code, value, separatorsFor(locale), (section, sectionValue) => format(section, sectionValue, options));
+            if (pre.text !== undefined) {
+                return pre.text;
+            }
+            value = pre.value;
+        }
         const isNegativeElapsedTime = typeof value === "number" &&
             value < 0 &&
             isSingleSectionElapsedTimePattern(pattern);
-        const formatted = format(pattern, isNegativeElapsedTime ? Math.abs(value) : value, { locale: localeForPattern(pattern, locale) });
+        const formatted = format(code, isNegativeElapsedTime ? Math.abs(value) : value, options);
         return isNegativeElapsedTime ? `-${formatted}` : formatted;
     }
     catch (err) {

package/dist/esm/index.d.ts

@@ -9,6 +9,7 @@ export * from "./locale";
 export * from "./date";
 export * from "./log";
 export * from "./array";
+export * from "./excel-number-format";
 export * from "./formatter";
 export * from "./memoize";
 export * from "./cell-data-helpers";
@@ -22,4 +23,5 @@ export * from "./data-validation";
 export * from "./content-hash";
 export * from "./shared-string-canonical";
 export * from "./keyboard";
+export * from "./sheet-span";
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC;AACtB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AACxB,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC"}

package/dist/esm/index.js

@@ -9,6 +9,7 @@ export * from "./locale";
 export * from "./date";
 export * from "./log";
 export * from "./array";
+export * from "./excel-number-format";
 export * from "./formatter";
 export * from "./memoize";
 export * from "./cell-data-helpers";
@@ -22,3 +23,4 @@ export * from "./data-validation";
 export * from "./content-hash";
 export * from "./shared-string-canonical";
 export * from "./keyboard";
+export * from "./sheet-span";

package/dist/esm/locale.d.ts

@@ -16,6 +16,21 @@ export declare const getLocaleDateParts: (locale: string) => [DatePartType, stri
  * de-DE → `d.m.yyyy`, hu-HU → `yyyy. mm. dd.`, en-CA → `yyyy-mm-dd`.
  */
 export declare const getDefaultDateFormat: (locale?: string) => string;
+export interface DateFieldTokens {
+    day: "d" | "dd";
+    month: "m" | "mm";
+    year: "yy" | "yyyy";
+}
+/**
+ * The day / month / year tokens of {@link getDefaultDateFormat} for a
+ * locale, i.e. whether the locale zero-pads each numeric field — ru-RU
+ * (`dd.mm.yyyy`) → `{ day: "dd", month: "mm", year: "yyyy" }`, en-US
+ * (`m/d/yyyy`) → `{ day: "d", month: "m", year: "yyyy" }`. A date typed
+ * as digits is displayed with the locale's own padding (Excel re-renders
+ * `30.9.2025` as `30.09.2025` under ru-RU), so the date parser assigns
+ * these tokens rather than echoing the padding the user happened to type.
+ */
+export declare const getDefaultDateFieldTokens: (locale?: string) => DateFieldTokens;
 /**
  * Default time pattern for a locale, honoring its 12/24-hour convention,
  * separators and hour padding — e.g. en-US → `h:mm:ss AM/PM`,

package/dist/esm/locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../locale.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,cAU5B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,GAAI,QAAQ,MAAM,qCAkC3D,CAAC;AAEF,eAAO,MAAM,kBAAkB,sDAAyC,CAAC;AAqFzE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAQ,MAA2B,WAClC,CAAC;AAuCvC;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAQ,MAA2B,EACnC,YAAW,QAAQ,GAAG,QAAmB,WACS,CAAC;AAErD,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,WAEvD,CAAC;AA2CF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAQ,MAA2B,WAClC,CAAC"}
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../locale.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,cAU5B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,GAAI,QAAQ,MAAM,qCAkC3D,CAAC;AAEF,eAAO,MAAM,kBAAkB,sDAAyC,CAAC;AAiGzE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAQ,MAA2B,WAClC,CAAC;AAEvC,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;IAChB,KAAK,EAAE,GAAG,GAAG,IAAI,CAAC;IAClB,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC;CACrB;AAwBD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAQ,MAA2B,KAClC,eAA4D,CAAC;AAuChE;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,SAAQ,MAA2B,EACnC,YAAW,QAAQ,GAAG,QAAmB,WACS,CAAC;AAErD,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,WAEvD,CAAC;AA2CF;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAQ,MAA2B,WAClC,CAAC"}

package/dist/esm/locale.js

@@ -105,9 +105,15 @@ const buildPatternFromParts = (parts, toToken) => {
     // trailing fields we skipped (e.g. an era) — trim stray whitespace.
     return pattern.trim();
 };
-const getDefaultDateFormatMemoized = memoize((locale) => {
+/**
+ * `formatToParts` of the locale's numeric short date for the sample
+ * instant — the single source both the default pattern and its per-field
+ * tokens are read from, so they can never disagree. Empty when Intl has
+ * no data for the locale.
+ */
+const getDefaultDateParts = memoize((locale) => {
     try {
-        const parts = new Intl.DateTimeFormat(locale, {
+        return new Intl.DateTimeFormat(locale, {
             calendar: "gregory",
             numberingSystem: "latn",
             year: "numeric",
@@ -115,13 +121,15 @@ const getDefaultDateFormatMemoized = memoize((locale) => {
             day: "numeric",
             timeZone: "UTC",
         }).formatToParts(FORMAT_SAMPLE_DATE);
-        const pattern = buildPatternFromParts(parts, dateFieldToken);
-        return pattern || "m/d/yyyy";
     }
     catch (err) {
-        return "m/d/yyyy";
+        return [];
     }
 });
+const getDefaultDateFormatMemoized = memoize((locale) => {
+    const pattern = buildPatternFromParts(getDefaultDateParts(locale), dateFieldToken);
+    return pattern || "m/d/yyyy";
+});
 /**
  * Default numeric (short) date pattern for a locale, preserving the
  * locale's field order, separators, literal text and zero-padding as
@@ -129,6 +137,35 @@ const getDefaultDateFormatMemoized = memoize((locale) => {
  * de-DE → `d.m.yyyy`, hu-HU → `yyyy. mm. dd.`, en-CA → `yyyy-mm-dd`.
  */
 export const getDefaultDateFormat = (locale = getCurrentLocale()) => getDefaultDateFormatMemoized(locale);
+const getDefaultDateFieldTokensMemoized = memoize((locale) => {
+    const tokens = { day: "d", month: "m", year: "yyyy" };
+    for (const part of getDefaultDateParts(locale)) {
+        switch (part.type) {
+            case "day":
+                tokens.day = part.value.length === 2 ? "dd" : "d";
+                break;
+            case "month":
+                tokens.month = part.value.length === 2 ? "mm" : "m";
+                break;
+            case "year":
+                tokens.year = part.value.length === 2 ? "yy" : "yyyy";
+                break;
+            default:
+                break;
+        }
+    }
+    return tokens;
+});
+/**
+ * The day / month / year tokens of {@link getDefaultDateFormat} for a
+ * locale, i.e. whether the locale zero-pads each numeric field — ru-RU
+ * (`dd.mm.yyyy`) → `{ day: "dd", month: "mm", year: "yyyy" }`, en-US
+ * (`m/d/yyyy`) → `{ day: "d", month: "m", year: "yyyy" }`. A date typed
+ * as digits is displayed with the locale's own padding (Excel re-renders
+ * `30.9.2025` as `30.09.2025` under ru-RU), so the date parser assigns
+ * these tokens rather than echoing the padding the user happened to type.
+ */
+export const getDefaultDateFieldTokens = (locale = getCurrentLocale()) => getDefaultDateFieldTokensMemoized(locale);
 const getDefaultTimeFormatMemoized = memoize((locale, precision) => {
     try {
         const parts = new Intl.DateTimeFormat(locale, {

package/dist/esm/sheet-span.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sheets covered by a 3-D reference span `first:last` (`Sheet1:Sheet3!A1`):
+ * every name between the two endpoints in tab order, inclusive. Excel spans
+ * the tabs between the endpoints whichever one is written first and matches
+ * sheet names case-insensitively. Returns undefined when an endpoint is not a
+ * sheet (the caller reports #REF!).
+ * @param sheetNames sheet names in tab order
+ * @param first
+ * @param last
+ * @returns
+ */
+export declare const resolveSheetSpan: (sheetNames: readonly string[], first: string, last: string) => string[] | undefined;
+//# sourceMappingURL=sheet-span.d.ts.map

package/dist/esm/sheet-span.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sheet-span.d.ts","sourceRoot":"","sources":["../../sheet-span.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GAC3B,YAAY,SAAS,MAAM,EAAE,EAC7B,OAAO,MAAM,EACb,MAAM,MAAM,KACX,MAAM,EAAE,GAAG,SAQb,CAAC"}

package/dist/esm/sheet-span.js

@@ -0,0 +1,20 @@
+/**
+ * Sheets covered by a 3-D reference span `first:last` (`Sheet1:Sheet3!A1`):
+ * every name between the two endpoints in tab order, inclusive. Excel spans
+ * the tabs between the endpoints whichever one is written first and matches
+ * sheet names case-insensitively. Returns undefined when an endpoint is not a
+ * sheet (the caller reports #REF!).
+ * @param sheetNames sheet names in tab order
+ * @param first
+ * @param last
+ * @returns
+ */
+export const resolveSheetSpan = (sheetNames, first, last) => {
+    const lower = sheetNames.map((name) => name.toLowerCase());
+    const start = lower.indexOf(first.toLowerCase());
+    const end = lower.indexOf(last.toLowerCase());
+    if (start === -1 || end === -1) {
+        return undefined;
+    }
+    return sheetNames.slice(Math.min(start, end), Math.max(start, end) + 1);
+};

package/dist/esm/tsconfig.esm.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../array.ts","../../cell-data-helpers.ts","../../color.ts","../../colors.ts","../../conditional-format.ts","../../content-hash.ts","../../data-validation.ts","../../date.ts","../../dom.ts","../../formatter.ts","../../formula-refs.ts","../../formula.ts","../../index.ts","../../keyboard.ts","../../locale.ts","../../log.ts","../../memoize.ts","../../numbers.ts","../../selection.ts","../../shared-string-canonical.ts","../../sort.ts","../../string.ts","../../table-styles.ts","../../typeguards.ts","../../uuid.ts","../../vitest.config.ts"],"version":"5.8.3"}
+{"root":["../../array.ts","../../cell-data-helpers.ts","../../color.ts","../../colors.ts","../../conditional-format.ts","../../content-hash.ts","../../data-validation.ts","../../date.ts","../../dom.ts","../../excel-number-format.ts","../../formatter.ts","../../formula-refs.ts","../../formula.ts","../../index.ts","../../keyboard.ts","../../locale.ts","../../log.ts","../../memoize.ts","../../numbers.ts","../../selection.ts","../../shared-string-canonical.ts","../../sheet-span.ts","../../sort.ts","../../string.ts","../../table-styles.ts","../../typeguards.ts","../../uuid.ts","../../vitest.config.ts"],"version":"5.8.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowsncolumns/utils",
-  "version": "9.2.39",
+  "version": "9.2.41",
   "author": "Vinay M",
   "license": "SEE LICENSE IN LICENSE.md",
   "main": "./dist/cjs/index.js",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "numfmt": "^3.2.2",
-    "@rowsncolumns/common-types": ">=5.2.30"
+    "@rowsncolumns/common-types": ">=5.2.32"
   },
   "devDependencies": {},
   "peerDependencies": {}