web-doc 0.6.2 → 0.7.0

package/dist/edit/pptx/text-ops.js

@@ -0,0 +1,267 @@
+import { patches } from "../ooxml/patch.js";
+import { committedParts, } from "./operations.js";
+import { alignedParagraphProperties, bodyPrefix, bodySuffix, changedRunProperties, colorProblem, itemsOfSegment, normalizeText, paragraphAt, paragraphXml, renamedProperties, runProperties, sliceOf, styleAt, textProblem, PARAGRAPH_BREAK, } from "./text-write.js";
+/** Resolves a text target; reports why it cannot be edited. */
+async function textTarget(id, context, issue) {
+    const record = await context.locate(id);
+    if (!record) {
+        issue("/target", "unknown-target", `No element ${id}`);
+        return undefined;
+    }
+    if (record.readOnly || !record.txBody || !record.text) {
+        issue("/target", "invalid-target", `Element ${id} has no editable text body`);
+        return undefined;
+    }
+    return {
+        record,
+        part: record.part,
+        txBody: record.txBody,
+        model: record.text,
+    };
+}
+/** Checks a range against its target; returns the clamped offsets. */
+function checkRange(target, id, range, issue) {
+    const length = target.model.text.length;
+    if (!range)
+        return { start: 0, end: length };
+    if (range.start.elementId !== id || range.end.elementId !== id) {
+        issue("/range", "invalid-range", "Both ends must lie on the target");
+        return undefined;
+    }
+    const { start } = range;
+    const { end } = range;
+    if (start.offset > length ||
+        end.offset > length ||
+        start.offset > end.offset) {
+        issue("/range", "invalid-range", `Offsets must satisfy 0 ≤ start ≤ end ≤ ${length}`);
+        return undefined;
+    }
+    const text = target.model.text;
+    for (const offset of [start.offset, end.offset])
+        if (offset > 0 &&
+            offset < length &&
+            (text.charCodeAt(offset) & 0xfc00) === 0xdc00 &&
+            (text.charCodeAt(offset - 1) & 0xfc00) === 0xd800) {
+            issue("/range", "invalid-range", "A range cannot split a surrogate pair");
+            return undefined;
+        }
+    for (const paragraph of target.model.paragraphs)
+        for (const run of paragraph.runs)
+            if (run.kind === "fld" &&
+                ((run.start < start.offset && start.offset < run.end) ||
+                    (run.start < end.offset && end.offset < run.end))) {
+                issue("/range", "invalid-range", "A range cannot start or end inside a field");
+                return undefined;
+            }
+    return { start: start.offset, end: end.offset };
+}
+/** Items of a run restricted to `[from, to)` of its text, as bytes when whole. */
+function runItems(part, run, from, to) {
+    if (to <= from)
+        return [];
+    if (from === run.start && to === run.end)
+        return [{ kind: "raw", xml: sliceOf(part, run.node) }];
+    if (run.kind === "br")
+        return [{ kind: "br", rPr: runProperties(part, run) }];
+    return [
+        {
+            kind: "run",
+            rPr: runProperties(part, run),
+            text: run.text.slice(from - run.start, to - run.start),
+        },
+    ];
+}
+function draftOf(part, paragraph) {
+    return {
+        pPr: sliceOf(part, paragraph.pPr),
+        items: [],
+        endParaRPr: sliceOf(part, paragraph.endParaRPr),
+    };
+}
+/** The whole body's new content with the paragraphs `[first, last]` replaced by `drafts`. */
+function bodyContent(part, txBody, model, first, last, drafts) {
+    const paragraphs = model.paragraphs;
+    const prefix = bodyPrefix(part, txBody, paragraphs[0]?.node);
+    const suffix = bodySuffix(part, txBody, paragraphs.at(-1)?.node);
+    const before = paragraphs
+        .slice(0, first)
+        .map((paragraph) => sliceOf(part, paragraph.node))
+        .join("");
+    const after = paragraphs
+        .slice(last + 1)
+        .map((paragraph) => sliceOf(part, paragraph.node))
+        .join("");
+    return `${prefix}${before}${drafts.map(paragraphXml).join("")}${after}${suffix}`;
+}
+function commitBody(context, target, content) {
+    const transaction = context.pkg.transaction();
+    transaction.patch(target.part, [
+        patches.replaceContent(target.part, target.txBody, content),
+    ]);
+    return transaction.commit().then((change) => ({
+        createdIds: [],
+        changedPages: [target.record.element.pageIndex],
+        warnings: change.warnings,
+        parts: committedParts(change),
+    }));
+}
+export const replaceTextHandler = {
+    async validate(operation, context, issue) {
+        const problem = textProblem(normalizeText(operation.text));
+        if (problem)
+            issue("/text", "invalid-text", `The text holds ${problem}`);
+        const target = await textTarget(operation.target, context, issue);
+        if (target)
+            checkRange(target, operation.target, operation.range, issue);
+    },
+    async apply(operation, context) {
+        const target = (await textTarget(operation.target, context, () => { }));
+        const { start, end } = checkRange(target, operation.target, operation.range, () => { });
+        return commitBody(context, target, replacedBodyContent(target.part, target.txBody, target.model, normalizeText(operation.text), start, end, !operation.range));
+    },
+};
+/**
+ * The new content of a text body with `[start, end)` of its text replaced:
+ * the paragraphs the range touches are rebuilt, the others keep their
+ * bytes. A whole replacement styles the new text like the first run that
+ * had text; a ranged one like the run at the start of the range.
+ */
+export function replacedBodyContent(part, txBody, model, text, start, end, whole) {
+    const paragraphs = model.paragraphs;
+    if (paragraphs.length === 0) {
+        // A body without paragraphs: the new text becomes its paragraphs.
+        const drafts = text.split(PARAGRAPH_BREAK).map((segment) => ({
+            pPr: "",
+            items: itemsOfSegment(segment, ""),
+            endParaRPr: "",
+        }));
+        return bodyContent(part, txBody, model, 0, -1, drafts);
+    }
+    const first = paragraphAt(model, start);
+    const last = paragraphAt(model, end);
+    const firstParagraph = paragraphs[first];
+    const lastParagraph = paragraphs[last];
+    const style = whole
+        ? firstTextStyle(part, model)
+        : end > start
+            ? (styleOfRunAt(part, firstParagraph, start) ??
+                styleAt(part, firstParagraph, start))
+            : styleAt(part, firstParagraph, start);
+    const head = [];
+    for (const run of firstParagraph.runs)
+        head.push(...runItems(part, run, run.start, Math.min(run.end, start)));
+    const tail = [];
+    for (const run of lastParagraph.runs)
+        tail.push(...runItems(part, run, Math.max(run.start, end), run.end));
+    const segments = text.split(PARAGRAPH_BREAK);
+    const drafts = [];
+    segments.forEach((segment, index) => {
+        const draft = draftOf(part, firstParagraph);
+        if (index === 0)
+            draft.items.push(...head);
+        draft.items.push(...itemsOfSegment(segment, style));
+        if (index === segments.length - 1) {
+            draft.items.push(...tail);
+            draft.endParaRPr = sliceOf(part, lastParagraph.endParaRPr);
+        }
+        drafts.push(draft);
+    });
+    return bodyContent(part, txBody, model, first, last, drafts);
+}
+/** The rPr of the run that holds the first replaced character. */
+function styleOfRunAt(part, paragraph, offset) {
+    const run = paragraph.runs.find((candidate) => candidate.kind !== "br" &&
+        candidate.start <= offset &&
+        offset < candidate.end);
+    return run ? runProperties(part, run) : undefined;
+}
+function firstTextStyle(part, model) {
+    for (const paragraph of model.paragraphs)
+        for (const run of paragraph.runs)
+            if (run.kind !== "br" && run.text.length > 0)
+                return runProperties(part, run);
+    const first = model.paragraphs[0];
+    return first?.endParaRPr
+        ? renamedProperties(part, first.endParaRPr, "a:rPr")
+        : "";
+}
+export const setTextStyleHandler = {
+    async validate(operation, context, issue) {
+        const { style } = operation;
+        if (style.color !== undefined) {
+            const problem = colorProblem(style.color);
+            if (problem)
+                issue("/style/color", "invalid-value", `Colour: ${problem}`);
+        }
+        if (style.fontFamily !== undefined) {
+            const problem = textProblem(style.fontFamily);
+            if (problem)
+                issue("/style/fontFamily", "invalid-value", `Font: ${problem}`);
+        }
+        const target = await textTarget(operation.target, context, issue);
+        if (target)
+            checkRange(target, operation.target, operation.range, issue);
+    },
+    async apply(operation, context) {
+        const target = (await textTarget(operation.target, context, () => { }));
+        const { start, end } = checkRange(target, operation.target, operation.range, () => { });
+        const { part, model } = target;
+        const { style } = operation;
+        const { align, ...runChange } = style;
+        const changesRuns = Object.keys(runChange).length > 0;
+        // Nothing to write: the body keeps its bytes and its autofit scale.
+        if (!changesRuns && align === undefined)
+            return { createdIds: [], changedPages: [], warnings: [] };
+        const paragraphs = model.paragraphs;
+        if (paragraphs.length === 0)
+            return { createdIds: [], changedPages: [], warnings: [] };
+        const first = paragraphAt(model, start);
+        const last = paragraphAt(model, end);
+        const drafts = [];
+        for (let index = first; index <= last; index += 1) {
+            const paragraph = paragraphs[index];
+            const draft = draftOf(part, paragraph);
+            if (align !== undefined)
+                draft.pPr = alignedParagraphProperties(part, paragraph.pPr, align);
+            for (const run of paragraph.runs) {
+                const from = Math.max(run.start, start);
+                const to = Math.min(run.end, end);
+                if (!changesRuns || to <= from) {
+                    draft.items.push({ kind: "raw", xml: sliceOf(part, run.node) });
+                    continue;
+                }
+                draft.items.push(...runItems(part, run, run.start, from));
+                draft.items.push(restyled(part, run, from, to, runChange));
+                draft.items.push(...runItems(part, run, to, run.end));
+            }
+            if (changesRuns && end >= paragraph.end && paragraph.endParaRPr)
+                draft.endParaRPr = changedRunProperties(part, paragraph.endParaRPr, runChange, "a:endParaRPr");
+            drafts.push(draft);
+        }
+        return commitBody(context, target, bodyContent(part, target.txBody, model, first, last, drafts));
+    },
+};
+/** The covered part of a run with the change applied; a field keeps its own bytes around a new rPr. */
+function restyled(part, run, from, to, change) {
+    const rPr = changedRunProperties(part, run.rPr, change);
+    if (run.kind === "br")
+        return { kind: "br", rPr };
+    if (run.kind === "fld") {
+        const xml = sliceOf(part, run.node);
+        const offset = run.node.start;
+        if (run.rPr)
+            return {
+                kind: "raw",
+                xml: xml.slice(0, run.rPr.start - offset) +
+                    rPr +
+                    xml.slice(run.rPr.end - offset),
+            };
+        const at = run.node.contentStart - offset;
+        return { kind: "raw", xml: `${xml.slice(0, at)}${rPr}${xml.slice(at)}` };
+    }
+    return {
+        kind: "run",
+        rPr,
+        text: run.text.slice(from - run.start, to - run.start),
+    };
+}

package/dist/edit/pptx/text-write.d.ts

@@ -0,0 +1,67 @@
+import type { EditColor } from "../types.js";
+import { type XmlElement, type XmlPart } from "../ooxml/xml.js";
+import type { ParagraphInfo, RunInfo, TextModel } from "./text.js";
+import { PARAGRAPH_BREAK } from "./text.js";
+import type { PptxTextAlign, PptxTextStyleChange } from "./types.js";
+/** A run of a rebuilt paragraph: untouched bytes, or a run or break with properties. */
+export type RunItem = {
+    readonly kind: "raw";
+    readonly xml: string;
+} | {
+    readonly kind: "run";
+    readonly rPr: string;
+    readonly text: string;
+} | {
+    readonly kind: "br";
+    readonly rPr: string;
+};
+export interface ParagraphDraft {
+    /** The `a:pPr` bytes, or "". */
+    pPr: string;
+    items: RunItem[];
+    /** The `a:endParaRPr` bytes, or "". */
+    endParaRPr: string;
+}
+export declare const THEME_COLORS: Set<string>;
+export declare const COLOR_MODIFIERS: Set<string>;
+/** Why a text cannot be written, or undefined when it can. */
+export declare function textProblem(text: string): string | undefined;
+export declare function colorProblem(color: unknown): string | undefined;
+/** `<a:solidFill>` for a colour in its theme or RGB form. */
+export declare function solidFillXml(color: EditColor): string;
+export declare function alignValue(align: PptxTextAlign): string;
+/** The bytes of a node, or "" without one. */
+export declare function sliceOf(part: XmlPart, node: XmlElement | undefined): string;
+/**
+ * Run properties with a change applied: attributes kept and set, children
+ * kept in order with the fill and the Latin face replaced where the schema
+ * puts them. `source` may be an `a:rPr`, an `a:endParaRPr` (renamed) or
+ * nothing.
+ */
+export declare function changedRunProperties(part: XmlPart, source: XmlElement | undefined, change: PptxTextStyleChange, tag?: string): string;
+/** Text as the engine stores it: Windows and classic Mac line ends become "\n". */
+export declare function normalizeText(text: string): string;
+/** `a:pPr` bytes with `algn` set, created when the paragraph has none. */
+export declare function alignedParagraphProperties(part: XmlPart, pPr: XmlElement | undefined, align: PptxTextAlign): string;
+/** A run or break as the file will carry it. */
+export declare function runXml(item: RunItem): string;
+export declare function paragraphXml(draft: ParagraphDraft): string;
+/** Items of text with its paragraph breaks removed: runs and breaks in `rPr`. */
+export declare function itemsOfSegment(segment: string, rPr: string): RunItem[];
+/** The rPr a run of inserted text takes at `offset`: the run before it, else the run after, else the paragraph end. */
+export declare function styleAt(part: XmlPart, paragraph: ParagraphInfo, offset: number): string;
+/** The `a:rPr` bytes of a run, or "". */
+export declare function runProperties(part: XmlPart, run: RunInfo): string;
+/** The bytes of a properties element under another tag name. */
+export declare function renamedProperties(part: XmlPart, node: XmlElement, tag: string): string;
+/**
+ * The bytes of a text body's content before its first paragraph, with the
+ * stale autofit scale dropped: `a:normAutofit`'s `fontScale` and
+ * `lnSpcReduction` describe the old text.
+ */
+export declare function bodyPrefix(part: XmlPart, txBody: XmlElement, firstParagraph: XmlElement | undefined): string;
+/** The bytes after the last paragraph (an extension list, usually nothing). */
+export declare function bodySuffix(part: XmlPart, txBody: XmlElement, lastParagraph: XmlElement | undefined): string;
+/** The index of the paragraph that holds an offset, taking the one before a break first. */
+export declare function paragraphAt(model: TextModel, offset: number): number;
+export { PARAGRAPH_BREAK };

package/dist/edit/pptx/text-write.js

@@ -0,0 +1,293 @@
+import { escapeText } from "../ooxml/xml.js";
+import { LINE_BREAK, PARAGRAPH_BREAK } from "./text.js";
+const FILLS = new Set([
+    "noFill",
+    "solidFill",
+    "gradFill",
+    "blipFill",
+    "pattFill",
+    "grpFill",
+]);
+/** Children of a:rPr that follow the fill in the schema. */
+const AFTER_FILL = new Set([
+    "effectLst",
+    "effectDag",
+    "highlight",
+    "uLnTx",
+    "uLn",
+    "uFillTx",
+    "uFill",
+    "latin",
+    "ea",
+    "cs",
+    "sym",
+    "hlinkClick",
+    "hlinkMouseOver",
+    "rtl",
+    "extLst",
+]);
+/** Children of a:rPr that follow a:latin in the schema. */
+const AFTER_LATIN = new Set([
+    "ea",
+    "cs",
+    "sym",
+    "hlinkClick",
+    "hlinkMouseOver",
+    "rtl",
+    "extLst",
+]);
+export const THEME_COLORS = new Set([
+    "bg1",
+    "tx1",
+    "bg2",
+    "tx2",
+    "dk1",
+    "lt1",
+    "dk2",
+    "lt2",
+    "accent1",
+    "accent2",
+    "accent3",
+    "accent4",
+    "accent5",
+    "accent6",
+    "hlink",
+    "folHlink",
+]);
+export const COLOR_MODIFIERS = new Set([
+    "tint",
+    "shade",
+    "alpha",
+    "lumMod",
+    "lumOff",
+    "satMod",
+    "satOff",
+    "hueMod",
+    "hueOff",
+]);
+/** Characters XML 1.0 cannot carry; a lone surrogate is caught separately. */
+const FORBIDDEN = /[\u0000-\u0008\u000c\u000e-\u001f\ufffe\uffff]/;
+const LONE_SURROGATE = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+/** Why a text cannot be written, or undefined when it can. */
+export function textProblem(text) {
+    if (FORBIDDEN.test(text))
+        return "control characters XML cannot carry";
+    if (LONE_SURROGATE.test(text))
+        return "a lone surrogate";
+    return undefined;
+}
+export function colorProblem(color) {
+    if (typeof color === "string")
+        return /^#[0-9A-Fa-f]{6}$/.test(color) ? undefined : "not #RRGGBB";
+    if (!color || typeof color !== "object")
+        return "not a colour";
+    const { theme, mods } = color;
+    if (typeof theme !== "string" || !THEME_COLORS.has(theme))
+        return "not a theme colour slot";
+    if (mods !== undefined) {
+        if (!mods || typeof mods !== "object" || Array.isArray(mods))
+            return "mods is not an object";
+        for (const [name, value] of Object.entries(mods)) {
+            if (!COLOR_MODIFIERS.has(name))
+                return `unknown modifier ${name}`;
+            if (typeof value !== "number" ||
+                !Number.isInteger(value) ||
+                Math.abs(value) > 100_000)
+                return `modifier ${name} is not an integer within ±100000`;
+        }
+    }
+    return undefined;
+}
+/** `<a:solidFill>` for a colour in its theme or RGB form. */
+export function solidFillXml(color) {
+    if (typeof color === "string")
+        return `<a:solidFill><a:srgbClr val="${color.slice(1).toUpperCase()}"/></a:solidFill>`;
+    const mods = Object.entries(color.mods ?? {})
+        .map(([name, value]) => `<a:${name} val="${value}"/>`)
+        .join("");
+    return mods
+        ? `<a:solidFill><a:schemeClr val="${color.theme}">${mods}</a:schemeClr></a:solidFill>`
+        : `<a:solidFill><a:schemeClr val="${color.theme}"/></a:solidFill>`;
+}
+export function alignValue(align) {
+    switch (align) {
+        case "left":
+            return "l";
+        case "center":
+            return "ctr";
+        case "right":
+            return "r";
+        default:
+            return "just";
+    }
+}
+/** The bytes of a node, or "" without one. */
+export function sliceOf(part, node) {
+    return node ? part.text.slice(node.start, node.end) : "";
+}
+/**
+ * Run properties with a change applied: attributes kept and set, children
+ * kept in order with the fill and the Latin face replaced where the schema
+ * puts them. `source` may be an `a:rPr`, an `a:endParaRPr` (renamed) or
+ * nothing.
+ */
+export function changedRunProperties(part, source, change, tag = "a:rPr") {
+    const attributes = new Map();
+    const children = [];
+    if (source) {
+        for (const attribute of source.attributes)
+            attributes.set(attribute.name, attribute.rawValue);
+        for (const child of source.children)
+            children.push({ local: child.local, xml: sliceOf(part, child) });
+    }
+    if (change.bold !== undefined)
+        attributes.set("b", change.bold ? "1" : "0");
+    if (change.italic !== undefined)
+        attributes.set("i", change.italic ? "1" : "0");
+    if (change.underline !== undefined)
+        attributes.set("u", change.underline ? "sng" : "none");
+    if (change.fontSize !== undefined)
+        attributes.set("sz", String(Math.round(change.fontSize * 100)));
+    if (change.color !== undefined)
+        replaceChild(children, FILLS, AFTER_FILL, "solidFill", solidFillXml(change.color));
+    if (change.fontFamily !== undefined)
+        replaceChild(children, new Set(["latin"]), AFTER_LATIN, "latin", `<a:latin typeface="${escapeAttributeValue(change.fontFamily)}"/>`);
+    const attributeText = [...attributes]
+        .map(([name, raw]) => ` ${name}="${raw}"`)
+        .join("");
+    const content = children.map((child) => child.xml).join("");
+    return content
+        ? `<${tag}${attributeText}>${content}</${tag}>`
+        : `<${tag}${attributeText}/>`;
+}
+function replaceChild(children, replaced, after, local, xml) {
+    const first = children.findIndex((child) => replaced.has(child.local));
+    for (let index = children.length - 1; index >= 0; index -= 1)
+        if (replaced.has(children[index].local))
+            children.splice(index, 1);
+    let at = first >= 0 ? first : children.findIndex((child) => after.has(child.local));
+    if (at < 0)
+        at = children.length;
+    children.splice(at, 0, { local, xml });
+}
+function escapeAttributeValue(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("\t", "&#9;")
+        .replaceAll("\n", "&#10;")
+        .replaceAll("\r", "&#13;");
+}
+/** Text as the engine stores it: Windows and classic Mac line ends become "\n". */
+export function normalizeText(text) {
+    return text.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+}
+/** `a:pPr` bytes with `algn` set, created when the paragraph has none. */
+export function alignedParagraphProperties(part, pPr, align) {
+    const value = alignValue(align);
+    if (!pPr)
+        return `<a:pPr algn="${value}"/>`;
+    const xml = sliceOf(part, pPr);
+    const existing = pPr.attributes.find((attribute) => attribute.name === "algn");
+    if (existing)
+        return (xml.slice(0, existing.start - pPr.start) +
+            `algn="${value}"` +
+            xml.slice(existing.end - pPr.start));
+    const insertAt = pPr.start + 1 + pPr.name.length - pPr.start;
+    return `${xml.slice(0, insertAt)} algn="${value}"${xml.slice(insertAt)}`;
+}
+/** A run or break as the file will carry it. */
+export function runXml(item) {
+    switch (item.kind) {
+        case "raw":
+            return item.xml;
+        case "br":
+            return item.rPr ? `<a:br>${item.rPr}</a:br>` : "<a:br/>";
+        default:
+            return item.text.length === 0
+                ? ""
+                : `<a:r>${item.rPr}<a:t>${escapeText(item.text)}</a:t></a:r>`;
+    }
+}
+export function paragraphXml(draft) {
+    return `<a:p>${draft.pPr}${draft.items.map(runXml).join("")}${draft.endParaRPr}</a:p>`;
+}
+/** Items of text with its paragraph breaks removed: runs and breaks in `rPr`. */
+export function itemsOfSegment(segment, rPr) {
+    const items = [];
+    const lines = segment.split(LINE_BREAK);
+    lines.forEach((line, index) => {
+        if (index > 0)
+            items.push({ kind: "br", rPr });
+        if (line.length > 0)
+            items.push({ kind: "run", rPr, text: line });
+    });
+    return items;
+}
+/** The rPr a run of inserted text takes at `offset`: the run before it, else the run after, else the paragraph end. */
+export function styleAt(part, paragraph, offset) {
+    let before;
+    for (const run of paragraph.runs)
+        if (run.kind !== "br" && run.start < offset && offset <= run.end)
+            before = run;
+    const after = paragraph.runs.find((run) => run.kind !== "br" && run.start <= offset && offset < run.end);
+    const inside = paragraph.runs.find((run) => run.kind !== "br" && run.start < offset && offset < run.end);
+    const source = inside ?? before ?? after;
+    if (source)
+        return runProperties(part, source);
+    return paragraph.endParaRPr
+        ? renamedProperties(part, paragraph.endParaRPr, "a:rPr")
+        : "";
+}
+/** The `a:rPr` bytes of a run, or "". */
+export function runProperties(part, run) {
+    return sliceOf(part, run.rPr);
+}
+/** The bytes of a properties element under another tag name. */
+export function renamedProperties(part, node, tag) {
+    const xml = sliceOf(part, node);
+    if (node.selfClosing)
+        return `<${tag}${xml.slice(1 + node.name.length, -2)}/>`;
+    return `<${tag}${xml.slice(1 + node.name.length, node.contentStart - node.start)}${xml.slice(node.contentStart - node.start, node.contentEnd - node.start)}</${tag}>`;
+}
+/**
+ * The bytes of a text body's content before its first paragraph, with the
+ * stale autofit scale dropped: `a:normAutofit`'s `fontScale` and
+ * `lnSpcReduction` describe the old text.
+ */
+export function bodyPrefix(part, txBody, firstParagraph) {
+    const end = firstParagraph ? firstParagraph.start : txBody.contentEnd;
+    let prefix = part.text.slice(txBody.contentStart, end);
+    const bodyPr = txBody.children.find((child) => child.local === "bodyPr");
+    const autofit = bodyPr?.children.find((child) => child.local === "normAutofit");
+    if (!autofit)
+        return prefix;
+    const cuts = autofit.attributes
+        .filter((attribute) => ["fontScale", "lnSpcReduction"].includes(attribute.name))
+        .map((attribute) => {
+        let start = attribute.start;
+        while (start > autofit.start && /\s/.test(part.text[start - 1]))
+            start -= 1;
+        return {
+            start: start - txBody.contentStart,
+            end: attribute.end - txBody.contentStart,
+        };
+    })
+        .sort((a, b) => b.start - a.start);
+    for (const cut of cuts)
+        prefix = prefix.slice(0, cut.start) + prefix.slice(cut.end);
+    return prefix;
+}
+/** The bytes after the last paragraph (an extension list, usually nothing). */
+export function bodySuffix(part, txBody, lastParagraph) {
+    return lastParagraph
+        ? part.text.slice(lastParagraph.end, txBody.contentEnd)
+        : "";
+}
+/** The index of the paragraph that holds an offset, taking the one before a break first. */
+export function paragraphAt(model, offset) {
+    const index = model.paragraphs.findIndex((paragraph) => paragraph.start <= offset && offset <= paragraph.end);
+    return index < 0 ? Math.max(0, model.paragraphs.length - 1) : index;
+}
+export { PARAGRAPH_BREAK };

package/dist/edit/pptx/text.d.ts

@@ -0,0 +1,41 @@
+import type { XmlElement, XmlPart } from "../ooxml/xml.js";
+export declare const PARAGRAPH_BREAK = "\n";
+export declare const LINE_BREAK = "\v";
+export type RunKind = "r" | "br" | "fld";
+export interface RunInfo {
+    readonly node: XmlElement;
+    readonly kind: RunKind;
+    /** Half-open offsets in the body's text. */
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+    /** `a:rPr` of the run or field, when present. */
+    readonly rPr?: XmlElement;
+}
+export interface ParagraphInfo {
+    readonly node: XmlElement;
+    /** Half-open offsets in the body's text, the trailing "\n" excluded. */
+    readonly start: number;
+    readonly end: number;
+    readonly runs: readonly RunInfo[];
+    readonly pPr?: XmlElement;
+    /** 0-based outline level (`a:pPr/@lvl`). */
+    readonly level: number;
+    readonly endParaRPr?: XmlElement;
+}
+export interface TextModel {
+    readonly text: string;
+    readonly paragraphs: readonly ParagraphInfo[];
+}
+/** Reads the text of a `p:txBody` or `a:txBody`. */
+export declare function readTextModel(part: XmlPart, txBody: XmlElement): TextModel;
+/** The first run that draws text, with its paragraph; undefined for an empty body. */
+export declare function firstTextRun(model: TextModel): {
+    readonly run: RunInfo;
+    readonly paragraph: ParagraphInfo;
+} | undefined;
+/** The cells of an `a:tbl`, row by row, as text models. */
+export declare function readTableCells(part: XmlPart, tbl: XmlElement): readonly (readonly {
+    node: XmlElement;
+    model: TextModel;
+}[])[];