@docx4j/core-ts 0.5.0 → 0.7.0

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

@@ -0,0 +1,4 @@
+import type { Outline } from '../content/Body.mjs';
+import type { TextBlock } from './TextResult.mjs';
+/** The outline of blocks: each paragraph with its address, paraId, style and text, each table with its size; a cell's blocks after its table. */
+export declare function outlineOfBlocks(blocks: readonly TextBlock[]): Outline;

package/dist/model/text/outline.mjs

@@ -0,0 +1,71 @@
+// CR-012 D3: Body.outline() and pkg.outline() read the text model. The paragraph text is the model's (hidden
+// text left out, a deleted mark joined, the view's), each text box's paragraphs follow their anchor at
+// `textbox:` addresses, flagged, and the options are the model's; the shape is the outline's own.
+import { setOutlineReader } from '../content/outline.mjs';
+import { Extractor } from './Extractor.mjs';
+import { PackageTrees, TextContext } from './TextContext.mjs';
+import { contextFor, optionsOf, isPackage } from './Texts.mjs';
+/** The story a body's blocks are in, from its address prefix. */
+function storyOf(prefix) {
+    const kind = prefix.split(':')[0];
+    switch (kind) {
+        case 'header': return 'HEADER';
+        case 'footer': return 'FOOTER';
+        case 'footnote': return 'FOOTNOTE';
+        case 'endnote': return 'ENDNOTE';
+        case 'comment': return 'COMMENT';
+        default: return 'MAIN';
+    }
+}
+/** The outline of blocks: each paragraph with its address, paraId, style and text, each table with its size; a cell's blocks after its table. */
+export function outlineOfBlocks(blocks) {
+    const paragraphs = [];
+    const tables = [];
+    const visit = (list) => {
+        var _a, _b, _c;
+        for (const block of list) {
+            if (block.kind === 'PARAGRAPH') {
+                const entry = { address: block.address, style: (_a = block.style) !== null && _a !== void 0 ? _a : 'Normal', text: block.text };
+                if (block.paraId)
+                    entry.paraId = block.paraId;
+                if (block.textbox)
+                    entry.textbox = true;
+                if (block.joined.length > 0)
+                    entry.joined = [...block.joined];
+                paragraphs.push(entry);
+            }
+            else if (block.kind === 'TABLE') {
+                tables.push({ address: block.address, rows: block.rows.length, cols: (_c = (_b = block.rows[0]) === null || _b === void 0 ? void 0 : _b.cells.length) !== null && _c !== void 0 ? _c : 0 });
+                for (const row of block.rows)
+                    for (const cell of row.cells)
+                        visit(cell.blocks);
+            }
+        }
+    };
+    visit(blocks);
+    return { paragraphs, tables };
+}
+setOutlineReader(async (body, options, context, blocks) => {
+    const o = optionsOf(options);
+    const pkg = body.package_;
+    const kind = storyOf(body.prefix);
+    if (!isPackage(pkg)) {
+        // content with no package: read as it stands, as Texts.of(content) does
+        const none = PackageTrees.none();
+        const x = new Extractor(none, o, 'planless', new TextContext(none));
+        if (blocks === undefined)
+            return outlineOfBlocks(x.extractContent(body.container, kind, body.prefix, undefined).blocks);
+        const starts = Extractor.fieldsAtBlocks(none, o, 'planless', new TextContext(none), body.container, kind, body.prefix, undefined);
+        return outlineOfBlocks(x.extractBlocks(body.container, kind, body.prefix, undefined, blocks, starts).blocks);
+    }
+    const ctx = await contextFor(pkg, context, o);
+    const part = body.part;
+    if (blocks === undefined)
+        return outlineOfBlocks(new Extractor(ctx.trees, o, 'view', ctx).extractContent(body.container, kind, body.prefix, part).blocks);
+    // some blocks (section 17.13): the plan made in the context itself, so that the siblings share it, and the
+    // reading under a sibling, so that it numbers no note and counts no list in the caller's context
+    if (o.view !== 'markup')
+        ctx.plan(o.view === 'accepted');
+    const starts = ctx.blockStarts(body.container, JSON.stringify(o.toMap()), () => Extractor.fieldsAtBlocks(ctx.trees, o, 'view', ctx, body.container, kind, body.prefix, part));
+    return outlineOfBlocks(new Extractor(ctx.trees, o, 'view', ctx.sibling()).extractBlocks(body.container, kind, body.prefix, part, blocks, starts).blocks);
+});

package/dist/model/wordIntegers.d.mts

@@ -0,0 +1,29 @@
+import { type WordIntegerReading, type WordIntegerStorage } from '@docx4j/generated-objects-ts/helpers/wml';
+/** `[min, max]` in the attribute's own unit: every value in it Word reads as written, and none outside. */
+export type KeptRange = readonly [number, number];
+/** The certain range of an attribute the table has but no round measured: outside it every measured attribute of its type changes. */
+export declare const UNMEASURED_RANGE: KeptRange;
+/** Whether a reading is of an attribute no round measured (`storage` says so), as against one Word reads to no number. */
+export declare const isUnmeasured: (reading: WordIntegerReading) => boolean;
+/**
+ * The range Word 365 keeps as written in an attribute of the table (CR-017 E1's `range`; CR-002 section 65.3's bounds):
+ * - a signed field `-2^(bits-1)` to `2^(bits-1) - 1`, an unsigned one `0` to `2^bits - 1`;
+ * - `w:ind`'s `firstLine` and `hanging`, one signed field, `0` to `32767` and `0` to `32768`;
+ * - a line or a row height whose sign is the rule: under `exact` `1` to `32768`, under `atLeast` `0` to `32767`, a line
+ *   under `auto` the plain signed field; a row height under `hRule="auto"` is ignored, so null;
+ * - a frame's height `0` to `32767` (15 bits);
+ * - then the clamps (a tab stop, the page size), and a column's width or space, whose negative Word replaces (a
+ *   computed width; -1, which it also keeps as written, its own sentinel).
+ * The rule is the `lineRule` or `hRule` beside the attribute, where it has one. Undefined for an attribute not in the
+ * table. 65535 in an attribute Word's save writes as -1 (`w:spacing`'s `before` and `after`, the unsigned page margins)
+ * is in the range, and Word reads a -1 there as 65535 too, its own spelling.
+ */
+export declare function keptRange(typeName: string, property: string, rule?: string): KeptRange | null | undefined;
+/** `keptRange` from the table's entry; `property` for the shared field, `rule` for a line or a height. */
+export declare function rangeOf(entry: WordIntegerStorage, property: string, rule?: string): KeptRange | null;
+/**
+ * Word's reading, for a message: the value, in the shared field's other attribute where the sign moved it (`25536 in
+ * w:hanging`), with the rule where the sign carries one (`atLeast 1`, `exact 32768`); `not known` for an unmeasured
+ * attribute.
+ */
+export declare function describeReading(reading: WordIntegerReading, attribute: string): string;

package/dist/model/wordIntegers.mjs

@@ -0,0 +1,78 @@
+// CR-017: what Word 365 keeps of an integer attribute, from the objects package's table (its CR-016, docx4j CR-066's
+// rounds 5 and 6, run by Jason 2026-10-26). Word stores each attribute in a field of its binary format's width, 16 bits
+// for most, and reads a value past it wrapped, sometimes then clamped, with no error or repair. The table gives the
+// width, the sign and the rules per attribute; this module turns an entry into the range of values Word keeps as
+// written, which the setters' guards (CR-002 section 65.3, `wordRange.mts`) and the out-of-range warnings (CR-017 P2
+// and P3, `XmlPart.valueOutOfRange`) both read, so there is one source for both. A report names its entry (`typeName`,
+// `property`, `storage` and the `rule` beside the value, objects 0.7.0), so `rangeOf` takes it straight.
+import { WORD_INTEGER_STORAGE } from '@docx4j/generated-objects-ts/helpers/wml';
+/** The certain range of an attribute the table has but no round measured: outside it every measured attribute of its type changes. */
+export const UNMEASURED_RANGE = [-32768, 65535];
+/** Whether a reading is of an attribute no round measured (`storage` says so), as against one Word reads to no number. */
+export const isUnmeasured = (reading) => reading.storage.startsWith('unmeasured');
+/**
+ * The range Word 365 keeps as written in an attribute of the table (CR-017 E1's `range`; CR-002 section 65.3's bounds):
+ * - a signed field `-2^(bits-1)` to `2^(bits-1) - 1`, an unsigned one `0` to `2^bits - 1`;
+ * - `w:ind`'s `firstLine` and `hanging`, one signed field, `0` to `32767` and `0` to `32768`;
+ * - a line or a row height whose sign is the rule: under `exact` `1` to `32768`, under `atLeast` `0` to `32767`, a line
+ *   under `auto` the plain signed field; a row height under `hRule="auto"` is ignored, so null;
+ * - a frame's height `0` to `32767` (15 bits);
+ * - then the clamps (a tab stop, the page size), and a column's width or space, whose negative Word replaces (a
+ *   computed width; -1, which it also keeps as written, its own sentinel).
+ * The rule is the `lineRule` or `hRule` beside the attribute, where it has one. Undefined for an attribute not in the
+ * table. 65535 in an attribute Word's save writes as -1 (`w:spacing`'s `before` and `after`, the unsigned page margins)
+ * is in the range, and Word reads a -1 there as 65535 too, its own spelling.
+ */
+export function keptRange(typeName, property, rule) {
+    var _a;
+    const entry = (_a = WORD_INTEGER_STORAGE[typeName]) === null || _a === void 0 ? void 0 : _a[property];
+    return entry === undefined ? undefined : rangeOf(entry, property, rule);
+}
+/** `keptRange` from the table's entry; `property` for the shared field, `rule` for a line or a height. */
+export function rangeOf(entry, property, rule) {
+    if (!entry.measured)
+        return UNMEASURED_RANGE;
+    const half = 2 ** (entry.bits - 1);
+    let min;
+    let max;
+    if (entry.heightFlag)
+        [min, max] = [0, half - 1];
+    else if (entry.pair)
+        [min, max] = property === entry.pair.negative ? [0, half] : [0, half - 1];
+    else if (entry.signRule) {
+        const read = rule !== null && rule !== void 0 ? rule : (entry.signRule === 'hRule' ? 'atLeast' : 'auto');
+        if (entry.signRule === 'hRule' && read === 'auto')
+            return null;
+        if (read === 'exact')
+            [min, max] = [1, half];
+        else if (read === 'atLeast')
+            [min, max] = [0, half - 1];
+        else
+            [min, max] = [-half, half - 1];
+    }
+    else if (entry.signed)
+        [min, max] = [-half, half - 1];
+    else
+        [min, max] = [0, 2 ** entry.bits - 1];
+    if (entry.negative !== undefined)
+        min = Math.max(min, 0);
+    if (entry.min !== undefined)
+        min = Math.max(min, entry.min);
+    if (entry.max !== undefined)
+        max = Math.min(max, entry.max);
+    return [min, max];
+}
+/** Whether a reading's storage string names a rule beside the value (a line's `lineRule`, a height's `hRule`). */
+const dependsOnRule = (storage) => /\brule\b|clearing exact/.test(storage);
+/**
+ * Word's reading, for a message: the value, in the shared field's other attribute where the sign moved it (`25536 in
+ * w:hanging`), with the rule where the sign carries one (`atLeast 1`, `exact 32768`); `not known` for an unmeasured
+ * attribute.
+ */
+export function describeReading(reading, attribute) {
+    if (reading.value === null)
+        return reading.storage.includes('computed') ? 'a width Word computes' : 'not known';
+    const where = reading.attribute !== undefined && reading.attribute !== attribute ? ` in w:${reading.attribute}` : '';
+    const rule = reading.rule !== undefined && dependsOnRule(reading.storage) ? `${reading.rule} ` : '';
+    return `${rule}${reading.value}${where}`;
+}

package/dist/office-js/document.mjs

@@ -15,10 +15,24 @@ function literal(text) {
 function w3cdtf(date) {
     return { TYPE_NAME: 'org_docx4j_docProps_core_dc_terms.W3CDTF', content: [date.toISOString().replace(/\.\d{3}Z$/, 'Z')] };
 }
+/**
+ * A `dcterms:created` or `dcterms:modified` value as Word 365 reads it (docx4j CR-067 section 12.2, Jason's probe of
+ * 2026-10-28; CR-018 D6): a date alone (`2024-02-03`) and a time with no offset (`2025-06-07T08:09:10`) are UTC, as a `Z`
+ * value is (Word showed 11:00 and 18:09 at UTC+11 and UTC+10), so they are read here as UTC fields, where ECMAScript's
+ * `Date` would read the offset-free time as local. A `Z` or an offset is honoured as before. The seconds are kept: Word
+ * shows the value to the minute, but this reads the stored instant.
+ */
 function dateOf(value) {
-    const text = literalText(value);
+    const text = literalText(value).trim();
     if (text === '')
         return undefined;
+    const bare = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?$/.exec(text);
+    if (bare) {
+        const [year, month, day, hour, minute, second, fraction] = bare.slice(1);
+        const ms = fraction === undefined ? 0 : Math.round(Number(`0.${fraction}`) * 1000);
+        const date = new Date(Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour !== null && hour !== void 0 ? hour : 0), Number(minute !== null && minute !== void 0 ? minute : 0), Number(second !== null && second !== void 0 ? second : 0), ms));
+        return Number.isNaN(date.getTime()) ? undefined : date;
+    }
     const date = new Date(text);
     return Number.isNaN(date.getTime()) ? undefined : date;
 }

package/dist/office-js/fragment.d.mts

@@ -1,10 +1,12 @@
-import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
 import type { Range } from '../model/content/Range.mjs';
 import type { Element } from '../model/content/tree.mjs';
 /**
- * A detached `w:p` holding exactly the range's text, with the runs and their formatting. The
- * paragraph is copied first, so the document is untouched.
+ * The blocks a range holds, as detached copies: within one paragraph, that paragraph trimmed to the range; across
+ * paragraphs, the first paragraph from the range's start, every block between whole (a table, a content control),
+ * and the last paragraph to the range's end, left out where the range ends at its start. The blocks are those
+ * `delete()` takes (`extentOf`), so a range starting or ending inside a table or a content control it doesn't hold
+ * whole is refused: a fragment of part of one isn't written.
  */
-export declare function paragraphElementOfRange(range: Range): Element<wml.P>;
-/** The range as a `w:p` fragment (extension; Office JS wraps a range in a pkg:package). */
+export declare function blocksOfRange(range: Range): Element[];
+/** The range as a fragment: its blocks' XML, one after another (extension; Office JS wraps a range in a pkg:package). */
 export declare function xmlOfRange(range: Range): Promise<string>;

package/dist/office-js/fragment.mjs

@@ -1,23 +1,72 @@
 // Marshalling a view back to a fragment: what `getOoxml()` and `toApiScript`'s fallback need.
-// A `w:p` copy holding only a range's text is the one piece the views do not offer (Range has no
-// element of its own: it is a span of the paragraph's text).
+// Copies of the blocks a range holds, its paragraphs trimmed to it, are the one piece the views do
+// not offer (Range has no element of its own: it is a span of its paragraphs' text).
 import { deepCopy, marshalString } from '@docx4j/generated-objects-ts';
+import { Body } from '../model/content/Body.mjs';
 import { Paragraph } from '../model/content/Paragraph.mjs';
+import { extentOf } from '../model/content/spanEdits.mjs';
+import { GeneralException } from '../model/content/generalException.mjs';
+import { NotSupportedError } from './errors.mjs';
 /**
- * A detached `w:p` holding exactly the range's text, with the runs and their formatting. The
- * paragraph is copied first, so the document is untouched.
+ * The body a detached copy is trimmed through. It reads as the paragraph's own body does (its package's styles
+ * decide which runs are hidden, and so the offsets), and writes untracked: trimming a copy is no edit of the
+ * document, and under tracking the trim would otherwise mark the rest of the copy deleted. What the trim queues on
+ * the package (a picture's relationship, a comment whose reference the copy lost) is settled at save against the
+ * document as it stands, which still holds them.
  */
-export function paragraphElementOfRange(range) {
-    const copy = deepCopy(range.paragraph.element);
-    const view = new Paragraph(copy, [copy], range.paragraph.parentBody);
+class CopyBody extends Body {
+    get changeTracker() {
+        return undefined;
+    }
+}
+/** A detached copy of `paragraph` holding only its text from `start` to `end`, with the runs and their formatting. */
+function trimmed(paragraph, start, end) {
+    const copy = deepCopy(paragraph.element);
+    const own = paragraph.parentBody;
+    const view = new Paragraph(copy, [copy], new CopyBody(own.part, { content: [copy] }, own.prefix, own.package_));
     const length = view.text.length;
-    if (range.end < length)
-        view.splice(range.end, length, '');
-    if (range.start > 0)
-        view.splice(0, range.start, '');
+    if (end < length)
+        view.splice(end, length, '');
+    if (start > 0)
+        view.splice(0, start, '');
     return copy;
 }
-/** The range as a `w:p` fragment (extension; Office JS wraps a range in a pkg:package). */
-export function xmlOfRange(range) {
-    return marshalString(paragraphElementOfRange(range));
+/**
+ * The blocks a range holds, as detached copies: within one paragraph, that paragraph trimmed to the range; across
+ * paragraphs, the first paragraph from the range's start, every block between whole (a table, a content control),
+ * and the last paragraph to the range's end, left out where the range ends at its start. The blocks are those
+ * `delete()` takes (`extentOf`), so a range starting or ending inside a table or a content control it doesn't hold
+ * whole is refused: a fragment of part of one isn't written.
+ */
+export function blocksOfRange(range) {
+    if (!range.spansParagraphs)
+        return [trimmed(range.paragraph, range.start, range.end)];
+    let extent;
+    try {
+        extent = extentOf(range, 'getOoxml');
+    }
+    catch (error) {
+        if (!(error instanceof GeneralException) && !(error instanceof NotSupportedError))
+            throw error;
+        throw new NotSupportedError('Range', 'getOoxml', "this range starts or ends inside a table or a content control it doesn't hold whole, "
+            + "and a fragment of part of one isn't written; take the whole table or control, or a range inside one cell");
+    }
+    const out = [];
+    for (let k = extent.first; k <= extent.last; k++) {
+        const block = extent.list[k];
+        if (k === extent.first && extent.head)
+            out.push(trimmed(extent.head, range.start, extent.head.text.length));
+        else if (k === extent.last && extent.tail) {
+            if (range.end > 0)
+                out.push(trimmed(extent.tail, 0, range.end));
+        }
+        else
+            out.push(deepCopy(block));
+    }
+    return out;
+}
+/** The range as a fragment: its blocks' XML, one after another (extension; Office JS wraps a range in a pkg:package). */
+export async function xmlOfRange(range) {
+    const xml = await Promise.all(blocksOfRange(range).map((block) => marshalString(block)));
+    return xml.join('');
 }

package/dist/office-js/proxy.d.mts

@@ -23,6 +23,14 @@ export declare class ClientResult<T = unknown> {
     resolveWith(value: T): void;
     /** True once `context.sync()` has filled it. */
     get isLoaded(): boolean;
+    /**
+     * Office JS's `load` on what an asynchronous member returned: nothing to load here, so the result itself.
+     * With `items`, a collection a member returns asynchronously (`range.getComments()`, the comment parts
+     * being read first) reads as Office JS code expects: `load`, `context.sync()`, then `items` (CR-014 phase 1).
+     */
+    load(): this;
+    /** The collection's items, once `context.sync()` has filled the result: an asynchronous collection's. */
+    get items(): T extends readonly (infer I)[] ? I[] : never;
     toJSON(): {
         value: T | undefined;
     };

package/dist/office-js/proxy.mjs

@@ -47,6 +47,21 @@ export class ClientResult {
     get isLoaded() {
         return this.loaded;
     }
+    /**
+     * Office JS's `load` on what an asynchronous member returned: nothing to load here, so the result itself.
+     * With `items`, a collection a member returns asynchronously (`range.getComments()`, the comment parts
+     * being read first) reads as Office JS code expects: `load`, `context.sync()`, then `items` (CR-014 phase 1).
+     */
+    load() {
+        return this;
+    }
+    /** The collection's items, once `context.sync()` has filled the result: an asynchronous collection's. */
+    get items() {
+        const value = this.value;
+        if (!Array.isArray(value))
+            throw new NotSupportedError('ClientResult', 'items', `the result of ${this.member}() is not a collection`);
+        return value;
+    }
     toJSON() {
         return { value: this.loaded ? this.result : undefined };
     }
@@ -219,6 +234,9 @@ export class Wrapper {
             return wrapped;
         });
         result.attach(settled);
+        // the next sync() reports a failure; code that throws before it (a member of the result called at once, as
+        // Office JS code chains `insertComment(...).getRange()`) leaves it unawaited, which must not end the process
+        settled.catch(() => { });
         this.context.enqueue(settled);
         return result;
     }
@@ -253,6 +271,12 @@ export class Wrapper {
             result.resolveWith(wrapped.length);
             return result;
         });
+        if (itemClass === 'ContentControl') {
+            // Office JS's ContentControlCollection lookups: the controls with the tag or title, as a collection
+            const matching = (key, value) => this.collection(items.filter((i) => unwrap(i)[key] === value), 'contentControls');
+            define('getByTag', (tag) => matching('tag', tag));
+            define('getByTitle', (title) => matching('title', title));
+        }
         define('load', () => collectionProxy);
         define('track', () => collectionProxy);
         define('untrack', () => collectionProxy);
@@ -268,6 +292,11 @@ export class Wrapper {
                 if (!(prop in obj))
                     throw new NotSupportedError(className, prop);
                 const member2 = Reflect.get(obj, prop, obj);
+                // the array's own methods (map, filter, forEach) give what they give: an Office JS collection has
+                // none, and a map's empty result made into a collection wouldn't serialize (CR-014 phase 1)
+                if (typeof member2 === 'function' && Object.prototype.hasOwnProperty.call(Array.prototype, prop)) {
+                    return member2.bind(obj);
+                }
                 if (typeof member2 === 'function' && !/^\d+$/.test(prop)) {
                     return (...args) => wrapperSelf.result(member2.apply(obj, args.map(unwrap)), prop);
                 }

package/dist/office-js/run.mjs

@@ -43,6 +43,8 @@ export class RequestContext {
 async function prepare(pkg, options) {
     const main = pkg.getMainDocumentPart();
     await main.getContents();
+    // a control's placeholderText reads the glossary's entries, read privately (CR-002 section 63)
+    await pkg.glossaryEntries.load(main.glossaryDocumentPart);
     if (options.unmarshalSideParts === false)
         return;
     const sideParts = [pkg.docPropsCorePart, pkg.docPropsExtendedPart, main.documentSettingsPart];

package/dist/office-js/supported.generated.mjs

@@ -5,6 +5,8 @@ export const SUBSET_MEMBERS = [
     'Body.clear',
     'Body.contentControls',
     'Body.getComments',
+    'Body.getContentControls',
+    'Body.getRange',
     'Body.getTrackedChanges',
     'Body.inlinePictures',
     'Body.insertBreak',
@@ -23,6 +25,7 @@ export const SUBSET_MEMBERS = [
     'Comment.content',
     'Comment.creationDate',
     'Comment.delete',
+    'Comment.getRange',
     'Comment.replies',
     'Comment.reply',
     'Comment.resolved',
@@ -36,6 +39,7 @@ export const SUBSET_MEMBERS = [
     'ContentControl.datePickerContentControl',
     'ContentControl.delete',
     'ContentControl.dropDownListContentControl',
+    'ContentControl.getContentControls',
     'ContentControl.getRange',
     'ContentControl.groupContentControl',
     'ContentControl.id',
@@ -47,6 +51,7 @@ export const SUBSET_MEMBERS = [
     'ContentControl.removeWhenEdited',
     'ContentControl.repeatingSectionContentControl',
     'ContentControl.search',
+    'ContentControl.showingPlaceholderText',
     'ContentControl.tables',
     'ContentControl.tag',
     'ContentControl.text',
@@ -57,6 +62,7 @@ export const SUBSET_MEMBERS = [
     'ContentControlListItem.displayText',
     'ContentControlListItem.index',
     'ContentControlListItem.value',
+    'ContentControlOptions.types',
     'CustomXmlNode.attributes',
     'CustomXmlNode.baseName',
     'CustomXmlNode.childNodes',
@@ -151,6 +157,7 @@ export const SUBSET_MEMBERS = [
     'Paragraph.firstLineIndent',
     'Paragraph.font',
     'Paragraph.getComments',
+    'Paragraph.getContentControls',
     'Paragraph.getRange',
     'Paragraph.getTrackedChanges',
     'Paragraph.insertBreak',
@@ -172,19 +179,27 @@ export const SUBSET_MEMBERS = [
     'Paragraph.startNewList',
     'Paragraph.style',
     'Paragraph.styleBuiltIn',
+    'Paragraph.tableNestingLevel',
     'Paragraph.text',
     'PictureContentControl.inlinePicture',
+    'Range.contentControls',
     'Range.delete',
+    'Range.expandTo',
     'Range.font',
     'Range.getComments',
+    'Range.getContentControls',
     'Range.getRange',
     'Range.getTrackedChanges',
     'Range.hyperlink',
     'Range.insertComment',
     'Range.insertParagraph',
     'Range.insertText',
+    'Range.isEmpty',
+    'Range.paragraphs',
     'Range.search',
     'Range.style',
+    'Range.styleBuiltIn',
+    'Range.tables',
     'Range.text',
     'RepeatingSectionContentControl.allowInsertDeleteSection',
     'RepeatingSectionContentControl.items',
@@ -196,6 +211,7 @@ export const SUBSET_MEMBERS = [
     'Table.delete',
     'Table.deleteRows',
     'Table.getCell',
+    'Table.getRange',
     'Table.headerRowCount',
     'Table.rowCount',
     'Table.rows',

package/dist/office-js/toApiScript.mjs

@@ -9,8 +9,8 @@ import { Docx4JException } from '../opc/exceptions.mjs';
 import { Body } from '../model/content/Body.mjs';
 import { Paragraph } from '../model/content/Paragraph.mjs';
 import { Range } from '../model/content/Range.mjs';
-import { isElement, typeNameOf, textOf } from '../model/content/tree.mjs';
-import { paragraphElementOfRange } from './fragment.mjs';
+import { isElement, typeNameOf, textOf, selectedBranchOf, ALTERNATE_CONTENT } from '../model/content/tree.mjs';
+import { blocksOfRange } from './fragment.mjs';
 import { builtInOf, displayNameOf } from '../model/content/styles.mjs';
 const TWIPS_PER_POINT = 20;
 /** Paragraph properties the verbs express; anything else sends the paragraph to `insertXml`. */
@@ -97,13 +97,23 @@ class Emitter {
     line(text) {
         this.lines.push(this.indent + text);
     }
-    /** A block-level element: a paragraph, a table, or anything else through `insertXml`. */
+    /**
+     * A block-level element: a paragraph, a table, or anything else through `insertXml`. A kept
+     * `mc:AlternateContent` is its selected branch's content, as Word reads it and as its save writes it:
+     * `insertXml` refuses the element itself (CR-013 phase 3).
+     */
     async element(element) {
+        var _a;
         const typeName = typeNameOf(element);
         if (typeName === 'org_docx4j_wml.P')
             await this.paragraph(element);
         else if (typeName === 'org_docx4j_wml.Tbl')
             await this.table(element);
+        else if (typeName === ALTERNATE_CONTENT) {
+            this.line('// an mc:AlternateContent: its selected branch, as Word reads it');
+            for (const child of (_a = selectedBranchOf(element.value)) !== null && _a !== void 0 ? _a : [])
+                await this.element(child);
+        }
         else
             await this.fallback(element);
     }
@@ -117,9 +127,10 @@ class Emitter {
             await this.fallback(element, error.message);
         }
     }
-    /** A range: its text and run formatting, as one paragraph. */
+    /** A range: its text and run formatting, as one paragraph; across paragraphs, each block it holds. */
     async range(range) {
-        await this.paragraph(paragraphElementOfRange(range));
+        for (const block of blocksOfRange(range))
+            await this.element(block);
     }
     emitParagraph(p) {
         const properties = this.paragraphProperties(p);
@@ -173,7 +184,7 @@ class Emitter {
      * the generated document (CR-001 Phase B step 2; the same holds for `runFormat` below).
      */
     paragraphProperties(p) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f;
         const pPr = p.pPr;
         if (!pPr)
             return [];
@@ -212,13 +223,14 @@ class Emitter {
             if (spacing.after !== undefined)
                 out.push(['spaceAfter', num(spacing.after / TWIPS_PER_POINT)]);
             if (spacing.line !== undefined) {
-                // Paragraph.lineSpacing writes w:lineRule="exact", so only an exact rule round-trips.
-                if (spacing.lineRule !== 'exact')
-                    throw new Unexpressible(`w:spacing w:lineRule="${(_c = spacing.lineRule) !== null && _c !== void 0 ? _c : 'auto'}"`);
+                // Paragraph.lineSpacing writes w:lineRule="auto", as Word's setter does (CR-002 section 65.9), so only an auto rule,
+                // stated or the default, round-trips.
+                if (spacing.lineRule !== undefined && spacing.lineRule !== 'auto')
+                    throw new Unexpressible(`w:spacing w:lineRule="${spacing.lineRule}"`);
                 out.push(['lineSpacing', num(spacing.line / TWIPS_PER_POINT)]);
             }
         }
-        const outlineLvl = (_d = pPr.outlineLvl) === null || _d === void 0 ? void 0 : _d.val;
+        const outlineLvl = (_c = pPr.outlineLvl) === null || _c === void 0 ? void 0 : _c.val;
         if (outlineLvl !== undefined)
             out.push(['outlineLevel', num(outlineLvl + 1)]);
         const numPr = pPr.numPr;
@@ -229,10 +241,10 @@ class Emitter {
             // to know whether the list is a bullet one (CR-002 section 17).
             if (!within(numPr, NUMPR_KEYS))
                 throw new Unexpressible(`w:numPr (${keysOf(numPr).filter((k) => !NUMPR_KEYS.has(k)).join(', ')})`);
-            const numId = (_e = numPr.numId) === null || _e === void 0 ? void 0 : _e.val;
+            const numId = (_d = numPr.numId) === null || _d === void 0 ? void 0 : _d.val;
             if (numId === undefined)
                 throw new Unexpressible('w:numPr with no w:numId');
-            out.push([CALL, numId === 0 ? 'detachFromList()' : `attachToList(${numId}, ${(_g = (_f = numPr.ilvl) === null || _f === void 0 ? void 0 : _f.val) !== null && _g !== void 0 ? _g : 0})`]);
+            out.push([CALL, numId === 0 ? 'detachFromList()' : `attachToList(${numId}, ${(_f = (_e = numPr.ilvl) === null || _e === void 0 ? void 0 : _e.val) !== null && _f !== void 0 ? _f : 0})`]);
         }
         return out;
     }
@@ -326,10 +338,15 @@ function tableGrid(tbl) {
         const typeName = typeNameOf(item);
         if (typeName === 'org_docx4j_wml.CTTblGridCol' || typeName === 'org_docx4j_wml.TblGrid')
             continue;
+        // a row- or cell-level mc:AlternateContent is no plain grid: the table goes whole through insertXml (CR-013 phase 3)
+        if (typeName === ALTERNATE_CONTENT)
+            return undefined;
         if (typeName !== 'org_docx4j_wml.Tr')
             continue;
         const row = [];
         for (const cell of ((_b = item.value.content) !== null && _b !== void 0 ? _b : [])) {
+            if (typeNameOf(cell) === ALTERNATE_CONTENT)
+                return undefined;
             if (typeNameOf(cell) !== 'org_docx4j_wml.Tc')
                 continue;
             const tc = cell.value;

package/dist/opc/DirectoryPartStore.d.mts

@@ -1,4 +1,4 @@
-import type { PartStore, PartSink, PutOptions } from './PartStore.mjs';
+import { type PartStore, type PartSink, type PutOptions } from './PartStore.mjs';
 /**
  * A package spread over a directory: `word/document.xml` is the file `<dir>/word/document.xml`,
  * `[Content_Types].xml` is read from the directory like any other entry, and a part's size comes
@@ -14,7 +14,10 @@ import type { PartStore, PartSink, PutOptions } from './PartStore.mjs';
  */
 export declare class DirectoryPartStore implements PartStore {
     readonly dir: string;
-    /** Store name (no leading '/') to [absolute file path, size]. */
+    /**
+     * Store name (no leading '/') to [absolute file path, size], looked up without case; of two files whose names differ only
+     * in case (a case-sensitive file system), the first in the walk is read and the rest counted (CR-024).
+     */
     private readonly entries;
     private constructor();
     /** Scans a directory and returns a store over it. */
@@ -22,6 +25,7 @@ export declare class DirectoryPartStore implements PartStore {
     private scan;
     partNames(): Iterable<string>;
     has(partName: string): boolean;
+    duplicates(): ReadonlyMap<string, number>;
     load(partName: string): Promise<Uint8Array>;
     size(partName: string): number | undefined;
 }