@svgrid/enterprise 3.0.2 → 3.1.0

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/parse.js

@@ -22,9 +22,9 @@ export function parse(tokens) {
             if (prec === undefined || prec < minPrec)
                 break;
             next();
-            // Left-associative for everything except `^`, which Excel binds right.
-            const nextMin = t.v === '^' ? prec : prec + 1;
-            left = { k: 'binary', op: t.v, left, right: expression(nextMin) };
+            // Every binary operator binds left, `^` included: Excel reads 2^3^2 as
+            // (2^3)^2, which is 64, where a right-binding `^` would make it 512.
+            left = { k: 'binary', op: t.v, left, right: expression(prec + 1) };
         }
         return left;
     }
@@ -47,8 +47,11 @@ export function parse(tokens) {
             case 'num': return { k: 'num', v: t.v };
             case 'str': return { k: 'str', v: t.v };
             case 'bool': return { k: 'bool', v: t.v };
+            case 'err': return { k: 'err', v: t.v };
             case 'ref': return { k: 'ref', ref: t.ref };
+            case 'spill': return { k: 'spill', ref: t.ref };
             case 'range': return { k: 'range', from: t.from, to: t.to };
+            case 'range3d': return { k: 'ref3d', sheetFrom: t.sheetFrom, sheetTo: t.sheetTo, from: t.from, to: t.to };
             case 'name': return { k: 'name', name: t.v };
             case 'table':
                 return t.columnTo === undefined
@@ -69,25 +72,54 @@ export function parse(tokens) {
                 if (!open || open.t !== 'lparen')
                     throw new FormulaError('#PARSE!');
                 const args = [];
+                // An argument left out between two commas, or before the closing
+                // paren after a comma, is an empty node rather than a parse error,
+                // as Excel reads `PMT(A1, A2, A3, , 1)`.
+                const argument = () => {
+                    const t = peek()?.t;
+                    return t === 'comma' || t === 'rparen' ? { k: 'empty' } : expression(1);
+                };
                 if (peek()?.t !== 'rparen') {
-                    args.push(expression(1));
+                    args.push(argument());
                     while (peek()?.t === 'comma') {
                         next();
-                        args.push(expression(1));
+                        args.push(argument());
                     }
                 }
                 const close = next();
                 if (!close || close.t !== 'rparen')
                     throw new FormulaError('#PARSE!');
-                return { k: 'fn', name: t.v, args };
+                let made = { k: 'fn', name: t.v, args };
+                // `=LAMBDA(x, x * 2)(5)`: a lambda written and called on the spot.
+                // Only a lambda is callable this way, so nothing else changes shape;
+                // the call is a `fn` node named `(`, which no tokenizer can produce.
+                while (made.k === 'fn' && (made.name === 'LAMBDA' || made.name === '(') && peek()?.t === 'lparen') {
+                    next();
+                    const callArgs = [made];
+                    if (peek()?.t !== 'rparen') {
+                        callArgs.push(argument());
+                        while (peek()?.t === 'comma') {
+                            next();
+                            callArgs.push(argument());
+                        }
+                    }
+                    const end = next();
+                    if (!end || end.t !== 'rparen')
+                        throw new FormulaError('#PARSE!');
+                    made = { k: 'fn', name: '(', args: callArgs };
+                }
+                return made;
             }
             case 'op': {
-                // Unary. Binds tighter than every binary operator except `^`, so
-                // `-2^2` is -(2^2) as in Excel, and `-A1*2` is (-A1)*2.
+                // Unary, and it binds tighter than every binary operator, `^`
+                // included: Excel reads -2^2 as (-2)^2, which is 4, not -4. Only the
+                // postfix `%` is tighter still, so -A1% is -(A1/100). The operand is
+                // therefore one term, not an expression: taking an expression here
+                // is what swallows the `^`.
                 if (t.v === '-')
-                    return { k: 'unary', op: '-', arg: expression(5) };
+                    return { k: 'unary', op: '-', arg: postfix(primary()) };
                 if (t.v === '+')
-                    return { k: 'unary', op: '+', arg: expression(5) };
+                    return { k: 'unary', op: '+', arg: postfix(primary()) };
                 throw new FormulaError('#PARSE!');
             }
             default:

package/dist/sheet/paste-special.d.ts

@@ -105,6 +105,18 @@ export declare function resolvePasteCell(source: ClipboardCell | undefined, exis
 }, at?: {
     row: number;
     col: number;
+}, 
+/** Where the cell came from and lands, for a transposed paste: its
+ *  relative references are turned rather than shifted. */
+turn?: {
+    source: {
+        row: number;
+        col: number;
+    };
+    dest: {
+        row: number;
+        col: number;
+    };
 }): PasteResolution;
 /**
  * A block from another application says nothing about where it was copied
@@ -161,4 +173,14 @@ export declare function planPaste(grid: ClipboardGrid, destination: {
         rows: number;
         cols: number;
     };
+    turn?: {
+        source: {
+            row: number;
+            col: number;
+        };
+        dest: {
+            row: number;
+            col: number;
+        };
+    };
 }>;