@docx4j/core-ts 0.4.0 → 0.6.0

package/dist/model/content/mathText.mjs

@@ -0,0 +1,267 @@
+const MATH_RUN = 'org_docx4j_math.CTR';
+const MATH_TEXT = 'org_docx4j_math.CTText';
+const MATH_RUN_TRACK_CHANGE = 'org_docx4j_wml.CTMathRunTrackChange';
+const CONTROL_PROPERTIES = 'org_docx4j_math.CTCtrlPr';
+/** True for an equation at run-holder level: `m:oMath` or `m:oMathPara`. */
+export function isMath(el) {
+    var _a;
+    const tn = (_a = el.value) === null || _a === void 0 ? void 0 : _a.TYPE_NAME;
+    return tn === 'org_docx4j_math.CTOMath' || tn === 'org_docx4j_math.CTOMathPara';
+}
+/**
+ * The text of an equation (`m:oMath`, `m:oMathPara`) in a view: the `m:t` of every math run in document
+ * order, a revision's runs as the view has them, a structure the view hides (its `m:ctrlPr`'s revision) left out
+ * whole, each letter mapped as Word draws it (`mathLetter`).
+ */
+export function mathTextOf(math, view = 'accepted') {
+    let out = '';
+    const hides = (name) => view === 'accepted' ? name === 'del' || name === 'moveFrom' : name === 'ins' || name === 'moveTo';
+    const runText = (run) => {
+        var _a, _b, _c, _d;
+        const rPr = mathRunProperties(run);
+        const add = (text) => { out += styled(String(text !== null && text !== void 0 ? text : ''), rPr); };
+        for (const o of (_a = run.content) !== null && _a !== void 0 ? _a : []) {
+            const el = o;
+            const v = el.value;
+            if ((v === null || v === void 0 ? void 0 : v.TYPE_NAME) === MATH_RUN_TRACK_CHANGE) {
+                if (hides((_b = el.name) === null || _b === void 0 ? void 0 : _b.localPart))
+                    continue;
+                for (const inner of (_c = v.rest) !== null && _c !== void 0 ? _c : []) {
+                    const iv = inner.value;
+                    if ((iv === null || iv === void 0 ? void 0 : iv.TYPE_NAME) === MATH_TEXT)
+                        add(iv.value);
+                }
+                continue;
+            }
+            if ((v === null || v === void 0 ? void 0 : v.TYPE_NAME) === MATH_TEXT)
+                add(v.value);
+            else if ((v === null || v === void 0 ? void 0 : v.TYPE_NAME) === 'org_docx4j_wml.Text' && ((_d = el.name) === null || _d === void 0 ? void 0 : _d.localPart) === 't')
+                add(v.value);
+        }
+    };
+    const visit = (value, depth) => {
+        if (typeof value !== 'object' || value === null || depth > 64)
+            return;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                visit(v, depth + 1);
+            return;
+        }
+        const named = value;
+        if (named.name !== undefined && 'value' in named) {
+            if (hides(named.name.localPart) && isRevisionValue(named.value))
+                return;
+            visit(named.value, depth + 1);
+            return;
+        }
+        const tn = value.TYPE_NAME;
+        if (tn === MATH_RUN) {
+            runText(value);
+            return;
+        }
+        if (isProperties(tn))
+            return;
+        if (tn !== undefined && tn.startsWith('org_docx4j_math.') && !CONTAINERS.has(tn)) {
+            // a structure the view hides, its own m:ctrlPr holding the revision, goes whole (CR-002 section 62.2, F2)
+            if (hidesStructure(value, hides))
+                return;
+            // a structure: `,`, its arguments joined by `-`, `.` (check 51 case 12)
+            out += ',';
+            argumentsOf(value).forEach((argument, i) => {
+                if (i > 0)
+                    out += '-';
+                visit(argument, depth + 1);
+            });
+            out += '.';
+            return;
+        }
+        for (const key of Object.keys(value)) {
+            if (key === 'PARENT' || key === 'TYPE_NAME')
+                continue;
+            visit(value[key], depth + 1);
+        }
+    };
+    visit(math, 0);
+    return out;
+}
+/**
+ * True when a structure is inserted or deleted, in Word's form a `w:ins` or `w:del` in the `m:ctrlPr` of its own
+ * properties (`m:sSupPr`, `m:fPr`, ...), and the view hides that revision. An argument's own `m:ctrlPr` marks no
+ * structure (CR-002 section 51).
+ */
+function hidesStructure(structure, hides) {
+    var _a;
+    for (const key of Object.keys(structure)) {
+        if (key === 'PARENT' || key === 'TYPE_NAME')
+            continue;
+        const properties = structure[key];
+        if (!((_a = properties === null || properties === void 0 ? void 0 : properties.TYPE_NAME) === null || _a === void 0 ? void 0 : _a.endsWith('Pr')) || !properties.ctrlPr)
+            continue;
+        if ((properties.ctrlPr.del && hides('del')) || (properties.ctrlPr.ins && hides('ins')))
+            return true;
+    }
+    return false;
+}
+/** What holds math elements without being a structure: an equation, a display equation, an argument. */
+const CONTAINERS = new Set(['org_docx4j_math.CTOMath', 'org_docx4j_math.CTOMathPara', 'org_docx4j_math.CTOMathArg']);
+/** A math object's properties (`m:fPr`, `m:radPr`, `m:ctrlPr`, ...): no text. */
+function isProperties(tn) {
+    return tn !== undefined && tn.startsWith('org_docx4j_math.') && (tn.endsWith('Pr') || tn === CONTROL_PROPERTIES);
+}
+/**
+ * A structure's arguments (`m:e`, `m:num`, `m:den`, `m:sub`, `m:sup`, `m:deg`, `m:lim`, `m:fName`) in schema
+ * order, a matrix's rows' arguments in turn, and a radical's degree left out where `m:degHide` hides it.
+ */
+function argumentsOf(structure) {
+    var _a;
+    const out = [];
+    const degHidden = on((_a = structure.radPr) === null || _a === void 0 ? void 0 : _a.degHide);
+    const take = (v) => {
+        var _a;
+        if (typeof v !== 'object' || v === null)
+            return;
+        if (Array.isArray(v)) {
+            for (const o of v)
+                take(o);
+            return;
+        }
+        const named = v;
+        const value = (named.name !== undefined && 'value' in named ? named.value : v);
+        if ((value === null || value === void 0 ? void 0 : value.TYPE_NAME) === 'org_docx4j_math.CTOMathArg') {
+            out.push(value);
+            return;
+        }
+        if (isProperties(value === null || value === void 0 ? void 0 : value.TYPE_NAME))
+            return;
+        if ((_a = value === null || value === void 0 ? void 0 : value.TYPE_NAME) === null || _a === void 0 ? void 0 : _a.startsWith('org_docx4j_math.')) {
+            for (const key of Object.keys(value))
+                if (key !== 'PARENT' && key !== 'TYPE_NAME')
+                    take(value[key]);
+        }
+    };
+    for (const key of Object.keys(structure)) {
+        if (key === 'PARENT' || key === 'TYPE_NAME' || (key === 'deg' && degHidden))
+            continue;
+        take(structure[key]);
+    }
+    return out;
+}
+/** An `m:` on/off property: present and not `0`, `false` or `off`. */
+function on(property) {
+    return property !== undefined && property !== null && property.val !== false && property.val !== 'off' && property.val !== '0' && property.val !== 0;
+}
+/** A `w:ins`, `w:del` or `w:move*` around math runs. */
+function isRevisionValue(value) {
+    const tn = value === null || value === void 0 ? void 0 : value.TYPE_NAME;
+    return tn === 'org_docx4j_wml.RunIns' || tn === 'org_docx4j_wml.RunDel' || tn === 'org_docx4j_wml.RunTrackChange' || tn === MATH_RUN_TRACK_CHANGE;
+}
+function mathRunProperties(run) {
+    var _a, _b, _c;
+    for (const o of (_a = run.content) !== null && _a !== void 0 ? _a : []) {
+        const v = o.value;
+        if ((v === null || v === void 0 ? void 0 : v.TYPE_NAME) === 'org_docx4j_math.CTRPR')
+            return { sty: (_b = v.sty) === null || _b === void 0 ? void 0 : _b.val, scr: (_c = v.scr) === null || _c === void 0 ? void 0 : _c.val, nor: on(v.nor) };
+    }
+    return { nor: false };
+}
+function styled(text, rPr) {
+    if (rPr.nor)
+        return text; // normal text: as the run's w:rPr draws it (check 51 case 11)
+    let out = '';
+    for (const c of text)
+        out += c === '-' ? '\u2212' : mathLetter(c, rPr.sty, rPr.scr); // a minus sign (check 51 case 6)
+    return out;
+}
+// Unicode's Mathematical Alphanumeric Symbols: each alphabet's capital A and small a, its digit zero
+// where it has digits, and its Greek block (capitals, nabla, smalls, then the variants).
+const LATIN = {
+    bold: [0x1D400, 0x1D41A], italic: [0x1D434, 0x1D44E], boldItalic: [0x1D468, 0x1D482],
+    script: [0x1D49C, 0x1D4B6], boldScript: [0x1D4D0, 0x1D4EA], fraktur: [0x1D504, 0x1D51E],
+    doubleStruck: [0x1D538, 0x1D552], boldFraktur: [0x1D56C, 0x1D586], sans: [0x1D5A0, 0x1D5BA],
+    sansBold: [0x1D5D4, 0x1D5EE], sansItalic: [0x1D608, 0x1D622], sansBoldItalic: [0x1D63C, 0x1D656],
+    monospace: [0x1D670, 0x1D68A],
+};
+const DIGITS = { bold: 0x1D7CE, doubleStruck: 0x1D7D8, sans: 0x1D7E2, sansBold: 0x1D7EC, monospace: 0x1D7F6 };
+const GREEK = { bold: 0x1D6A8, italic: 0x1D6E2, boldItalic: 0x1D71C, sansBold: 0x1D756, sansBoldItalic: 0x1D790 };
+/** The letters Unicode left where they were before the block: the BMP's letterlike symbols. */
+const HOLES = {
+    italic: { h: 0x210E },
+    script: { B: 0x212C, E: 0x2130, F: 0x2131, H: 0x210B, I: 0x2110, L: 0x2112, M: 0x2133, R: 0x211B, e: 0x212F, g: 0x210A, o: 0x2134 },
+    fraktur: { C: 0x212D, H: 0x210C, I: 0x2111, R: 0x211C, Z: 0x2128 },
+    doubleStruck: { C: 0x2102, H: 0x210D, N: 0x2115, P: 0x2119, Q: 0x211A, R: 0x211D, Z: 0x2124 },
+};
+/** A Greek letter's place in an alphabet's Greek block of 58. */
+function greekIndex(cp) {
+    if (cp >= 0x391 && cp <= 0x3A1)
+        return cp - 0x391; // Alpha to Rho
+    if (cp === 0x3F4)
+        return 17; // capital theta symbol
+    if (cp >= 0x3A3 && cp <= 0x3A9)
+        return cp - 0x3A3 + 18; // Sigma to Omega
+    if (cp === 0x2207)
+        return 25; // nabla
+    if (cp >= 0x3B1 && cp <= 0x3C9)
+        return cp - 0x3B1 + 26; // alpha to omega, final sigma among them
+    const variants = { 0x2202: 51, 0x3F5: 52, 0x3D1: 53, 0x3F0: 54, 0x3D5: 55, 0x3F1: 56, 0x3D6: 57 };
+    return variants[cp];
+}
+/**
+ * A character as Word draws it in a math run with this `m:sty` (`p`, `b`, `i`, `bi`; none is Word's default,
+ * italic) and `m:scr` (`roman`, the default, `script`, `fraktur`, `double-struck`, `sans-serif`,
+ * `monospace`), as check 51 measured: letters, Greek capitals, small letters and nabla alike, in the
+ * alphabet of the style and script; digits upright in the script's family (bold for bold or bold italic,
+ * sans-serif under sans-serif, none of their own in script or fraktur); a character no alphabet has is
+ * itself.
+ */
+export function mathLetter(c, sty, scr) {
+    var _a;
+    const cp = c.codePointAt(0);
+    const bold = sty === 'b' || sty === 'bi';
+    const italic = sty === undefined || sty === 'i' || sty === 'bi';
+    let alphabet;
+    let digits;
+    switch (scr !== null && scr !== void 0 ? scr : 'roman') {
+        case 'roman':
+            alphabet = bold ? (italic ? 'boldItalic' : 'bold') : italic ? 'italic' : undefined;
+            digits = bold ? 'bold' : undefined;
+            break;
+        case 'script':
+            alphabet = bold ? 'boldScript' : 'script';
+            break;
+        case 'fraktur':
+            alphabet = bold ? 'boldFraktur' : 'fraktur';
+            break;
+        case 'double-struck':
+            alphabet = 'doubleStruck';
+            digits = 'doubleStruck';
+            break;
+        case 'sans-serif':
+            alphabet = bold ? (italic ? 'sansBoldItalic' : 'sansBold') : italic ? 'sansItalic' : 'sans';
+            digits = bold ? 'sansBold' : 'sans';
+            break;
+        case 'monospace':
+            alphabet = 'monospace';
+            digits = 'monospace';
+            break;
+        default: alphabet = undefined;
+    }
+    if (cp >= 0x30 && cp <= 0x39) {
+        const zero = digits === undefined ? undefined : DIGITS[digits];
+        return zero === undefined ? c : String.fromCodePoint(zero + cp - 0x30);
+    }
+    if (alphabet === undefined)
+        return c;
+    const hole = (_a = HOLES[alphabet]) === null || _a === void 0 ? void 0 : _a[c];
+    if (hole !== undefined)
+        return String.fromCodePoint(hole);
+    const latin = LATIN[alphabet];
+    if (cp >= 0x41 && cp <= 0x5A)
+        return String.fromCodePoint(latin[0] + cp - 0x41);
+    if (cp >= 0x61 && cp <= 0x7A)
+        return String.fromCodePoint(latin[1] + cp - 0x61);
+    const g = greekIndex(cp);
+    if (g === undefined)
+        return c;
+    const base = GREEK[alphabet];
+    return base === undefined ? c : String.fromCodePoint(base + g);
+}

package/dist/model/content/officeText.d.mts

@@ -0,0 +1,27 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import { type Element } from './tree.mjs';
+/** The text without the characters XML 1.0 excludes (E3). */
+export declare function dropExcluded(text: string): string;
+/** True when the text holds a character a writer writes as an element. */
+export declare function holdsElementCharacters(text: string): boolean;
+/**
+ * How a writer takes a line feed and a carriage return:
+ * - `paragraphs`: a paragraph break each, `\r\n` one (E1: `insertText` and every writer through `Paragraph.splice`);
+ *   the caller splits the text into lines (`linesOf`);
+ * - `one-paragraph`: `\n` and `\r\n` a `w:br`, `\r` a `w:cr` (E2: `insertParagraph`, `Paragraph.text =`), a recorded
+ *   departure from Word, which writes their escapes as text;
+ * - `multi-line`: each a `w:br` (a multi-line plain-text control, or a bound block control of one: section 61 item 3);
+ * - `single-line`: none, and no break either (a single-line plain-text control: F3).
+ */
+export type LineBreaks = 'paragraphs' | 'one-paragraph' | 'multi-line' | 'single-line';
+/** The text a writer of that kind writes, its line feeds and carriage returns turned into its characters. */
+export declare function forWriter(text: string, lineBreaks: LineBreaks): string;
+/** The text's lines, at each line feed, carriage return or `\r\n` (E1). */
+export declare function linesOf(text: string): string[];
+/** A run's items for a text: a `w:t` for each plain stretch, the element each mapped character reads as. */
+export declare function officeItems(text: string): Element[];
+/**
+ * A run of text a writer keeps in one paragraph (E2: `insertParagraph`, `Paragraph.text =`), or in a plain-text control
+ * as its kind takes it: the excluded characters dropped, every other character that is an element written as it.
+ */
+export declare function oneParagraphRun(text: string, rPr?: wml.RPr, lineBreaks?: LineBreaks): Element<wml.R>;

package/dist/model/content/officeText.mjs

@@ -0,0 +1,74 @@
+// Office JS's characters written back (CR-002 section 60). The readers give Word's character stream (CR-012 phase 4,
+// `officeItemText`): a `w:br` U+000B, a page break U+000C, a column break U+000E, a `w:cr` U+000D, the non-breaking and
+// optional hyphens U+001E and U+001F, a note reference U+0002. A writer turns each back into the element it reads as
+// (D1, as Word 365's writers do in check 55), drops the characters XML 1.0 excludes (E3: Word drops them too), and
+// takes a line feed or carriage return as its kind of writer does: a paragraph break for `insertText` (E1), a break
+// for `insertParagraph` (E2), a break or nothing in a bound or plain-text control (section 61 item 3, F3).
+import * as el from '@docx4j/generated-objects-ts/el/org_docx4j_wml';
+import { t as textItem, br as breakItem, tab as tabItem } from '@docx4j/generated-objects-ts/builders/wml';
+import { runOf } from './tree.mjs';
+/**
+ * The characters XML 1.0 excludes that are no element: U+0002 (a note reference, which no text makes) and the other C0
+ * controls but tab, line feed, carriage return and the five that are elements, U+FFFE, U+FFFF and an unpaired surrogate.
+ */
+const EXCLUDED = /[\u0000-\u0008\u000F-\u001D￾￿]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+/** The characters a writer writes as elements: tab, the three breaks, a carriage return, a line feed, the two hyphens. */
+const ELEMENT_CHARACTERS = /[\t\n\r\u000B\u000C\u000E\u001E\u001F]/;
+/** The text without the characters XML 1.0 excludes (E3). */
+export function dropExcluded(text) {
+    return text.replace(EXCLUDED, '');
+}
+/** True when the text holds a character a writer writes as an element. */
+export function holdsElementCharacters(text) {
+    return ELEMENT_CHARACTERS.test(text);
+}
+/** The text a writer of that kind writes, its line feeds and carriage returns turned into its characters. */
+export function forWriter(text, lineBreaks) {
+    switch (lineBreaks) {
+        case 'one-paragraph': return text.replace(/\r\n|\n/g, '\u000B');
+        case 'multi-line': return text.replace(/\r\n|\r|\n/g, '\u000B');
+        case 'single-line': return text.replace(/\r\n|[\r\n\u000B\u000C\u000E]/g, '');
+        default: return text;
+    }
+}
+/** The text's lines, at each line feed, carriage return or `\r\n` (E1). */
+export function linesOf(text) {
+    return text.split(/\r\n|\r|\n/);
+}
+/** The element a character reads as (`officeItemText` in reverse); a line feed a `w:br`. */
+function elementFor(c) {
+    switch (c) {
+        case '\t': return tabItem();
+        case '\u000C': return breakItem('page');
+        case '\u000E': return breakItem('column');
+        case '\r': return el.cr({});
+        case '\u001E': return el.noBreakHyphen({});
+        case '\u001F': return el.softHyphen({});
+        default: return breakItem(); // U+000B, and a line feed a writer left
+    }
+}
+/** A run's items for a text: a `w:t` for each plain stretch, the element each mapped character reads as. */
+export function officeItems(text) {
+    const out = [];
+    let plain = '';
+    for (const c of text) {
+        if (ELEMENT_CHARACTERS.test(c)) {
+            if (plain !== '')
+                out.push(textItem(plain));
+            plain = '';
+            out.push(elementFor(c));
+        }
+        else
+            plain += c;
+    }
+    if (plain !== '')
+        out.push(textItem(plain));
+    return out;
+}
+/**
+ * A run of text a writer keeps in one paragraph (E2: `insertParagraph`, `Paragraph.text =`), or in a plain-text control
+ * as its kind takes it: the excluded characters dropped, every other character that is an element written as it.
+ */
+export function oneParagraphRun(text, rPr, lineBreaks = 'one-paragraph') {
+    return runOf(officeItems(forWriter(dropExcluded(text), lineBreaks)), rPr);
+}

package/dist/model/content/outline.d.mts

@@ -0,0 +1,5 @@
+import type { Body, Outline } from './Body.mjs';
+/** What `Body.outline` asks of the text model: the outline of a body, or of its top-level blocks at these indices, under these options and context. */
+export type OutlineReader = (body: Body, options: unknown, context: unknown, blocks?: readonly number[]) => Promise<Outline>;
+export declare function setOutlineReader(implementation: OutlineReader): void;
+export declare function outlineReader(): OutlineReader;

package/dist/model/content/outline.mjs

@@ -0,0 +1,13 @@
+// The outline's reader (CR-012 D3): the text model's, which this module can't import, since the text model
+// imports the content API. The text model registers it (`model/text/outline.mts`), and the package classes
+// load that module, as the comment parts register themselves (CR-002 phase G).
+import { Docx4JException } from '../../opc/exceptions.mjs';
+let reader;
+export function setOutlineReader(implementation) {
+    reader = implementation;
+}
+export function outlineReader() {
+    if (!reader)
+        throw new Docx4JException('The text model is not loaded: import @docx4j/core-ts, @docx4j/core-ts/model or @docx4j/core-ts/packages');
+    return reader;
+}

package/dist/model/content/placeholders.d.mts

@@ -0,0 +1,110 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import { type Element } from './tree.mjs';
+import type { XmlPart } from '../../parts/XmlPart.mjs';
+import type { Part } from '../../parts/Part.mjs';
+/** Word's default placeholder entry, which a control Word makes names (checks 64 to 66). */
+export declare const DEFAULT_PLACEHOLDER_ENTRY = "DefaultPlaceholder_-1854013440";
+/** The default entry's text, as Word 365 writes it. */
+export declare const DEFAULT_PLACEHOLDER_TEXT = "Click or tap here to enter text.";
+/** A default placeholder entry: its name and its text. */
+export interface DefaultEntry {
+    name: string;
+    text: string;
+}
+/**
+ * Word's default placeholder entry for each kind of control that has one, as Word 365 makes them from the Developer tab
+ * (Jason's `placeholders.docx`, 2026-10-25; CR-002 section 63.22, as docx4j's CR-063 D8 has it): each in the glossary
+ * with the default entry's `w:docPartPr`, its body one run in the Placeholder Text style. A picture, a check box and a
+ * repeating section have none; the group, citation, equation, bibliography and `w:docPartObj` kinds are unmeasured.
+ */
+export declare const DEFAULT_ENTRIES: {
+    readonly text: {
+        readonly name: "DefaultPlaceholder_-1854013440";
+        readonly text: "Click or tap here to enter text.";
+    };
+    readonly date: {
+        readonly name: "DefaultPlaceholder_-1854013437";
+        readonly text: "Click or tap to enter a date.";
+    };
+    readonly list: {
+        readonly name: "DefaultPlaceholder_-1854013438";
+        readonly text: "Choose an item.";
+    };
+    readonly buildingBlock: {
+        readonly name: "DefaultPlaceholder_-1854013436";
+        readonly text: "Choose a building block.";
+    };
+    readonly repeatingSectionItem: {
+        readonly name: "DefaultPlaceholder_-1854013435";
+        readonly text: "Enter any content that you want to repeat, including other content controls. You can also insert this control around table rows in order to repeat parts of a table.";
+    };
+};
+/** The default entry Word gives a control of this kind (`DEFAULT_ENTRIES`); undefined for a kind it gives none. */
+export declare function defaultEntryFor(sdtPr: wml.SdtPr | undefined): DefaultEntry | undefined;
+/** The glossary entry a control's `w:placeholder` names; undefined where it names none (the bare form). */
+export declare function placeholderEntryOf(sdtPr: wml.SdtPr | undefined): string | undefined;
+/**
+ * Names `entry` in the control's `w:placeholder`, where Word writes it: after `w:id`, before `w:showingPlcHdr` and the
+ * binding (check 64's controls, as Word saved them).
+ */
+export declare function namePlaceholderEntry(sdtPr: wml.SdtPr, entry: string): void;
+/** A new entry's name, as Word names one: 32 upper-case hex digits, a new GUID's (check 65). */
+export declare function newEntryName(): string;
+/** What a package's glossary gives: an entry's text by name. */
+export interface GlossaryHost {
+    getMainDocumentPart(): {
+        glossaryDocumentPart: XmlPart<wml.GlossaryDocument> | undefined;
+        addTargetPart(part: Part): unknown;
+    };
+}
+/**
+ * The placeholder entries of a package's glossary: those its glossary document part holds, read privately (the part
+ * stays untouched), and those written since, which go into the glossary when the package is saved (`flush`).
+ */
+export declare class GlossaryEntries {
+    /** Entries by name, as the glossary part was last read; undefined until `load`. */
+    private read;
+    /** The part they were read from. */
+    private source;
+    /** Entries to write on save: name, text. */
+    private readonly pending;
+    /** Reads the glossary's entries, privately; again only where the part changed. */
+    load(glossary: XmlPart<wml.GlossaryDocument> | undefined): Promise<void>;
+    /**
+     * An entry's text, `null` where neither the glossary nor this session holds it, as Office JS reads it (check 65). An
+     * entry's paragraphs are a `\r` apart, as a control's are.
+     */
+    textOf(name: string): string | null;
+    /**
+     * An entry's body, the blocks of its `w:docPartBody` (not copies), `null` where neither the glossary nor this session
+     * holds it; an entry written this session is one paragraph, one run of its text in the Placeholder Text style.
+     */
+    bodyOf(name: string): Element[] | null;
+    /** True once the glossary has been read (`load`): until then an entry it holds reads as missing. */
+    get loaded(): boolean;
+    private entry;
+    /** Whether the glossary holds an entry of this name, or one is waiting to be written. */
+    has(name: string): boolean;
+    /** An entry to write on save, where the glossary doesn't hold one of that name. */
+    require(name: string, text: string): void;
+    /** True while entries wait for the save. */
+    get waiting(): boolean;
+    /** Entries waiting for the save, for a clone. */
+    copyTo(target: GlossaryEntries): void;
+    /**
+     * Writes the waiting entries into the glossary, making it where the file has none (D9 (a): the glossary document
+     * part and a styles part holding Placeholder Text, related from it), and puts Placeholder Text into a glossary's
+     * styles part that lacks it: an entry whose style its glossary lacks loses it in Word's save (check 65's 65b).
+     */
+    flush(host: GlossaryHost, make: {
+        glossary: () => XmlPart<wml.GlossaryDocument>;
+        styles: () => XmlPart<wml.Styles>;
+    }): Promise<void>;
+}
+/**
+ * What a control shows of an entry (CR-002 section 63.18, as revised by 63.21): a copy of each of its body's paragraphs'
+ * run-level content, every run as the glossary holds it. Word brought an entry back so, the control's own run properties
+ * not over it (check 68, cases 21 to 24), and doesn't restyle it (check 65's 65b, case 9). The paragraphs' properties stay
+ * in the glossary, whose styles they name.
+ */
+export declare function entryContentOf(body: Element[]): Element[][];