@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/sheet/conditional-formats.js

@@ -0,0 +1,341 @@
+/**
+ * Conditional formatting, Excel's: rules over cells that colour them by
+ * what they hold. Highlight Cells Rules (greater than, between, text that
+ * contains, duplicates), Top/Bottom Rules (top 10, above average), Data
+ * Bars, Color Scales and Icon Sets, each over rectangles that move with
+ * an insert or delete.
+ *
+ * Rules are evaluated over COMPUTED values (what a formula shows, not its
+ * text), which is why the model lives here beside the workbook rather than
+ * in the grid's own value-driven rules. The statistics a rule needs over
+ * its range (min, max, mean, rank, counts) are computed once per repaint by
+ * the shell and handed in, so a thousand cells cost one pass.
+ *
+ * Priority is array order, first rule first, as Excel's Manage Rules lists
+ * them: the first rule that decides a property wins it, and a rule with
+ * Stop If True stops the rules below it for the cells it matches.
+ */
+import { isError } from './ast.js';
+import { toText } from './coerce.js';
+import { translateFormula } from './refs.js';
+import { rectContains, shiftRects, subtractRect, rectsIntersect } from './rects.js';
+// ---------------------------------------------------------------------------
+// Excel's palettes
+// ---------------------------------------------------------------------------
+/** The six "with" styles of Excel's Highlight Cells dialogs. */
+export const CF_PRESET_STYLES = [
+    { id: 'light-red', label: 'Light Red Fill with Dark Red Text', style: { fill: '#FFC7CE', color: '#9C0006' } },
+    { id: 'yellow', label: 'Yellow Fill with Dark Yellow Text', style: { fill: '#FFEB9C', color: '#9C5700' } },
+    { id: 'green', label: 'Green Fill with Dark Green Text', style: { fill: '#C6EFCE', color: '#006100' } },
+    { id: 'red-fill', label: 'Light Red Fill', style: { fill: '#FFC7CE' } },
+    { id: 'red-text', label: 'Red Text', style: { color: '#9C0006' } },
+];
+export const DATA_BAR_COLOR = '#638EC6';
+/** Excel's colour for the bars left of the axis. */
+export const DATA_BAR_NEGATIVE_COLOR = '#FF0000';
+export const COLOR_SCALES = {
+    'green-yellow-red': ['#63BE7B', '#FFEB84', '#F8696B'],
+    'red-yellow-green': ['#F8696B', '#FFEB84', '#63BE7B'],
+    'green-white': ['#63BE7B', '#FCFCFF'],
+    'white-red': ['#FCFCFF', '#F8696B'],
+};
+let nextId = 1;
+export function cfId() {
+    nextId += 1;
+    return `cf${Date.now().toString(36)}${nextId}`;
+}
+// ---------------------------------------------------------------------------
+// Statistics
+// ---------------------------------------------------------------------------
+/**
+ * The numbers and the texts a rule's rectangles hold. One pass; the shell
+ * caches the result per rule until the next repaint.
+ */
+export function ruleStats(rule, valueAt, displayAt) {
+    const numbers = [];
+    const counts = new Map();
+    let sum = 0;
+    for (const [r1, c1, r2, c2] of rule.rects) {
+        for (let r = r1; r <= r2; r += 1) {
+            for (let c = c1; c <= c2; c += 1) {
+                const v = valueAt(r, c);
+                if (typeof v === 'number' && Number.isFinite(v)) {
+                    numbers.push(v);
+                    sum += v;
+                }
+                if (rule.kind === 'duplicates') {
+                    const shown = displayAt(r, c);
+                    if (shown !== '')
+                        counts.set(shown, (counts.get(shown) ?? 0) + 1);
+                }
+            }
+        }
+    }
+    numbers.sort((a, b) => a - b);
+    return {
+        sorted: numbers,
+        min: numbers[0] ?? 0,
+        max: numbers[numbers.length - 1] ?? 0,
+        mean: numbers.length ? sum / numbers.length : 0,
+        counts,
+    };
+}
+// ---------------------------------------------------------------------------
+// Evaluation
+// ---------------------------------------------------------------------------
+function numberOf(text, ctx) {
+    const v = ctx.evaluate(text);
+    if (isError(v) || typeof v === 'boolean')
+        return null;
+    const n = typeof v === 'number' ? v : Number(v);
+    return Number.isFinite(n) ? n : null;
+}
+function textOf(text, ctx) {
+    const t = text.trim();
+    if (!t.startsWith('='))
+        return t;
+    const v = ctx.evaluate(t);
+    return isError(v) ? '' : toText(v);
+}
+function cellIs(value, operator, a, b) {
+    if (a === null)
+        return false;
+    switch (operator) {
+        case 'greater': return value > a;
+        case 'less': return value < a;
+        case 'greaterOrEqual': return value >= a;
+        case 'lessOrEqual': return value <= a;
+        case 'equal': return value === a;
+        case 'notEqual': return value !== a;
+        case 'between': return b !== null && value >= Math.min(a, b) && value <= Math.max(a, b);
+        case 'notBetween': return b !== null && (value < Math.min(a, b) || value > Math.max(a, b));
+    }
+}
+/** Whether a styling rule matches the cell. */
+function matches(rule, value, display, stats, ctx, at) {
+    switch (rule.kind) {
+        case 'cellIs': {
+            const isEquality = rule.operator === 'equal' || rule.operator === 'notEqual';
+            const a = numberOf(rule.value1, ctx);
+            if (typeof value === 'number' && (a !== null || !isEquality)) {
+                return cellIs(value, rule.operator, a, rule.value2 === undefined ? null : numberOf(rule.value2, ctx));
+            }
+            // Equal to / not equal to compare as text where either side is text,
+            // as Excel does: 5 is not equal to 'Paid', and 'paid' is equal to it.
+            if (!isEquality)
+                return false;
+            const same = display !== '' && display.toLowerCase() === textOf(rule.value1, ctx).toLowerCase();
+            return rule.operator === 'equal' ? same : display !== '' && !same;
+        }
+        case 'text': {
+            if (display === '')
+                return false;
+            const hay = display.toLowerCase();
+            const needle = textOf(rule.value, ctx).toLowerCase();
+            if (needle === '')
+                return false;
+            switch (rule.match) {
+                case 'contains': return hay.includes(needle);
+                case 'notContains': return !hay.includes(needle);
+                case 'beginsWith': return hay.startsWith(needle);
+                case 'endsWith': return hay.endsWith(needle);
+                default: return false;
+            }
+        }
+        case 'duplicates': {
+            if (display === '')
+                return false;
+            const n = stats.counts.get(display) ?? 0;
+            return rule.unique ? n === 1 : n > 1;
+        }
+        case 'topBottom': {
+            if (typeof value !== 'number' || !stats.sorted.length)
+                return false;
+            const count = rule.percent
+                ? Math.max(1, Math.round((stats.sorted.length * rule.rank) / 100))
+                : rule.rank;
+            if (count <= 0)
+                return false;
+            // The cut is the count-th value from the top (or bottom); ties keep
+            // every cell at that value in, as Excel's do.
+            const sorted = stats.sorted;
+            const cut = rule.top
+                ? sorted[Math.max(sorted.length - count, 0)]
+                : sorted[Math.min(count - 1, sorted.length - 1)];
+            return rule.top ? value >= cut : value <= cut;
+        }
+        case 'average': {
+            if (typeof value !== 'number' || !stats.sorted.length)
+                return false;
+            return rule.above ? value > stats.mean : value < stats.mean;
+        }
+        case 'formula': {
+            // Written for the rule's top-left cell and moved to the cell being
+            // painted, as a copied formula would be: =$B2>100 on A2:A9 reads
+            // each row's B. TRUE, or a number other than 0, formats.
+            const text = rule.formula.trim();
+            if (!text)
+                return false;
+            const origin = rule.rects[0];
+            const source = text.startsWith('=') ? text : `=${text}`;
+            const moved = origin && at ? String(translateFormula(source, at.row - origin[0], at.col - origin[1])) : source;
+            const v = ctx.evaluate(moved, at);
+            if (isError(v))
+                return false;
+            return typeof v === 'boolean' ? v : typeof v === 'number' ? v !== 0 : false;
+        }
+        default:
+            return false;
+    }
+}
+/**
+ * A data bar's geometry. Excel measures from zero: over a non-negative
+ * range 10, 20, 40 draw a quarter, a half and the whole width, so the
+ * smallest value keeps a bar. A range with negatives puts an axis where
+ * zero falls between the minimum and the maximum, and a bar grows away
+ * from it, right for a positive value and left for a negative one, each
+ * as its share of the whole span, as Excel's automatic axis draws them.
+ */
+function dataBarFor(value, stats) {
+    const lo = Math.min(0, stats.min);
+    const hi = Math.max(0, stats.max);
+    const span = hi - lo;
+    const negative = value < 0;
+    if (span === 0)
+        return { ratio: 0, axis: 0, negative };
+    const axis = lo < 0 ? -lo / span : 0;
+    const ratio = Math.min(1, Math.abs(value) / span);
+    return { ratio, axis, negative };
+}
+/** Where a number sits in a range, 0..1; 0.5 for a flat range. */
+function ratioOf(value, stats) {
+    if (stats.max === stats.min)
+        return 0.5;
+    return Math.min(1, Math.max(0, (value - stats.min) / (stats.max - stats.min)));
+}
+/** Linear interpolate two hex colours. */
+function lerp(a, b, t) {
+    const pa = parseHex(a);
+    const pb = parseHex(b);
+    if (!pa || !pb)
+        return a;
+    const k = Math.min(1, Math.max(0, t));
+    const ch = (i) => Math.round(pa[i] + (pb[i] - pa[i]) * k).toString(16).padStart(2, '0');
+    return `#${ch(0)}${ch(1)}${ch(2)}`;
+}
+function parseHex(hex) {
+    const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+    if (!m)
+        return null;
+    const n = parseInt(m[1], 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+/** The colour a scale gives a position 0..1. */
+export function scaleColor(colors, t) {
+    if (colors.length === 2)
+        return lerp(colors[0], colors[1], t);
+    return t <= 0.5 ? lerp(colors[0], colors[1], t * 2) : lerp(colors[1], colors[2], (t - 0.5) * 2);
+}
+/** Which of an icon set's three icons a position 0..1 gets: Excel's thirds. */
+export function iconIndex(t) {
+    return t >= 2 / 3 ? 0 : t >= 1 / 3 ? 1 : 2;
+}
+/**
+ * What the rules say about (r, c). Array order is priority; the first rule
+ * that decides a property (the fill, the text colour, the bar, the icon)
+ * keeps it; a matching rule with Stop If True ends the walk.
+ */
+export function evaluateCf(rules, r, c, value, display, statsFor, ctx) {
+    let out = null;
+    for (const rule of rules) {
+        if (!rule.rects.some((rect) => rectContains(rect, r, c)))
+            continue;
+        let hit = false;
+        if (rule.kind === 'dataBar') {
+            if (typeof value === 'number' && !(out?.dataBar)) {
+                const bar = dataBarFor(value, statsFor(rule));
+                out = { ...(out ?? {}), dataBar: { ...bar, color: bar.negative ? rule.negativeColor ?? DATA_BAR_NEGATIVE_COLOR : rule.color } };
+                hit = true;
+            }
+        }
+        else if (rule.kind === 'colorScale') {
+            const current = out ?? {};
+            if (typeof value === 'number' && current.style?.fill === undefined) {
+                const stats = statsFor(rule);
+                out = { ...current, style: { ...(current.style ?? {}), fill: scaleColor(rule.colors, ratioOf(value, stats)) } };
+                hit = true;
+            }
+        }
+        else if (rule.kind === 'iconSet') {
+            if (typeof value === 'number' && !(out?.icon)) {
+                const stats = statsFor(rule);
+                out = { ...(out ?? {}), icon: { set: rule.set, index: iconIndex(ratioOf(value, stats)) } };
+                hit = true;
+            }
+        }
+        else if (hasStyle(rule) && matches(rule, value, display, statsFor(rule), ctx, { row: r, col: c })) {
+            const style = { ...(out?.style ?? {}) };
+            const own = rule.style;
+            for (const key of Object.keys(own)) {
+                if (style[key] === undefined && own[key] !== undefined)
+                    style[key] = own[key];
+            }
+            out = { ...(out ?? {}), style };
+            hit = true;
+        }
+        if (hit && rule.stopIfTrue)
+            break;
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Bookkeeping
+// ---------------------------------------------------------------------------
+/** The rules after an insert or delete. */
+export function shiftCf(rules, edit) {
+    return shiftRects(rules, edit);
+}
+/** The rules with the rectangles cut out of them: Clear Rules from Selected Cells. */
+export function removeCf(rules, rects) {
+    const out = [];
+    for (const rule of rules) {
+        let kept = [...rule.rects];
+        for (const hole of rects)
+            kept = kept.flatMap((rect) => subtractRect(rect, hole));
+        if (kept.length)
+            out.push({ ...rule, rects: kept });
+    }
+    return out;
+}
+/** The rules touching any of the rectangles. */
+export function cfIn(rules, rects) {
+    return rules.filter((rule) => rule.rects.some((a) => rects.some((b) => rectsIntersect(a, b))));
+}
+const OPERATOR_WORDS = {
+    greater: 'greater than', less: 'less than', between: 'between', notBetween: 'not between',
+    equal: 'equal to', notEqual: 'not equal to', greaterOrEqual: 'greater than or equal to', lessOrEqual: 'less than or equal to',
+};
+const MATCH_WORDS = {
+    contains: 'contains', notContains: 'does not contain', beginsWith: 'begins with', endsWith: 'ends with',
+};
+/** A rule in words, the way Excel's Manage Rules lists it. */
+export function describeCf(rule) {
+    switch (rule.kind) {
+        case 'cellIs':
+            return rule.operator === 'between' || rule.operator === 'notBetween'
+                ? `Cell Value ${OPERATOR_WORDS[rule.operator]} ${rule.value1} and ${rule.value2 ?? ''}`
+                : `Cell Value ${OPERATOR_WORDS[rule.operator]} ${rule.value1}`;
+        case 'text': return `Cell Value ${MATCH_WORDS[rule.match]} '${rule.value}'`;
+        case 'duplicates': return rule.unique ? 'Unique Values' : 'Duplicate Values';
+        case 'topBottom': return `${rule.top ? 'Top' : 'Bottom'} ${rule.rank}${rule.percent ? '%' : ''}`;
+        case 'average': return rule.above ? 'Above Average' : 'Below Average';
+        case 'formula': return `Formula: ${rule.formula}`;
+        case 'dataBar': return 'Data Bar';
+        case 'colorScale': return rule.colors.length === 3 ? 'Graded Color Scale' : 'Two-Color Scale';
+        case 'iconSet': return 'Icon Set';
+    }
+}
+/** Whether a rule carries a style the dialog can edit. */
+export function hasStyle(rule) {
+    return 'style' in rule;
+}

package/dist/sheet/csv.d.ts

@@ -0,0 +1,32 @@
+import type { SheetState } from './document.js';
+/**
+ * A sheet as CSV, the way Excel's Save As CSV writes one: what the cells
+ * SHOW, so a formula goes out as its value and a formatted number as its
+ * text; a field with a comma, a quote or a line break in quotes, a quote
+ * doubled; CRLF between rows; trailing empty cells kept so every row has
+ * the sheet's width.
+ */
+export declare function csvText(rows: ReadonlyArray<ReadonlyArray<string>>, separator?: string): string;
+/**
+ * CSV text back into rows.
+ *
+ * A scan, not a split: a quoted field may hold the separator, a line break
+ * or a doubled quote, and every real export uses all three. CRLF and LF both
+ * end a row, a BOM at the start is dropped (Excel writes one), and the
+ * separator is guessed when it is not given, so a semicolon file from a
+ * European Excel and a tab file pasted from anywhere read as themselves.
+ */
+export declare function csvRows(text: string, separator?: string): string[][];
+/** The separator a file uses: the one that divides its first lines evenly. */
+export declare function guessCsvSeparator(text: string): string;
+/**
+ * A CSV (or TSV) file as a one-sheet document.
+ *
+ * Every spreadsheet exports CSV and every one of them reads it back the same
+ * way: a field that looks like a number IS a number, and one that looks like
+ * a percentage, a currency amount or a grouped number keeps the format it
+ * implies, which is what `parseEntry` decides for typing. A field is never
+ * read as a formula - a CSV holding `=1+1` is text in Excel too, since the
+ * file came from somewhere else.
+ */
+export declare function sheetStateFromCsv(text: string, sheetName?: string, separator?: string): SheetState;

package/dist/sheet/csv.js

@@ -0,0 +1,158 @@
+import { parseEntry } from './entry.js';
+import { formatKeyAt } from './format-store.js';
+/**
+ * A sheet as CSV, the way Excel's Save As CSV writes one: what the cells
+ * SHOW, so a formula goes out as its value and a formatted number as its
+ * text; a field with a comma, a quote or a line break in quotes, a quote
+ * doubled; CRLF between rows; trailing empty cells kept so every row has
+ * the sheet's width.
+ */
+export function csvText(rows, separator = ',') {
+    const width = rows.reduce((max, row) => Math.max(max, row.length), 0);
+    const field = (text) => /[",\r\n]/.test(text) || text.includes(separator) ? `"${text.replace(/"/g, '""')}"` : text;
+    return rows
+        .map((row) => Array.from({ length: width }, (_, i) => field(row[i] ?? '')).join(separator))
+        .join('\r\n');
+}
+/**
+ * CSV text back into rows.
+ *
+ * A scan, not a split: a quoted field may hold the separator, a line break
+ * or a doubled quote, and every real export uses all three. CRLF and LF both
+ * end a row, a BOM at the start is dropped (Excel writes one), and the
+ * separator is guessed when it is not given, so a semicolon file from a
+ * European Excel and a tab file pasted from anywhere read as themselves.
+ */
+export function csvRows(text, separator) {
+    const body = text.replace(/^/, '');
+    if (body === '')
+        return [];
+    const sep = separator ?? guessCsvSeparator(body);
+    const rows = [];
+    let row = [];
+    let field = '';
+    let quoted = false;
+    let i = 0;
+    const endField = () => { row.push(field); field = ''; };
+    const endRow = () => { endField(); rows.push(row); row = []; };
+    while (i < body.length) {
+        const ch = body[i];
+        if (quoted) {
+            if (ch === '"') {
+                if (body[i + 1] === '"') {
+                    field += '"';
+                    i += 2;
+                    continue;
+                }
+                quoted = false;
+                i += 1;
+                continue;
+            }
+            field += ch;
+            i += 1;
+            continue;
+        }
+        if (ch === '"' && field === '') {
+            quoted = true;
+            i += 1;
+            continue;
+        }
+        if (body.startsWith(sep, i)) {
+            endField();
+            i += sep.length;
+            continue;
+        }
+        if (ch === '\r') {
+            if (body[i + 1] === '\n')
+                i += 1;
+            endRow();
+            i += 1;
+            continue;
+        }
+        if (ch === '\n') {
+            endRow();
+            i += 1;
+            continue;
+        }
+        field += ch;
+        i += 1;
+    }
+    if (field !== '' || row.length)
+        endRow();
+    return rows;
+}
+/** The separator a file uses: the one that divides its first lines evenly. */
+export function guessCsvSeparator(text) {
+    const lines = text.split(/\r?\n/).filter((line) => line !== '').slice(0, 20);
+    if (!lines.length)
+        return ',';
+    let best = null;
+    for (const sep of [',', ';', '\t', '|']) {
+        // Count outside quotes: a comma inside "Smith, John" divides nothing.
+        const counts = lines.map((line) => {
+            let n = 0;
+            let quoted = false;
+            for (let i = 0; i < line.length; i += 1) {
+                const ch = line[i];
+                if (ch === '"') {
+                    quoted = !quoted;
+                    continue;
+                }
+                if (!quoted && line.startsWith(sep, i))
+                    n += 1;
+            }
+            return n;
+        });
+        const present = counts.filter((n) => n > 0).length;
+        if (!present)
+            continue;
+        const first = counts.find((n) => n > 0) ?? 0;
+        const even = counts.every((n) => n === 0 || n === first);
+        const score = present * (even ? 3 : 1) + first;
+        if (!best || score > best.score)
+            best = { sep, score };
+    }
+    return best?.sep ?? ',';
+}
+/**
+ * A CSV (or TSV) file as a one-sheet document.
+ *
+ * Every spreadsheet exports CSV and every one of them reads it back the same
+ * way: a field that looks like a number IS a number, and one that looks like
+ * a percentage, a currency amount or a grouped number keeps the format it
+ * implies, which is what `parseEntry` decides for typing. A field is never
+ * read as a formula - a CSV holding `=1+1` is text in Excel too, since the
+ * file came from somewhere else.
+ */
+export function sheetStateFromCsv(text, sheetName = 'Sheet1', separator) {
+    const rows = csvRows(text, separator);
+    const cells = [];
+    const formats = {};
+    rows.forEach((row, r) => {
+        const line = [];
+        row.forEach((field, c) => {
+            const parsed = field === '' ? null : parseEntry(field);
+            if (parsed) {
+                line.push(parsed.value);
+                if (parsed.numFmt)
+                    formats[formatKeyAt(r, c)] = { numFmt: parsed.numFmt };
+                return;
+            }
+            // A leading = would be read as a formula by the workbook, and this
+            // text was never one: Excel's own CSV import keeps it as it reads.
+            line.push(field.startsWith('=') ? `'${field}` : field);
+        });
+        cells.push(line);
+    });
+    return {
+        version: 1,
+        workbook: { sheets: [{ name: sheetName, cells }], active: sheetName, names: {} },
+        sheets: {
+            [sheetName]: {
+                formats, columnWidths: {}, rowHeights: [], hidden: { rows: [], cols: [] },
+                freeze: { rows: 0, cols: 0 }, comments: {}, protected: false,
+                merges: [], validation: [], conditionalFormats: [], autoFilter: null,
+            },
+        },
+    };
+}

package/dist/sheet/culture.d.ts

@@ -0,0 +1,87 @@
+/**
+ * How a locale spells a number, a date and a formula.
+ *
+ * The rule this module exists to enforce: **the workbook stores the
+ * invariant spelling, always.** A formula in the document is
+ * `=SUM(1.5, A1)` whatever the user's locale, and a number is `1234.5`.
+ * The culture is a layer over the top, applied when a formula is shown for
+ * editing and un-applied when one is typed.
+ *
+ * That is what Excel does, and it is the only arrangement where a file
+ * written in Berlin opens in Boston. Storing `=SUMME(1,5;A1)` would make
+ * the document's meaning depend on who saved it, and every reader, writer
+ * and test would have to carry the locale to make sense of a cell.
+ *
+ * What a culture changes:
+ *   - the decimal mark and the group mark, `1.234,5` against `1,234.5`
+ *   - the argument separator, which Excel makes `;` wherever the decimal
+ *     mark is `,`, since `,` is then busy
+ *   - the order of a slash date, `31/12` against `12/31`
+ *
+ * What it does NOT change: function names, which stay English here, and
+ * the spelling in the file, which stays invariant.
+ */
+export type SheetCulture = {
+    /** The locale this was derived from, for the number formatter. */
+    locale: string;
+    /** The decimal mark, `.` or `,`. */
+    decimal: string;
+    /** The group mark, which may be a non-breaking space. */
+    group: string;
+    /** What separates a function's arguments: `,`, or `;` where `,` is the
+     *  decimal mark. */
+    argSeparator: string;
+    /** How a slash date reads: day first, month first, or year first. */
+    dateOrder: 'dmy' | 'mdy' | 'ymd';
+};
+export declare const SPACE_GROUP_MARKS: ReadonlyArray<string>;
+/** The spelling the document itself uses, and the default. */
+export declare const INVARIANT_CULTURE: SheetCulture;
+/**
+ * The culture a locale implies, read off `Intl` rather than a table, so a
+ * locale nobody thought of still comes out right.
+ *
+ * Falls back to the invariant culture where `Intl` is missing or the
+ * locale is not one it knows, since a sheet that renders in the wrong
+ * separators is better than one that does not render.
+ */
+export declare function cultureFromLocale(locale: string): SheetCulture;
+/** True where the culture spells everything the way the document does. */
+export declare const isInvariant: (c: SheetCulture) => boolean;
+/**
+ * A stored formula as the user's locale spells it, for the formula bar.
+ *
+ * `=SUM(1.5, A1)` becomes `=SUM(1,5; A1)` in a German sheet.
+ */
+export declare function formulaToCulture(formula: string, culture: SheetCulture): string;
+/**
+ * A typed formula back to the spelling the document stores.
+ *
+ * The inverse of `formulaToCulture`, with one deliberate kindness: where
+ * the culture's separator is `;`, a `,` between arguments is taken as a
+ * separator too, so a user with an English keyboard habit is not stopped.
+ * A `,` that sits between digits is still the decimal mark, so nothing
+ * ambiguous is guessed at.
+ */
+export declare function formulaFromCulture(formula: string, culture: SheetCulture): string;
+/**
+ * A number as the culture writes it, back to a plain number.
+ *
+ * Returns null when the text is not a number in this culture, so the
+ * caller can fall through to treating it as text. The group mark is
+ * dropped wherever it appears rather than checked for position, as Excel
+ * does: `1.2.3,4` is not worth refusing on a technicality.
+ */
+export declare function parseNumberInCulture(text: string, culture: SheetCulture): number | null;
+/** A number as the culture writes it, for display. */
+export declare function formatNumberInCulture(value: number, culture: SheetCulture): string;
+/**
+ * The day, month and year a slash date names, in this culture's order.
+ *
+ * Returns null when the pieces cannot be a date, which is what tells a
+ * slash date apart from a fraction typed without a whole part.
+ */
+export declare function slashDateParts(a: number, b: number, culture: SheetCulture): {
+    month: number;
+    day: number;
+} | null;