@docx4j/core-ts 0.3.2 → 0.5.0

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

@@ -10,7 +10,8 @@ export interface Bound {
      * The tree object: for an element, what a walk of the typed tree would hand you at that path,
      * never a `{ name, value }` wrapper; for an attribute or a text node, the object of the element
      * that owns it. Undefined for an element the model does not build - a wildcard child is its own
-     * object, so this is undefined only above the root or for a node the marshal did not report.
+     * object, and so is each element inside one (the node at the same place in the tree), so this is
+     * undefined only above the root or for a node the marshal did not report.
      */
     object: unknown;
     /** Set when an attribute was selected: its qualified name on `object`'s element. */

package/dist/model/content/binder.mjs

@@ -33,11 +33,12 @@ export async function bindSnapshot(element) {
 /** Turns selected nodes into `Bound`s against a snapshot, with one path cache for them all. */
 export function boundsOf(nodes, snapshot) {
     const paths = new Paths();
+    const indexes = new Map();
     return nodes.map((node) => {
         const owner = owningElement(node);
         const bound = {
             node,
-            object: owner === undefined ? undefined : snapshot.objects.get(owner),
+            object: owner === undefined ? undefined : objectOf(owner, snapshot.objects, indexes),
             path: paths.of(node),
         };
         if (node.nodeType === 2)
@@ -45,6 +46,49 @@ export function boundsOf(nodes, snapshot) {
         return bound;
     });
 }
+/**
+ * The tree object behind a snapshot element. The marshal reports a wildcard child's imported copy
+ * but nothing inside it, so an element there maps to the node at the same place under the original:
+ * the copy is deep, so the child positions agree. Since CR-010 phase 4 a kept branch's DrawingML is
+ * DOM from the branch down (an `xdr:graphicFrame`, a `p:sp`), and a selection lands inside it.
+ * Below a typed ancestor an unreported element stays unmapped.
+ */
+function objectOf(element, objects, indexes) {
+    if (objects.has(element))
+        return objects.get(element);
+    const path = [];
+    let at = element;
+    while (!objects.has(at)) {
+        path.push(at);
+        const parent = at.parentNode;
+        if (parent === null || parent.nodeType !== 1)
+            return undefined;
+        at = parent;
+    }
+    let node = objects.get(at);
+    if (!isNode(node))
+        return undefined;
+    for (let k = path.length - 1; k >= 0; k--) {
+        node = node.childNodes[childIndex(path[k], indexes)];
+        if (node === undefined || node === null)
+            return undefined;
+    }
+    return node;
+}
+/** A node's position among its parent's child nodes, each parent's counted once. */
+function childIndex(node, indexes) {
+    var _a;
+    const parent = node.parentNode;
+    let index = indexes.get(parent);
+    if (index === undefined) {
+        index = new Map();
+        let i = 0;
+        for (let child = parent.firstChild; child; child = child.nextSibling)
+            index.set(child, i++);
+        indexes.set(parent, index);
+    }
+    return (_a = index.get(node)) !== null && _a !== void 0 ? _a : -1;
+}
 /**
  * The element an XPath result belongs to: itself for an element, its owner for an attribute, its
  * parent for a text, comment or processing-instruction node. A document node has none.
@@ -123,6 +167,9 @@ class Paths {
         return (_b = positions.get(element)) !== null && _b !== void 0 ? _b : 0;
     }
 }
+function isNode(node) {
+    return typeof node === 'object' && node !== null && typeof node.nodeType === 'number';
+}
 function isElement(node) {
     return typeof node === 'object' && node !== null && node.nodeType === 1;
 }

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

@@ -7,12 +7,13 @@ export { List, ListItem, ListItemNotFoundError, NumberingFacade, listsOf, listLa
 export { type Author, type CommentContent, type CommentOptions, type CommentEntry, type CommentParts, type CommentPartsAccess, type CommentsExtensible, type CommentMarker, COMMENT_TEXT_STYLE, COMMENT_REFERENCE_STYLE, markersOf, markersOfParagraph, commentIdsOf } from './comments.mjs';
 export { Font, type UnderlineType, type RPrHolder, type FontTracking } from './Font.mjs';
 export { Table, TableRow, TableCell, cellOf } from './Table.mjs';
-export { InlinePicture, imageInfoOf, naturalSizeEmu, addImage, writableWidthEmu, type ImageFormat, type ImageInfo, type InlinePictureOptions, type NewPicture } from './InlinePicture.mjs';
+export { layoutModeOf, textWidthTwips, gridWidthsOf, widthTypeOf, insertGridColumns, deleteGridColumns, gridRangeOf, type TableLayoutMode, type ColumnInsertion } from './tableColumns.mjs';
+export { InlinePicture, imageInfoOf, naturalSizeEmu, addImage, addImagePart, writableWidthEmu, type ImageFormat, type ImageInfo, type InlinePictureOptions, type NewPicture, type NewImagePart } from './InlinePicture.mjs';
 export { ContentControl, collectControls, collectRunControls, W14_NS, W15_NS, type ContentControlType, type ContentControlForm, type ContentControlAppearance } from './ContentControl.mjs';
 export { contentOf, isFlatOpc, rewriteRelationshipIds, type OoxmlOptions } from './ooxml.mjs';
 export { type SearchOptions, searchPattern, findAll, matchesOf, expandReplacement } from './search.mjs';
-export { segmentsOf, runsOf, runItemsOf, childrenOf, rowsOf, cellsOf, BLOCK_LEVEL_TYPES, SDT_TYPES, runOf, paragraphOf, textOfView, revisionKindOf, type TextSegment, type Located, type TextView, type TextViewOptions, type RevisionKind, type RevisionHolder } from './tree.mjs';
-export { TrackedChange, trackedChangesOfParagraph, trackedChangesOfRow, joinWithNext, type TrackedChangeType, type TrackedChangeTarget } from './TrackedChange.mjs';
+export { segmentsOf, runsOf, runItemsOf, selectedBranchOf, isAlternateContent, childrenOf, rowsOf, cellsOf, BLOCK_LEVEL_TYPES, SDT_TYPES, runOf, paragraphOf, textOfView, revisionKindOf, type TextSegment, type Located, type TextView, type TextViewOptions, type RevisionKind, type RevisionHolder } from './tree.mjs';
+export { TrackedChange, trackedChangesOfParagraph, trackedChangesOfRow, joinWithNext, type TrackedChangeType, type TrackedChangeTarget, type NoteRemovals } from './TrackedChange.mjs';
 export { ChangeTracker, trackerOf, calendarOf, dateOf, wordCalendarOf, revisionDateOf, copyRPr, markDeleted, markInserted, highestAnnotationId, MARKUP_TYPES, toDeletedText, toRestoredText, restoreRPr, restorePPr, trackInsertedParagraph, trackInsertedTable, trackInsertedBlocks, wrapNewRuns, wrapInsertedRuns, paraRPrOf, rowPrOf, pruneParagraphProperties, type ChangeTrackingMode, type TrackingHost, type TrackingScope, type TrackedPart, } from './tracking.mjs';
 export { wml, wmlOne, p, r, t, br, tab, tbl, tr, tc, sdt, sdtPr, nextSdtId, sdtProperty, sdtKindOf, inlinePicture, rPrToElements, rPrFromElements, textOf, walk, walkAll, find, linkParents, applyRunOptions, readRunOptions, UNDERLINE_TO_WML, isElement, typeNameOf, W_NS, type Element, type Wrapper, type WmlOptions, type Raw, type Interpolated, type RunOptions, type RunFormatting, type ParagraphOptions, type TableOptions, type CellOptions, type SdtKind, type SdtForm, type SdtOptions } from '@docx4j/generated-objects-ts/builders/wml';
 export { StylesFacade, type StylePackageLike } from './stylesFacade.mjs';

package/dist/model/content/index.mjs

@@ -9,11 +9,12 @@ export { List, ListItem, ListItemNotFoundError, NumberingFacade, listsOf, listLa
 export { COMMENT_TEXT_STYLE, COMMENT_REFERENCE_STYLE, markersOf, markersOfParagraph, commentIdsOf } from './comments.mjs';
 export { Font } from './Font.mjs';
 export { Table, TableRow, TableCell, cellOf } from './Table.mjs';
-export { InlinePicture, imageInfoOf, naturalSizeEmu, addImage, writableWidthEmu } from './InlinePicture.mjs';
+export { layoutModeOf, textWidthTwips, gridWidthsOf, widthTypeOf, insertGridColumns, deleteGridColumns, gridRangeOf } from './tableColumns.mjs';
+export { InlinePicture, imageInfoOf, naturalSizeEmu, addImage, addImagePart, writableWidthEmu } from './InlinePicture.mjs';
 export { ContentControl, collectControls, collectRunControls, W14_NS, W15_NS } from './ContentControl.mjs';
 export { contentOf, isFlatOpc, rewriteRelationshipIds } from './ooxml.mjs';
 export { searchPattern, findAll, matchesOf, expandReplacement } from './search.mjs';
-export { segmentsOf, runsOf, runItemsOf, childrenOf, rowsOf, cellsOf, BLOCK_LEVEL_TYPES, SDT_TYPES, runOf, paragraphOf, textOfView, revisionKindOf } from './tree.mjs';
+export { segmentsOf, runsOf, runItemsOf, selectedBranchOf, isAlternateContent, childrenOf, rowsOf, cellsOf, BLOCK_LEVEL_TYPES, SDT_TYPES, runOf, paragraphOf, textOfView, revisionKindOf } from './tree.mjs';
 // change tracking (CR-002 phase F)
 export { TrackedChange, trackedChangesOfParagraph, trackedChangesOfRow, joinWithNext } from './TrackedChange.mjs';
 export { ChangeTracker, trackerOf, calendarOf, dateOf, wordCalendarOf, revisionDateOf, copyRPr, markDeleted, markInserted, highestAnnotationId, MARKUP_TYPES, toDeletedText, toRestoredText, restoreRPr, restorePPr, trackInsertedParagraph, trackInsertedTable, trackInsertedBlocks, wrapNewRuns, wrapInsertedRuns, paraRPrOf, rowPrOf, pruneParagraphProperties, } from './tracking.mjs';

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

@@ -0,0 +1,30 @@
+import type { Part } from '../../parts/Part.mjs';
+/**
+ * Adds to `into` every relationship id a tree references: the `r:` attributes of its typed objects (read
+ * off the model's mapping, as docx4j reads its fields' `@XmlAttribute`), those kept in an
+ * `otherAttributes` map, and those of any DOM it holds.
+ */
+export declare function relationshipIdsIn(tree: unknown, into: Set<string>): void;
+/**
+ * The relationships of `part` among `candidates` that nothing left in the part references are removed,
+ * and the part each targeted when no relationship in the package targets it any more, with what that
+ * part alone related to (`RelationshipsPart.removeParts`). A part not unmarshalled can't be read for
+ * what still references, so nothing is removed from it.
+ */
+export declare function dropRelationshipsUnused(part: Part, candidates: Set<string>): void;
+/**
+ * Relationship ids, by the name of the part they belong to, that content removed outside a
+ * resolution referenced: a picture deleted with tracking off, or taken back from its author's own
+ * insertion. They are settled when the package is saved rather than at once, so that content put
+ * back in the meantime (a cut and a paste of the same drawing) keeps its relationship.
+ */
+export type RelationshipRemovals = Map<string, Set<string>>;
+/** Queues `ids` of `part` for `flushPendingRelationshipRemovals`. */
+export declare function queueRelationshipRemovals(pending: RelationshipRemovals | undefined, part: Part | undefined, ids: Iterable<string>): void;
+/** What `flushPendingRelationshipRemovals` needs of the package. */
+interface PartsHost {
+    getPart(name: string): Part | undefined;
+}
+/** Settles the queued ids against each part as it now stands (`dropRelationshipsUnused`); then `pending` is empty. */
+export declare function flushPendingRelationshipRemovals(pkg: PartsHost, pending: RelationshipRemovals): void;
+export {};

package/dist/model/content/relationships.mjs

@@ -0,0 +1,133 @@
+/**
+ * The relationships content references, and the removal of those nothing references any more
+ * (CR-002 section 46, docx4j CR-043's D7): shared by the tracked-change resolution
+ * (`TrackedChange.mts`) and the pictures (`InlinePicture.delete`, section 47).
+ */
+import { getContextSync } from '@docx4j/generated-objects-ts';
+const R_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+/** Per type, the properties that are attributes in the relationships namespace (`r:id`, `r:embed`, `r:link`, ...). */
+const relationshipAttributes = new Map();
+function relationshipAttributesOf(typeName) {
+    var _a, _b;
+    let names = relationshipAttributes.get(typeName);
+    if (names)
+        return names;
+    const found = [];
+    let info;
+    try {
+        info = getContextSync().getTypeInfoByName(typeName);
+    }
+    catch {
+        info = undefined;
+    }
+    for (let ti = info; ti; ti = ti.baseTypeInfo) {
+        for (const property of (_a = ti.properties) !== null && _a !== void 0 ? _a : []) {
+            if (((_b = property.attributeName) === null || _b === void 0 ? void 0 : _b.namespaceURI) === R_NS && property.name)
+                found.push(property.name);
+        }
+    }
+    relationshipAttributes.set(typeName, names = found);
+    return names;
+}
+/**
+ * Adds to `into` every relationship id a tree references: the `r:` attributes of its typed objects (read
+ * off the model's mapping, as docx4j reads its fields' `@XmlAttribute`), those kept in an
+ * `otherAttributes` map, and those of any DOM it holds.
+ */
+export function relationshipIdsIn(tree, into) {
+    const seen = new Set();
+    const visitDom = (node) => {
+        if (node.nodeType !== 1)
+            return;
+        const attributes = node.attributes;
+        for (let i = 0; i < attributes.length; i++) {
+            const a = attributes[i];
+            if (a.namespaceURI === R_NS && a.value)
+                into.add(a.value);
+        }
+        for (let c = node.firstChild; c; c = c.nextSibling)
+            visitDom(c);
+    };
+    const visit = (o) => {
+        if (typeof o !== 'object' || o === null || seen.has(o))
+            return;
+        seen.add(o);
+        if (Array.isArray(o)) {
+            for (const item of o)
+                visit(item);
+            return;
+        }
+        if (typeof o.nodeType === 'number') {
+            visitDom(o);
+            return;
+        }
+        const record = o;
+        const typeName = record.TYPE_NAME;
+        if (typeof typeName === 'string') {
+            for (const name of relationshipAttributesOf(typeName)) {
+                const value = record[name];
+                if (typeof value === 'string' && value)
+                    into.add(value);
+            }
+        }
+        const other = record.otherAttributes;
+        if (other && typeof other === 'object') {
+            for (const [key, value] of Object.entries(other))
+                if (key.startsWith(`{${R_NS}}`) && typeof value === 'string')
+                    into.add(value);
+        }
+        for (const key in record)
+            if (key !== 'PARENT' && key !== 'otherAttributes')
+                visit(record[key]);
+    };
+    visit(tree);
+}
+/**
+ * The relationships of `part` among `candidates` that nothing left in the part references are removed,
+ * and the part each targeted when no relationship in the package targets it any more, with what that
+ * part alone related to (`RelationshipsPart.removeParts`). A part not unmarshalled can't be read for
+ * what still references, so nothing is removed from it.
+ */
+export function dropRelationshipsUnused(part, candidates) {
+    var _a, _b;
+    const rels = part.relationshipsPart;
+    const contents = part.isUnmarshalled
+        ? part.contents : undefined;
+    if (!rels || contents === undefined)
+        return;
+    const used = new Set();
+    relationshipIdsIn(contents, used);
+    for (const id of candidates) {
+        if (used.has(id))
+            continue;
+        const rel = rels.getRelationshipById(id);
+        if (!rel)
+            continue;
+        const target = rels.getPart(rel);
+        rels.removeRelationship(rel);
+        if (target && target.sourceRelationships.length === 0) {
+            (_a = target.relationshipsPart) === null || _a === void 0 ? void 0 : _a.removeParts();
+            (_b = target.package) === null || _b === void 0 ? void 0 : _b.parts.remove(target.partName);
+        }
+    }
+}
+/** Queues `ids` of `part` for `flushPendingRelationshipRemovals`. */
+export function queueRelationshipRemovals(pending, part, ids) {
+    if (!pending || !part)
+        return;
+    let set = pending.get(part.partName.name);
+    for (const id of ids) {
+        if (!set)
+            pending.set(part.partName.name, set = new Set());
+        set.add(id);
+    }
+}
+/** Settles the queued ids against each part as it now stands (`dropRelationshipsUnused`); then `pending` is empty. */
+export function flushPendingRelationshipRemovals(pkg, pending) {
+    for (const [name, ids] of pending) {
+        const part = pkg.getPart(name);
+        if (part)
+            dropRelationshipsUnused(part, ids);
+    }
+    pending.clear();
+}

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

@@ -23,8 +23,10 @@ export declare class StylesFacade {
      *
      * A style already in the document is left exactly as it is - the document's own definition wins
      * over the default, always, since a consumer must not silently restyle a document it was asked to
-     * add a footnote to. An id the defaults do not carry throws a `Docx4JException` naming it: the
-     * caller asked for a definition nothing here has, and inventing one would be worse than saying so.
+     * add a footnote to. An id none of the sources carry - the defaults, the nine spliceable styles,
+     * the comment and placeholder styles, and Word's built-ins from docx4j's `KnownStyles.xml`
+     * (section 41) - throws a `Docx4JException` naming it: the caller asked for a definition nothing
+     * here has, and inventing one would be worse than saying so.
      * The whole closure is worked out before anything is written, so a call that throws has changed
      * nothing (CR-002 section 31).
      *

package/dist/model/content/stylesFacade.mjs

@@ -5,13 +5,16 @@ import { DEFAULT_STYLES_XML } from '../../parts/wml/defaultStyles.mjs';
 import { SPLICEABLE_STYLES_XML } from '../../parts/wml/spliceableStyles.mjs';
 import { commentStyles } from '../../parts/wml/commentStyles.mjs';
 import { placeholderStyle } from '../../parts/wml/placeholderStyle.mjs';
+import { KNOWN_STYLES_XML } from '../../parts/wml/knownStyles.mjs';
 import { Docx4JException } from '../../opc/exceptions.mjs';
 /**
  * Where a definition is looked up, unmarshalled once and never handed out (a copy is spliced in):
  * the defaults `createPackage()` writes, and then the nine styles docx4j's own `styles.xml` carries
  * **commented out** - which is why a created document has no `FootnoteText` although the file
  * appears to contain one, and why this facade exists (CR-002 section 22.2) - with Word's two comment
- * styles and its `PlaceholderText` after them.
+ * styles and its `PlaceholderText` after them, and last Word's 164 built-ins as docx4j's
+ * `KnownStyles.xml` carries them (CR-002 section 41: `Heading5`, `Quote`, `HTMLCode`, ...), the
+ * list numbering some of them name dropped, since no numbering definition comes with them.
  */
 let sources;
 function styleSources() {
@@ -20,8 +23,17 @@ function styleSources() {
         const defaults = await read(DEFAULT_STYLES_XML);
         // and Word's two comment styles, which the comment parts add when they are made, for a caller
         // that makes the comment itself (CR-002 section 37), and Word's PlaceholderText, which a
-        // placeholder run names (CR-002 section 40)
-        return { defaults, all: [...defaults, ...(await read(SPLICEABLE_STYLES_XML)), ...commentStyles(), placeholderStyle()] };
+        // placeholder run names (CR-002 section 40); then the known styles (section 41), each without
+        // the w:numPr the file left on the headings and list styles: it names a w:numId of the document
+        // the file was taken from, which the document being spliced into need not have, and a heading
+        // spliced with it would join a list that is not there (the editor's copy drops it the same way)
+        const known = (await read(KNOWN_STYLES_XML)).map((style) => {
+            var _a;
+            if ((_a = style.pPr) === null || _a === void 0 ? void 0 : _a.numPr)
+                delete style.pPr.numPr;
+            return style;
+        });
+        return { defaults, all: [...defaults, ...(await read(SPLICEABLE_STYLES_XML)), ...commentStyles(), placeholderStyle(), ...known] };
     })()));
 }
 /**
@@ -42,8 +54,10 @@ export class StylesFacade {
      *
      * A style already in the document is left exactly as it is - the document's own definition wins
      * over the default, always, since a consumer must not silently restyle a document it was asked to
-     * add a footnote to. An id the defaults do not carry throws a `Docx4JException` naming it: the
-     * caller asked for a definition nothing here has, and inventing one would be worse than saying so.
+     * add a footnote to. An id none of the sources carry - the defaults, the nine spliceable styles,
+     * the comment and placeholder styles, and Word's built-ins from docx4j's `KnownStyles.xml`
+     * (section 41) - throws a `Docx4JException` naming it: the caller asked for a definition nothing
+     * here has, and inventing one would be worse than saying so.
      * The whole closure is worked out before anything is written, so a call that throws has changed
      * nothing (CR-002 section 31).
      *
@@ -105,7 +119,7 @@ function closureOf(wanted, present, source) {
         seen.add(id);
         const template = source.find((s) => s.styleId === id);
         if (template === undefined) {
-            throw new Docx4JException(`No definition to splice for the style ${id}: neither docx4j's default styles, the nine it comments out, the two comment styles nor PlaceholderText carry one. Define it yourself on the styles part.`);
+            throw new Docx4JException(`No definition to splice for the style ${id}: neither docx4j's default styles, the nine it comments out, the two comment styles, PlaceholderText nor Word's built-ins in docx4j's KnownStyles.xml carry one. Define it yourself on the styles part.`);
         }
         // what it is based on and linked to must be there too, and before it reads better in the part
         for (const dependency of [(_a = template.basedOn) === null || _a === void 0 ? void 0 : _a.val, (_b = template.link) === null || _b === void 0 ? void 0 : _b.val]) {

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

@@ -0,0 +1,48 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import { type Element } from './tree.mjs';
+import { type ChangeTracker } from './tracking.mjs';
+/** The default text width in twips (A4 with 2.54 cm margins), as the objects package's `tbl` builder uses. */
+export declare const DEFAULT_TEXT_WIDTH = 9026;
+export type TableLayoutMode = 'fixed' | 'window' | 'contents';
+/** Which of Word's three layout modes a table is in, read as Word's Table Properties reads the file. */
+export declare function layoutModeOf(tbl: wml.Tbl): TableLayoutMode;
+/** The section's text width in twips: the page less its margins and gutter, else the default. */
+export declare function textWidthTwips(container: {
+    sectPr?: wml.SectPr;
+} | undefined): number;
+/** The grid's column widths in twips; a table without a `w:tblGrid` gets one from its first row (equal columns over the text width when the cells state none). */
+export declare function gridWidthsOf(tbl: wml.Tbl, textWidth: number): number[];
+/** The form a cell's width takes: its own `w:tcW` type, else the table's `w:tblW` type, else twips (section 42.2 item 4). */
+export declare function widthTypeOf(tc: wml.Tc | undefined, tbl: wml.Tbl): string;
+export interface ColumnInsertion {
+    /** The new cells per row, in row order; a row whose spanning cell was widened, or whose skipped columns grew, has none. */
+    cells: Element<wml.Tc>[][];
+}
+/**
+ * Inserts `count` grid columns at `gridIndex` (0 to the column count). The new column copies the
+ * width of the column to the right of the boundary when there is one, else the left (check 40:
+ * Insert Right in a narrow cell beside a wide one took the wide width; Insert Right in a spanning
+ * cell took the column after it), and each row's new cell takes the properties of the cell on the
+ * same side, less its span and merges. A cell spanning the boundary keeps its span and the new
+ * cell goes before it (check 40b1); a row's `w:gridBefore` or `w:gridAfter` covering the boundary
+ * grows instead. `values` is by row, then by new column. While changes are tracked the table
+ * change is recorded as Word's Office JS records one (check 40c): the old properties, every
+ * cell's properties - the new cells' as made - the grid as it is after, and the new cells' text in
+ * a `w:ins`, with no mark insertion.
+ */
+export declare function insertGridColumns(tbl: wml.Tbl, textWidth: number, gridIndex: number, count: number, values: string[][] | undefined, tracker: ChangeTracker | undefined): ColumnInsertion;
+/**
+ * Removes `count` grid columns from `columnIndex`: a cell covering only removed columns goes, one
+ * spanning further shrinks, a row's skipped columns shrink; the grid loses the columns, a `w:tblW`
+ * in twips loses their width, and in window mode the grid is rescaled to the width it had and the
+ * cells' percentages written again. While changes are tracked the cells still go, untracked, as
+ * Word's own Delete Columns and Office JS's `deleteColumns` leave them (known issues, entry 2;
+ * check 40c), and the table change is recorded as Office JS records it: the old properties, the
+ * remaining cells' properties, the grid as it is after.
+ */
+export declare function deleteGridColumns(tbl: wml.Tbl, textWidth: number, columnIndex: number, count: number, tracker: ChangeTracker | undefined): void;
+/** The grid columns a cell covers: its start and the one past its end. */
+export declare function gridRangeOf(tr: wml.Tr, tc: wml.Tc): {
+    start: number;
+    end: number;
+} | undefined;