@docx4j/core-ts 0.4.0 → 0.6.0

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

@@ -1,6 +1,7 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
-import { type UnderlineType } from '@docx4j/generated-objects-ts/builders/wml';
+import { type RunOptions, type RunFormatting, type UnderlineType } from '@docx4j/generated-objects-ts/builders/wml';
 import type { ChangeTracker } from './tracking.mjs';
+import type { ThemeColors } from '../color/ThemeColors.mjs';
 export type { UnderlineType };
 /** Something with run properties: a run, or the paragraph mark. */
 export interface RPrHolder {
@@ -12,13 +13,33 @@ export interface FontTracking {
     /** The runs that are this author's own insertion: Word changes those in place, with no w:rPrChange. */
     ownInsertions: ReadonlySet<object>;
 }
+/** A run's formatting as a `Font` reads it: its properties, and its document font's name. */
+export interface RunReading {
+    formatting: RunFormatting;
+    name: string;
+}
+/** A paragraph mark's run properties as a `Font` reads them: `w:pPr/w:rPr` without the mark's own revisions. */
+export declare function markHolderOf(p: wml.P): RPrHolder;
+/**
+ * A run's reading from its properties: in the effective view a theme colour the colour Word draws, given the
+ * document's theme colours (`w:themeColor`, tint and shade, over the `w:val` beside it, which is a cache: check 53,
+ * CR-008 phase 2), and an automatic colour (`w:val="auto"`, or none) `#000000`, as Office JS reads them (CR-002
+ * section 59); and `name` its document font where one is given.
+ */
+export declare function readingOf(rPr: wml.RPr | undefined, effective: boolean, name?: string, themeColors?: ThemeColors): RunReading;
 /**
  * A subset of Office JS `Word.Font` over the run properties (`w:rPr`) of one or more runs.
  *
- * **Reads report effective formatting** (CR-001 Phase B step 2): the first run in scope
- * resolved through the document defaults, the paragraph style and the character style, which
- * is what Office JS reports. Pass an `effective` supplier for that; without one the view falls
- * back to direct formatting, which is what `getFont({ direct: true })` asks for.
+ * **Reads report effective formatting** (CR-001 Phase B step 2): each run in scope resolved through
+ * the document defaults, the paragraph style and the character style. Pass an `effective` supplier
+ * for that; without one the view reads direct formatting, which is what `getFont({ direct: true })`
+ * asks for. Where the runs differ a property reads as Office JS reads it (Word 365, checks 52 and 53;
+ * CR-002 section 59): `null`, `''` for the name, the colour and the highlight, and `Mixed` for the
+ * underline. Office JS's own types say `boolean` and `number` there, and so do these. With no run in
+ * scope, a paragraph with no text reads its mark's run properties (`w:pPr/w:rPr`, check 52 case 60),
+ * and an empty range its paragraph's style. An automatic colour (`w:val="auto"`, or none) reads
+ * `#000000` in the effective view, and a theme colour the colour Word draws (CR-008 phase 2), as Office JS reads them
+ * (check 53).
  *
  * **Writes are always direct**, and apply to every run in scope. Both directions go through
  * the objects package's one name-to-`w:rPr` mapping (`builders/wml` applyRunOptions /
@@ -31,27 +52,40 @@ export interface FontTracking {
  * package whose selector has not been built yet falls back to that.
  */
 export declare class Font {
+    /** The runs in scope; `write` is true for a write, which may split runs to have them, and false for a read, which must not. */
     private readonly holders;
     /** The change tracker and this author's own insertions, when the package is tracking changes. */
     private readonly tracking?;
-    /** The effective `w:rPr` of the first run in scope; absent for a direct-formatting view. */
+    /** The effective `w:rPr` of a run in scope; absent for a direct-formatting view. */
     private readonly effective?;
     /** The document font of that effective `w:rPr` with its theme reference resolved
      *  (`RunFontSelector.asciiFontName`); absent for a direct-formatting view, and undefined
      *  where the package has no selector yet. */
     private readonly asciiFontName?;
-    constructor(holders: () => RPrHolder[], 
+    /** The paragraph mark, read where no run is in scope: a paragraph with no text (CR-002 section 59). */
+    private readonly mark?;
+    /** The document's theme colours, which a theme colour is read through (CR-008 phase 2); absent for a direct view. */
+    private readonly themeColors?;
+    constructor(
+    /** The runs in scope; `write` is true for a write, which may split runs to have them, and false for a read, which must not. */
+    holders: (write: boolean) => RPrHolder[], 
     /** The change tracker and this author's own insertions, when the package is tracking changes. */
     tracking?: (() => FontTracking | undefined) | undefined, 
-    /** The effective `w:rPr` of the first run in scope; absent for a direct-formatting view. */
+    /** The effective `w:rPr` of a run in scope; absent for a direct-formatting view. */
     effective?: ((rPr: wml.RPr | undefined) => wml.RPr | undefined) | undefined, 
     /** The document font of that effective `w:rPr` with its theme reference resolved
      *  (`RunFontSelector.asciiFontName`); absent for a direct-formatting view, and undefined
      *  where the package has no selector yet. */
-    asciiFontName?: ((rPr: wml.RPr | undefined) => string | undefined) | undefined);
-    private effectiveRPr;
-    private read;
-    private apply;
+    asciiFontName?: ((rPr: wml.RPr | undefined) => string | undefined) | undefined, 
+    /** The paragraph mark, read where no run is in scope: a paragraph with no text (CR-002 section 59). */
+    mark?: (() => RPrHolder | undefined) | undefined, 
+    /** The document's theme colours, which a theme colour is read through (CR-008 phase 2); absent for a direct view. */
+    themeColors?: (() => ThemeColors | undefined) | undefined);
+    /** Each run in scope, read; the mark's properties where there is none, else the paragraph's style's. */
+    protected readings(): RunReading[];
+    /** A property every reading agrees on, else `null` (also where nothing is read). */
+    private value;
+    protected apply(opts: RunOptions): void;
     get bold(): boolean;
     set bold(v: boolean);
     get italic(): boolean;
@@ -69,18 +103,34 @@ export declare class Font {
     /**
      * The document font formatting this run's Latin text: `w:rFonts/@w:ascii` of the effective
      * properties, the face `w:asciiTheme` names, else `w:hAnsi`, else the document default
-     * (docx4j `RunFontSelector.asciiFontName`). '' only in a direct-formatting view with no
-     * `w:ascii`, or where the package's `RunFontSelector` has not been built yet.
+     * (docx4j `RunFontSelector.asciiFontName`). '' where the runs differ, in a direct-formatting
+     * view with no `w:ascii`, or where the package's `RunFontSelector` has not been built yet.
      */
     get name(): string;
     set name(v: string);
-    /** Size in points (w:sz is half-points); 0 only in a direct-formatting view with no w:sz. */
+    /** Size in points (w:sz is half-points); 0 only in a direct-formatting view with no w:sz; `null` where the runs differ. */
     get size(): number;
     set size(v: number);
-    /** '#RRGGBB', or the raw value ('auto', a theme colour name) when it is not a hex triple; '' when not set. */
+    /**
+     * '#RRGGBB': in the effective view the colour Word draws, so a theme colour (`w:themeColor`, with its tint or shade)
+     * through the document's theme, as Office JS reads it (check 53; CR-008 phase 2), and `#000000` for automatic; in
+     * the direct view `w:val` as written, '' when not set; the raw value where it is not a hex triple and no theme
+     * colour applies; '' where the runs differ.
+     */
     get color(): string;
     set color(v: string);
-    /** '#RRGGBB' of the highlight, or null when there is none. */
+    /** '#RRGGBB' of the highlight, or null when there is none; '' where the runs differ. */
     get highlightColor(): string | null;
     set highlightColor(v: string | null);
 }
+/**
+ * The `Font` of a range across paragraphs (CR-014): each run read in its own paragraph, as `Font` reads them. A write
+ * goes to `write` (phase 2: every run and mark in the range, as Word formats them).
+ */
+export declare class MixedFont extends Font {
+    private readonly reads;
+    private readonly write;
+    constructor(reads: () => RunReading[], write: (opts: RunOptions) => void);
+    protected readings(): RunReading[];
+    protected apply(opts: RunOptions): void;
+}

package/dist/model/content/Font.mjs

@@ -1,11 +1,47 @@
 import { applyRunOptions, readRunOptions } from '@docx4j/generated-objects-ts/builders/wml';
+import { WordColors } from '../color/WordColors.mjs';
+/** A paragraph mark's run properties as a `Font` reads them: `w:pPr/w:rPr` without the mark's own revisions. */
+export function markHolderOf(p) {
+    var _a;
+    const rPr = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr;
+    if (!rPr)
+        return {};
+    const { ins: _ins, del: _del, moveFrom: _from, moveTo: _to, rPrChange: _change, ...rest } = rPr;
+    return { rPr: { ...rest, TYPE_NAME: 'org_docx4j_wml.RPr' } };
+}
+/**
+ * A run's reading from its properties: in the effective view a theme colour the colour Word draws, given the
+ * document's theme colours (`w:themeColor`, tint and shade, over the `w:val` beside it, which is a cache: check 53,
+ * CR-008 phase 2), and an automatic colour (`w:val="auto"`, or none) `#000000`, as Office JS reads them (CR-002
+ * section 59); and `name` its document font where one is given.
+ */
+export function readingOf(rPr, effective, name, themeColors) {
+    var _a;
+    const formatting = readRunOptions(rPr);
+    if (effective) {
+        const themed = (_a = rPr === null || rPr === void 0 ? void 0 : rPr.color) === null || _a === void 0 ? void 0 : _a.themeColor;
+        const drawn = themed === undefined || themed === null || themed === 'none' || themeColors === undefined
+            ? undefined : WordColors.of(rPr.color, themeColors);
+        if (drawn !== undefined)
+            formatting.color = `#${drawn.toHex()}`;
+        else if (formatting.color === '' || formatting.color === 'auto')
+            formatting.color = '#000000';
+    }
+    return { formatting, name: name !== null && name !== void 0 ? name : formatting.name };
+}
 /**
  * A subset of Office JS `Word.Font` over the run properties (`w:rPr`) of one or more runs.
  *
- * **Reads report effective formatting** (CR-001 Phase B step 2): the first run in scope
- * resolved through the document defaults, the paragraph style and the character style, which
- * is what Office JS reports. Pass an `effective` supplier for that; without one the view falls
- * back to direct formatting, which is what `getFont({ direct: true })` asks for.
+ * **Reads report effective formatting** (CR-001 Phase B step 2): each run in scope resolved through
+ * the document defaults, the paragraph style and the character style. Pass an `effective` supplier
+ * for that; without one the view reads direct formatting, which is what `getFont({ direct: true })`
+ * asks for. Where the runs differ a property reads as Office JS reads it (Word 365, checks 52 and 53;
+ * CR-002 section 59): `null`, `''` for the name, the colour and the highlight, and `Mixed` for the
+ * underline. Office JS's own types say `boolean` and `number` there, and so do these. With no run in
+ * scope, a paragraph with no text reads its mark's run properties (`w:pPr/w:rPr`, check 52 case 60),
+ * and an empty range its paragraph's style. An automatic colour (`w:val="auto"`, or none) reads
+ * `#000000` in the effective view, and a theme colour the colour Word draws (CR-008 phase 2), as Office JS reads them
+ * (check 53).
  *
  * **Writes are always direct**, and apply to every run in scope. Both directions go through
  * the objects package's one name-to-`w:rPr` mapping (`builders/wml` applyRunOptions /
@@ -18,32 +54,52 @@ import { applyRunOptions, readRunOptions } from '@docx4j/generated-objects-ts/bu
  * package whose selector has not been built yet falls back to that.
  */
 export class Font {
-    constructor(holders, 
+    constructor(
+    /** The runs in scope; `write` is true for a write, which may split runs to have them, and false for a read, which must not. */
+    holders, 
     /** The change tracker and this author's own insertions, when the package is tracking changes. */
     tracking, 
-    /** The effective `w:rPr` of the first run in scope; absent for a direct-formatting view. */
+    /** The effective `w:rPr` of a run in scope; absent for a direct-formatting view. */
     effective, 
     /** The document font of that effective `w:rPr` with its theme reference resolved
      *  (`RunFontSelector.asciiFontName`); absent for a direct-formatting view, and undefined
      *  where the package has no selector yet. */
-    asciiFontName) {
+    asciiFontName, 
+    /** The paragraph mark, read where no run is in scope: a paragraph with no text (CR-002 section 59). */
+    mark, 
+    /** The document's theme colours, which a theme colour is read through (CR-008 phase 2); absent for a direct view. */
+    themeColors) {
         this.holders = holders;
         this.tracking = tracking;
         this.effective = effective;
         this.asciiFontName = asciiFontName;
+        this.mark = mark;
+        this.themeColors = themeColors;
     }
-    effectiveRPr() {
-        var _a;
-        const direct = (_a = this.holders()[0]) === null || _a === void 0 ? void 0 : _a.rPr;
-        return this.effective ? this.effective(direct) : direct;
+    /** Each run in scope, read; the mark's properties where there is none, else the paragraph's style's. */
+    readings() {
+        var _a, _b, _c;
+        let holders = this.holders(false);
+        if (holders.length === 0)
+            holders = [(_b = (_a = this.mark) === null || _a === void 0 ? void 0 : _a.call(this)) !== null && _b !== void 0 ? _b : {}];
+        const themeColors = this.effective ? (_c = this.themeColors) === null || _c === void 0 ? void 0 : _c.call(this) : undefined;
+        return holders.map((h) => {
+            var _a;
+            const rPr = this.effective ? this.effective(h.rPr) : h.rPr;
+            return readingOf(rPr, this.effective !== undefined, (_a = this.asciiFontName) === null || _a === void 0 ? void 0 : _a.call(this, rPr), themeColors);
+        });
     }
-    read() {
-        return readRunOptions(this.effectiveRPr());
+    /** A property every reading agrees on, else `null` (also where nothing is read). */
+    value(key) {
+        const all = this.readings().map((r) => r.formatting[key]);
+        if (all.length === 0)
+            return null;
+        return all.every((v) => v === all[0]) ? all[0] : null;
     }
     apply(opts) {
         var _a, _b;
         const tracking = (_a = this.tracking) === null || _a === void 0 ? void 0 : _a.call(this);
-        for (const h of this.holders()) {
+        for (const h of this.holders(true)) {
             (_b = h.rPr) !== null && _b !== void 0 ? _b : (h.rPr = { TYPE_NAME: 'org_docx4j_wml.RPr' });
             // the properties as they are now become w:rPrChange, unless this run is our own insertion
             if (tracking && !tracking.ownInsertions.has(h))
@@ -53,42 +109,65 @@ export class Font {
                 tracking.tracker.settleRPrChange(h);
         }
     }
-    get bold() { return this.read().bold; }
+    get bold() { return this.value('bold'); }
     set bold(v) { this.apply({ bold: v }); }
-    get italic() { return this.read().italic; }
+    get italic() { return this.value('italic'); }
     set italic(v) { this.apply({ italic: v }); }
-    get underline() { return this.read().underline; }
+    get underline() { var _a; return ((_a = this.value('underline')) !== null && _a !== void 0 ? _a : 'Mixed'); }
     set underline(v) { this.apply({ underline: v }); }
-    get strikeThrough() { return this.read().strikeThrough; }
+    get strikeThrough() { return this.value('strikeThrough'); }
     set strikeThrough(v) { this.apply({ strikeThrough: v }); }
-    get doubleStrikeThrough() { return this.read().doubleStrikeThrough; }
+    get doubleStrikeThrough() { return this.value('doubleStrikeThrough'); }
     set doubleStrikeThrough(v) { this.apply({ doubleStrikeThrough: v }); }
-    get subscript() { return this.read().subscript; }
+    get subscript() { return this.value('subscript'); }
     set subscript(v) { this.apply({ subscript: v }); }
-    get superscript() { return this.read().superscript; }
+    get superscript() { return this.value('superscript'); }
     set superscript(v) { this.apply({ superscript: v }); }
     /**
      * The document font formatting this run's Latin text: `w:rFonts/@w:ascii` of the effective
      * properties, the face `w:asciiTheme` names, else `w:hAnsi`, else the document default
-     * (docx4j `RunFontSelector.asciiFontName`). '' only in a direct-formatting view with no
-     * `w:ascii`, or where the package's `RunFontSelector` has not been built yet.
+     * (docx4j `RunFontSelector.asciiFontName`). '' where the runs differ, in a direct-formatting
+     * view with no `w:ascii`, or where the package's `RunFontSelector` has not been built yet.
      */
     get name() {
-        if (this.asciiFontName !== undefined) {
-            const resolved = this.asciiFontName(this.effectiveRPr());
-            if (resolved !== undefined)
-                return resolved;
-        }
-        return this.read().name;
+        const all = this.readings().map((r) => r.name);
+        return all.length > 0 && all.every((n) => n === all[0]) ? all[0] : '';
     }
     set name(v) { this.apply({ name: v }); }
-    /** Size in points (w:sz is half-points); 0 only in a direct-formatting view with no w:sz. */
-    get size() { return this.read().size; }
+    /** Size in points (w:sz is half-points); 0 only in a direct-formatting view with no w:sz; `null` where the runs differ. */
+    get size() { return this.value('size'); }
     set size(v) { this.apply({ size: v }); }
-    /** '#RRGGBB', or the raw value ('auto', a theme colour name) when it is not a hex triple; '' when not set. */
-    get color() { return this.read().color; }
+    /**
+     * '#RRGGBB': in the effective view the colour Word draws, so a theme colour (`w:themeColor`, with its tint or shade)
+     * through the document's theme, as Office JS reads it (check 53; CR-008 phase 2), and `#000000` for automatic; in
+     * the direct view `w:val` as written, '' when not set; the raw value where it is not a hex triple and no theme
+     * colour applies; '' where the runs differ.
+     */
+    get color() { var _a; return ((_a = this.value('color')) !== null && _a !== void 0 ? _a : ''); }
     set color(v) { this.apply({ color: v }); }
-    /** '#RRGGBB' of the highlight, or null when there is none. */
-    get highlightColor() { return this.read().highlightColor; }
+    /** '#RRGGBB' of the highlight, or null when there is none; '' where the runs differ. */
+    get highlightColor() {
+        const all = this.readings().map((r) => r.formatting.highlightColor);
+        if (all.length === 0)
+            return null;
+        return all.every((v) => v === all[0]) ? all[0] : '';
+    }
     set highlightColor(v) { this.apply({ highlightColor: v }); }
 }
+/**
+ * The `Font` of a range across paragraphs (CR-014): each run read in its own paragraph, as `Font` reads them. A write
+ * goes to `write` (phase 2: every run and mark in the range, as Word formats them).
+ */
+export class MixedFont extends Font {
+    constructor(reads, write) {
+        super(() => []);
+        this.reads = reads;
+        this.write = write;
+    }
+    readings() {
+        return this.reads();
+    }
+    apply(opts) {
+        this.write(opts);
+    }
+}

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

@@ -1,4 +1,5 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import type * as dml from '@docx4j/generated-objects-ts/modules/org_docx4j_dml';
 import type * as wp from '@docx4j/generated-objects-ts/modules/org_docx4j_dml_wordprocessingDrawing';
 import { IMAGE_CONTENT_TYPES_BY_EXTENSION } from '../../opc/ContentTypes.mjs';
 import { ImagePart } from '../../parts/BinaryPart.mjs';
@@ -70,11 +71,42 @@ export declare function addImagePart(source: Part, base64: string): NewImagePart
  * that shows it. docx4j: `BinaryPartAbstractImage.createImagePart` then `createImageInline`.
  */
 export declare function addImage(source: Part, base64: string, scope: object, maxCx: number | undefined, options?: InlinePictureOptions): NewPicture;
+/**
+ * The run showing an image already related from the part as `relId`, an inline picture `cx` by `cy` EMU, its drawing id
+ * the next free one in `scope` and named `Picture <id>`, as `addImage` names one.
+ */
+export declare function imageRunOf(relId: string, scope: object, cx: number, cy: number): Element<wml.R>;
 /** The writable width of a section in EMU (page width less the margins), for scaling. */
 export declare function writableWidthEmu(container: object): number | undefined;
+/** The `asvg:svgBlip` in a blip's `a:extLst`, if any: an SVG picture's SVG (CR-002 section 52). */
+export declare function svgBlipOf(blip: dml.CTBlip | undefined): {
+    embed?: string;
+} | undefined;
+/**
+ * Points a blip at a new image the way Word's own picture binding does (test/README.md checks 46 and
+ * 47; CR-002 section 52). The blip's effects and other extensions stay.
+ * - A raster image goes in `r:embed`, and an `asvg:svgBlip` is taken away. Left in place, Word would go
+ *   on drawing its old SVG, and would replace the new image with a PNG of that SVG when it saves.
+ * - An SVG goes under the `asvg:svgBlip`, and `r:embed` is taken away. Word puts a PNG of the SVG it
+ *   makes itself in `r:embed`, which this package cannot make, and Word 365 draws the SVG without one.
+ * `r:link` is left as it was.
+ */
+export declare function setBlipImage(blip: dml.CTBlip, relId: string, svg: boolean): void;
+/**
+ * The inline pictures a run's item holds: the item itself when it is a `w:drawing` whose `wp:inline`
+ * holds a `pic:pic`, and those in a kept `mc:AlternateContent`'s selected branch (`selectedBranchOf`,
+ * CR-010 phase 3). A drawing of anything else, such as a chart, a text box, a group or SmartArt, is no
+ * inline picture: Office JS lists none for an inline text box (CR-010 section 12.6, test/README.md
+ * check 42).
+ */
+export declare function picturesIn(item: Element): Element<wml.Drawing>[];
 /**
- * A subset of Office JS `Word.InlinePicture` over a `w:drawing` holding a `wp:inline`. A view:
- * the drawing, the run it is in and the paragraph. Sizes are points, as Office JS reports them.
+ * A subset of Office JS `Word.InlinePicture` over a `w:drawing` holding a `wp:inline` with a `pic:pic`.
+ * A view: the drawing, the run it is in and the paragraph. Sizes are points, as Office JS reports them.
+ *
+ * A picture in a kept `mc:AlternateContent`'s selected branch has the element as its `holder`. Reads and
+ * the setters are the selected branch's drawing; `delete` removes the element whole, every branch with
+ * it (CR-010 phase 3).
  */
 export declare class InlinePicture {
     /** The `w:drawing` element pair. */
@@ -82,11 +114,15 @@ export declare class InlinePicture {
     /** The run holding the drawing, and the array holding the run. */
     readonly run: Element<wml.R>;
     readonly paragraph: Paragraph;
+    /** The run's item the drawing stands in, where that is not the drawing: a kept `mc:AlternateContent`. */
+    readonly holder?: Element | undefined;
     constructor(
     /** The `w:drawing` element pair. */
     element: Element<wml.Drawing>, 
     /** The run holding the drawing, and the array holding the run. */
-    run: Element<wml.R>, paragraph: Paragraph);
+    run: Element<wml.R>, paragraph: Paragraph, 
+    /** The run's item the drawing stands in, where that is not the drawing: a kept `mc:AlternateContent`. */
+    holder?: Element | undefined);
     /** The wp:inline; a floating picture (wp:anchor) is not an InlinePicture, and throws. */
     get inline(): wp.Inline;
     /** Width in points, as Office JS. */
@@ -100,19 +136,58 @@ export declare class InlinePicture {
     /** wp:docPr/@title (typed since objects 0.1.3; before that the attribute was not marshalled, CR-002 section 8). */
     get altTextTitle(): string;
     set altTextTitle(text: string);
-    /** The kind of image, from the content type of the part the picture embeds. */
+    /**
+     * The kind of image, from the content type of the part `getBase64` reads: `Svg` for an SVG picture
+     * (`svgImagePart`), else the `a:blip`'s part's. Office JS gives `null` for an SVG picture, though its
+     * typings declare the property non-null and `Word.ImageFormat` has `Svg` (test/README.md check 45);
+     * this package gives `Svg`, a departure (CR-002 section 52).
+     */
     get imageFormat(): ImageFormat;
     /** The relationship id of the embedded image (r:embed), if any (extension). */
     get relId(): string | undefined;
-    /** The image's bytes as base64 (Office JS getBase64ImageSrc). */
+    /**
+     * The relationship id of the SVG the picture embeds beside its image, if any (extension): the
+     * `r:embed` of an `asvg:svgBlip` in the `a:blip`'s `a:extLst`, as Office 2016 and later write an SVG
+     * picture, with the `a:blip`'s own image a PNG of it for readers that don't understand SVG.
+     */
+    get svgRelId(): string | undefined;
+    /**
+     * The image's bytes as base64 (Office JS getBase64ImageSrc). For an SVG picture, the SVG
+     * (`svgImagePart`), as Office JS gives it (test/README.md check 43); else the `a:blip`'s image.
+     */
     getBase64(): Promise<string>;
     /** Office JS's name for `getBase64()`. */
     getBase64ImageSrc(): Promise<string>;
-    /** The image part this picture embeds (extension). */
+    /** The image part this picture embeds: the `a:blip`'s, which is an SVG picture's PNG (extension). */
     imagePart(): ImagePart | undefined;
-    /** Removes the picture; the run goes too when the picture was all it held. */
+    /** The SVG part an SVG picture embeds beside its image (`svgRelId`), if any (extension). */
+    svgImagePart(): ImagePart | undefined;
+    private partFor;
+    /**
+     * Removes the picture; the run goes too when the picture was all it held. A picture in a kept
+     * `mc:AlternateContent` takes the element with it, every branch (`holder`).
+     *
+     * While the package tracks changes it is marked deleted instead: its run goes into a `w:del`, and
+     * when the run held more than the picture, the picture is first given a run of its own with the
+     * same properties, so the deletion holds it alone. Accepting the deletion then takes it, and its
+     * image part with it (CR-002 section 46). A picture its author inserted under tracking is taken
+     * back, as `Paragraph.delete` takes back its own text, and one inside a deletion is refused.
+     *
+     * A picture removed outright (tracking off, or taken back) queues its image relationship on the
+     * package. On save the relationship goes if nothing then references it, and the image part with it
+     * when nothing else targets it. Waiting for the save lets a picture cut and pasted back keep its
+     * image.
+     */
     delete(): void;
+    /** The picture's run in a `w:del`, the picture split into a run of its own when the run held more. */
+    private markDeleted;
     private pic;
+    /**
+     * Refuses a write to a picture in a paragraph in a branch of a kept block-, row- or cell-level
+     * `mc:AlternateContent` (CR-013 D4). A picture in a run-level element's branch is the run's own, and
+     * deleting it removes the element (CR-010 phase 3).
+     */
+    private assertWritable;
     private resize;
 }
 export { IMAGE_CONTENT_TYPES_BY_EXTENSION };