@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/sheet/packs/text-date.d.ts

@@ -0,0 +1,2 @@
+import type { SheetFunction } from '../functions.js';
+export declare const TEXT_DATE_FUNCTIONS: Record<string, SheetFunction>;

package/dist/sheet/packs/text-date.js

@@ -0,0 +1,332 @@
+/**
+ * More of Excel's text and date functions.
+ *
+ * Dates in this engine are the `yyyy-mm-dd` text the DATE family already
+ * hands back, or a serial number; `toDate` reads either. The functions that
+ * produce a date produce the text form, the ones that produce a time
+ * produce a serial fraction of a day, which the `h:mm` number formats show.
+ */
+import { FormulaError, err } from '../ast.js';
+import { toNumber, toText, isBlank, toDate, isoDate, dateSerial } from '../coerce.js';
+const first = (a) => a.flat[0] ?? '';
+const nth = (a, i) => a.args[i]?.[0] ?? '';
+const num = (a, i) => toNumber(nth(a, i));
+function opt(a, i, fallback) {
+    const v = a.args[i]?.[0];
+    return v === undefined || v === '' ? fallback : toNumber(v);
+}
+const DAY_MS = 86400000;
+/** Hours, minutes and seconds out of a value: a serial's fraction, a
+ *  `hh:mm[:ss] [AM|PM]` text (with or without a date before it), or a
+ *  date-time `toDate` can read. */
+function timeOf(v) {
+    if (typeof v === 'number') {
+        const secs = Math.round((v - Math.floor(v)) * 86400) % 86400;
+        return { h: Math.floor(secs / 3600), m: Math.floor((secs % 3600) / 60), s: secs % 60 };
+    }
+    const text = toText(v).trim();
+    const m = /(\d{1,2}):(\d{2})(?::(\d{2}))?\s*(AM|PM|am|pm)?\s*$/.exec(text);
+    if (m) {
+        let h = Number(m[1]);
+        const meridian = m[4]?.toUpperCase();
+        if (meridian === 'PM' && h < 12)
+            h += 12;
+        if (meridian === 'AM' && h === 12)
+            h = 0;
+        if (h > 23 || Number(m[2]) > 59 || Number(m[3] ?? 0) > 59)
+            throw new FormulaError('#VALUE!');
+        return { h, m: Number(m[2]), s: Number(m[3] ?? 0) };
+    }
+    const d = toDate(v);
+    return { h: d.getUTCHours(), m: d.getUTCMinutes(), s: d.getUTCSeconds() };
+}
+const isWeekend = (d) => d.getUTCDay() === 0 || d.getUTCDay() === 6;
+const daySerial = (d) => Math.floor(dateSerial(d));
+/** The holidays argument of NETWORKDAYS / WORKDAY as a set of day serials. */
+function holidaySet(values) {
+    const out = new Set();
+    for (const v of values ?? []) {
+        if (isBlank(v))
+            continue;
+        out.add(daySerial(toDate(v)));
+    }
+    return out;
+}
+const isLetter = (ch) => ch.toLowerCase() !== ch.toUpperCase();
+const lastOfMonth = (d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth() + 1, 0)).getUTCDate();
+/** Days between two dates on a 360-day year, the US (NASD) method Excel
+ *  defaults to. */
+function days360(s, e) {
+    let d1 = s.getUTCDate();
+    let d2 = e.getUTCDate();
+    if (d1 === 31 || (s.getUTCMonth() === 1 && d1 === lastOfMonth(s)))
+        d1 = 30;
+    if (d2 === 31 && d1 === 30)
+        d2 = 30;
+    return (e.getUTCFullYear() - s.getUTCFullYear()) * 360 + (e.getUTCMonth() - s.getUTCMonth()) * 30 + (d2 - d1);
+}
+const isLeap = (y) => (y % 4 === 0 && y % 100 !== 0) || y % 400 === 0;
+export const TEXT_DATE_FUNCTIONS = {
+    // ---- Text ------------------------------------------------------------
+    // Excel capitalises a letter that follows anything but a letter, so
+    // "76BudGet" is "76Budget" and "2-way" is "2-Way".
+    PROPER: (a) => {
+        const s = toText(first(a));
+        let out = '';
+        let afterLetter = false;
+        for (const ch of s) {
+            if (isLetter(ch)) {
+                out += afterLetter ? ch.toLowerCase() : ch.toUpperCase();
+                afterLetter = true;
+            }
+            else {
+                out += ch;
+                afterLetter = false;
+            }
+        }
+        return out;
+    },
+    REPT: (a) => {
+        const n = Math.trunc(num(a, 1));
+        if (n < 0)
+            return err('#VALUE!');
+        return toText(nth(a, 0)).repeat(n);
+    },
+    // VALUE reads what a typed entry would: a plain number, a currency or
+    // grouped one, a percentage, a time or a date.
+    VALUE: (a) => {
+        const v = first(a);
+        if (typeof v === 'number')
+            return v;
+        if (typeof v === 'boolean')
+            return err('#VALUE!');
+        const text = toText(v).trim();
+        if (text === '')
+            return err('#VALUE!');
+        const cleaned = text.replace(/[$,]/g, '');
+        if (/^-?\d*\.?\d+(e[+-]?\d+)?%$/i.test(cleaned))
+            return Number(cleaned.slice(0, -1)) / 100;
+        const n = Number(cleaned);
+        if (cleaned !== '' && Number.isFinite(n))
+            return n;
+        if (/^\d{1,2}:\d{2}(:\d{2})?\s*(AM|PM)?$/i.test(text)) {
+            const t = timeOf(text);
+            return (t.h * 3600 + t.m * 60 + t.s) / 86400;
+        }
+        try {
+            return dateSerial(toDate(text));
+        }
+        catch {
+            return err('#VALUE!');
+        }
+    },
+    /**
+     * NUMBERVALUE(text, [decimal], [group]): VALUE for a number written the
+     * way another country writes one. The separators are given rather than
+     * guessed, which is the whole point of it: "1.234,56" is a thousand two
+     * hundred in Germany and one point two in Britain, and only the caller
+     * knows which.
+     */
+    NUMBERVALUE: (a) => {
+        const v = first(a);
+        if (typeof v === 'number')
+            return v;
+        if (typeof v === 'boolean')
+            return err('#VALUE!');
+        const decimal = (toText(nth(a, 1)) || '.').trim().slice(0, 1) || '.';
+        const group = (toText(nth(a, 2)) || ',').trim().slice(0, 1);
+        if (decimal === group)
+            return err('#VALUE!');
+        let text = toText(v).trim();
+        if (text === '')
+            return 0;
+        // Trailing percent signs each divide by a hundred, as Excel's do.
+        let percents = 0;
+        while (text.endsWith('%')) {
+            percents += 1;
+            text = text.slice(0, -1).trim();
+        }
+        // Excel reads the group separator as a thousands mark, so one AFTER the
+        // decimal separator is not a number written another way, it is a typo:
+        // "1.5,5" is #VALUE! rather than fifteen and a half.
+        const point = text.indexOf(decimal);
+        if (group !== '' && point >= 0 && text.indexOf(group, point) > point)
+            return err('#VALUE!');
+        // The group separator is dropped and the decimal one becomes a point;
+        // spaces are dropped too, since a space is a group separator in half of
+        // Europe whatever was asked for.
+        const stripped = text
+            .split('').filter((ch) => ch !== group && !/\s/.test(ch)).join('')
+            .replace(decimal, '.');
+        if (stripped === '' || /[^0-9.+-]/.test(stripped))
+            return err('#VALUE!');
+        const n = Number(stripped);
+        if (!Number.isFinite(n))
+            return err('#VALUE!');
+        return n / 100 ** percents;
+    },
+    CHAR: (a) => {
+        const n = Math.trunc(num(a, 0));
+        if (n < 1 || n > 255)
+            return err('#VALUE!');
+        return String.fromCharCode(n);
+    },
+    CODE: (a) => {
+        const s = toText(first(a));
+        return s === '' ? err('#VALUE!') : s.charCodeAt(0);
+    },
+    UNICHAR: (a) => {
+        const n = Math.trunc(num(a, 0));
+        if (n < 1 || n > 0x10ffff)
+            return err('#VALUE!');
+        return String.fromCodePoint(n);
+    },
+    UNICODE: (a) => {
+        const s = toText(first(a));
+        return s === '' ? err('#VALUE!') : s.codePointAt(0);
+    },
+    EXACT: (a) => toText(nth(a, 0)) === toText(nth(a, 1)),
+    CLEAN: (a) => {
+        let out = '';
+        for (const ch of toText(first(a)))
+            if (ch.charCodeAt(0) >= 32)
+                out += ch;
+        return out;
+    },
+    REPLACE: (a) => {
+        const s = toText(nth(a, 0));
+        const start = Math.trunc(num(a, 1));
+        const count = Math.trunc(num(a, 2));
+        if (start < 1 || count < 0)
+            return err('#VALUE!');
+        return s.slice(0, start - 1) + toText(nth(a, 3)) + s.slice(start - 1 + count);
+    },
+    T: (a) => (typeof first(a) === 'string' ? first(a) : ''),
+    N: (a) => {
+        const v = first(a);
+        return typeof v === 'number' ? v : typeof v === 'boolean' ? (v ? 1 : 0) : 0;
+    },
+    // ---- Date and time ---------------------------------------------------
+    // WEEKDAY(date, [type]): 1 counts Sunday as 1, 2 counts Monday as 1, 3
+    // counts Monday as 0; 11 to 17 count from Monday to Sunday as 1.
+    WEEKDAY: (a) => {
+        const day = toDate(nth(a, 0)).getUTCDay();
+        const type = opt(a, 1, 1);
+        if (type === 1)
+            return day + 1;
+        if (type === 2)
+            return ((day + 6) % 7) + 1;
+        if (type === 3)
+            return (day + 6) % 7;
+        if (type >= 11 && type <= 17) {
+            const start = (type - 10) % 7;
+            return ((day - start + 7) % 7) + 1;
+        }
+        return err('#NUM!');
+    },
+    // EDATE(date, months): the same day `months` on, clamped to the end of a
+    // shorter month, so a 31st in January lands on the 28th or 29th.
+    EDATE: (a) => {
+        const d = toDate(nth(a, 0));
+        const months = Math.trunc(num(a, 1));
+        const y = d.getUTCFullYear();
+        const m = d.getUTCMonth() + months;
+        const last = new Date(Date.UTC(y, m + 1, 0)).getUTCDate();
+        return isoDate(new Date(Date.UTC(y, m, Math.min(d.getUTCDate(), last))));
+    },
+    NETWORKDAYS: (a) => {
+        const start = daySerial(toDate(nth(a, 0)));
+        const end = daySerial(toDate(nth(a, 1)));
+        const holidays = holidaySet(a.args[2]);
+        const from = Math.min(start, end);
+        const to = Math.max(start, end);
+        let count = 0;
+        for (let s = from; s <= to; s += 1) {
+            if (!isWeekend(toDate(s)) && !holidays.has(s))
+                count += 1;
+        }
+        return end < start ? -count : count;
+    },
+    WORKDAY: (a) => {
+        let s = daySerial(toDate(nth(a, 0)));
+        let left = Math.trunc(num(a, 1));
+        const holidays = holidaySet(a.args[2]);
+        const step = left < 0 ? -1 : 1;
+        while (left !== 0) {
+            s += step;
+            if (isWeekend(toDate(s)) || holidays.has(s))
+                continue;
+            left -= step;
+        }
+        return isoDate(toDate(s));
+    },
+    // WEEKNUM(date, [type]): 1 and 2 make the week holding January 1 week 1,
+    // starting Sunday or Monday; 11 to 17 start on Monday to Sunday; 21 is
+    // the ISO week.
+    WEEKNUM: (a) => {
+        const d = toDate(nth(a, 0));
+        const type = opt(a, 1, 1);
+        if (type === 21) {
+            const t = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+            // Move to the Thursday of this week; its year is the ISO year.
+            t.setUTCDate(t.getUTCDate() - ((t.getUTCDay() + 6) % 7) + 3);
+            const jan4 = new Date(Date.UTC(t.getUTCFullYear(), 0, 4));
+            const firstThursday = new Date(jan4.getTime());
+            firstThursday.setUTCDate(jan4.getUTCDate() - ((jan4.getUTCDay() + 6) % 7) + 3);
+            return 1 + Math.round((t.getTime() - firstThursday.getTime()) / (7 * DAY_MS));
+        }
+        const startDay = type === 1 ? 0 : type === 2 ? 1 : type >= 11 && type <= 17 ? (type - 10) % 7 : -1;
+        if (startDay < 0)
+            return err('#NUM!');
+        const jan1 = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+        const offset = (jan1.getUTCDay() - startDay + 7) % 7;
+        const dayOfYear = Math.floor((Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()) - jan1.getTime()) / DAY_MS);
+        return Math.floor((dayOfYear + offset) / 7) + 1;
+    },
+    HOUR: (a) => timeOf(first(a)).h,
+    MINUTE: (a) => timeOf(first(a)).m,
+    SECOND: (a) => timeOf(first(a)).s,
+    // TIME(hour, minute, second): a fraction of a day, wrapping past 24 hours.
+    TIME: (a) => {
+        const secs = Math.trunc(num(a, 0)) * 3600 + Math.trunc(num(a, 1)) * 60 + Math.trunc(num(a, 2));
+        if (secs < 0)
+            return err('#NUM!');
+        return (secs % 86400) / 86400;
+    },
+    DATEVALUE: (a) => {
+        const v = first(a);
+        if (typeof v === 'number')
+            return err('#VALUE!');
+        return daySerial(toDate(v));
+    },
+    TIMEVALUE: (a) => {
+        const t = timeOf(first(a));
+        return (t.h * 3600 + t.m * 60 + t.s) / 86400;
+    },
+    DAYS360: (a) => days360(toDate(nth(a, 0)), toDate(nth(a, 1))),
+    // YEARFRAC(start, end, [basis]): 0 is US 30/360, 1 actual/actual, 2
+    // actual/360, 3 actual/365, 4 European 30/360 (read as US here).
+    YEARFRAC: (a) => {
+        const s = toDate(nth(a, 0));
+        const e = toDate(nth(a, 1));
+        const basis = Math.trunc(opt(a, 2, 0));
+        const from = s.getTime() <= e.getTime() ? s : e;
+        const to = s.getTime() <= e.getTime() ? e : s;
+        if (basis === 0 || basis === 4)
+            return days360(from, to) / 360;
+        const days = daySerial(to) - daySerial(from);
+        if (basis === 2)
+            return days / 360;
+        if (basis === 3)
+            return days / 365;
+        if (basis !== 1)
+            return err('#NUM!');
+        // Actual/actual: the average year length across the span.
+        const y1 = from.getUTCFullYear();
+        const y2 = to.getUTCFullYear();
+        let total = 0;
+        for (let y = y1; y <= y2; y += 1)
+            total += isLeap(y) ? 366 : 365;
+        return days / (total / (y2 - y1 + 1));
+    },
+};

package/dist/sheet/packs/trig.d.ts

@@ -0,0 +1,2 @@
+import type { SheetFunction } from '../functions.js';
+export declare const TRIG_FUNCTIONS: Record<string, SheetFunction>;

package/dist/sheet/packs/trig.js

@@ -0,0 +1,73 @@
+/**
+ * Excel's Math and Trigonometry family: the circular functions, their
+ * inverses, the hyperbolic set, and the two that turn one angle measure
+ * into the other.
+ *
+ * Two traps live here, both of which read as a bug in a model rather than
+ * as a difference of convention:
+ *
+ *   - `ATAN2` takes its arguments x first, y second, which is the opposite
+ *     order from every C-family `atan2`. `=ATAN2(-1, 1)` is 3/4 pi in
+ *     Excel; handing the pair straight to `Math.atan2` gives -1/4 pi.
+ *   - The reciprocal functions are undefined where their partner is zero,
+ *     and Excel reports that as `#DIV/0!` rather than as infinity.
+ *
+ * Domain errors are `#NUM!`, as Excel reports them: ASIN past 1, ACOSH
+ * below 1, ATANH at 1.
+ */
+import { err } from '../ast.js';
+import { toNumber } from '../coerce.js';
+const nth = (a, i) => a.args[i]?.[0] ?? '';
+const num = (a, i) => toNumber(nth(a, i));
+/** A result that has to lie in a domain, with Excel's error when it does not. */
+const guard = (ok, value) => (ok ? value() : err('#NUM!'));
+/**
+ * A reciprocal of a circular function. Excel calls the pole `#DIV/0!`, and
+ * a pole is where the partner function is zero. Comparing against an exact
+ * zero is right for COT(0) and CSC(0), which is what people actually type;
+ * at pi the partner is only near zero in binary floating point, and Excel
+ * answers with the same large number JavaScript does, so nothing is snapped.
+ */
+const reciprocal = (partner) => (partner === 0 ? err('#DIV/0!') : 1 / partner);
+export const TRIG_FUNCTIONS = {
+    // ---- Circular --------------------------------------------------------
+    SIN: (a) => Math.sin(num(a, 0)),
+    COS: (a) => Math.cos(num(a, 0)),
+    TAN: (a) => Math.tan(num(a, 0)),
+    COT: (a) => reciprocal(Math.tan(num(a, 0))),
+    SEC: (a) => reciprocal(Math.cos(num(a, 0))),
+    CSC: (a) => reciprocal(Math.sin(num(a, 0))),
+    // ---- Inverse circular ------------------------------------------------
+    ASIN: (a) => { const x = num(a, 0); return guard(x >= -1 && x <= 1, () => Math.asin(x)); },
+    ACOS: (a) => { const x = num(a, 0); return guard(x >= -1 && x <= 1, () => Math.acos(x)); },
+    ATAN: (a) => Math.atan(num(a, 0)),
+    // Excel's argument order is (x, y); Math.atan2 wants (y, x).
+    ATAN2: (a) => {
+        const x = num(a, 0);
+        const y = num(a, 1);
+        return x === 0 && y === 0 ? err('#DIV/0!') : Math.atan2(y, x);
+    },
+    // ACOT is the angle in (0, pi), which is what pi/2 minus ATAN gives for
+    // every real argument, zero included.
+    ACOT: (a) => Math.PI / 2 - Math.atan(num(a, 0)),
+    // ---- Hyperbolic ------------------------------------------------------
+    SINH: (a) => Math.sinh(num(a, 0)),
+    COSH: (a) => Math.cosh(num(a, 0)),
+    TANH: (a) => Math.tanh(num(a, 0)),
+    COTH: (a) => reciprocal(Math.tanh(num(a, 0))),
+    SECH: (a) => reciprocal(Math.cosh(num(a, 0))),
+    CSCH: (a) => reciprocal(Math.sinh(num(a, 0))),
+    // ---- Inverse hyperbolic ---------------------------------------------
+    ASINH: (a) => Math.asinh(num(a, 0)),
+    ACOSH: (a) => { const x = num(a, 0); return guard(x >= 1, () => Math.acosh(x)); },
+    ATANH: (a) => { const x = num(a, 0); return guard(x > -1 && x < 1, () => Math.atanh(x)); },
+    // ACOTH is defined outside [-1, 1]; at the ends it is a pole.
+    ACOTH: (a) => {
+        const x = num(a, 0);
+        return guard(Math.abs(x) > 1, () => 0.5 * Math.log((x + 1) / (x - 1)));
+    },
+    // ---- Angle measure and the odd one out -------------------------------
+    DEGREES: (a) => (num(a, 0) * 180) / Math.PI,
+    RADIANS: (a) => (num(a, 0) * Math.PI) / 180,
+    SQRTPI: (a) => { const x = num(a, 0); return guard(x >= 0, () => Math.sqrt(x * Math.PI)); },
+};

package/dist/sheet/page-setup.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Excel's Page Setup, per sheet: what the Page Layout tab sets and File >
+ * Print reads. Orientation, paper, margins, the print area, the rows that
+ * repeat at the top of every page, whether gridlines and headings print,
+ * and the scale. Margins are in inches, the unit the file keeps them in.
+ * Nothing here touches the DOM; `print.ts` turns a sheet and its setup
+ * into the page.
+ */
+import type { Rect } from './rects.js';
+import type { StructuralEdit } from './refs.js';
+export type PageOrientation = 'portrait' | 'landscape';
+/** The papers Excel's list starts with, with their OOXML `paperSize` codes. */
+export declare const PAPER_SIZES: {
+    readonly Letter: {
+        readonly code: 1;
+        readonly css: "letter";
+    };
+    readonly Tabloid: {
+        readonly code: 3;
+        readonly css: "11in 17in";
+    };
+    readonly Legal: {
+        readonly code: 5;
+        readonly css: "legal";
+    };
+    readonly A3: {
+        readonly code: 8;
+        readonly css: "A3";
+    };
+    readonly A4: {
+        readonly code: 9;
+        readonly css: "A4";
+    };
+    readonly A5: {
+        readonly code: 11;
+        readonly css: "A5";
+    };
+};
+export type PaperSize = keyof typeof PAPER_SIZES;
+/** Inches, as the file keeps them: page edges, and the header and footer bands. */
+export type PageMargins = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    header: number;
+    footer: number;
+};
+/** Excel's Margins dropdown. */
+export declare const MARGIN_PRESETS: Record<'normal' | 'narrow' | 'wide', PageMargins>;
+export type MarginPreset = keyof typeof MARGIN_PRESETS;
+export type PageSetup = {
+    orientation: PageOrientation;
+    paper: PaperSize;
+    margins: PageMargins;
+    /** The cells that print, or null for everything the sheet holds. */
+    printArea: Rect[] | null;
+    /** Rows repeated at the top of every page, `[first, last]` 0-based, or null. */
+    printTitleRows: [number, number] | null;
+    gridlines: boolean;
+    headings: boolean;
+    /** Percent; 100 prints at size. */
+    scale: number;
+};
+export declare const defaultPageSetup: () => PageSetup;
+/** A copy safe to hand out or save. */
+export declare function copyPageSetup(setup: PageSetup): PageSetup;
+/** Which preset the margins are, if any, for the dropdown's lit entry. */
+export declare function marginPresetOf(margins: PageMargins): MarginPreset | null;
+/** The setup after an insert or delete: the print area and the title rows move with their lines. */
+export declare function shiftPageSetup(setup: PageSetup, edit: StructuralEdit): PageSetup;
+/** `@page` margins from inches, the order CSS wants. */
+export declare function marginsCss(margins: PageMargins): string;

package/dist/sheet/page-setup.js

@@ -0,0 +1,73 @@
+import { shiftRect, lineShift } from './rects.js';
+/** The papers Excel's list starts with, with their OOXML `paperSize` codes. */
+export const PAPER_SIZES = {
+    Letter: { code: 1, css: 'letter' },
+    Tabloid: { code: 3, css: '11in 17in' },
+    Legal: { code: 5, css: 'legal' },
+    A3: { code: 8, css: 'A3' },
+    A4: { code: 9, css: 'A4' },
+    A5: { code: 11, css: 'A5' },
+};
+/** Excel's Margins dropdown. */
+export const MARGIN_PRESETS = {
+    normal: { top: 0.75, bottom: 0.75, left: 0.7, right: 0.7, header: 0.3, footer: 0.3 },
+    narrow: { top: 0.75, bottom: 0.75, left: 0.25, right: 0.25, header: 0.3, footer: 0.3 },
+    wide: { top: 1, bottom: 1, left: 1, right: 1, header: 0.5, footer: 0.5 },
+};
+export const defaultPageSetup = () => ({
+    orientation: 'portrait',
+    paper: 'A4',
+    margins: { ...MARGIN_PRESETS.normal },
+    printArea: null,
+    printTitleRows: null,
+    gridlines: false,
+    headings: false,
+    scale: 100,
+});
+/** A copy safe to hand out or save. */
+export function copyPageSetup(setup) {
+    return {
+        ...setup,
+        margins: { ...setup.margins },
+        printArea: setup.printArea ? setup.printArea.map(([r1, c1, r2, c2]) => [r1, c1, r2, c2]) : null,
+        printTitleRows: setup.printTitleRows ? [setup.printTitleRows[0], setup.printTitleRows[1]] : null,
+    };
+}
+/** Which preset the margins are, if any, for the dropdown's lit entry. */
+export function marginPresetOf(margins) {
+    for (const [name, preset] of Object.entries(MARGIN_PRESETS)) {
+        if (Object.keys(preset).every((k) => Math.abs(preset[k] - margins[k]) < 1e-6))
+            return name;
+    }
+    return null;
+}
+/** The setup after an insert or delete: the print area and the title rows move with their lines. */
+export function shiftPageSetup(setup, edit) {
+    const out = copyPageSetup(setup);
+    if (out.printArea) {
+        const moved = out.printArea.map((r) => shiftRect(r, edit)).filter((r) => r !== null);
+        out.printArea = moved.length ? moved : null;
+    }
+    if (out.printTitleRows && (edit.kind === 'insertRows' || edit.kind === 'deleteRows')) {
+        const shift = lineShift(edit);
+        const [a, b] = out.printTitleRows;
+        if (edit.kind === 'insertRows') {
+            out.printTitleRows = [shift(a), shift(b)];
+        }
+        else {
+            const rows = [];
+            for (let r = a; r <= b; r += 1) {
+                const next = shift(r);
+                if (next !== null)
+                    rows.push(next);
+            }
+            out.printTitleRows = rows.length ? [rows[0], rows[rows.length - 1]] : null;
+        }
+    }
+    return out;
+}
+/** `@page` margins from inches, the order CSS wants. */
+export function marginsCss(margins) {
+    const inch = (n) => `${Math.round(n * 100) / 100}in`;
+    return `${inch(margins.top)} ${inch(margins.right)} ${inch(margins.bottom)} ${inch(margins.left)}`;
+}

package/dist/sheet/palette.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Excel's colour picker, as data: the ten theme colours with five tints and
+ * shades each, then the ten standard colours. These are the values a
+ * spreadsheet user expects to find under Fill Colour and Font Colour, and
+ * they are cell DATA (a fill the document carries) rather than chrome, which
+ * is why they are literal hex here and not theme tokens.
+ */
+export type PaletteColour = {
+    value: string;
+    label: string;
+};
+export declare const STANDARD_COLOURS: ReadonlyArray<PaletteColour>;
+/** Mix `hex` toward white (`amount` > 0) or black (`amount` < 0). */
+export declare function tint(hex: string, amount: number): string;
+export type PaletteRow = ReadonlyArray<PaletteColour>;
+/** Ten columns by six rows: the base row, then five variations per column. */
+export declare const THEME_COLOURS: ReadonlyArray<PaletteRow>;
+/** The whole picker flattened, for a `select` fallback and for tests. */
+export declare const ALL_COLOURS: ReadonlyArray<PaletteColour>;

package/dist/sheet/palette.js

@@ -0,0 +1,84 @@
+/**
+ * Excel's colour picker, as data: the ten theme colours with five tints and
+ * shades each, then the ten standard colours. These are the values a
+ * spreadsheet user expects to find under Fill Colour and Font Colour, and
+ * they are cell DATA (a fill the document carries) rather than chrome, which
+ * is why they are literal hex here and not theme tokens.
+ */
+/** The Office theme's base row: white, black, two greys, then six accents. */
+const THEME_BASE = [
+    { value: '#FFFFFF', label: 'White, Background 1' },
+    { value: '#000000', label: 'Black, Text 1' },
+    { value: '#E7E6E6', label: 'Light Gray, Background 2' },
+    { value: '#44546A', label: 'Blue-Gray, Text 2' },
+    { value: '#4472C4', label: 'Blue, Accent 1' },
+    { value: '#ED7D31', label: 'Orange, Accent 2' },
+    { value: '#A5A5A5', label: 'Gray, Accent 3' },
+    { value: '#FFC000', label: 'Gold, Accent 4' },
+    { value: '#5B9BD5', label: 'Blue, Accent 5' },
+    { value: '#70AD47', label: 'Green, Accent 6' },
+];
+export const STANDARD_COLOURS = [
+    { value: '#C00000', label: 'Dark Red' },
+    { value: '#FF0000', label: 'Red' },
+    { value: '#FFC000', label: 'Orange' },
+    { value: '#FFFF00', label: 'Yellow' },
+    { value: '#92D050', label: 'Light Green' },
+    { value: '#00B050', label: 'Green' },
+    { value: '#00B0F0', label: 'Light Blue' },
+    { value: '#0070C0', label: 'Blue' },
+    { value: '#002060', label: 'Dark Blue' },
+    { value: '#7030A0', label: 'Purple' },
+];
+function hexToRgb(hex) {
+    const n = parseInt(hex.slice(1), 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+function rgbToHex([r, g, b]) {
+    const part = (v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, '0').toUpperCase();
+    return `#${part(r)}${part(g)}${part(b)}`;
+}
+/** Mix `hex` toward white (`amount` > 0) or black (`amount` < 0). */
+export function tint(hex, amount) {
+    const [r, g, b] = hexToRgb(hex);
+    const target = amount > 0 ? 255 : 0;
+    const t = Math.abs(amount);
+    return rgbToHex([r + (target - r) * t, g + (target - g) * t, b + (target - b) * t]);
+}
+/**
+ * Excel's five variations under each theme colour. Lighter 80/60/40 % for
+ * the accents; the white and black columns run the other way, as they do in
+ * Excel, so white gets greys and black gets lighter greys rather than five
+ * identical swatches.
+ */
+const STEPS = [
+    { amount: 0.8, label: 'Lighter 80%' },
+    { amount: 0.6, label: 'Lighter 60%' },
+    { amount: 0.4, label: 'Lighter 40%' },
+    { amount: -0.25, label: 'Darker 25%' },
+    { amount: -0.5, label: 'Darker 50%' },
+];
+const WHITE_STEPS = [-0.05, -0.15, -0.25, -0.35, -0.5];
+const BLACK_STEPS = [0.5, 0.35, 0.25, 0.15, 0.05];
+/** Ten columns by six rows: the base row, then five variations per column. */
+export const THEME_COLOURS = (() => {
+    const rows = [THEME_BASE.map((c) => ({ ...c }))];
+    for (let step = 0; step < 5; step += 1) {
+        rows.push(THEME_BASE.map((base, col) => {
+            const amount = col === 0 ? WHITE_STEPS[step] : col === 1 ? BLACK_STEPS[step] : STEPS[step].amount;
+            const name = base.label.split(',')[0];
+            const how = col === 0
+                ? `Darker ${Math.round(Math.abs(amount) * 100)}%`
+                : col === 1
+                    ? `Lighter ${Math.round(amount * 100)}%`
+                    : STEPS[step].label;
+            return { value: tint(base.value, amount), label: `${name}, ${how}` };
+        }));
+    }
+    return rows;
+})();
+/** The whole picker flattened, for a `select` fallback and for tests. */
+export const ALL_COLOURS = [
+    ...THEME_COLOURS.flat(),
+    ...STANDARD_COLOURS,
+];

package/dist/sheet/parse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Precedence-climbing parser over the token stream.
+ *
+ * One structural choice worth naming: a whole-column reference like `A:A`
+ * lexes as a range whose `to.row` is null, and the evaluator fills that in
+ * from the sheet's last used row. Resolving it here instead would bake the
+ * row count into the AST, and the AST is cached across edits that change it.
+ */
+import { type Node } from './ast.js';
+import { type Token } from './tokenize.js';
+export declare function parse(tokens: ReadonlyArray<Token>): Node;
+/** Tokenize and parse one formula. Accepts the leading `=` or not. */
+export declare function parseFormula(src: string): Node;