@rowsncolumns/utils 9.5.6 → 9.6.1

package/dist/esm/data-validation.js

@@ -1,4 +1,5 @@
 import { escapeConditionFormulaText, normalizeConditionOperand, } from "./condition-operand";
+import { checkIfStringIsReference } from "./selection";
 const FORMULA_PREDICATE_BASE_CELL_REF = "A1";
 /**
  * A leading apostrophe in a data-validation / conditional-format list entry is
@@ -6,6 +7,52 @@ const FORMULA_PREDICATE_BASE_CELL_REF = "A1";
  * text — never part of the value itself.
  */
 export const stripDataValidationTextPrefix = (entry) => entry.startsWith("'") ? entry.slice(1) : entry;
+/**
+ * A `ONE_OF_LIST` value that is a SOURCE FORMULA rather than literal items,
+ * returned trimmed with its leading `=` (`=RegionList`, `=$A$2:$A$9`,
+ * `=Sheet2!A1:A5`, `=INDIRECT("…")`). Excel's List type has one Source box
+ * that takes either literal items (`Yes,No`) or a formula starting with `=`;
+ * the "Dropdown" (`ONE_OF_LIST`) / "Dropdown (from a range)" (`ONE_OF_RANGE`)
+ * split means a `=…` typed into the literal dropdown is read the way Excel
+ * reads it — as a `ONE_OF_RANGE` over that source. A quoted literal
+ * (`"=a,b"`, Excel's quoted list), a `=` inside a later item (`a,=b`) and a
+ * bare `=` stay literal. Rust twin: `rnc_model::validation::one_of_list_formula_source`.
+ */
+export const getDataValidationListFormulaSource = (value) => {
+    const trimmed = (value ?? "").trim();
+    return trimmed.startsWith("=") && trimmed.slice(1).trim()
+        ? trimmed
+        : undefined;
+};
+/**
+ * The condition type a rule behaves as: a `ONE_OF_LIST` whose first value is
+ * a source formula (`getDataValidationListFormulaSource`) behaves as
+ * `ONE_OF_RANGE`; every other condition is its own type. Rust twin:
+ * `rnc_model::validation::effective_condition_kind`.
+ */
+export const getEffectiveDataValidationConditionType = (condition) => condition?.type === "ONE_OF_LIST" &&
+    getDataValidationListFormulaSource(condition.values?.[0]?.userEnteredValue)
+    ? "ONE_OF_RANGE"
+    : condition?.type ?? undefined;
+/**
+ * The reference a list rule draws its options from, or `undefined` when the
+ * rule is a literal item list (or not a list rule at all). `ONE_OF_RANGE` is
+ * always a reference (its value, `""` when missing); a `ONE_OF_LIST` is one
+ * when its value is a source formula (`=RegionList`) or a bare A1 reference
+ * (`$A$1:$A$5`). Shared by the dropdown options, the commit gate and
+ * `checkBooleanRule`, so the three always agree.
+ */
+export const getDataValidationListReference = (condition) => {
+    const firstValue = condition?.values?.[0]?.userEnteredValue;
+    if (getEffectiveDataValidationConditionType(condition) === "ONE_OF_RANGE") {
+        return getDataValidationListFormulaSource(firstValue) ?? firstValue ?? "";
+    }
+    if (condition?.type === "ONE_OF_LIST" &&
+        checkIfStringIsReference(firstValue)) {
+        return firstValue;
+    }
+    return undefined;
+};
 /**
  * Whether a cell's current text matches a ONE_OF_LIST option, with Excel's
  * text-prefix semantics on BOTH sides: the option strips its leading `'`
@@ -80,20 +127,23 @@ export const buildDataValidationExpression = (rule, baseCellRef, locale) => {
 };
 const buildDataValidationConditionExpression = (rule, baseCellRef, locale) => {
     const condition = rule?.condition;
-    if (!condition?.type)
+    // A ONE_OF_LIST whose value is a source formula (`=RegionList`) compiles as
+    // the ONE_OF_RANGE over that source, as Excel's List type reads it.
+    const type = getEffectiveDataValidationConditionType(condition);
+    if (!condition || !type)
         return undefined;
     const values = condition.values ?? [];
     const fromRaw = values[0]?.userEnteredValue;
     const toRaw = values[1]?.userEnteredValue;
-    if (condition.type === "CUSTOM_FORMULA") {
+    if (type === "CUSTOM_FORMULA") {
         const raw = fromRaw ?? "";
         const trimmed = raw.trim();
         if (!trimmed)
             return undefined;
         return trimmed.startsWith("=") ? trimmed : `=${trimmed}`;
     }
-    const fromExpr = normalizeConditionOperand(fromRaw, condition.type, locale);
-    const toExpr = normalizeConditionOperand(toRaw, condition.type, locale);
+    const fromExpr = normalizeConditionOperand(fromRaw, type, locale);
+    const toExpr = normalizeConditionOperand(toRaw, type, locale);
     if (!fromExpr && !toExpr)
         return undefined;
     const comparisonOperatorMap = {
@@ -112,51 +162,49 @@ const buildDataValidationConditionExpression = (rule, baseCellRef, locale) => {
         TEXT_EQ: "=",
         TEXT_NOT_EQ: "<>",
     };
-    if (condition.type === "NUMBER_BETWEEN" ||
-        condition.type === "DATE_BETWEEN") {
+    if (type === "NUMBER_BETWEEN" || type === "DATE_BETWEEN") {
         if (!fromExpr || !toExpr)
             return undefined;
         return `=AND(${baseCellRef}>=${fromExpr},${baseCellRef}<=${toExpr})`;
     }
-    if (condition.type === "NUMBER_NOT_BETWEEN" ||
-        condition.type === "DATE_NOT_BETWEEN") {
+    if (type === "NUMBER_NOT_BETWEEN" || type === "DATE_NOT_BETWEEN") {
         if (!fromExpr || !toExpr)
             return undefined;
         return `=OR(${baseCellRef}<${fromExpr},${baseCellRef}>${toExpr})`;
     }
-    const comparisonOperator = comparisonOperatorMap[condition.type];
+    const comparisonOperator = comparisonOperatorMap[type];
     if (comparisonOperator) {
         if (!fromExpr)
             return undefined;
         return `=${baseCellRef}${comparisonOperator}${fromExpr}`;
     }
-    if (condition.type === "TEXT_CONTAINS") {
+    if (type === "TEXT_CONTAINS") {
         if (!fromExpr)
             return undefined;
         return `=ISNUMBER(SEARCH(${fromExpr},${baseCellRef}))`;
     }
-    if (condition.type === "TEXT_NOT_CONTAINS") {
+    if (type === "TEXT_NOT_CONTAINS") {
         if (!fromExpr)
             return undefined;
         return `=NOT(ISNUMBER(SEARCH(${fromExpr},${baseCellRef})))`;
     }
-    if (condition.type === "TEXT_STARTS_WITH") {
+    if (type === "TEXT_STARTS_WITH") {
         if (!fromExpr)
             return undefined;
         return `=LEFT(${baseCellRef},LEN(${fromExpr}))=${fromExpr}`;
     }
-    if (condition.type === "TEXT_ENDS_WITH") {
+    if (type === "TEXT_ENDS_WITH") {
         if (!fromExpr)
             return undefined;
         return `=RIGHT(${baseCellRef},LEN(${fromExpr}))=${fromExpr}`;
     }
-    if (condition.type === "TEXT_IS_EMAIL") {
+    if (type === "TEXT_IS_EMAIL") {
         return `=ISNUMBER(SEARCH("@",${baseCellRef}))`;
     }
-    if (condition.type === "TEXT_IS_URL") {
+    if (type === "TEXT_IS_URL") {
         return `=OR(LEFT(${baseCellRef},7)="http://",LEFT(${baseCellRef},8)="https://")`;
     }
-    if (condition.type === "ONE_OF_RANGE") {
+    if (type === "ONE_OF_RANGE") {
         if (!fromExpr)
             return undefined;
         if (rule?.allowBlank) {
@@ -164,7 +212,7 @@ const buildDataValidationConditionExpression = (rule, baseCellRef, locale) => {
         }
         return `=COUNTIF(${fromExpr},${baseCellRef})>0`;
     }
-    if (condition.type === "ONE_OF_LIST") {
+    if (type === "ONE_OF_LIST") {
         const entries = fromRaw
             ? fromRaw.split(",").map((entry) => entry.trim())
             : [];
@@ -181,10 +229,14 @@ const buildDataValidationConditionExpression = (rule, baseCellRef, locale) => {
                     ? [textCondition, `${baseCellRef}="'"`]
                     : [textCondition];
             }
+            // A list ITEM is never a formula (a source formula is the whole value,
+            // see `getEffectiveDataValidationConditionType`): `"=a,b"` and `a,=b`
+            // list the text `=a` / `=b`.
+            if (entry.startsWith("=")) {
+                return [`${baseCellRef}="${escapeConditionFormulaText(entry)}"`];
+            }
             return entry
-                ? [
-                    `${baseCellRef}=${normalizeConditionOperand(entry, condition.type, locale)}`,
-                ]
+                ? [`${baseCellRef}=${normalizeConditionOperand(entry, type, locale)}`]
                 : [];
         })
             .filter((entry) => Boolean(entry));
@@ -194,13 +246,13 @@ const buildDataValidationConditionExpression = (rule, baseCellRef, locale) => {
             ? `=${conditions[0]}`
             : `=OR(${conditions.join(",")})`;
     }
-    if (condition.type === "BLANK") {
+    if (type === "BLANK") {
         return `=${baseCellRef}=""`;
     }
-    if (condition.type === "NOT_BLANK") {
+    if (type === "NOT_BLANK") {
         return `=${baseCellRef}<>""`;
     }
-    if (condition.type === "BOOLEAN") {
+    if (type === "BOOLEAN") {
         return `=OR(${baseCellRef}=TRUE,${baseCellRef}=FALSE)`;
     }
     return undefined;

package/dist/esm/formatter.d.ts

@@ -44,5 +44,47 @@ export declare const withShortAmPmMarker: (pattern: string) => string | undefine
  */
 export declare const withWorkbookSeparators: (pattern: string, locale?: string) => string | undefined;
 export declare const ssfFormat: (pattern: string, value: any, locale?: string) => string;
+/**
+ * One piece of a number format's width-aware output (see
+ * {@link ssfFormatLayout}):
+ *  - `text` — literal characters, painted as they are;
+ *  - `fill` — Excel's `*x`: `x` repeated to fill the cell's free width;
+ *  - `skip` — Excel's `_x`: blank space as wide as the glyph `x`;
+ *  - `digit` — a `?` placeholder with no digit: blank space as wide as a
+ *    digit.
+ */
+export type NumberFormatLayoutPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "fill";
+    char: string;
+} | {
+    type: "skip";
+    char: string;
+} | {
+    type: "digit";
+};
+/**
+ * Excel's width-aware number-format output: `*x` repeats `x` to the cell's
+ * width, `_x` reserves the width of `x` and `?` reserves a digit's width
+ * ("Number format codes", support.microsoft.com). A plain formatted string
+ * cannot carry that — `ssfFormat` drops the fill and renders the reserves as
+ * single spaces — so the painter asks for the parts and expands them with
+ * measured glyph widths.
+ *
+ * Returns `undefined` when the pattern has none of those tokens (the plain
+ * string is already exact), and for East Asian numeral codes. The parts'
+ * plain text ({@link numberFormatLayoutText}) equals `ssfFormat`'s output;
+ * callers compare it against the string they paint and ignore the layout
+ * when the two disagree.
+ */
+export declare const ssfFormatLayout: (pattern: string, value: any, locale?: string) => NumberFormatLayoutPart[] | undefined;
+/**
+ * The plain string a layout stands for — what `ssfFormat` returns for the
+ * same pattern and value: fills drop out, skips and digit pads are one
+ * space each.
+ */
+export declare const numberFormatLayoutText: (parts: readonly NumberFormatLayoutPart[]) => string;
 export declare const ssfFormatColor: (pattern: string, value: any) => string | undefined;
 //# sourceMappingURL=formatter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../formatter.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OASlE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KACjC,OAWF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAWlE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAOlE,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,KAAG,OA4B1D,CAAC;AA+LF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,MAAM,GAAG,SA4C9D,CAAC;AAiIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,MAAM,EACf,SAAS,MAAM,KACd,MAAM,GAAG,SAiBX,CAAC;AAiBF,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,OAAO,GAAG,EACV,SAAS,MAAM,KACd,MA0CF,CAAC;AAmLF,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,EACf,OAAO,GAAG,KACT,MAAM,GAAG,SAoBX,CAAC"}
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../formatter.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OASlE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KACjC,OAWF,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAWlE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,GAAG,SAAS,GAAG,IAAI,KAAG,OAOlE,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,KAAG,OA4B1D,CAAC;AA+LF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,KAAG,MAAM,GAAG,SA4C9D,CAAC;AAiIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,GACjC,SAAS,MAAM,EACf,SAAS,MAAM,KACd,MAAM,GAAG,SAiBX,CAAC;AAiBF,eAAO,MAAM,SAAS,GACpB,SAAS,MAAM,EACf,OAAO,GAAG,EACV,SAAS,MAAM,KACd,MASF,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAoDtB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,MAAM,EACf,OAAO,GAAG,EACV,SAAS,MAAM,KACd,sBAAsB,EAAE,GAAG,SA8C7B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO,SAAS,sBAAsB,EAAE,KACvC,MAOF,CAAC;AAkQF,eAAO,MAAM,cAAc,GACzB,SAAS,MAAM,EACf,OAAO,GAAG,KACT,MAAM,GAAG,SAoBX,CAAC"}

package/dist/esm/formatter.js

@@ -1,4 +1,5 @@
 import { addLocale, format, formatColor, getFormatDateInfo, getLocale, isDateFormat, isTextFormat, } from "numfmt";
+import { prepareCjkNumberFormat } from "./cjk-number-format";
 import { IndexedColors } from "./colors";
 import { excelNumberPrePass, splitFormatSections, } from "./excel-number-format";
 /**
@@ -498,6 +499,153 @@ const withWorkbookSeparatorsCached = (code, locale) => {
     return rewritten;
 };
 export 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);
+};
+const LAYOUT_FILL_MARK = "\uE000";
+const LAYOUT_SKIP_MARK = "\uE001";
+const LAYOUT_LITERAL_SPACE = "\uE002";
+const LAYOUT_DIGIT_PAD = "\u00a0";
+/**
+ * Quote every literal space of `code` as a private-use sentinel so that,
+ * rendered with numfmt's `nbsp` option, the only non-breaking spaces left
+ * in the output are the `?` digit pads.
+ */
+const markLiteralSpaces = (code) => {
+    let out = "";
+    let inQuotes = false;
+    let inBrackets = false;
+    for (let i = 0; i < code.length; i++) {
+        const char = code[i];
+        if (inQuotes) {
+            if (char === '"')
+                inQuotes = false;
+            out += char === " " ? LAYOUT_LITERAL_SPACE : char;
+            continue;
+        }
+        if (inBrackets) {
+            if (char === "]")
+                inBrackets = false;
+            out += char;
+            continue;
+        }
+        if (char === '"') {
+            inQuotes = true;
+        }
+        else if (char === "[") {
+            inBrackets = true;
+        }
+        else if (char === "\\" && code[i + 1] === " ") {
+            out += `"${LAYOUT_LITERAL_SPACE}"`;
+            i++;
+            continue;
+        }
+        else if (char === "\\" || char === "_" || char === "*") {
+            out += char + (code[i + 1] ?? "");
+            i++;
+            continue;
+        }
+        else if (char === " ") {
+            out += `"${LAYOUT_LITERAL_SPACE}"`;
+            continue;
+        }
+        out += char;
+    }
+    return out;
+};
+/** Does the pattern carry a `*` fill, `_` skip or `?` placeholder at all? */
+const LAYOUT_TOKEN_REGEX = /[*_?]/;
+/**
+ * Excel's width-aware number-format output: `*x` repeats `x` to the cell's
+ * width, `_x` reserves the width of `x` and `?` reserves a digit's width
+ * ("Number format codes", support.microsoft.com). A plain formatted string
+ * cannot carry that — `ssfFormat` drops the fill and renders the reserves as
+ * single spaces — so the painter asks for the parts and expands them with
+ * measured glyph widths.
+ *
+ * Returns `undefined` when the pattern has none of those tokens (the plain
+ * string is already exact), and for East Asian numeral codes. The parts'
+ * plain text ({@link numberFormatLayoutText}) equals `ssfFormat`'s output;
+ * callers compare it against the string they paint and ignore the layout
+ * when the two disagree.
+ */
+export const ssfFormatLayout = (pattern, value, locale) => {
+    if (!pattern || !LAYOUT_TOKEN_REGEX.test(pattern))
+        return undefined;
+    if (typeof value === "number" && prepareCjkNumberFormat(pattern, value, locale)) {
+        return undefined;
+    }
+    const raw = ssfFormatBase(pattern, value, locale, {
+        nbsp: true,
+        fillChar: LAYOUT_FILL_MARK,
+        skipChar: LAYOUT_SKIP_MARK,
+        transform: markLiteralSpaces,
+    });
+    if (raw === undefined)
+        return undefined;
+    // A locale whose group separator is itself a non-breaking space makes the
+    // digit pads ambiguous: keep those as plain spaces.
+    const digitPads = separatorsFor(locale).group !== LAYOUT_DIGIT_PAD;
+    const parts = [];
+    let text = "";
+    const flush = () => {
+        if (text)
+            parts.push({ type: "text", text });
+        text = "";
+    };
+    for (let i = 0; i < raw.length; i++) {
+        const char = raw[i];
+        if (char === LAYOUT_FILL_MARK || char === LAYOUT_SKIP_MARK) {
+            const next = raw[i + 1] ?? " ";
+            flush();
+            parts.push({
+                type: char === LAYOUT_FILL_MARK ? "fill" : "skip",
+                char: next,
+            });
+            i++;
+        }
+        else if (char === LAYOUT_DIGIT_PAD) {
+            if (digitPads) {
+                flush();
+                parts.push({ type: "digit" });
+            }
+            else {
+                text += char;
+            }
+        }
+        else if (char === LAYOUT_LITERAL_SPACE) {
+            text += " ";
+        }
+        else {
+            text += char;
+        }
+    }
+    flush();
+    return parts.some((part) => part.type !== "text") ? parts : undefined;
+};
+/**
+ * The plain string a layout stands for — what `ssfFormat` returns for the
+ * same pattern and value: fills drop out, skips and digit pads are one
+ * space each.
+ */
+export const numberFormatLayoutText = (parts) => {
+    let out = "";
+    for (const part of parts) {
+        if (part.type === "text")
+            out += part.text;
+        else if (part.type !== "fill")
+            out += " ";
+    }
+    return out;
+};
+function ssfFormatBase(pattern, value, locale, layout) {
     try {
         if (locale)
             ensureNumfmtLocale(locale);
@@ -506,12 +654,22 @@ export 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 (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
@@ -529,9 +687,9 @@ export const ssfFormat = (pattern, value, locale) => {
         return isNegativeElapsedTime ? `-${formatted}` : formatted;
     }
     catch (err) {
-        return String(value);
+        return layout ? undefined : String(value);
     }
-};
+}
 /**
  * Excel's legacy fixed 56-color palette used by `[ColorN]` directives
  * inside number format patterns (1-indexed). This palette is INDEPENDENT

package/dist/esm/tsconfig.esm.tsbuildinfo

@@ -1 +1 @@
-{"root":["../../array.ts","../../cell-data-helpers.ts","../../clipboard-html-sanitize.ts","../../color.ts","../../colors.ts","../../condition-operand.ts","../../conditional-format.ts","../../content-hash.ts","../../data-validation.ts","../../date.ts","../../dom.ts","../../excel-number-format.ts","../../formatter.ts","../../formula-locale.ts","../../formula-refs.ts","../../formula.ts","../../index.ts","../../keyboard.ts","../../locale.ts","../../log.ts","../../memoize.ts","../../numbers.ts","../../rich-text-html.ts","../../rich-text-links.ts","../../selection.ts","../../shared-string-canonical.ts","../../sheet-names.ts","../../sheet-protection.ts","../../sheet-span.ts","../../sort.ts","../../sparkline-groups.ts","../../string.ts","../../table-names.ts","../../table-styles.ts","../../table-totals.ts","../../typeguards.ts","../../uuid.ts","../../vitest.config.ts","../../formula-locale/formula-locale-data.generated.ts"],"version":"5.8.3"}
+{"root":["../../array.ts","../../cell-data-helpers.ts","../../cjk-number-format.ts","../../clipboard-html-sanitize.ts","../../color.ts","../../colors.ts","../../condition-operand.ts","../../conditional-format.ts","../../content-hash.ts","../../data-validation.ts","../../date.ts","../../dom.ts","../../excel-number-format.ts","../../formatter.ts","../../formula-locale.ts","../../formula-refs.ts","../../formula.ts","../../index.ts","../../keyboard.ts","../../locale.ts","../../log.ts","../../memoize.ts","../../numbers.ts","../../rich-text-html.ts","../../rich-text-links.ts","../../selection.ts","../../shared-string-canonical.ts","../../sheet-names.ts","../../sheet-protection.ts","../../sheet-span.ts","../../sort.ts","../../sparkline-groups.ts","../../string.ts","../../table-names.ts","../../table-styles.ts","../../table-totals.ts","../../typeguards.ts","../../uuid.ts","../../vitest.config.ts","../../formula-locale/formula-locale-data.generated.ts"],"version":"5.8.3"}

package/package.json

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