@m0saic/templates 0.2.0

package/dist/m0saic/code/_shared/code-diff.js

@@ -0,0 +1,220 @@
+"use strict";
+/** Deterministic line LCS, motion grouping, and block-level fade coalescing. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lcsDiffLines = lcsDiffLines;
+exports.groupMotionUnits = groupMotionUnits;
+exports.refineMotionUnits = refineMotionUnits;
+exports.coalesceFadeUnits = coalesceFadeUnits;
+function validateLines(lines, name) {
+    if (!Array.isArray(lines))
+        throw new Error(`${name} must be an array`);
+    lines.forEach((line, index) => {
+        if (typeof line !== "string") {
+            throw new Error(`${name}[${index}] must be a string`);
+        }
+    });
+}
+/**
+ * Classic O(N·M) exact-line LCS diff.
+ *
+ * Tie-break is load-bearing: when deleting or adding retains the same LCS
+ * length, emit the deletion first. Equal lines always match immediately.
+ *
+ * The table is a SUFFIX DP (lcs[i][j] = LCS of before[i..], after[j..]) with a
+ * forward walk, so its `lcs[i + 1][j] >= lcs[i][j + 1]` tie-break is the exact
+ * equivalent of the plan's prefix-table `L[i-1][j] >= L[i][j-1]` — do not
+ * "fix" one to match the other's index arithmetic.
+ */
+function lcsDiffLines(before, after) {
+    validateLines(before, "lcsDiffLines: before");
+    validateLines(after, "lcsDiffLines: after");
+    const rows = before.length + 1;
+    const cols = after.length + 1;
+    const lcs = Array.from({ length: rows }, () => Array(cols).fill(0));
+    for (let i = before.length - 1; i >= 0; i -= 1) {
+        for (let j = after.length - 1; j >= 0; j -= 1) {
+            lcs[i][j] =
+                before[i] === after[j]
+                    ? 1 + lcs[i + 1][j + 1]
+                    : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < before.length || j < after.length) {
+        if (i < before.length && j < after.length && before[i] === after[j]) {
+            ops.push({
+                kind: "same",
+                text: before[i],
+                fromLine: i,
+                toLine: j,
+            });
+            i += 1;
+            j += 1;
+        }
+        else if (i < before.length &&
+            (j >= after.length || lcs[i + 1][j] >= lcs[i][j + 1])) {
+            ops.push({
+                kind: "del",
+                text: before[i],
+                fromLine: i,
+                toLine: null,
+            });
+            i += 1;
+        }
+        else {
+            ops.push({
+                kind: "add",
+                text: after[j],
+                fromLine: null,
+                toLine: j,
+            });
+            j += 1;
+        }
+    }
+    return ops;
+}
+/** Maximal contiguous same-vector moves, removals, and additions. */
+function groupMotionUnits(ops) {
+    if (!Array.isArray(ops)) {
+        throw new Error("groupMotionUnits: ops must be an array");
+    }
+    const units = [];
+    for (const op of ops) {
+        const previous = units[units.length - 1];
+        if (op.kind === "same") {
+            const deltaLines = op.toLine - op.fromLine;
+            const line = {
+                text: op.text,
+                fromLine: op.fromLine,
+                toLine: op.toLine,
+            };
+            const lastLine = previous === null || previous === void 0 ? void 0 : previous.lines[previous.lines.length - 1];
+            if ((previous === null || previous === void 0 ? void 0 : previous.kind) === "move" &&
+                previous.deltaLines === deltaLines &&
+                (lastLine === null || lastLine === void 0 ? void 0 : lastLine.fromLine) === op.fromLine - 1 &&
+                lastLine.toLine === op.toLine - 1) {
+                previous.lines.push(line);
+            }
+            else {
+                units.push({
+                    kind: "move",
+                    fromStartLine: op.fromLine,
+                    toStartLine: op.toLine,
+                    deltaLines,
+                    lines: [line],
+                });
+            }
+            continue;
+        }
+        if (op.kind === "del") {
+            const line = {
+                text: op.text,
+                fromLine: op.fromLine,
+                toLine: null,
+            };
+            const lastLine = previous === null || previous === void 0 ? void 0 : previous.lines[previous.lines.length - 1];
+            if ((previous === null || previous === void 0 ? void 0 : previous.kind) === "remove" &&
+                (lastLine === null || lastLine === void 0 ? void 0 : lastLine.fromLine) === op.fromLine - 1) {
+                previous.lines.push(line);
+            }
+            else {
+                units.push({
+                    kind: "remove",
+                    fromStartLine: op.fromLine,
+                    lines: [line],
+                });
+            }
+            continue;
+        }
+        const line = {
+            text: op.text,
+            fromLine: null,
+            toLine: op.toLine,
+        };
+        const lastLine = previous === null || previous === void 0 ? void 0 : previous.lines[previous.lines.length - 1];
+        if ((previous === null || previous === void 0 ? void 0 : previous.kind) === "add" &&
+            (lastLine === null || lastLine === void 0 ? void 0 : lastLine.toLine) === op.toLine - 1) {
+            previous.lines.push(line);
+        }
+        else {
+            units.push({
+                kind: "add",
+                toStartLine: op.toLine,
+                lines: [line],
+            });
+        }
+    }
+    return units;
+}
+/** Split blocks into one-line units without changing any line mapping. */
+function refineMotionUnits(units, grouping) {
+    if (grouping === "block") {
+        return units.map((unit) => ({
+            ...unit,
+            lines: unit.lines.map((line) => ({ ...line })),
+        }));
+    }
+    const refined = [];
+    for (const unit of units) {
+        for (const line of unit.lines) {
+            if (unit.kind === "move") {
+                refined.push({
+                    kind: "move",
+                    fromStartLine: line.fromLine,
+                    toStartLine: line.toLine,
+                    deltaLines: unit.deltaLines,
+                    lines: [{ ...line }],
+                });
+            }
+            else if (unit.kind === "remove") {
+                refined.push({
+                    kind: "remove",
+                    fromStartLine: line.fromLine,
+                    lines: [{ ...line }],
+                });
+            }
+            else {
+                refined.push({
+                    kind: "add",
+                    toStartLine: line.toLine,
+                    lines: [{ ...line }],
+                });
+            }
+        }
+    }
+    return refined;
+}
+/** Collapse block-level fades and static lines into three sparse raster units. */
+function coalesceFadeUnits(units, grouping = "block") {
+    if (grouping !== "block") {
+        throw new Error(`coalesceFadeUnits: unsupported grouping ${JSON.stringify(grouping)}`);
+    }
+    const staticLines = [];
+    const removalLines = [];
+    const additionLines = [];
+    const moves = [];
+    for (const unit of units) {
+        if (unit.kind === "remove")
+            removalLines.push(...unit.lines.map((line) => ({ ...line })));
+        else if (unit.kind === "add")
+            additionLines.push(...unit.lines.map((line) => ({ ...line })));
+        else if (unit.deltaLines === 0)
+            staticLines.push(...unit.lines.map((line) => ({ ...line })));
+        else
+            moves.push({ ...unit, lines: unit.lines.map((line) => ({ ...line })) });
+    }
+    return {
+        ...(staticLines.length > 0
+            ? { staticUnderlay: { kind: "static", lines: staticLines } }
+            : {}),
+        ...(removalLines.length > 0
+            ? { removalRaster: { kind: "remove", lines: removalLines } }
+            : {}),
+        ...(additionLines.length > 0
+            ? { additionRaster: { kind: "add", lines: additionLines } }
+            : {}),
+        moves,
+    };
+}

package/dist/m0saic/code/_shared/code-lexer.d.ts

@@ -0,0 +1,28 @@
+/** Deterministic, dependency-free TypeScript/JavaScript syntax lexer. */
+import type { CodeTokenKind } from "./code-theme";
+export type CodeLanguage = "ts" | "js";
+export interface CodeToken {
+    text: string;
+    kind: CodeTokenKind;
+    /** Zero-based character-grid column in the normalized line. */
+    col: number;
+}
+export interface LexedCodeLine {
+    text: string;
+    tokens: CodeToken[];
+}
+export interface LexedCodeState {
+    /** CRLF-normalized, tab-expanded source. */
+    code: string;
+    language: CodeLanguage;
+    lines: LexedCodeLine[];
+}
+export interface LexTsJsOptions {
+    tabWidth?: number;
+}
+export declare function normalizeCodeSource(code: string, tabWidth?: number): string;
+/**
+ * Lex TS/JS without parser dependencies. Regex literals are the documented v1
+ * gap: their characters still retain exact columns but use operator/ident/etc.
+ */
+export declare function lexTsJs(code: string, language?: CodeLanguage, options?: LexTsJsOptions): LexedCodeState;

package/dist/m0saic/code/_shared/code-lexer.js

@@ -0,0 +1,226 @@
+"use strict";
+/** Deterministic, dependency-free TypeScript/JavaScript syntax lexer. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCodeSource = normalizeCodeSource;
+exports.lexTsJs = lexTsJs;
+const JS_KEYWORDS = new Set([
+    "async", "await", "break", "case", "catch", "class", "const", "continue",
+    "debugger", "default", "delete", "do", "else", "export", "extends", "false",
+    "finally", "for", "from", "function", "get", "if", "import", "in", "instanceof",
+    "let", "new", "null", "of", "return", "set", "static", "super", "switch",
+    "this", "throw", "true", "try", "typeof", "undefined", "var", "void", "while",
+    "with", "yield",
+]);
+const TS_ONLY_KEYWORDS = new Set([
+    "abstract", "any", "as", "asserts", "bigint", "boolean", "declare", "enum",
+    "global", "implements", "infer", "interface", "is", "keyof", "module", "namespace",
+    "never", "number", "object", "override", "private", "protected", "public", "readonly",
+    "require", "satisfies", "string", "symbol", "type", "unknown",
+]);
+const PUNCTUATION = new Set(["(", ")", "{", "}", "[", "]", ";", ",", ":", "."]);
+const OPERATOR_CHARS = new Set(Array.from("+-*/%=!<>&|^~?"));
+function isIdentifierStart(char) {
+    return /[A-Za-z_$]/.test(char);
+}
+function isIdentifierPart(char) {
+    return /[A-Za-z0-9_$]/.test(char);
+}
+function isDigit(char) {
+    return char >= "0" && char <= "9";
+}
+function pushToken(tokens, text, kind, col) {
+    if (text.length === 0)
+        return;
+    const previous = tokens[tokens.length - 1];
+    if ((previous === null || previous === void 0 ? void 0 : previous.kind) === kind &&
+        previous.col + Array.from(previous.text).length === col) {
+        previous.text += text;
+    }
+    else {
+        tokens.push({ text, kind, col });
+    }
+}
+function scanQuoted(line, start, quote) {
+    let index = start + 1;
+    while (index < line.length) {
+        if (line[index] === "\\")
+            index += 2;
+        else if (line[index] === quote)
+            return index + 1;
+        else
+            index += 1;
+    }
+    return line.length;
+}
+function scanNumber(line, start) {
+    const match = line.slice(start).match(/^(?:0[xX][0-9a-fA-F_]+n?|0[bB][01_]+n?|0[oO][0-7_]+n?|(?:\d[\d_]*(?:\.[\d_]*)?|\.[\d_]+)(?:[eE][+-]?[\d_]+)?n?)/);
+    return match == null ? start + 1 : start + match[0].length;
+}
+function isKeyword(identifier, language) {
+    return JS_KEYWORDS.has(identifier) ||
+        (language === "ts" && TS_ONLY_KEYWORDS.has(identifier));
+}
+function scanTemplateText(line, start, opening, tokens, state) {
+    let index = opening ? start + 1 : start;
+    while (index < line.length) {
+        if (line[index] === "\\") {
+            index = Math.min(line.length, index + 2);
+            continue;
+        }
+        if (line[index] === "`") {
+            index += 1;
+            pushToken(tokens, line.slice(start, index), "string", start);
+            state.templates.pop();
+            return index;
+        }
+        if (line[index] === "$" && line[index + 1] === "{") {
+            index += 2;
+            pushToken(tokens, line.slice(start, index), "string", start);
+            const frame = state.templates[state.templates.length - 1];
+            frame.inExpression = true;
+            frame.braceDepth = 0;
+            return index;
+        }
+        index += 1;
+    }
+    pushToken(tokens, line.slice(start), "string", start);
+    return line.length;
+}
+function lexLine(line, language, state) {
+    var _a;
+    const tokens = [];
+    let index = 0;
+    while (index < line.length) {
+        if (state.inBlockComment) {
+            const close = line.indexOf("*/", index);
+            const end = close < 0 ? line.length : close + 2;
+            pushToken(tokens, line.slice(index, end), "comment", index);
+            index = end;
+            if (close < 0)
+                break;
+            state.inBlockComment = false;
+            continue;
+        }
+        const template = state.templates[state.templates.length - 1];
+        if (template && !template.inExpression) {
+            index = scanTemplateText(line, index, false, tokens, state);
+            continue;
+        }
+        const char = line[index];
+        const next = (_a = line[index + 1]) !== null && _a !== void 0 ? _a : "";
+        if (/\s/.test(char)) {
+            let end = index + 1;
+            while (end < line.length && /\s/.test(line[end]))
+                end += 1;
+            pushToken(tokens, line.slice(index, end), "plain", index);
+            index = end;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            pushToken(tokens, line.slice(index), "comment", index);
+            break;
+        }
+        if (char === "/" && next === "*") {
+            const close = line.indexOf("*/", index + 2);
+            const end = close < 0 ? line.length : close + 2;
+            pushToken(tokens, line.slice(index, end), "comment", index);
+            index = end;
+            state.inBlockComment = close < 0;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            const end = scanQuoted(line, index, char);
+            pushToken(tokens, line.slice(index, end), "string", index);
+            index = end;
+            continue;
+        }
+        if (char === "`") {
+            state.templates.push({ inExpression: false, braceDepth: 0 });
+            index = scanTemplateText(line, index, true, tokens, state);
+            continue;
+        }
+        if ((template === null || template === void 0 ? void 0 : template.inExpression) && char === "}") {
+            if (template.braceDepth === 0) {
+                pushToken(tokens, char, "string", index);
+                template.inExpression = false;
+            }
+            else {
+                pushToken(tokens, char, "punct", index);
+                template.braceDepth -= 1;
+            }
+            index += 1;
+            continue;
+        }
+        if ((template === null || template === void 0 ? void 0 : template.inExpression) && char === "{") {
+            template.braceDepth += 1;
+            pushToken(tokens, char, "punct", index);
+            index += 1;
+            continue;
+        }
+        if (isIdentifierStart(char)) {
+            let end = index + 1;
+            while (end < line.length && isIdentifierPart(line[end]))
+                end += 1;
+            const identifier = line.slice(index, end);
+            let lookahead = end;
+            while (lookahead < line.length && /\s/.test(line[lookahead]))
+                lookahead += 1;
+            const kind = isKeyword(identifier, language)
+                ? "keyword"
+                : line[lookahead] === "("
+                    ? "fnCall"
+                    : "ident";
+            pushToken(tokens, identifier, kind, index);
+            index = end;
+            continue;
+        }
+        if (isDigit(char) || (char === "." && isDigit(next))) {
+            const end = scanNumber(line, index);
+            pushToken(tokens, line.slice(index, end), "number", index);
+            index = end;
+            continue;
+        }
+        if (OPERATOR_CHARS.has(char)) {
+            let end = index + 1;
+            while (end < line.length && OPERATOR_CHARS.has(line[end]))
+                end += 1;
+            pushToken(tokens, line.slice(index, end), "operator", index);
+            index = end;
+            continue;
+        }
+        if (PUNCTUATION.has(char)) {
+            pushToken(tokens, char, "punct", index);
+            index += 1;
+            continue;
+        }
+        pushToken(tokens, char, "plain", index);
+        index += 1;
+    }
+    return { text: line, tokens };
+}
+function normalizeCodeSource(code, tabWidth = 2) {
+    if (typeof code !== "string") {
+        throw new Error("normalizeCodeSource: code must be a string");
+    }
+    if (!Number.isInteger(tabWidth) || tabWidth < 1 || tabWidth > 16) {
+        throw new Error(`normalizeCodeSource: tabWidth must be an integer from 1 to 16, got ${tabWidth}`);
+    }
+    return code.replace(/\r\n?/g, "\n").replace(/\t/g, " ".repeat(tabWidth));
+}
+/**
+ * Lex TS/JS without parser dependencies. Regex literals are the documented v1
+ * gap: their characters still retain exact columns but use operator/ident/etc.
+ */
+function lexTsJs(code, language = "ts", options = {}) {
+    var _a;
+    if (language !== "ts" && language !== "js") {
+        throw new Error(`lexTsJs: language must be "ts" or "js", got ${JSON.stringify(language)}`);
+    }
+    const normalized = normalizeCodeSource(code, (_a = options.tabWidth) !== null && _a !== void 0 ? _a : 2);
+    const state = { inBlockComment: false, templates: [] };
+    return {
+        code: normalized,
+        language,
+        lines: normalized.split("\n").map((line) => lexLine(line, language, state)),
+    };
+}

package/dist/m0saic/code/_shared/code-metrics.d.ts

@@ -0,0 +1,58 @@
+/** Deterministic JetBrains-Mono grid math and integer code-block bounds. */
+/** JetBrains Mono's registered advance width: 600 units on a 1000-unit em. */
+export declare const JETBRAINS_MONO_ADVANCE_EM = 0.6;
+export declare const MIN_AUTOFIT_FONT_SIZE = 8;
+export interface CodeLineLike {
+    text: string;
+}
+export interface CodeGridMetrics {
+    fontSize: number;
+    lineHeight: number;
+    charW: number;
+    lineStep: number;
+    lineCount: number;
+    maxColumns: number;
+    width: number;
+    height: number;
+}
+export interface CodeBlockRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    originCol: number;
+    originLine: number;
+    endCol: number;
+    endLine: number;
+}
+export interface AutoFitCodeOptions {
+    preferredFontSize: number;
+    lineHeight?: number;
+    minFontSize?: number;
+    maxWidth: number;
+    maxHeight: number;
+    charWidthEm?: number;
+}
+export interface AutoFitCodeResult {
+    fontSize: number;
+    fits: boolean;
+    overflowX: boolean;
+    overflowY: boolean;
+    metrics: CodeGridMetrics;
+}
+/** Count Unicode code points; v1's documented envelope remains single-width glyphs. */
+export declare function codeColumnCount(text: string): number;
+export declare function measureCodeGrid(lines: ReadonlyArray<CodeLineLike>, options: {
+    fontSize: number;
+    lineHeight?: number;
+    charWidthEm?: number;
+}): CodeGridMetrics;
+/** Round a grid-aligned block outward once, matching the A2 raster placement. */
+export declare function codeBlockRect(span: {
+    originCol?: number;
+    originLine: number;
+    endCol: number;
+    endLine: number;
+}, metrics: Pick<CodeGridMetrics, "charW" | "lineStep">): CodeBlockRect;
+/** Largest integer font size that fits, clamped at the documented 8px floor. */
+export declare function autoFitCodeFont(lines: ReadonlyArray<CodeLineLike>, options: AutoFitCodeOptions): AutoFitCodeResult;

package/dist/m0saic/code/_shared/code-metrics.js

@@ -0,0 +1,140 @@
+"use strict";
+/** Deterministic JetBrains-Mono grid math and integer code-block bounds. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_AUTOFIT_FONT_SIZE = exports.JETBRAINS_MONO_ADVANCE_EM = void 0;
+exports.codeColumnCount = codeColumnCount;
+exports.measureCodeGrid = measureCodeGrid;
+exports.codeBlockRect = codeBlockRect;
+exports.autoFitCodeFont = autoFitCodeFont;
+/** JetBrains Mono's registered advance width: 600 units on a 1000-unit em. */
+exports.JETBRAINS_MONO_ADVANCE_EM = 0.6;
+exports.MIN_AUTOFIT_FONT_SIZE = 8;
+function requirePositiveFinite(value, name) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`${name} must be a finite number > 0, got ${value}`);
+    }
+}
+function requireNonNegativeFinite(value, name) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${name} must be a finite number >= 0, got ${value}`);
+    }
+}
+/** Count Unicode code points; v1's documented envelope remains single-width glyphs. */
+function codeColumnCount(text) {
+    if (typeof text !== "string") {
+        throw new Error("codeColumnCount: text must be a string");
+    }
+    return Array.from(text).length;
+}
+function measureCodeGrid(lines, options) {
+    var _a, _b;
+    if (!Array.isArray(lines)) {
+        throw new Error("measureCodeGrid: lines must be an array");
+    }
+    const lineHeight = (_a = options.lineHeight) !== null && _a !== void 0 ? _a : 1.5;
+    const charWidthEm = (_b = options.charWidthEm) !== null && _b !== void 0 ? _b : exports.JETBRAINS_MONO_ADVANCE_EM;
+    requirePositiveFinite(options.fontSize, "measureCodeGrid: fontSize");
+    requirePositiveFinite(lineHeight, "measureCodeGrid: lineHeight");
+    requirePositiveFinite(charWidthEm, "measureCodeGrid: charWidthEm");
+    let maxColumns = 0;
+    lines.forEach((line, index) => {
+        if (line == null || typeof line.text !== "string") {
+            throw new Error(`measureCodeGrid: lines[${index}].text must be a string`);
+        }
+        maxColumns = Math.max(maxColumns, codeColumnCount(line.text));
+    });
+    const charW = options.fontSize * charWidthEm;
+    const lineStep = Math.max(1, Math.round(options.fontSize * lineHeight));
+    return {
+        fontSize: options.fontSize,
+        lineHeight,
+        charW,
+        lineStep,
+        lineCount: lines.length,
+        maxColumns,
+        width: maxColumns === 0 ? 0 : Math.ceil(maxColumns * charW),
+        height: lines.length * lineStep,
+    };
+}
+/** Round a grid-aligned block outward once, matching the A2 raster placement. */
+function codeBlockRect(span, metrics) {
+    var _a;
+    const originCol = (_a = span.originCol) !== null && _a !== void 0 ? _a : 0;
+    for (const [name, value] of [
+        ["originCol", originCol],
+        ["originLine", span.originLine],
+        ["endCol", span.endCol],
+        ["endLine", span.endLine],
+    ]) {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`codeBlockRect: ${name} must be a non-negative integer, got ${value}`);
+        }
+    }
+    if (span.endCol < originCol || span.endLine < span.originLine) {
+        throw new Error("codeBlockRect: end coordinates must not precede the origin");
+    }
+    requirePositiveFinite(metrics.charW, "codeBlockRect: charW");
+    requirePositiveFinite(metrics.lineStep, "codeBlockRect: lineStep");
+    const x = Math.floor(originCol * metrics.charW);
+    const y = Math.floor(span.originLine * metrics.lineStep);
+    const right = Math.ceil(span.endCol * metrics.charW);
+    const bottom = Math.ceil(span.endLine * metrics.lineStep);
+    return {
+        x,
+        y,
+        width: Math.max(0, right - x),
+        height: Math.max(0, bottom - y),
+        originCol,
+        originLine: span.originLine,
+        endCol: span.endCol,
+        endLine: span.endLine,
+    };
+}
+/** Largest integer font size that fits, clamped at the documented 8px floor. */
+function autoFitCodeFont(lines, options) {
+    var _a, _b, _c;
+    const lineHeight = (_a = options.lineHeight) !== null && _a !== void 0 ? _a : 1.5;
+    const minFontSize = (_b = options.minFontSize) !== null && _b !== void 0 ? _b : exports.MIN_AUTOFIT_FONT_SIZE;
+    const charWidthEm = (_c = options.charWidthEm) !== null && _c !== void 0 ? _c : exports.JETBRAINS_MONO_ADVANCE_EM;
+    requirePositiveFinite(options.preferredFontSize, "autoFitCodeFont: preferredFontSize");
+    requirePositiveFinite(minFontSize, "autoFitCodeFont: minFontSize");
+    requirePositiveFinite(lineHeight, "autoFitCodeFont: lineHeight");
+    requirePositiveFinite(charWidthEm, "autoFitCodeFont: charWidthEm");
+    requireNonNegativeFinite(options.maxWidth, "autoFitCodeFont: maxWidth");
+    requireNonNegativeFinite(options.maxHeight, "autoFitCodeFont: maxHeight");
+    const floorSize = Math.max(1, Math.ceil(minFontSize));
+    const preferredSize = Math.max(floorSize, Math.floor(options.preferredFontSize));
+    let metrics = measureCodeGrid(lines, {
+        fontSize: preferredSize,
+        lineHeight,
+        charWidthEm,
+    });
+    for (let candidate = preferredSize; candidate >= floorSize; candidate -= 1) {
+        metrics = measureCodeGrid(lines, {
+            fontSize: candidate,
+            lineHeight,
+            charWidthEm,
+        });
+        if (metrics.width <= options.maxWidth && metrics.height <= options.maxHeight) {
+            return {
+                fontSize: candidate,
+                fits: true,
+                overflowX: false,
+                overflowY: false,
+                metrics,
+            };
+        }
+    }
+    metrics = measureCodeGrid(lines, {
+        fontSize: floorSize,
+        lineHeight,
+        charWidthEm,
+    });
+    return {
+        fontSize: floorSize,
+        fits: false,
+        overflowX: metrics.width > options.maxWidth,
+        overflowY: metrics.height > options.maxHeight,
+        metrics,
+    };
+}