@docx4j/core-ts 0.1.0 → 0.1.2

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

@@ -1,20 +1,55 @@
 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 { ChangeTracker } from './tracking.mjs';
 export type { UnderlineType };
 /** Something with run properties: a run, or the paragraph mark. */
 export interface RPrHolder {
     rPr?: wml.RPr;
 }
+/** What a `Font` needs to write a formatting revision (CR-002 phase F); undefined when tracking is off. */
+export interface FontTracking {
+    tracker: ChangeTracker;
+    /** The runs that are this author's own insertion: Word changes those in place, with no w:rPrChange. */
+    ownInsertions: ReadonlySet<object>;
+}
 /**
- * A subset of Office JS `Word.Font`, over the direct run properties (w:rPr) of one or more
- * runs. Reads report the first run's direct formatting (effective formatting through styles
- * is CR-001 Phase B); writes apply to every run in scope. Both go through the objects
- * package's one name-to-w:rPr mapping (`builders/wml` applyRunOptions / readRunOptions),
- * which its `r(text, opts)` builder shares.
+ * 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.
+ *
+ * **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 /
+ * readRunOptions), which its `r(text, opts)` builder shares.
+ *
+ * `name` is effective too since step 4: it is `RunFontSelector.asciiFontName` of the resolved
+ * properties, so a run whose font comes from the theme (`w:asciiTheme`) reads the face the
+ * theme names, and one that names no font anywhere reads the document default rather than ''.
+ * `getFont({ direct: true }).name` is still `w:rFonts/@w:ascii` of the run itself, and a
+ * package whose selector has not been built yet falls back to that.
  */
 export declare class Font {
     private readonly holders;
-    constructor(holders: () => RPrHolder[]);
+    /** 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. */
+    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 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. */
+    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;
     get bold(): boolean;
@@ -31,10 +66,15 @@ export declare class Font {
     set subscript(v: boolean);
     get superscript(): boolean;
     set superscript(v: boolean);
-    /** The ASCII font name (w:rFonts/@w:ascii); '' when not set directly. */
+    /**
+     * 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.
+     */
     get name(): string;
     set name(v: string);
-    /** Size in points (w:sz is half-points); 0 when not set directly. */
+    /** Size in points (w:sz is half-points); 0 only in a direct-formatting view with no w:sz. */
     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. */

package/dist/model/content/Font.mjs

@@ -1,23 +1,53 @@
 import { applyRunOptions, readRunOptions } from '@docx4j/generated-objects-ts/builders/wml';
 /**
- * A subset of Office JS `Word.Font`, over the direct run properties (w:rPr) of one or more
- * runs. Reads report the first run's direct formatting (effective formatting through styles
- * is CR-001 Phase B); writes apply to every run in scope. Both go through the objects
- * package's one name-to-w:rPr mapping (`builders/wml` applyRunOptions / readRunOptions),
- * which its `r(text, opts)` builder shares.
+ * 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.
+ *
+ * **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 /
+ * readRunOptions), which its `r(text, opts)` builder shares.
+ *
+ * `name` is effective too since step 4: it is `RunFontSelector.asciiFontName` of the resolved
+ * properties, so a run whose font comes from the theme (`w:asciiTheme`) reads the face the
+ * theme names, and one that names no font anywhere reads the document default rather than ''.
+ * `getFont({ direct: true }).name` is still `w:rFonts/@w:ascii` of the run itself, and a
+ * package whose selector has not been built yet falls back to that.
  */
 export class Font {
-    constructor(holders) {
+    constructor(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. */
+    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) {
         this.holders = holders;
+        this.tracking = tracking;
+        this.effective = effective;
+        this.asciiFontName = asciiFontName;
     }
-    read() {
+    effectiveRPr() {
         var _a;
-        return readRunOptions((_a = this.holders()[0]) === null || _a === void 0 ? void 0 : _a.rPr);
+        const direct = (_a = this.holders()[0]) === null || _a === void 0 ? void 0 : _a.rPr;
+        return this.effective ? this.effective(direct) : direct;
+    }
+    read() {
+        return readRunOptions(this.effectiveRPr());
     }
     apply(opts) {
-        var _a;
+        var _a, _b;
+        const tracking = (_a = this.tracking) === null || _a === void 0 ? void 0 : _a.call(this);
         for (const h of this.holders()) {
-            (_a = h.rPr) !== null && _a !== void 0 ? _a : (h.rPr = { TYPE_NAME: 'org_docx4j_wml.RPr' });
+            (_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))
+                tracking.tracker.recordRPrChange(h.rPr);
             applyRunOptions(h.rPr, opts);
         }
     }
@@ -35,10 +65,22 @@ export class Font {
     set subscript(v) { this.apply({ subscript: v }); }
     get superscript() { return this.read().superscript; }
     set superscript(v) { this.apply({ superscript: v }); }
-    /** The ASCII font name (w:rFonts/@w:ascii); '' when not set directly. */
-    get name() { return this.read().name; }
+    /**
+     * 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.
+     */
+    get name() {
+        if (this.asciiFontName !== undefined) {
+            const resolved = this.asciiFontName(this.effectiveRPr());
+            if (resolved !== undefined)
+                return resolved;
+        }
+        return this.read().name;
+    }
     set name(v) { this.apply({ name: v }); }
-    /** Size in points (w:sz is half-points); 0 when not set directly. */
+    /** 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; }
     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. */

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

@@ -0,0 +1,103 @@
+import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+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';
+import type { Part } from '../../parts/Part.mjs';
+import { type Element } from './tree.mjs';
+import type { Paragraph } from './Paragraph.mjs';
+/** Office JS `Word.ImageFormat`, the subset Word writes into a docx. */
+export type ImageFormat = 'Unsupported' | 'Bmp' | 'Emf' | 'Gif' | 'Jpeg' | 'Png' | 'Svg' | 'Tiff' | 'Wmf';
+/** What a header reader answers: pixels and the resolution the file declares. */
+export interface ImageInfo {
+    contentType: string;
+    /** The file extension a part of this kind is given ('png'). */
+    extension: string;
+    widthPx: number;
+    heightPx: number;
+    /** Horizontal and vertical resolution; 96 when the format carries none (docx4j's default). */
+    dpiX: number;
+    dpiY: number;
+}
+/**
+ * The size and kind of an image, from its header: PNG (IHDR and pHYs), JPEG (SOFn and the JFIF
+ * APP0 densities), GIF (the logical screen descriptor) and BMP (the DIB header, with its pixels
+ * per metre). docx4j reads these through XML Graphics Commons' ImageInfo; this is the same
+ * information, and the same 96 dpi default when a file declares none.
+ */
+export declare function imageInfoOf(bytes: Uint8Array): ImageInfo;
+/** The natural size of an image in EMU: pixels over the resolution it declares. */
+export declare function naturalSizeEmu(info: ImageInfo): {
+    cx: number;
+    cy: number;
+};
+/** Options for `insertInlinePicture`; Office JS has none, this is the extension surface. */
+export interface InlinePictureOptions {
+    /** wp:docPr/@name, the filename hint docx4j asks for. */
+    name?: string;
+    /** wp:docPr/@descr, Office JS altTextDescription. */
+    altTextDescription?: string;
+    /** wp:docPr/@title, Office JS altTextTitle; not written when absent. */
+    altTextTitle?: string;
+    /** The width in points; the height follows the aspect ratio unless it is given too. */
+    width?: number;
+    height?: number;
+}
+/** The run holding a new picture, plus the image part it added (the caller inserts the run). */
+export interface NewPicture {
+    run: Element<wml.R>;
+    drawing: Element<wml.Drawing>;
+    imagePart: ImagePart;
+    relId: string;
+}
+/**
+ * Adds the image as a part of `source` (the main document part, or the header or footer the body
+ * belongs to) with a relationship, and builds the run 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 writable width of a section in EMU (page width less the margins), for scaling. */
+export declare function writableWidthEmu(container: object): number | undefined;
+/**
+ * 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.
+ */
+export declare class InlinePicture {
+    /** The `w:drawing` element pair. */
+    readonly element: Element<wml.Drawing>;
+    /** The run holding the drawing, and the array holding the run. */
+    readonly run: Element<wml.R>;
+    readonly paragraph: Paragraph;
+    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);
+    /** The wp:inline; a floating picture (wp:anchor) is not an InlinePicture, and throws. */
+    get inline(): wp.Inline;
+    /** Width in points, as Office JS. */
+    get width(): number;
+    set width(points: number);
+    get height(): number;
+    set height(points: number);
+    /** wp:docPr/@descr (Word's alt text). */
+    get altTextDescription(): string;
+    set altTextDescription(text: string);
+    /** 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. */
+    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). */
+    getBase64(): Promise<string>;
+    /** Office JS's name for `getBase64()`. */
+    getBase64ImageSrc(): Promise<string>;
+    /** The image part this picture embeds (extension). */
+    imagePart(): ImagePart | undefined;
+    /** Removes the picture; the run goes too when the picture was all it held. */
+    delete(): void;
+    private pic;
+    private resize;
+}
+export { IMAGE_CONTENT_TYPES_BY_EXTENSION };

package/dist/model/content/InlinePicture.mjs

@@ -0,0 +1,361 @@
+import { inlinePicture } from '@docx4j/generated-objects-ts/builders/wml';
+import { Docx4JException } from '../../opc/exceptions.mjs';
+import { ContentTypes, IMAGE_CONTENT_TYPES_BY_EXTENSION } from '../../opc/ContentTypes.mjs';
+import { base64Decode, base64Encode } from '../../xml/dom.mjs';
+import { ImagePart } from '../../parts/BinaryPart.mjs';
+import { PartName } from '../../opc/PartName.mjs';
+import { find, runOf } from './tree.mjs';
+/** English Metric Units per inch, and per twip (docx4j UnitsOfMeasurement). */
+const EMU_PER_INCH = 914400;
+const EMU_PER_TWIP = 635;
+/** docx4j's ImageInfo default when a format carries no resolution. */
+const DEFAULT_DPI = 96;
+const EMU_PER_POINT = 12700;
+/**
+ * The size and kind of an image, from its header: PNG (IHDR and pHYs), JPEG (SOFn and the JFIF
+ * APP0 densities), GIF (the logical screen descriptor) and BMP (the DIB header, with its pixels
+ * per metre). docx4j reads these through XML Graphics Commons' ImageInfo; this is the same
+ * information, and the same 96 dpi default when a file declares none.
+ */
+export function imageInfoOf(bytes) {
+    const png = pngInfo(bytes);
+    if (png)
+        return png;
+    const jpeg = jpegInfo(bytes);
+    if (jpeg)
+        return jpeg;
+    const gif = gifInfo(bytes);
+    if (gif)
+        return gif;
+    const bmp = bmpInfo(bytes);
+    if (bmp)
+        return bmp;
+    const head = Array.from(bytes.subarray(0, 8)).map((b) => b.toString(16).padStart(2, '0')).join(' ');
+    throw new Docx4JException(`Unsupported image format (first bytes ${head}); PNG, JPEG, GIF and BMP are read here`);
+}
+function be16(b, at) { return (b[at] << 8) | b[at + 1]; }
+function be32(b, at) { return ((b[at] << 24) >>> 0) + (b[at + 1] << 16) + (b[at + 2] << 8) + b[at + 3]; }
+function le16(b, at) { return b[at] | (b[at + 1] << 8); }
+function le32(b, at) { return (b[at] | (b[at + 1] << 8) | (b[at + 2] << 16) | (b[at + 3] << 24)) >>> 0; }
+function sle32(b, at) { return b[at] | (b[at + 1] << 8) | (b[at + 2] << 16) | (b[at + 3] << 24); }
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+function pngInfo(b) {
+    if (b.length < 24 || PNG_SIGNATURE.some((v, i) => b[i] !== v))
+        return undefined;
+    const info = {
+        contentType: ContentTypes.IMAGE_PNG, extension: 'png',
+        widthPx: be32(b, 16), heightPx: be32(b, 20), dpiX: DEFAULT_DPI, dpiY: DEFAULT_DPI,
+    };
+    // pHYs: pixels per unit, unit 1 = metre.
+    for (let at = 8; at + 8 <= b.length;) {
+        const length = be32(b, at);
+        const type = String.fromCharCode(b[at + 4], b[at + 5], b[at + 6], b[at + 7]);
+        if (type === 'pHYs' && at + 8 + 9 <= b.length) {
+            if (b[at + 8 + 8] === 1) {
+                info.dpiX = Math.round(be32(b, at + 8) * 0.0254) || DEFAULT_DPI;
+                info.dpiY = Math.round(be32(b, at + 12) * 0.0254) || DEFAULT_DPI;
+            }
+            break;
+        }
+        if (type === 'IDAT' || type === 'IEND')
+            break;
+        at += 12 + length;
+    }
+    return info;
+}
+function jpegInfo(b) {
+    if (b.length < 4 || b[0] !== 0xff || b[1] !== 0xd8)
+        return undefined;
+    const info = {
+        contentType: ContentTypes.IMAGE_JPEG, extension: 'jpeg',
+        widthPx: 0, heightPx: 0, dpiX: DEFAULT_DPI, dpiY: DEFAULT_DPI,
+    };
+    for (let at = 2; at + 4 <= b.length;) {
+        if (b[at] !== 0xff) {
+            at++;
+            continue;
+        }
+        const marker = b[at + 1];
+        if (marker === 0xd8 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            at += 2;
+            continue;
+        }
+        if (marker === 0xd9 || marker === 0xda)
+            break;
+        const length = be16(b, at + 2);
+        const data = at + 4;
+        if (marker === 0xe0 && b.length >= data + 12 && String.fromCharCode(b[data], b[data + 1], b[data + 2], b[data + 3]) === 'JFIF') {
+            const units = b[data + 7];
+            const x = be16(b, data + 8);
+            const y = be16(b, data + 10);
+            if (units === 1 && x && y) {
+                info.dpiX = x;
+                info.dpiY = y;
+            }
+            else if (units === 2 && x && y) {
+                info.dpiX = Math.round(x * 2.54);
+                info.dpiY = Math.round(y * 2.54);
+            }
+        }
+        // SOF0..SOF15, less the marker-only and non-frame ones
+        if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+            info.heightPx = be16(b, data + 1);
+            info.widthPx = be16(b, data + 3);
+            if (info.widthPx && info.heightPx)
+                return info;
+        }
+        at += 2 + length;
+    }
+    return info.widthPx && info.heightPx ? info : undefined;
+}
+function gifInfo(b) {
+    if (b.length < 10 || b[0] !== 0x47 || b[1] !== 0x49 || b[2] !== 0x46)
+        return undefined;
+    return { contentType: ContentTypes.IMAGE_GIF, extension: 'gif', widthPx: le16(b, 6), heightPx: le16(b, 8), dpiX: DEFAULT_DPI, dpiY: DEFAULT_DPI };
+}
+function bmpInfo(b) {
+    if (b.length < 26 || b[0] !== 0x42 || b[1] !== 0x4d)
+        return undefined;
+    const headerSize = le32(b, 14);
+    const info = { contentType: ContentTypes.IMAGE_BMP, extension: 'bmp', widthPx: 0, heightPx: 0, dpiX: DEFAULT_DPI, dpiY: DEFAULT_DPI };
+    if (headerSize === 12) {
+        info.widthPx = le16(b, 18);
+        info.heightPx = le16(b, 20);
+        return info;
+    }
+    info.widthPx = sle32(b, 18);
+    info.heightPx = Math.abs(sle32(b, 22));
+    if (b.length >= 46) {
+        const x = sle32(b, 38);
+        const y = sle32(b, 42);
+        if (x > 0)
+            info.dpiX = Math.round(x * 0.0254) || DEFAULT_DPI;
+        if (y > 0)
+            info.dpiY = Math.round(y * 0.0254) || DEFAULT_DPI;
+    }
+    return info;
+}
+/** The natural size of an image in EMU: pixels over the resolution it declares. */
+export function naturalSizeEmu(info) {
+    return {
+        cx: Math.max(1, Math.round((info.widthPx / (info.dpiX || DEFAULT_DPI)) * EMU_PER_INCH)),
+        cy: Math.max(1, Math.round((info.heightPx / (info.dpiY || DEFAULT_DPI)) * EMU_PER_INCH)),
+    };
+}
+/**
+ * Adds the image as a part of `source` (the main document part, or the header or footer the body
+ * belongs to) with a relationship, and builds the run that shows it. docx4j:
+ * `BinaryPartAbstractImage.createImagePart` then `createImageInline`.
+ */
+export function addImage(source, base64, scope, maxCx, options = {}) {
+    var _a, _b;
+    const pkg = source.package;
+    if (!pkg)
+        throw new Docx4JException('This part is not in a package yet; add it before adding an image');
+    const bytes = base64Decode(base64);
+    const info = imageInfoOf(bytes);
+    const imagePart = new ImagePart(freeImageName(pkg, info.extension), info.contentType);
+    imagePart.setBytes(bytes);
+    const rel = source.addTargetPart(imagePart);
+    let { cx, cy } = naturalSizeEmu(info);
+    if (options.width !== undefined) {
+        const wanted = Math.round(options.width * EMU_PER_POINT);
+        cy = options.height !== undefined ? Math.round(options.height * EMU_PER_POINT) : Math.max(1, Math.round((cy * wanted) / cx));
+        cx = wanted;
+    }
+    else if (options.height !== undefined) {
+        const wanted = Math.round(options.height * EMU_PER_POINT);
+        cx = Math.max(1, Math.round((cx * wanted) / cy));
+        cy = wanted;
+    }
+    else if (maxCx !== undefined && cx > maxCx) {
+        // docx4j CxCy.scale: an image wider than the text area is scaled down, keeping the ratio.
+        cy = Math.max(1, Math.round((cy * maxCx) / cx));
+        cx = maxCx;
+    }
+    const id = nextDrawingId(scope);
+    const name = (_a = options.name) !== null && _a !== void 0 ? _a : `Picture ${id}`;
+    const drawing = inlinePicture(rel.id, {
+        cx, cy, id, name,
+        descr: (_b = options.altTextDescription) !== null && _b !== void 0 ? _b : '',
+        ...(options.altTextTitle === undefined ? {} : { title: options.altTextTitle }),
+    });
+    return { run: runOf([drawing]), drawing, imagePart, relId: rel.id };
+}
+/** `/word/media/imageN.<ext>`, the first N free in the package (docx4j getNewPartName). */
+function freeImageName(pkg, extension) {
+    for (let i = 1;; i++) {
+        const name = PartName.of(`/word/media/image${i}.${extension}`);
+        if (!pkg.getPart(name))
+            return name;
+    }
+}
+/** An id no other drawing in this part uses: wp:docPr and pic:cNvPr are the same type. */
+function nextDrawingId(scope) {
+    let max = 0;
+    for (const props of find(scope, 'org_docx4j_dml.CTNonVisualDrawingProps')) {
+        if (typeof props.id === 'number' && props.id > max)
+            max = props.id;
+    }
+    return max + 1;
+}
+/** The writable width of a section in EMU (page width less the margins), for scaling. */
+export function writableWidthEmu(container) {
+    var _a, _b, _c, _d;
+    const sectPr = container.sectPr;
+    const pgSz = sectPr === null || sectPr === void 0 ? void 0 : sectPr.pgSz;
+    if (!(pgSz === null || pgSz === void 0 ? void 0 : pgSz.w))
+        return undefined;
+    const left = (_b = (_a = sectPr === null || sectPr === void 0 ? void 0 : sectPr.pgMar) === null || _a === void 0 ? void 0 : _a.left) !== null && _b !== void 0 ? _b : 0;
+    const right = (_d = (_c = sectPr === null || sectPr === void 0 ? void 0 : sectPr.pgMar) === null || _c === void 0 ? void 0 : _c.right) !== null && _d !== void 0 ? _d : 0;
+    const twips = pgSz.w - left - right;
+    return twips > 0 ? twips * EMU_PER_TWIP : undefined;
+}
+const FORMAT_BY_CONTENT_TYPE = {
+    [ContentTypes.IMAGE_PNG]: 'Png', [ContentTypes.IMAGE_X_PNG]: 'Png', [ContentTypes.IMAGE_JPEG]: 'Jpeg',
+    [ContentTypes.IMAGE_GIF]: 'Gif', [ContentTypes.IMAGE_BMP]: 'Bmp', [ContentTypes.IMAGE_TIFF]: 'Tiff',
+    [ContentTypes.IMAGE_SVG]: 'Svg', [ContentTypes.IMAGE_EMF]: 'Emf', [ContentTypes.IMAGE_EMF2]: 'Emf',
+    [ContentTypes.IMAGE_WMF]: 'Wmf',
+};
+/**
+ * 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.
+ */
+export class InlinePicture {
+    constructor(
+    /** The `w:drawing` element pair. */
+    element, 
+    /** The run holding the drawing, and the array holding the run. */
+    run, paragraph) {
+        this.element = element;
+        this.run = run;
+        this.paragraph = paragraph;
+    }
+    /** The wp:inline; a floating picture (wp:anchor) is not an InlinePicture, and throws. */
+    get inline() {
+        var _a;
+        const first = (_a = this.element.value.anchorOrInline) === null || _a === void 0 ? void 0 : _a[0];
+        if (!first || first.TYPE_NAME !== 'org_docx4j_dml_wordprocessingDrawing.Inline') {
+            throw new Docx4JException('This drawing is not an inline picture (wp:anchor is a floating shape)');
+        }
+        return first;
+    }
+    /** Width in points, as Office JS. */
+    get width() {
+        return this.inline.extent.cx / EMU_PER_POINT;
+    }
+    set width(points) {
+        this.resize(Math.round(points * EMU_PER_POINT), undefined);
+    }
+    get height() {
+        return this.inline.extent.cy / EMU_PER_POINT;
+    }
+    set height(points) {
+        this.resize(undefined, Math.round(points * EMU_PER_POINT));
+    }
+    /** wp:docPr/@descr (Word's alt text). */
+    get altTextDescription() {
+        var _a;
+        return (_a = this.inline.docPr.descr) !== null && _a !== void 0 ? _a : '';
+    }
+    set altTextDescription(text) {
+        this.inline.docPr.descr = text;
+        const p = this.pic();
+        if (p)
+            p.nvPicPr.cNvPr.descr = text;
+    }
+    /** wp:docPr/@title (typed since objects 0.1.3; before that the attribute was not marshalled, CR-002 section 8). */
+    get altTextTitle() {
+        var _a;
+        return (_a = this.inline.docPr.title) !== null && _a !== void 0 ? _a : '';
+    }
+    set altTextTitle(text) {
+        this.inline.docPr.title = text;
+    }
+    /** The kind of image, from the content type of the part the picture embeds. */
+    get imageFormat() {
+        var _a;
+        const part = this.imagePart();
+        return (_a = (part && FORMAT_BY_CONTENT_TYPE[part.contentType])) !== null && _a !== void 0 ? _a : 'Unsupported';
+    }
+    /** The relationship id of the embedded image (r:embed), if any (extension). */
+    get relId() {
+        var _a, _b;
+        return (_b = (_a = this.pic()) === null || _a === void 0 ? void 0 : _a.blipFill.blip) === null || _b === void 0 ? void 0 : _b.embed;
+    }
+    /** The image's bytes as base64 (Office JS getBase64ImageSrc). */
+    async getBase64() {
+        const part = this.imagePart();
+        if (!part)
+            throw new Docx4JException('This picture has no image part (a linked or missing image)');
+        return base64Encode(await part.getBytes());
+    }
+    /** Office JS's name for `getBase64()`. */
+    getBase64ImageSrc() {
+        return this.getBase64();
+    }
+    /** The image part this picture embeds (extension). */
+    imagePart() {
+        var _a;
+        const relId = this.relId;
+        const source = this.paragraph.parentBody.part;
+        if (!relId || !source)
+            return undefined;
+        const part = (_a = source.relationshipsPart) === null || _a === void 0 ? void 0 : _a.getPart(relId);
+        return part instanceof ImagePart ? part : undefined;
+    }
+    /** Removes the picture; the run goes too when the picture was all it held. */
+    delete() {
+        var _a;
+        const content = this.run.value.content;
+        const at = (_a = content === null || content === void 0 ? void 0 : content.indexOf(this.element)) !== null && _a !== void 0 ? _a : -1;
+        if (content && at >= 0)
+            content.splice(at, 1);
+        if (!content || content.length === 0) {
+            const holder = runHolderOf(this.paragraph.p, this.run);
+            const i = holder ? holder.indexOf(this.run) : -1;
+            if (holder && i >= 0)
+                holder.splice(i, 1);
+        }
+    }
+    pic() {
+        const any = this.inline.graphic.graphicData.any;
+        const first = any === null || any === void 0 ? void 0 : any[0];
+        return first && typeof first === 'object' && 'value' in first ? first.value : undefined;
+    }
+    resize(cx, cy) {
+        var _a, _b;
+        const extent = this.inline.extent;
+        const ratio = extent.cy / extent.cx;
+        const w = cx !== null && cx !== void 0 ? cx : Math.max(1, Math.round(cy / ratio));
+        const h = cy !== null && cy !== void 0 ? cy : Math.max(1, Math.round(cx * ratio));
+        extent.cx = w;
+        extent.cy = h;
+        const ext = (_b = (_a = this.pic()) === null || _a === void 0 ? void 0 : _a.spPr.xfrm) === null || _b === void 0 ? void 0 : _b.ext;
+        if (ext) {
+            ext.cx = w;
+            ext.cy = h;
+        }
+    }
+}
+/** The array holding a run inside a paragraph (the paragraph's content, or a holder's). */
+function runHolderOf(p, run) {
+    const seek = (items) => {
+        var _a, _b, _c;
+        if (!items)
+            return undefined;
+        if (items.includes(run))
+            return items;
+        for (const item of items) {
+            const v = item.value;
+            if (typeof v !== 'object' || v === null)
+                continue;
+            const nested = seek((_b = (_a = v.content) !== null && _a !== void 0 ? _a : v.customXmlOrSmartTagOrSdt) !== null && _b !== void 0 ? _b : (_c = v.sdtContent) === null || _c === void 0 ? void 0 : _c.content);
+            if (nested)
+                return nested;
+        }
+        return undefined;
+    };
+    return seek(p.content);
+}
+export { IMAGE_CONTENT_TYPES_BY_EXTENSION };