@docx4j/core-ts 0.3.2 → 0.5.0

package/dist/model/content/Range.mjs

@@ -1,6 +1,6 @@
 import { Font } from './Font.mjs';
 import { runFontSelectorOf } from '../fonts/lookup.mjs';
-import { typeNameOf, linkParents, runItemsOf, runsOf } from './tree.mjs';
+import { typeNameOf, linkParents, runItemsOf, runsOf, revisionKindOf, WHOLE } from './tree.mjs';
 import { Docx4JException } from '../../opc/exceptions.mjs';
 import { ContentControl } from './ContentControl.mjs';
 import { sdt as sdtOf, nextSdtId, applyRunOptions, t as textElement } from '@docx4j/generated-objects-ts/builders/wml';
@@ -15,12 +15,23 @@ import { commentApi } from './comments.mjs';
  * A subset of Office JS `Word.Range`: a span of text within one paragraph, [start, end) in the
  * paragraph's text. Positions are recomputed from the tree on every use, so a range stays
  * valid across edits made through it; edits made elsewhere may shift it.
+ *
+ * A picture has a place in the text and no text of its own, so a picture at the range's start or
+ * end offset may be inside it or outside it. `whole` says: a range from `Paragraph.getRange('Whole')`
+ * or `'Content'` holds the paragraph's whole content, the pictures at its edges too, and deleting or
+ * replacing it deletes them; any other range holds the pictures strictly inside it, so that a search
+ * hit replaced does not take the picture beside it (CR-002 section 48).
  */
 export class Range {
-    constructor(paragraph, start, end) {
+    constructor(paragraph, start, end, whole = false) {
         this.paragraph = paragraph;
         this.start = start;
         this.end = end;
+        this.whole = whole;
+    }
+    /** The edges `Paragraph.splice` is given: both for a whole range. */
+    get edges() {
+        return this.whole ? WHOLE : undefined;
     }
     get paragraphs() {
         return [this.paragraph];
@@ -93,7 +104,7 @@ export class Range {
     insertText(text, location) {
         let r;
         if (location === 'Replace')
-            r = this.paragraph.splice(this.start, this.end, text);
+            r = this.paragraph.splice(this.start, this.end, text, 'before', this.edges);
         // text put before the range joins the run the range starts in - inside the link the range is on,
         // as Office JS (check 32: insertText('Before') on a link's text went into the link, as 'After' did)
         else if (location === 'Before' || location === 'Start')
@@ -145,9 +156,9 @@ export class Range {
                 : { element: el, container: this.paragraph.container };
         });
     }
-    /** Removes the span's text. */
+    /** Removes the span's text, and the pictures in it (CR-002 section 48). */
     delete() {
-        this.paragraph.splice(this.start, this.end, '');
+        this.paragraph.splice(this.start, this.end, '', 'before', this.edges);
         this.end = this.start;
     }
     search(text, options) {
@@ -183,7 +194,7 @@ export class Range {
             return new Range(this.paragraph, this.start, this.start);
         if (location === 'End')
             return new Range(this.paragraph, this.end, this.end);
-        return new Range(this.paragraph, this.start, this.end);
+        return new Range(this.paragraph, this.start, this.end, this.whole);
     }
     /** The span's text as it stands (extension; Office JS getOoxml wraps it in a package). */
     toString() {
@@ -209,7 +220,7 @@ export class Range {
      * span gets an empty control at its position. Returns the control.
      */
     insertContentControl(kind) {
-        var _a, _b;
+        var _a;
         const paragraph = this.paragraph;
         const body = paragraph.parentBody;
         // The control is built empty first: `sdt` refuses a kind that cannot be run-level (a repeating
@@ -220,62 +231,44 @@ export class Range {
             paragraph.insertItemsAt(this.start, [sdt]);
             return new ContentControl(sdt, containerOf(sdt, paragraph), body);
         }
-        paragraph.splitAt(this.start);
-        paragraph.splitAt(this.end);
-        const segments = paragraph.segments().filter((s) => s.start >= this.start && s.end <= this.end);
-        if (segments.length === 0)
+        // Every refusal before anything changes (CR-002 section 43): until then the runs were split first.
+        const covered = coveredSegments(paragraph, this.start, this.end);
+        if (covered.length === 0)
             throw new Docx4JException('This range covers no run');
-        const owner = segments[0].runOwner;
-        if (segments.some((s) => s.runOwner !== owner)) {
+        const coveredOwner = covered[0].runOwner;
+        if (covered.some((s) => s.runOwner !== coveredOwner)) {
             throw new Docx4JException('This range spans more than one run holder (a hyperlink or a tracked change); wrap a narrower span');
         }
-        const items = [];
-        for (const segment of segments) {
-            const element = owner[segment.runIndex];
-            if (!items.includes(element))
-                items.push(element);
-        }
-        const at = owner.indexOf(items[0]);
+        refuseTrackedDeletion(coveredOwner, covered);
         const tracker = paragraph.changeTracker;
-        const revision = segments[0].revision;
+        const coveredRevision = revisionHolding(covered[0], coveredOwner);
+        if (tracker && coveredRevision && itemsKeyOf(coveredRevision) === undefined) {
+            throw new Docx4JException('This range is in a revision that cannot be split around a content control');
+        }
+        paragraph.splitAt(this.start);
+        paragraph.splitAt(this.end);
+        const segments = paragraph.segments().filter((s) => s.start >= this.start && s.end <= this.end);
+        const owner = segments[0].runOwner;
+        const { at, items } = wrappedItems(owner, segments);
+        const revision = revisionHolding(segments[0], owner);
         if (tracker && revision) {
             // The runs are in a revision: the control goes between its halves, not in it, and the runs go
             // into the control in a revision of the same kind and attributes with a new id - Word's form for
             // inserted text wrapped in a new control (check 30, inserted-text-wrapped: the w:ins inside the
             // control, the control's own markers outside it).
-            const index = revision.items.indexOf(items[0]);
-            revision.items.splice(index, items.length);
-            const value = revision.value;
-            const itemsKey = Object.keys(value).find((key) => value[key] === revision.items);
-            const inner = {};
-            for (const [key, v] of Object.entries(value))
-                if (key !== itemsKey && key !== 'PARENT')
-                    inner[key] = v;
-            inner.id = tracker.nextId();
-            inner[itemsKey] = items;
-            const wrapped = { name: revision.element.name, value: inner };
-            linkParents(items, inner);
+            revision.items.splice(at, items.length);
+            const wrapped = revisionAround(revision, items, tracker.nextId());
             sdt.value.sdtContent.content = [wrapped];
             linkParents(wrapped, sdt.value.sdtContent);
-            const holderOwner = revision.owner;
-            const parent = (_a = revision.value.PARENT) !== null && _a !== void 0 ? _a : paragraph.p;
-            if (revision.items.length === 0) {
-                holderOwner.splice(holderOwner.indexOf(revision.element), 1, sdt); // the whole revision wrapped
-                linkParents(sdt, parent);
-            }
-            else if (index === 0) {
-                holderOwner.splice(holderOwner.indexOf(revision.element), 0, sdt); // its start wrapped
-                linkParents(sdt, parent);
-            }
-            else if (!paragraph.splitHolderAround(revision, index, sdt, () => tracker.nextId())) {
+            if (!placeInRevision(paragraph, revision, at, sdt, () => tracker.nextId())) {
                 throw new Docx4JException('This range is in a revision that cannot be split around a content control');
             }
-            markHolderInserted(tracker, sdt, holderOwner, () => { });
-            return new ContentControl(sdt, holderOwner, body);
+            markHolderInserted(tracker, sdt, revision.owner, () => { });
+            return new ContentControl(sdt, revision.owner, body);
         }
         sdt.value.sdtContent.content = items;
         owner.splice(at, items.length, sdt);
-        linkParents(sdt, (_b = segments[0].run.PARENT) !== null && _b !== void 0 ? _b : paragraph.p);
+        linkParents(sdt, (_a = segments[0].run.PARENT) !== null && _a !== void 0 ? _a : paragraph.p);
         // under tracking the control itself is the insertion, the runs in it what they were (check 30)
         if (tracker)
             markHolderInserted(tracker, sdt, owner, () => { });
@@ -340,12 +333,18 @@ export class Range {
             start = Math.min(start, span[0]);
             end = Math.max(end, span[1]);
         }
-        this.removeHyperlinks();
-        if (value === '')
-            return;
         const hash = value.indexOf('#');
         const address = hash === -1 ? value : value.slice(0, hash);
         const location = hash === -1 ? '' : value.slice(hash + 1);
+        // Every refusal comes before anything changes, judged on what the range would hold once the links
+        // it touches were unwrapped (CR-002 section 43). Until then the setter unwrapped them, added the
+        // relationship and split the runs before it refused, so a refused call left the links gone, an
+        // orphan relationship and split runs (found by the docx4j-python session).
+        if (value !== '')
+            this.refuseUnlinkable(start, end, address);
+        this.removeHyperlinks();
+        if (value === '')
+            return;
         // w:history="1" is what Word writes on every hyperlink it makes, and what docx4j writes when
         // it builds one (MainDocumentPart.addHyperlink): "add the target to the viewed hyperlinks"
         // (ECMA-376 17.16.22). Readers do not depend on it, but a document holding one holder from
@@ -359,26 +358,79 @@ export class Range {
         paragraph.splitAt(start);
         paragraph.splitAt(end);
         const segments = paragraph.segments().filter((seg) => seg.start >= start && seg.end <= end);
-        if (segments.length === 0)
-            throw new Docx4JException('This range covers no run');
         const owner = segments[0].runOwner;
-        if (segments.some((seg) => seg.runOwner !== owner)) {
-            throw new Docx4JException('This range spans more than one run holder (a hyperlink or a tracked change); wrap a narrower span');
+        const { at, items } = wrappedItems(owner, segments);
+        const revision = revisionHolding(segments[0], owner);
+        let runsParent = holder.value;
+        if (revision) {
+            // A w:hyperlink cannot be in a w:ins or w:moveTo (CT_RunTrackChange holds EG_ContentRunContent
+            // only), so over runs in one, tracked or not, the link goes between the revision's halves and the
+            // runs into it in a revision of the same kind and attributes with a new id, as a content control
+            // over inserted text does (CR-002 section 43; the docx4j-python session's form). Until then the
+            // link went into the revision, which marshalled with an xsi:type. Word's own form for a link set
+            // on inserted text is a HYPERLINK field in the one w:ins (check 30, link-on-inserted-text), which
+            // this setter's getter would not read back.
+            revision.items.splice(at, items.length);
+            const inner = revisionAround(revision, items, paragraph.nextAnnotationId());
+            holder.value.content = [inner];
+            linkParents(inner, holder.value);
+            if (!placeInRevision(paragraph, revision, at, holder, () => paragraph.nextAnnotationId())) {
+                throw new Docx4JException('This range is in a revision that cannot be split around a hyperlink');
+            }
+            runsParent = inner.value;
         }
-        const items = [];
-        for (const segment of segments) {
-            const element = owner[segment.runIndex];
-            if (!items.includes(element))
-                items.push(element);
+        else {
+            holder.value.content = items;
+            owner.splice(at, items.length, holder);
+            linkParents(holder, (_a = segments[0].run.PARENT) !== null && _a !== void 0 ? _a : paragraph.p);
         }
-        const at = owner.indexOf(items[0]);
-        holder.value.content = items;
-        owner.splice(at, items.length, holder);
-        linkParents(holder, (_a = segments[0].run.PARENT) !== null && _a !== void 0 ? _a : paragraph.p);
         this.restyle(holder.value, true);
-        mergeTextRuns(holder.value.content, holder.value);
+        mergeTextRuns(items, runsParent);
         (_c = (_b = paragraph.parentBody.package_) === null || _b === void 0 ? void 0 : _b.requireStyles) === null || _c === void 0 ? void 0 : _c.call(_b, [HYPERLINK_STYLE]);
     }
+    /**
+     * Refuses, before anything changes, a link the setter could not make over [start, end): one with an
+     * address on a range with no part, over no run, over runs in more than one holder, or around a
+     * tracked deletion - each judged as the range would stand once the links it touches were unwrapped,
+     * their runs then in the list holding them.
+     */
+    refuseUnlinkable(start, end, address) {
+        const paragraph = this.paragraph;
+        if (address !== '' && !paragraph.parentBody.part) {
+            throw new Docx4JException('This range has no part, so a hyperlink cannot be related to it');
+        }
+        const touched = hyperlinkHolders(paragraph).filter((h) => this.touches(h));
+        const unwrapsInto = new Map();
+        for (const holder of touched) {
+            const inner = runItemsOf(holder.value);
+            if (inner)
+                unwrapsInto.set(inner, containerOf(holder, paragraph));
+        }
+        const ownerOnceUnwrapped = (owner) => {
+            let o = owner;
+            for (let guard = 0; guard < 100 && unwrapsInto.has(o); guard++)
+                o = unwrapsInto.get(o);
+            return o;
+        };
+        const covered = coveredSegments(paragraph, start, end);
+        if (covered.length === 0)
+            throw new Docx4JException('This range covers no run');
+        const owner = ownerOnceUnwrapped(covered[0].runOwner);
+        if (covered.some((seg) => ownerOnceUnwrapped(seg.runOwner) !== owner)) {
+            throw new Docx4JException('This range spans more than one run holder (a hyperlink or a tracked change); wrap a narrower span');
+        }
+        const unwrapped = new Set(touched);
+        const flatten = (items) => items.flatMap((item) => {
+            var _a;
+            return (unwrapped.has(item)
+                ? flatten(((_a = runItemsOf(item.value)) !== null && _a !== void 0 ? _a : [])) : [item]);
+        });
+        refuseTrackedDeletion(flatten(owner), covered);
+        const revision = revisionHolding(covered[0], owner);
+        if (revision && itemsKeyOf(revision) === undefined) {
+            throw new Docx4JException('This range is in a revision that cannot be split around a hyperlink');
+        }
+    }
     /** The first `w:hyperlink` this range touches, if any. */
     hyperlinkHolder() {
         return hyperlinkHolders(this.paragraph).find((holder) => this.touches(holder));
@@ -541,6 +593,84 @@ function hyperlinkHolders(paragraph) {
     return out;
 }
 /** The run-level array holding an element, after `insertItemsAt` put it somewhere in the paragraph. */
+/**
+ * The segments a range covers, read before its runs are split at its edges: those inside it, and those
+ * a split would cut, whose inner part then is. What `segments()` gives inside the range once it is
+ * split, so that a wrapper's refusals can come before anything changes.
+ */
+function coveredSegments(paragraph, start, end) {
+    return paragraph.segments().filter((s) => (s.start >= start && s.end <= end) || (s.start < end && s.end > start));
+}
+/**
+ * The items a range's runs are wrapped in place of: everything from the first run it covers to the
+ * last, in the one list holding them, so that what lies between - a bookmark, a comment's range, a
+ * proofing mark - goes into the wrapper with them. Until CR-002 section 43 as many items were taken as
+ * there were runs, from the first, which dropped what lay between and left a run in two places.
+ */
+function wrappedItems(owner, segments) {
+    const indexes = segments.map((s) => owner.indexOf(s.runOwner[s.runIndex])).filter((i) => i >= 0);
+    const at = Math.min(...indexes);
+    return { at, items: owner.slice(at, Math.max(...indexes) + 1) };
+}
+/**
+ * Refuses a range with a tracked deletion (or text moved away) between its runs: having no text in
+ * the range's, it would be wrapped unseen, and a range spanning a tracked change is refused (CR-002
+ * section 43).
+ */
+function refuseTrackedDeletion(items, segments) {
+    const indexes = segments.map((s) => items.indexOf(s.runOwner[s.runIndex])).filter((i) => i >= 0);
+    if (indexes.length === 0)
+        return;
+    for (const item of items.slice(Math.min(...indexes), Math.max(...indexes) + 1)) {
+        const kind = revisionKindOf(item);
+        if (kind === 'del' || kind === 'moveFrom') {
+            throw new Docx4JException('This range spans a tracked deletion; wrap the text on either side of it');
+        }
+    }
+}
+/** The `w:ins` or `w:moveTo` a segment's run is directly in, when `owner` is its own item list. */
+function revisionHolding(segment, owner) {
+    return segment.revision !== undefined && segment.revision.items === owner ? segment.revision : undefined;
+}
+/** The key under which a revision's value holds its items, or undefined where none does. */
+function itemsKeyOf(revision) {
+    const value = revision.value;
+    return Object.keys(value).find((key) => value[key] === revision.items);
+}
+/** A revision of the same kind and attributes as `revision`, with a new id, holding `items`. */
+function revisionAround(revision, items, id) {
+    const value = revision.value;
+    const itemsKey = itemsKeyOf(revision);
+    const inner = {};
+    for (const [key, v] of Object.entries(value))
+        if (key !== itemsKey && key !== 'PARENT')
+            inner[key] = v;
+    inner.id = id;
+    inner[itemsKey] = items;
+    linkParents(items, inner);
+    return { name: revision.element.name, value: inner };
+}
+/**
+ * Puts `item` where items from `index` on were taken out of `revision`: in its place where it holds
+ * nothing now, before it where they were its first, else between its halves. False where the revision
+ * cannot be split.
+ */
+function placeInRevision(paragraph, revision, index, item, nextId) {
+    var _a;
+    const owner = revision.owner;
+    const parent = (_a = revision.value.PARENT) !== null && _a !== void 0 ? _a : paragraph.p;
+    if (revision.items.length === 0) {
+        owner.splice(owner.indexOf(revision.element), 1, item); // the whole revision wrapped
+        linkParents(item, parent);
+        return true;
+    }
+    if (index === 0) {
+        owner.splice(owner.indexOf(revision.element), 0, item); // its start wrapped
+        linkParents(item, parent);
+        return true;
+    }
+    return paragraph.splitHolderAround(revision, index, item, nextId);
+}
 function containerOf(element, paragraph) {
     var _a, _b;
     var _c;

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

@@ -4,6 +4,7 @@ import type { Body } from './Body.mjs';
 import type { Paragraph } from './Paragraph.mjs';
 import type { Range } from './Range.mjs';
 import { type ChangeTracker } from './tracking.mjs';
+import { type TableLayoutMode } from './tableColumns.mjs';
 /**
  * A subset of Office JS `Word.Table` over a `w:tbl`. Rows are read through row-level content
  * controls (an OpenDoPE repeat wraps its `w:tr` in a `w:sdt`), so `rows` is what Word shows.
@@ -51,6 +52,30 @@ export declare class Table {
      * tracks changes the rows stay and take a `w:trPr/w:del` instead (CR-002 phase F).
      */
     deleteRows(rowIndex: number, rowCount?: number): void;
+    /**
+     * Adds columns at the start or the end (Office JS `Table.addColumns`), the new cells taking the
+     * properties and width of the column beside them - the one to the right of the boundary when
+     * there is one, else the left - in the table's layout mode as Word 365 writes it (CR-002 section
+     * 42, checks 39 and 40): fixed copies the width and grows the table past the margin, AutoFit to
+     * window rescales the grid and writes the cells' percentages again, AutoFit to contents stays
+     * automatic. `values` is by row, then by new column. Returns the new cells per row, an extension
+     * (Office JS returns nothing); a row whose skipped columns grew instead has none. Tracked, the
+     * table change is recorded as Office JS records one and the new cells' text is an insertion.
+     */
+    addColumns(location: 'Start' | 'End', columnCount: number, values?: string[][]): TableCell[][];
+    /**
+     * Removes `columnCount` grid columns from `columnIndex` (one by default; Office JS
+     * `Table.deleteColumns`): a cell covering only those columns goes, one spanning further shrinks.
+     * Tracked, the cells still go and the table change is recorded, as Office JS's deletion leaves
+     * it (section 42.3; check 40c; Word's own is not tracked at all, known issues entry 2).
+     */
+    deleteColumns(columnIndex: number, columnCount?: number): void;
+    /** Which of Word's three layout modes the table is in: fixed, AutoFit to window, or AutoFit to contents (extension). */
+    get layoutMode(): TableLayoutMode;
+    /** The section's text width in twips, for the window mode and a percentage width. */
+    textWidth(): number;
+    /** Views of new cells, row by row. */
+    cellViewsOf(cells: Element<wml.Tc>[][]): TableCell[][];
     /** Removes the table from its container; tracked, every row is marked deleted instead. */
     delete(): void;
     /** The package's change tracker while `changeTrackingMode` is on (CR-002 phase F). */
@@ -118,7 +143,20 @@ export declare class TableCell {
     insertText(text: string, location: 'Start' | 'End' | 'Replace'): Range;
     /** The cell width in points (w:tcW in twips), as Office JS reports it; 0 when it is not a fixed width. */
     get width(): number;
+    /**
+     * Written in the form the cell states, else its table, else twips (CR-002 section 42.2 item 4): a
+     * cell in percent takes the points as a share of the section's text width; `auto` becomes twips,
+     * a stated width being what was asked for.
+     */
     set width(points: number);
+    /**
+     * New columns before or after this cell (Office JS `TableCell.insertColumns`), the new cells
+     * taking this cell's properties and width, as `Table.addColumns` does. Returns the new cells per
+     * row (extension).
+     */
+    insertColumns(location: 'Before' | 'After', columnCount: number, values?: string[][]): TableCell[][];
+    /** Removes the grid columns this cell covers (Office JS `TableCell.deleteColumn`); tracked as `Table.deleteColumns` is. */
+    deleteColumn(): void;
     /** Office JS TableCell.columnWidth, the same value. */
     get columnWidth(): number;
     set columnWidth(points: number);

package/dist/model/content/Table.mjs

@@ -4,6 +4,7 @@ import { Docx4JException } from '../../opc/exceptions.mjs';
 import { typeNameOf, childrenOf, linkParents, textOf, rowsOf, cellsOf } from './tree.mjs';
 import { builtInOf, idOfBuiltIn, styleNameOf, styleIdOf } from './styles.mjs';
 import { trackInsertedBlocks } from './tracking.mjs';
+import { insertGridColumns, deleteGridColumns, gridRangeOf, textWidthTwips, widthTypeOf, layoutModeOf } from './tableColumns.mjs';
 /** The default table width in twips (A4 with 2.54 cm margins), as the objects package's `tbl` builder uses. */
 const DEFAULT_WIDTH = 9026;
 const TWIPS_PER_POINT = 20;
@@ -128,6 +129,51 @@ export class Table {
                 row.container.splice(i, 1);
         }
     }
+    /**
+     * Adds columns at the start or the end (Office JS `Table.addColumns`), the new cells taking the
+     * properties and width of the column beside them - the one to the right of the boundary when
+     * there is one, else the left - in the table's layout mode as Word 365 writes it (CR-002 section
+     * 42, checks 39 and 40): fixed copies the width and grows the table past the margin, AutoFit to
+     * window rescales the grid and writes the cells' percentages again, AutoFit to contents stays
+     * automatic. `values` is by row, then by new column. Returns the new cells per row, an extension
+     * (Office JS returns nothing); a row whose skipped columns grew instead has none. Tracked, the
+     * table change is recorded as Office JS records one and the new cells' text is an insertion.
+     */
+    addColumns(location, columnCount, values) {
+        const at = location === 'Start' ? 0 : this.columnWidths().length;
+        const inserted = insertGridColumns(this.tbl, this.textWidth(), at, columnCount, values, this.changeTracker);
+        return this.cellViewsOf(inserted.cells);
+    }
+    /**
+     * Removes `columnCount` grid columns from `columnIndex` (one by default; Office JS
+     * `Table.deleteColumns`): a cell covering only those columns goes, one spanning further shrinks.
+     * Tracked, the cells still go and the table change is recorded, as Office JS's deletion leaves
+     * it (section 42.3; check 40c; Word's own is not tracked at all, known issues entry 2).
+     */
+    deleteColumns(columnIndex, columnCount = 1) {
+        var _a, _b, _c;
+        deleteGridColumns(this.tbl, this.textWidth(), columnIndex, columnCount, this.changeTracker);
+        if (((_c = (_b = (_a = this.tbl.tblGrid) === null || _a === void 0 ? void 0 : _a.gridCol) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0) === 0 || rowsOf(this.tbl).every((row) => cellsOf(row.element.value).length === 0))
+            this.delete();
+    }
+    /** Which of Word's three layout modes the table is in: fixed, AutoFit to window, or AutoFit to contents (extension). */
+    get layoutMode() {
+        return layoutModeOf(this.tbl);
+    }
+    /** The section's text width in twips, for the window mode and a percentage width. */
+    textWidth() {
+        return textWidthTwips(this.parentBody.container);
+    }
+    /** Views of new cells, row by row. */
+    cellViewsOf(cells) {
+        const rows = this.rows;
+        return cells.map((rowCells, i) => {
+            const row = rows[i];
+            if (!row || rowCells.length === 0)
+                return [];
+            return row.cells.filter((cell) => rowCells.includes(cell.element));
+        });
+    }
     /** Removes the table from its container; tracked, every row is marked deleted instead. */
     delete() {
         const tracker = this.changeTracker;
@@ -311,12 +357,44 @@ export class TableCell {
         const w = (_a = this.tc.tcPr) === null || _a === void 0 ? void 0 : _a.tcW;
         return (w === null || w === void 0 ? void 0 : w.type) === 'dxa' ? ((_b = w.w) !== null && _b !== void 0 ? _b : 0) / TWIPS_PER_POINT : 0;
     }
+    /**
+     * Written in the form the cell states, else its table, else twips (CR-002 section 42.2 item 4): a
+     * cell in percent takes the points as a share of the section's text width; `auto` becomes twips,
+     * a stated width being what was asked for.
+     */
     set width(points) {
         var _a, _b;
         var _c, _d;
+        const twips = Math.round(points * TWIPS_PER_POINT);
         const tcW = ((_b = (_d = ((_a = (_c = this.tc).tcPr) !== null && _a !== void 0 ? _a : (_c.tcPr = {}))).tcW) !== null && _b !== void 0 ? _b : (_d.tcW = {}));
-        tcW.w = Math.round(points * TWIPS_PER_POINT);
-        tcW.type = 'dxa';
+        if (widthTypeOf(this.tc, this.parentTable.tbl) === 'pct') {
+            tcW.w = Math.round((twips * 5000) / this.parentTable.textWidth());
+            tcW.type = 'pct';
+        }
+        else {
+            tcW.w = twips;
+            tcW.type = 'dxa';
+        }
+    }
+    /**
+     * New columns before or after this cell (Office JS `TableCell.insertColumns`), the new cells
+     * taking this cell's properties and width, as `Table.addColumns` does. Returns the new cells per
+     * row (extension).
+     */
+    insertColumns(location, columnCount, values) {
+        const range = gridRangeOf(this.parentRow.tr, this.tc);
+        if (!range)
+            throw new Docx4JException('This cell is not in its row');
+        const table = this.parentTable;
+        const inserted = insertGridColumns(table.tbl, table.textWidth(), location === 'Before' ? range.start : range.end, columnCount, values, table.changeTracker);
+        return table.cellViewsOf(inserted.cells);
+    }
+    /** Removes the grid columns this cell covers (Office JS `TableCell.deleteColumn`); tracked as `Table.deleteColumns` is. */
+    deleteColumn() {
+        const range = gridRangeOf(this.parentRow.tr, this.tc);
+        if (!range)
+            throw new Docx4JException('This cell is not in its row');
+        this.parentTable.deleteColumns(range.start, range.end - range.start);
     }
     /** Office JS TableCell.columnWidth, the same value. */
     get columnWidth() {