@rowsncolumns/utils 9.2.35

package/dist/esm/formula.js

@@ -0,0 +1,298 @@
+import { checkIfStringIsReference } from "./selection";
+/* Close parenthesis mapping */
+const inverseParenMap = {
+    "(": ")",
+    "[": "]",
+};
+/* Check if a str is function parenthesis */
+const isParen = (char) => "()[]".indexOf(char) !== -1;
+/* Check if a str is open parenthesis */
+const isOpenParen = (char) => "(" === char || "[" === char;
+/**
+ * Add/remove parenthesis in formulas
+ * @param str
+ * @returns
+ */
+export const balanceParentheses = (str) => {
+    const chars = str.split("");
+    const stack = [];
+    for (let i = 0; i < chars.length; i++) {
+        const char = chars[i];
+        if (isParen(char)) {
+            if (isOpenParen(char)) {
+                stack.push(char);
+            }
+            else {
+                if (stack.length !== 0)
+                    stack.pop();
+            }
+        }
+    }
+    return str + stack.map((item) => inverseParenMap[item]).join("");
+};
+/**
+ * Add closing quotes in formulas when a string is unterminated.
+ * Handles escaped quotes ("") inside strings.
+ */
+export const balanceQuotes = (str) => {
+    let inString = false;
+    let openScopeCount = 0;
+    let stringStartScopeCount = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str[i];
+        if (char === '"') {
+            if (inString && str[i + 1] === '"') {
+                i += 1;
+                continue;
+            }
+            inString = !inString;
+            if (inString) {
+                stringStartScopeCount = openScopeCount;
+            }
+            continue;
+        }
+        if (!inString) {
+            if (isOpenParen(char)) {
+                openScopeCount++;
+            }
+            else if (char === ")" || char === "]") {
+                if (openScopeCount > 0)
+                    openScopeCount--;
+            }
+        }
+    }
+    if (!inString) {
+        return str;
+    }
+    let insertIndex = str.length;
+    while (insertIndex > 0 && /\s/.test(str[insertIndex - 1])) {
+        insertIndex -= 1;
+    }
+    let closeStart = insertIndex;
+    while (closeStart > 0) {
+        const char = str[closeStart - 1];
+        if (char !== ")" && char !== "]")
+            break;
+        closeStart -= 1;
+    }
+    const trailingParensCount = insertIndex - closeStart;
+    const parensToKeepOutside = Math.min(stringStartScopeCount, trailingParensCount);
+    const insertionPos = insertIndex - parensToKeepOutside;
+    return `${str.slice(0, insertionPos)}"${str.slice(insertionPos)}`;
+};
+/**
+ * Add/remove parenthesis and add closing quotes in formulas.
+ */
+export const balanceFormula = (str) => {
+    return balanceParentheses(str);
+};
+/**
+ * Check if parenthesis is balanced
+ * @param str
+ * @returns
+ */
+export const isBalancedParenthesis = (str) => {
+    return balanceParentheses(str).length === str.length;
+};
+export const looksLikeMarkdown = (text) => {
+    const normalizedText = text.replace(/\\n/g, "\n").replace(/\\r/g, "\r");
+    const trimmedStart = normalizedText.trimStart();
+    if (!trimmedStart) {
+        return false;
+    }
+    const firstLine = trimmedStart.split("\n", 1)[0];
+    // Text starting with `---` is considered markdown (horizontal rule or front matter)
+    if (firstLine.startsWith("--")) {
+        return true;
+    }
+    // Front matter: starts with --- and another --- appears within a few lines.
+    if (/^---\s*$/.test(firstLine)) {
+        const lines = trimmedStart.split("\n").slice(1, 20);
+        if (lines.some((line) => /^---\s*$/.test(line))) {
+            return true;
+        }
+        // Heuristic: if a front-matter-like start is followed by markdown markers,
+        // treat it as markdown even without a closing ---.
+        if (lines.some((line) => /^(#{1,6}\s|>\s|[-*]\s|\d+\.\s|\|)/.test(line.trimStart()))) {
+            return true;
+        }
+    }
+    // Common markdown markers.
+    if (/^(#{1,6}\s|>\s|[-*]\s|\d+\.\s|\|)/.test(trimmedStart)) {
+        return true;
+    }
+    // Horizontal rule only (line with ---/***/___).
+    return /^(?:---|\*\*\*|___)\s*$/.test(firstLine);
+};
+let defaultEnableAtFormula = false;
+export const setDefaultEnableAtFormula = (enable) => {
+    defaultEnableAtFormula = enable ?? false;
+};
+/**
+ * Check if text is a formula
+ * @param text
+ * @returns
+ */
+export const isAFormula = (text) => {
+    const textStr = String(text);
+    if (looksLikeMarkdown(textStr)) {
+        return false;
+    }
+    // A formula's expression can never legitimately begin with a second "="
+    // right after the leading one — neither Excel nor Google Sheets has a token
+    // that starts an expression with "=". So "==", "===", "=== heading ===" and
+    // similar are decorative/label text, not a (broken) formula. Treat them as
+    // plain text instead of routing them through the calculator.
+    if (textStr.startsWith("==")) {
+        return false;
+    }
+    return !!textStr.startsWith("=") || isAlternateFormula(textStr);
+};
+/* Quoted string literal, e.g. `"North Region"` (with `""` escapes). */
+const STRING_LITERAL_ONLY = /^"(?:[^"]|"")*"$/;
+/* Numeric literal, e.g. `42`, `-1.5`, `.5`, `1e3`, `12%`. */
+const NUMERIC_LITERAL_ONLY = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?%?$/;
+/* Boolean literal. */
+const BOOLEAN_LITERAL_ONLY = /^(?:TRUE|FALSE)$/i;
+/* Formula operators that can only appear in an expression that needs
+ * the calculator (scanned outside quoted segments). */
+const FORMULA_OPERATOR = /[+\-*/^&<>=]/;
+/**
+ * Check if text is a formula-shaped expression stored WITHOUT the
+ * leading "=". OOXML defined names (`<definedName>` in workbook.xml)
+ * store their expressions bare — `OFFSET(Sheet1!$A$1,0,0,10)` rather
+ * than `=OFFSET(...)` — so `isAFormula` can't classify them.
+ *
+ * Returns false for anything that already resolves as a static value
+ * or plain reference today: quoted string / numeric / boolean
+ * literals, single-area range references (including external-workbook
+ * references like `'[1]Revenue'!$A$17`), and broken `#REF!`
+ * expressions. Returns true only for expressions that need the
+ * calculator: function calls and operator expressions.
+ * @param text
+ * @returns
+ */
+export const isBareFormulaExpression = (text) => {
+    if (typeof text !== "string") {
+        return false;
+    }
+    const trimmed = text.trim();
+    if (!trimmed || trimmed.startsWith("=")) {
+        return false;
+    }
+    if (trimmed.includes("#REF!")) {
+        return false;
+    }
+    if (STRING_LITERAL_ONLY.test(trimmed) ||
+        NUMERIC_LITERAL_ONLY.test(trimmed) ||
+        BOOLEAN_LITERAL_ONLY.test(trimmed)) {
+        return false;
+    }
+    if (checkIfStringIsReference(trimmed)) {
+        return false;
+    }
+    // Function call or parenthesized sub-expression.
+    if (trimmed.includes("(")) {
+        return true;
+    }
+    // Operator expression like `Sheet1!$A$1*2`. Strip string literals
+    // and quoted sheet names first so `'My-Sheet'!$A$1` isn't misread
+    // as subtraction.
+    const scannable = trimmed
+        .replace(/"(?:[^"]|"")*"/g, "")
+        .replace(/'[^']*'/g, "");
+    return FORMULA_OPERATOR.test(scannable);
+};
+// Pre-compiled `\p{Sc}` (Unicode currency-symbol category) check. Used to
+// distinguish currency input like `-$100` / `+€50` from formula-prefixed
+// input like `-A1` / `+SUM(A1:B2)`. Wrapped in try/catch because some
+// older JS engines don't support Unicode property escapes.
+const CURRENCY_SYMBOL_START = (() => {
+    try {
+        return new RegExp("^\\p{Sc}", "u");
+    }
+    catch {
+        return /^[£$€¥₹₽₩₪₫₴₸₺₼₾₿]/;
+    }
+})();
+// Check if its alternate formula
+// ie the text starts with +
+export const isAlternateFormula = (text) => {
+    // @ can be treated as formula in Excel (even if invalid), but is disabled by default here
+    if (text.startsWith("@"))
+        return defaultEnableAtFormula;
+    if (!text.startsWith("+") && !text.startsWith("-"))
+        return false;
+    // Remove the leading + and check if what remains is just a number
+    const afterSign = text.slice(1).trim();
+    // If it's empty or just a number literal, it's not a formula
+    // Also check with common thousands separators removed (comma and period)
+    // to handle locale-formatted numbers like "1,234" or "1.234"
+    if (!afterSign || !isNaN(Number(afterSign))) {
+        return false;
+    }
+    // Excel parity: a leading sign followed by a currency symbol is the start
+    // of a (possibly in-progress) currency negative / positive — `-$100`,
+    // `+€50`, `-£1,234.56`. Excel treats these as currency, not formulas,
+    // even mid-type (the bare `-$` shows as text until digits are added).
+    if (CURRENCY_SYMBOL_START.test(afterSign)) {
+        return false;
+    }
+    // Check for numbers with thousands separators (e.g., "1,234" or "1.234,56")
+    // Strip commas and periods that look like thousands separators
+    const withoutThousandsSeparators = afterSign.replace(/[,.]/g, "");
+    if (/^\d+$/.test(withoutThousandsSeparators)) {
+        return false;
+    }
+    // If there is whitespace with no letters, treat it as text unless it uses
+    // non-hyphen operators (phone numbers like "+1 224-535-1764").
+    const hasLetters = /[A-Za-z]/.test(afterSign);
+    if (/\s/.test(afterSign) && !hasLetters) {
+        return /[+*/^=<>]/.test(afterSign);
+    }
+    // Otherwise, it's a formula like +A1, +SUM(A1:B2), +1-2, etc.
+    return true;
+};
+// Check if its a valid formula
+export const isValidFormula = (text) => {
+    const str = String(text);
+    return str[0] === "=" && str.length > 1;
+};
+/**
+ * Check if a key is an Arrow key
+ * @param code
+ * @returns
+ */
+export const isAnArrowKey = (code) => code.startsWith("Arrow");
+/**
+ * Iterate over all cells in a bound
+ * @param bounds
+ * @param callback
+ */
+export const iterateCells = function* (top, right, bottom, left) {
+    for (let rowIndex = top; rowIndex <= bottom; rowIndex++) {
+        const rightBound = typeof right === "function" ? right(rowIndex) : right;
+        for (let columnIndex = left; columnIndex <= rightBound; columnIndex++) {
+            yield [rowIndex, columnIndex];
+        }
+    }
+};
+export function* combineIterators(...generators) {
+    for (const generator of generators) {
+        if (generator)
+            yield* generator;
+    }
+}
+export const iterateCellsInRange = (range) => {
+    return iterateCells(range.startRowIndex, range.endColumnIndex, range.endRowIndex, range.startColumnIndex);
+};
+/**
+ * Iterate all cells in multiple selections
+ * @param selections
+ * @returns
+ */
+export const iterateSelections = function* (selections) {
+    for (const selection of selections) {
+        yield iterateCellsInRange(selection.range);
+    }
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./numbers";
+export * from "./uuid";
+export * from "./typeguards";
+export * from "./string";
+export * from "./formula";
+export * from "./color";
+export * from "./dom";
+export * from "./locale";
+export * from "./date";
+export * from "./log";
+export * from "./array";
+export * from "./formatter";
+export * from "./memoize";
+export * from "./cell-data-helpers";
+export * from "./selection";
+export * from "./colors";
+export * from "./formula-refs";
+export * from "./sort";
+export * from "./table-styles";
+export * from "./conditional-format";
+export * from "./data-validation";
+export * from "./content-hash";
+export * from "./shared-string-canonical";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/esm/index.js

@@ -0,0 +1,23 @@
+export * from "./numbers";
+export * from "./uuid";
+export * from "./typeguards";
+export * from "./string";
+export * from "./formula";
+export * from "./color";
+export * from "./dom";
+export * from "./locale";
+export * from "./date";
+export * from "./log";
+export * from "./array";
+export * from "./formatter";
+export * from "./memoize";
+export * from "./cell-data-helpers";
+export * from "./selection";
+export * from "./colors";
+export * from "./formula-refs";
+export * from "./sort";
+export * from "./table-styles";
+export * from "./conditional-format";
+export * from "./data-validation";
+export * from "./content-hash";
+export * from "./shared-string-canonical";

package/dist/esm/locale.d.ts

@@ -0,0 +1,34 @@
+export declare const getCurrentLocale: () => string;
+export type DatePartType = "month" | "day" | "year";
+/**
+ * PARSER metadata only: relative day/month order for a locale, with the
+ * year deliberately moved last so the date-parser's regex can use fixed
+ * capture-group positions. This ordering is WRONG for display in
+ * year-first locales (ja-JP, hu-HU, sv-SE, …) — formatting helpers must
+ * use the `formatToParts`-driven builders below instead.
+ */
+export declare const getLocaleDatePartsNotMemoized: (locale: string) => [DatePartType, string, string][];
+export declare const getLocaleDateParts: (locale: string) => [DatePartType, string, string][];
+/**
+ * Default numeric (short) date pattern for a locale, preserving the
+ * locale's field order, separators, literal text and zero-padding as
+ * reported by `Intl.DateTimeFormat(...).formatToParts()` — e.g.
+ * de-DE → `d.m.yyyy`, hu-HU → `yyyy. mm. dd.`, en-CA → `yyyy-mm-dd`.
+ */
+export declare const getDefaultDateFormat: (locale?: string) => string;
+/**
+ * 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`,
+ * de-DE → `hh:mm:ss`, fi-FI → `h.mm.ss`.
+ */
+export declare const getDefaultTimeFormat: (locale?: string, precision?: "minute" | "second") => string;
+export declare const getDefaultDateTimeFormat: (locale?: string) => string;
+/**
+ * Long (full) date pattern for a locale, following the locale's own
+ * field placement and literal text — e.g. de-DE →
+ * `[$-de-DE]dddd, d. mmmm yyyy`, ja-JP → `[$-ja-JP]yyyy"年"m"月"d"日"dddd`.
+ * Localized weekday/month names are best-effort: they render through the
+ * spreadsheet formatter's own locale data via the `[$-locale]` tag.
+ */
+export declare const getLongDateFormat: (locale?: string) => string;
+//# sourceMappingURL=locale.d.ts.map

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

@@ -0,0 +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"}

package/dist/esm/locale.js

@@ -0,0 +1,223 @@
+import { memoize } from "./memoize";
+let defaultLocale;
+export const getCurrentLocale = () => {
+    if (defaultLocale) {
+        return defaultLocale;
+    }
+    try {
+        defaultLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    }
+    catch (err) {
+        defaultLocale = "en-US";
+    }
+    return defaultLocale;
+};
+/**
+ * PARSER metadata only: relative day/month order for a locale, with the
+ * year deliberately moved last so the date-parser's regex can use fixed
+ * capture-group positions. This ordering is WRONG for display in
+ * year-first locales (ja-JP, hu-HU, sv-SE, …) — formatting helpers must
+ * use the `formatToParts`-driven builders below instead.
+ */
+export const getLocaleDatePartsNotMemoized = (locale) => {
+    let parts = [];
+    try {
+        const formatObj = new Intl.DateTimeFormat(locale).formatToParts(new Date());
+        for (const part of formatObj) {
+            if (part.type === "day") {
+                parts.push(["day", "d", "dd"]);
+            }
+            if (part.type === "month") {
+                parts.push(["month", "m", "mm"]);
+            }
+            if (part.type === "year") {
+                parts.push(["year", "yy", "yyyy"]);
+            }
+        }
+        // Always move year to last to prevent
+        // errors in Regex (duplicate capture group)
+        parts.sort((_, [typeB]) => {
+            if (typeB === "year") {
+                return -1;
+            }
+            return 1;
+        });
+    }
+    catch (err) {
+        // en-US
+        parts = [
+            ["month", "m", "mm"],
+            ["day", "d", "dd"],
+            ["year", "yy", "yyyy"],
+        ];
+    }
+    return parts;
+};
+export const getLocaleDateParts = memoize(getLocaleDatePartsNotMemoized);
+/**
+ * Fixed sample instant used to discover a locale's date/time pattern via
+ * `formatToParts`. Every numeric field is single-digit (5 April 2008,
+ * 05:09:07 UTC) so locale padding is observable: a locale that renders
+ * "05" for the day pads days, one that renders "5" does not.
+ */
+const FORMAT_SAMPLE_DATE = new Date(Date.UTC(2008, 3, 5, 5, 9, 7));
+/**
+ * Literal characters that spreadsheet number-format syntax accepts
+ * unquoted inside a date/time section. Anything else (words such as
+ * "г.", CJK markers such as 年/月/日, bidi controls, commas — which
+ * numfmt/Excel read as the thousands/scaling operator, e.g. hu-HU's
+ * `.,` literal — …) must be wrapped in double quotes.
+ */
+const SAFE_PATTERN_LITERAL = /^[\s./:-]*$/;
+const escapePatternLiteral = (value) => {
+    if (SAFE_PATTERN_LITERAL.test(value)) {
+        return value;
+    }
+    // Number-format strings cannot represent an embedded double quote —
+    // no locale literal contains one, so dropping it is safe.
+    return `"${value.replace(/"/g, "")}"`;
+};
+const numericFieldToken = (short, long, partValue) => (partValue.length === 2 ? long : short);
+const dateFieldToken = (part) => {
+    switch (part.type) {
+        case "day":
+            return numericFieldToken("d", "dd", part.value);
+        case "month":
+            return numericFieldToken("m", "mm", part.value);
+        case "year":
+            return part.value.length === 2 ? "yy" : "yyyy";
+        case "literal":
+            return escapePatternLiteral(part.value);
+        default:
+            // era and other exotic fields have no spreadsheet token — skip.
+            return undefined;
+    }
+};
+const buildPatternFromParts = (parts, toToken) => {
+    let pattern = "";
+    for (const part of parts) {
+        const token = toToken(part);
+        if (token !== undefined) {
+            pattern += token;
+        }
+    }
+    // A locale's pattern may end (or begin) with a literal that belongs to
+    // trailing fields we skipped (e.g. an era) — trim stray whitespace.
+    return pattern.trim();
+};
+const getDefaultDateFormatMemoized = memoize((locale) => {
+    try {
+        const parts = new Intl.DateTimeFormat(locale, {
+            calendar: "gregory",
+            numberingSystem: "latn",
+            year: "numeric",
+            month: "numeric",
+            day: "numeric",
+            timeZone: "UTC",
+        }).formatToParts(FORMAT_SAMPLE_DATE);
+        const pattern = buildPatternFromParts(parts, dateFieldToken);
+        return pattern || "m/d/yyyy";
+    }
+    catch (err) {
+        return "m/d/yyyy";
+    }
+});
+/**
+ * Default numeric (short) date pattern for a locale, preserving the
+ * locale's field order, separators, literal text and zero-padding as
+ * reported by `Intl.DateTimeFormat(...).formatToParts()` — e.g.
+ * de-DE → `d.m.yyyy`, hu-HU → `yyyy. mm. dd.`, en-CA → `yyyy-mm-dd`.
+ */
+export const getDefaultDateFormat = (locale = getCurrentLocale()) => getDefaultDateFormatMemoized(locale);
+const getDefaultTimeFormatMemoized = memoize((locale, precision) => {
+    try {
+        const parts = new Intl.DateTimeFormat(locale, {
+            numberingSystem: "latn",
+            hour: "numeric",
+            minute: "numeric",
+            ...(precision === "second" ? { second: "numeric" } : {}),
+            timeZone: "UTC",
+        }).formatToParts(FORMAT_SAMPLE_DATE);
+        const pattern = buildPatternFromParts(parts, (part) => {
+            switch (part.type) {
+                case "hour":
+                    return numericFieldToken("h", "hh", part.value);
+                case "minute":
+                    return "mm";
+                case "second":
+                    return "ss";
+                case "dayPeriod":
+                    // Spreadsheet syntax only has the English AM/PM token; its
+                    // presence is what switches the hour field to 12-hour mode.
+                    return "AM/PM";
+                case "literal":
+                    return escapePatternLiteral(part.value);
+                default:
+                    return undefined;
+            }
+        });
+        const fallback = precision === "second" ? "h:mm:ss AM/PM" : "h:mm AM/PM";
+        return pattern || fallback;
+    }
+    catch (err) {
+        return precision === "second" ? "h:mm:ss AM/PM" : "h:mm AM/PM";
+    }
+});
+/**
+ * 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`,
+ * de-DE → `hh:mm:ss`, fi-FI → `h.mm.ss`.
+ */
+export const getDefaultTimeFormat = (locale = getCurrentLocale(), precision = "second") => getDefaultTimeFormatMemoized(locale, precision);
+export const getDefaultDateTimeFormat = (locale) => {
+    return getDefaultDateFormat(locale) + " " + getDefaultTimeFormat(locale);
+};
+const getLongDateFormatMemoized = memoize((locale) => {
+    try {
+        const parts = new Intl.DateTimeFormat(locale, {
+            calendar: "gregory",
+            numberingSystem: "latn",
+            weekday: "long",
+            year: "numeric",
+            month: "long",
+            day: "numeric",
+            timeZone: "UTC",
+        }).formatToParts(FORMAT_SAMPLE_DATE);
+        const pattern = buildPatternFromParts(parts, (part) => {
+            switch (part.type) {
+                case "weekday":
+                    return "dddd";
+                case "month":
+                    // CJK locales keep the month numeric even in long dates
+                    // ("9月"): Intl reports the digit with 月/월 as a literal, and
+                    // the formatter's own `mmmm` would re-append the marker.
+                    return /^\d+$/.test(part.value)
+                        ? numericFieldToken("m", "mm", part.value)
+                        : "mmmm";
+                case "day":
+                    return numericFieldToken("d", "dd", part.value);
+                case "year":
+                    return part.value.length === 2 ? "yy" : "yyyy";
+                case "literal":
+                    return escapePatternLiteral(part.value);
+                default:
+                    return undefined;
+            }
+        });
+        if (!pattern) {
+            return `[$-${locale}]dddd, mmmm d, yyyy`;
+        }
+        return `[$-${locale}]${pattern}`;
+    }
+    catch (err) {
+        return `[$-${locale}]dddd, mmmm d, yyyy`;
+    }
+});
+/**
+ * Long (full) date pattern for a locale, following the locale's own
+ * field placement and literal text — e.g. de-DE →
+ * `[$-de-DE]dddd, d. mmmm yyyy`, ja-JP → `[$-ja-JP]yyyy"年"m"月"d"日"dddd`.
+ * Localized weekday/month names are best-effort: they render through the
+ * spreadsheet formatter's own locale data via the `[$-locale]` tag.
+ */
+export const getLongDateFormat = (locale = getCurrentLocale()) => getLongDateFormatMemoized(locale);

package/dist/esm/log.d.ts

@@ -0,0 +1,4 @@
+export declare const log: (...args: any[]) => false | void;
+export declare const debug: (...args: any[]) => false | void;
+export declare const error: (...args: any[]) => false | void;
+//# sourceMappingURL=log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../log.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,GAAG,GAAI,GAAG,MAAM,GAAG,EAAE,iBAC6B,CAAC;AAChE,eAAO,MAAM,KAAK,GAAI,GAAG,MAAM,GAAG,EAAE,iBAC6B,CAAC;AAClE,eAAO,MAAM,KAAK,GAAI,GAAG,MAAM,GAAG,EAAE,iBAC6B,CAAC"}

package/dist/esm/log.js

@@ -0,0 +1,3 @@
+export const log = (...args) => process.env.NODE_ENV !== "production" && console.log(...args);
+export const debug = (...args) => process.env.NODE_ENV !== "production" && console.debug(...args);
+export const error = (...args) => process.env.NODE_ENV !== "production" && console.error(...args);

package/dist/esm/memoize.d.ts

@@ -0,0 +1,18 @@
+export declare const memoize: <T extends unknown[], K>(fn: (...args: T) => K) => (...args: T) => K;
+/**
+ * Mint a stable cellXfs key ("sid") for a CellFormat. The key is
+ * `contentHash` (FNV-1a-64 → 8-char base62) over a delimiter-separated
+ * canonical serialization of the format's defined properties — the
+ * previous 31-bit rolling int hash silently collided two different
+ * formats onto one registry key (first-writer wins, so e.g. a red
+ * format could hijack a blue one on import).
+ *
+ * Sids are minted at import/edit time and persisted in the doc's
+ * cellXfs map together with the cell references that carry them —
+ * readback resolves a stored sid against the stored map, never by
+ * re-hashing. Changing this algorithm therefore only affects newly
+ * minted keys; existing docs keep resolving their old sids.
+ */
+export declare const getCellXfsKey: (userObj: any | null | undefined) => string;
+export declare const definedProps: <T extends Record<string, any> | undefined | null>(obj: T) => Partial<NonNullable<T>> | T;
+//# sourceMappingURL=memoize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../memoize.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,CAAC,MAE3D,GAAG,MAAM,CAAC,MASnB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,GAAG,GAAG,IAAI,GAAG,SAAS,KAAG,MA4D/D,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,EAC3E,KAAK,CAAC,KACL,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAU5B,CAAC"}