docxmlater 10.4.1 → 11.0.4

package/dist/esm/elements/Image.js

@@ -0,0 +1,1288 @@
+import { promises as fs } from 'fs';
+import { defaultLogger } from '../utils/logger.js';
+import { inchesToEmus, UNITS } from '../utils/units.js';
+import { XMLBuilder } from '../xml/XMLBuilder.js';
+export class Image {
+    source;
+    width;
+    height;
+    description;
+    name;
+    title;
+    relationshipId;
+    imageData;
+    extension;
+    docPrId = 1;
+    dpi = 96;
+    effectExtent;
+    wrap;
+    position;
+    anchor;
+    crop;
+    effects;
+    rotation = 0;
+    flipH = false;
+    flipV = false;
+    border;
+    presetGeometry = 'rect';
+    compressionState = 'none';
+    bwMode = 'auto';
+    inlineDistT = 0;
+    inlineDistB = 0;
+    inlineDistL = 0;
+    inlineDistR = 0;
+    noChangeAspect = true;
+    hidden = false;
+    blipFillDpi;
+    blipFillRotWithShape;
+    picLocks = {
+        noChangeAspect: true,
+        noChangeArrowheads: true,
+    };
+    picNonVisualProps = { id: '0', name: '', descr: '' };
+    isLinked = false;
+    svgRelationshipId;
+    _rawPassthrough = new Map();
+    static async fromFile(path, properties = {}) {
+        const image = new Image({ source: path, ...properties });
+        await image.loadImageDataForDimensions();
+        return image;
+    }
+    static async fromBuffer(buffer, mimeTypeOrProperties, width, height) {
+        let properties;
+        if (typeof mimeTypeOrProperties === 'string') {
+            properties = {
+                width: width,
+                height: height,
+            };
+        }
+        else {
+            properties = mimeTypeOrProperties || {};
+        }
+        const image = new Image({ source: buffer, ...properties });
+        await image.loadImageDataForDimensions();
+        return image;
+    }
+    static async create(properties) {
+        if (Buffer.isBuffer(properties.source)) {
+            return Image.fromBuffer(properties.source, properties);
+        }
+        else if (typeof properties.source === 'string') {
+            return Image.fromFile(properties.source, properties);
+        }
+        else {
+            throw new Error('Invalid source: must be file path or Buffer');
+        }
+    }
+    constructor(properties) {
+        this.source = properties.source;
+        this.description = properties.description || 'Image';
+        this.name = properties.name || 'image';
+        this.title = properties.title;
+        this.relationshipId = properties.relationshipId;
+        this.extension = this.detectExtension();
+        this.width = properties.width || inchesToEmus(6);
+        this.height = properties.height || inchesToEmus(4);
+        this.effectExtent = properties.effectExtent;
+        this.wrap = properties.wrap;
+        this.position = properties.position;
+        this.anchor = properties.anchor;
+        this.crop = properties.crop;
+        this.effects = properties.effects;
+        if (properties.border) {
+            this.border = properties.border;
+        }
+        if (properties.rotation !== undefined && properties.rotation !== 0) {
+            this.rotation = ((properties.rotation % 360) + 360) % 360;
+        }
+        this.flipH = properties.flipH || false;
+        this.flipV = properties.flipV || false;
+        if (properties.presetGeometry !== undefined)
+            this.presetGeometry = properties.presetGeometry;
+        if (properties.compressionState !== undefined)
+            this.compressionState = properties.compressionState;
+        if (properties.bwMode !== undefined)
+            this.bwMode = properties.bwMode;
+        if (properties.inlineDistT !== undefined)
+            this.inlineDistT = properties.inlineDistT;
+        if (properties.inlineDistB !== undefined)
+            this.inlineDistB = properties.inlineDistB;
+        if (properties.inlineDistL !== undefined)
+            this.inlineDistL = properties.inlineDistL;
+        if (properties.inlineDistR !== undefined)
+            this.inlineDistR = properties.inlineDistR;
+        if (properties.noChangeAspect !== undefined)
+            this.noChangeAspect = properties.noChangeAspect;
+        if (properties.hidden !== undefined)
+            this.hidden = properties.hidden;
+        if (properties.blipFillDpi !== undefined)
+            this.blipFillDpi = properties.blipFillDpi;
+        if (properties.blipFillRotWithShape !== undefined)
+            this.blipFillRotWithShape = properties.blipFillRotWithShape;
+        if (properties.picLocks !== undefined)
+            this.picLocks = properties.picLocks;
+        if (properties.picNonVisualProps !== undefined)
+            this.picNonVisualProps = properties.picNonVisualProps;
+        if (properties.isLinked !== undefined)
+            this.isLinked = properties.isLinked;
+        if (properties.svgRelationshipId !== undefined)
+            this.svgRelationshipId = properties.svgRelationshipId;
+        this.dpi = 96;
+    }
+    async loadImageDataForDimensions() {
+        let tempData;
+        try {
+            if (Buffer.isBuffer(this.source)) {
+                tempData = this.source;
+            }
+            else if (typeof this.source === 'string') {
+                await fs.access(this.source);
+                tempData = await fs.readFile(this.source);
+            }
+            if (tempData) {
+                this.imageData = tempData;
+                const defaultWidth = inchesToEmus(6);
+                const defaultHeight = inchesToEmus(4);
+                const hasExplicitDimensions = this.width !== defaultWidth || this.height !== defaultHeight;
+                if (!hasExplicitDimensions) {
+                    const dimensions = this.detectDimensions();
+                    if (dimensions) {
+                        this.dpi = this.detectDPI() || 96;
+                        const emuPerInch = 914400;
+                        const pixelsPerInch = this.dpi;
+                        this.width = Math.round((dimensions.width / pixelsPerInch) * emuPerInch);
+                        this.height = Math.round((dimensions.height / pixelsPerInch) * emuPerInch);
+                    }
+                }
+                if (typeof this.source === 'string') {
+                    this.imageData = undefined;
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            defaultLogger.error(`Failed to load image for dimensions: ${message}`);
+            throw new Error(`Image loading failed: ${message}`);
+        }
+    }
+    async ensureDataLoaded() {
+        if (this.imageData)
+            return;
+        try {
+            if (Buffer.isBuffer(this.source)) {
+                this.imageData = this.source;
+            }
+            else if (typeof this.source === 'string') {
+                await fs.access(this.source);
+                this.imageData = await fs.readFile(this.source);
+            }
+            else {
+                throw new Error('Invalid image source');
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            defaultLogger.error(`Failed to load image data: ${message}`);
+            throw new Error(`Image data loading failed: ${message}`);
+        }
+    }
+    releaseData() {
+        if (typeof this.source === 'string') {
+            this.imageData = undefined;
+        }
+    }
+    validateImageData() {
+        if (this.isLinked) {
+            return { valid: true };
+        }
+        if (!this.imageData || this.imageData.length === 0) {
+            return { valid: false, error: 'Empty image data' };
+        }
+        if (this.extension === 'svg') {
+            return { valid: true };
+        }
+        const signatures = {
+            png: [0x89, 0x50, 0x4e, 0x47],
+            jpg: [0xff, 0xd8],
+            jpeg: [0xff, 0xd8],
+            gif: [0x47, 0x49, 0x46],
+            bmp: [0x42, 0x4d],
+            tiff: [0x49, 0x49, 0x2a, 0x00],
+            tif: [0x49, 0x49, 0x2a, 0x00],
+        };
+        if (this.extension === 'emf') {
+            if (this.imageData.length >= 44 &&
+                this.imageData[40] === 0x20 &&
+                this.imageData[41] === 0x45 &&
+                this.imageData[42] === 0x4d &&
+                this.imageData[43] === 0x46) {
+                return { valid: true };
+            }
+            return { valid: false, error: 'Invalid EMF signature' };
+        }
+        if (this.extension === 'wmf') {
+            if (this.imageData.length >= 4) {
+                if (this.imageData[0] === 0xd7 &&
+                    this.imageData[1] === 0xcd &&
+                    this.imageData[2] === 0xc6 &&
+                    this.imageData[3] === 0x9a) {
+                    return { valid: true };
+                }
+                if (this.imageData[0] === 0x01 &&
+                    this.imageData[1] === 0x00 &&
+                    this.imageData[2] === 0x09 &&
+                    this.imageData[3] === 0x00) {
+                    return { valid: true };
+                }
+            }
+            return { valid: false, error: 'Invalid WMF signature' };
+        }
+        const sig = signatures[this.extension];
+        if (sig) {
+            for (let i = 0; i < sig.length; i++) {
+                if (this.imageData[i] !== sig[i]) {
+                    return { valid: false, error: `Invalid ${this.extension.toUpperCase()} signature` };
+                }
+            }
+        }
+        return { valid: true };
+    }
+    detectExtension() {
+        if (typeof this.source === 'string') {
+            const match = /\.([a-z]+)$/i.exec(this.source);
+            if (match?.[1]) {
+                return match[1].toLowerCase();
+            }
+        }
+        if (Buffer.isBuffer(this.source) && this.source.length >= 4) {
+            const buf = this.source;
+            if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47)
+                return 'png';
+            if (buf[0] === 0xff && buf[1] === 0xd8)
+                return 'jpeg';
+            if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46)
+                return 'gif';
+            if (buf[0] === 0x42 && buf[1] === 0x4d)
+                return 'bmp';
+            if (buf[0] === 0x49 && buf[1] === 0x49 && buf[2] === 0x2a && buf[3] === 0x00)
+                return 'tiff';
+            if (buf[0] === 0x4d && buf[1] === 0x4d && buf[2] === 0x00 && buf[3] === 0x2a)
+                return 'tiff';
+            if (buf.length >= 44 &&
+                buf[0] === 0x01 &&
+                buf[1] === 0x00 &&
+                buf[2] === 0x00 &&
+                buf[3] === 0x00 &&
+                buf[40] === 0x20 &&
+                buf[41] === 0x45 &&
+                buf[42] === 0x4d &&
+                buf[43] === 0x46)
+                return 'emf';
+            if (buf[0] === 0xd7 && buf[1] === 0xcd && buf[2] === 0xc6 && buf[3] === 0x9a)
+                return 'wmf';
+            if (buf[0] === 0x01 && buf[1] === 0x00 && buf[2] === 0x09 && buf[3] === 0x00)
+                return 'wmf';
+            if (buf[0] === 0x3c ||
+                (buf[0] === 0xef && buf[1] === 0xbb && buf[2] === 0xbf && buf.length > 3 && buf[3] === 0x3c))
+                return 'svg';
+        }
+        return 'png';
+    }
+    detectDimensions() {
+        if (!this.imageData || this.imageData.length < 24)
+            return null;
+        if (this.imageData[0] === 0x89 &&
+            this.imageData[1] === 0x50 &&
+            this.imageData[2] === 0x4e &&
+            this.imageData[3] === 0x47) {
+            return this.detectPngDimensions();
+        }
+        if (this.imageData[0] === 0xff && this.imageData[1] === 0xd8) {
+            return this.detectJpegDimensions();
+        }
+        if (this.imageData[0] === 0x47 && this.imageData[1] === 0x49 && this.imageData[2] === 0x46) {
+            return this.detectGifDimensions();
+        }
+        if (this.imageData[0] === 0x42 && this.imageData[1] === 0x4d) {
+            return this.detectBmpDimensions();
+        }
+        if ((this.imageData[0] === 0x49 && this.imageData[1] === 0x49 && this.imageData[2] === 0x2a) ||
+            (this.imageData[0] === 0x4d && this.imageData[1] === 0x4d && this.imageData[2] === 0x00)) {
+            return this.detectTiffDimensions();
+        }
+        if (this.imageData.length >= 44 &&
+            this.imageData[40] === 0x20 &&
+            this.imageData[41] === 0x45 &&
+            this.imageData[42] === 0x4d &&
+            this.imageData[43] === 0x46) {
+            return this.detectEmfDimensions();
+        }
+        if (this.imageData[0] === 0xd7 &&
+            this.imageData[1] === 0xcd &&
+            this.imageData[2] === 0xc6 &&
+            this.imageData[3] === 0x9a) {
+            return this.detectWmfDimensions();
+        }
+        if (this.imageData[0] === 0x3c ||
+            (this.imageData[0] === 0xef && this.imageData[1] === 0xbb && this.imageData[2] === 0xbf)) {
+            return this.detectSvgDimensions();
+        }
+        return null;
+    }
+    detectPngDimensions() {
+        if (!this.imageData || this.imageData.length < 24)
+            return null;
+        const width = this.imageData.readUInt32BE(16);
+        const height = this.imageData.readUInt32BE(20);
+        return { width, height };
+    }
+    detectGifDimensions() {
+        if (!this.imageData || this.imageData.length < 10)
+            return null;
+        const width = this.imageData.readUInt16LE(6);
+        const height = this.imageData.readUInt16LE(8);
+        if (width > 0 && height > 0)
+            return { width, height };
+        return null;
+    }
+    detectBmpDimensions() {
+        if (!this.imageData || this.imageData.length < 26)
+            return null;
+        const width = this.imageData.readInt32LE(18);
+        const height = Math.abs(this.imageData.readInt32LE(22));
+        if (width > 0 && height > 0)
+            return { width, height };
+        return null;
+    }
+    detectTiffDimensions() {
+        if (!this.imageData || this.imageData.length < 14)
+            return null;
+        const isLittleEndian = this.imageData[0] === 0x49;
+        const ifdOffset = isLittleEndian
+            ? this.imageData.readUInt32LE(4)
+            : this.imageData.readUInt32BE(4);
+        if (ifdOffset + 14 > this.imageData.length)
+            return null;
+        const numEntries = isLittleEndian
+            ? this.imageData.readUInt16LE(ifdOffset)
+            : this.imageData.readUInt16BE(ifdOffset);
+        let width = 0;
+        let height = 0;
+        for (let i = 0; i < numEntries; i++) {
+            const entryOffset = ifdOffset + 2 + i * 12;
+            if (entryOffset + 12 > this.imageData.length)
+                break;
+            const tag = isLittleEndian
+                ? this.imageData.readUInt16LE(entryOffset)
+                : this.imageData.readUInt16BE(entryOffset);
+            const value = isLittleEndian
+                ? this.imageData.readUInt32LE(entryOffset + 8)
+                : this.imageData.readUInt32BE(entryOffset + 8);
+            if (tag === 256)
+                width = value;
+            if (tag === 257)
+                height = value;
+            if (width > 0 && height > 0)
+                break;
+        }
+        if (width > 0 && height > 0)
+            return { width, height };
+        return null;
+    }
+    detectJpegDimensions() {
+        if (!this.imageData || this.imageData.length < 12)
+            return null;
+        let offset = 2;
+        while (offset < this.imageData.length - 1) {
+            if (this.imageData[offset] !== 0xff)
+                break;
+            const marker = this.imageData[offset + 1];
+            if (marker === undefined)
+                break;
+            if (marker === 0x00 || marker === 0xff) {
+                offset++;
+                continue;
+            }
+            const isSOF = marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+            if (isSOF) {
+                if (offset + 9 > this.imageData.length)
+                    break;
+                const height = this.imageData.readUInt16BE(offset + 5);
+                const width = this.imageData.readUInt16BE(offset + 7);
+                if (width > 0 && height > 0)
+                    return { width, height };
+            }
+            if (marker === 0xda || marker === 0xd9)
+                break;
+            const segmentLength = this.imageData.readUInt16BE(offset + 2);
+            if (segmentLength < 2 || offset + 2 + segmentLength > this.imageData.length)
+                break;
+            offset += 2 + segmentLength;
+        }
+        return null;
+    }
+    detectSvgDimensions() {
+        if (!this.imageData)
+            return null;
+        try {
+            const svgText = this.imageData.toString('utf-8').substring(0, 2000);
+            const widthMatch = /<svg[^>]*\bwidth\s*=\s*["']?(\d+(?:\.\d+)?)/i.exec(svgText);
+            const heightMatch = /<svg[^>]*\bheight\s*=\s*["']?(\d+(?:\.\d+)?)/i.exec(svgText);
+            if (widthMatch?.[1] && heightMatch?.[1]) {
+                return {
+                    width: Math.round(parseFloat(widthMatch[1])),
+                    height: Math.round(parseFloat(heightMatch[1])),
+                };
+            }
+            const viewBoxMatch = /<svg[^>]*\bviewBox\s*=\s*["']?\s*[\d.]+\s+[\d.]+\s+([\d.]+)\s+([\d.]+)/i.exec(svgText);
+            if (viewBoxMatch?.[1] && viewBoxMatch?.[2]) {
+                return {
+                    width: Math.round(parseFloat(viewBoxMatch[1])),
+                    height: Math.round(parseFloat(viewBoxMatch[2])),
+                };
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    detectEmfDimensions() {
+        if (!this.imageData || this.imageData.length < 40)
+            return null;
+        try {
+            const left = this.imageData.readInt32LE(24);
+            const top = this.imageData.readInt32LE(28);
+            const right = this.imageData.readInt32LE(32);
+            const bottom = this.imageData.readInt32LE(36);
+            const widthMm = (right - left) / 100;
+            const heightMm = (bottom - top) / 100;
+            const width = Math.round((widthMm / 25.4) * 96);
+            const height = Math.round((heightMm / 25.4) * 96);
+            if (width > 0 && height > 0)
+                return { width, height };
+        }
+        catch {
+        }
+        return null;
+    }
+    detectWmfDimensions() {
+        if (!this.imageData || this.imageData.length < 22)
+            return null;
+        try {
+            const left = this.imageData.readInt16LE(6);
+            const top = this.imageData.readInt16LE(8);
+            const right = this.imageData.readInt16LE(10);
+            const bottom = this.imageData.readInt16LE(12);
+            const unitsPerInch = this.imageData.readUInt16LE(14);
+            if (unitsPerInch > 0) {
+                const width = Math.round(((right - left) / unitsPerInch) * 96);
+                const height = Math.round(((bottom - top) / unitsPerInch) * 96);
+                if (width > 0 && height > 0)
+                    return { width, height };
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    async getImageDataAsync() {
+        await this.ensureDataLoaded();
+        if (!this.imageData)
+            throw new Error('Failed to load image data');
+        return this.imageData;
+    }
+    getImageData() {
+        if (!this.imageData)
+            throw new Error('Image data not loaded. Call ensureDataLoaded first.');
+        return this.imageData;
+    }
+    getExtension() {
+        return this.extension;
+    }
+    getDPI() {
+        return this.dpi;
+    }
+    getWidth() {
+        return this.width;
+    }
+    getHeight() {
+        return this.height;
+    }
+    getImageDataSafe() {
+        return this.imageData ?? null;
+    }
+    setWidth(width, maintainAspectRatio = true) {
+        if (maintainAspectRatio && this.height > 0) {
+            const ratio = this.height / this.width;
+            this.height = Math.round(width * ratio);
+        }
+        this.width = width;
+        return this;
+    }
+    setHeight(height, maintainAspectRatio = true) {
+        if (maintainAspectRatio && this.width > 0) {
+            const ratio = this.width / this.height;
+            this.width = Math.round(height * ratio);
+        }
+        this.height = height;
+        return this;
+    }
+    setSize(width, height) {
+        this.width = width;
+        this.height = height;
+        return this;
+    }
+    async updateImageData(newSource) {
+        this.source = newSource;
+        this.imageData = undefined;
+        await this.loadImageDataForDimensions();
+        this.extension = this.detectExtension();
+        this.dpi = this.detectDPI() || 96;
+    }
+    setRelationshipId(relationshipId) {
+        this.relationshipId = relationshipId;
+        return this;
+    }
+    getRelationshipId() {
+        return this.relationshipId;
+    }
+    setDocPrId(id) {
+        this.docPrId = id;
+        return this;
+    }
+    setAltText(altText) {
+        this.description = altText;
+        return this;
+    }
+    getAltText() {
+        return this.description;
+    }
+    setTitle(title) {
+        this.title = title;
+        return this;
+    }
+    getTitle() {
+        return this.title;
+    }
+    rotate(degrees) {
+        this.rotation = ((degrees % 360) + 360) % 360;
+        if (this.rotation === 90 || this.rotation === 270) {
+            [this.width, this.height] = [this.height, this.width];
+        }
+        return this;
+    }
+    getRotation() {
+        return this.rotation;
+    }
+    setFlipH(flip) {
+        this.flipH = flip;
+        return this;
+    }
+    getFlipH() {
+        return this.flipH;
+    }
+    setFlipV(flip) {
+        this.flipV = flip;
+        return this;
+    }
+    getFlipV() {
+        return this.flipV;
+    }
+    getPresetGeometry() {
+        return this.presetGeometry;
+    }
+    setPresetGeometry(geom) {
+        this.presetGeometry = geom;
+        return this;
+    }
+    getCompressionState() {
+        return this.compressionState;
+    }
+    setCompressionState(state) {
+        this.compressionState = state;
+        return this;
+    }
+    getBwMode() {
+        return this.bwMode;
+    }
+    setBwMode(mode) {
+        this.bwMode = mode;
+        return this;
+    }
+    getInlineDistT() {
+        return this.inlineDistT;
+    }
+    getInlineDistB() {
+        return this.inlineDistB;
+    }
+    getInlineDistL() {
+        return this.inlineDistL;
+    }
+    getInlineDistR() {
+        return this.inlineDistR;
+    }
+    setInlineDist(distT, distB, distL, distR) {
+        this.inlineDistT = distT;
+        this.inlineDistB = distB;
+        this.inlineDistL = distL;
+        this.inlineDistR = distR;
+        return this;
+    }
+    getNoChangeAspect() {
+        return this.noChangeAspect;
+    }
+    setNoChangeAspect(val) {
+        this.noChangeAspect = val;
+        return this;
+    }
+    getHidden() {
+        return this.hidden;
+    }
+    setHidden(val) {
+        this.hidden = val;
+        return this;
+    }
+    getBlipFillDpi() {
+        return this.blipFillDpi;
+    }
+    setBlipFillDpi(dpi) {
+        this.blipFillDpi = dpi;
+        return this;
+    }
+    getBlipFillRotWithShape() {
+        return this.blipFillRotWithShape;
+    }
+    setBlipFillRotWithShape(val) {
+        this.blipFillRotWithShape = val;
+        return this;
+    }
+    getPicLocks() {
+        return { ...this.picLocks };
+    }
+    setPicLocks(locks) {
+        this.picLocks = locks;
+        return this;
+    }
+    getPicNonVisualProps() {
+        return { ...this.picNonVisualProps };
+    }
+    setPicNonVisualProps(props) {
+        this.picNonVisualProps = props;
+        return this;
+    }
+    getIsLinked() {
+        return this.isLinked;
+    }
+    setIsLinked(val) {
+        this.isLinked = val;
+        return this;
+    }
+    getSvgRelationshipId() {
+        return this.svgRelationshipId;
+    }
+    setSvgRelationshipId(id) {
+        this.svgRelationshipId = id;
+        return this;
+    }
+    _setRawPassthrough(slot, xml) {
+        this._rawPassthrough.set(slot, xml);
+    }
+    _getRawPassthrough(slot) {
+        return this._rawPassthrough.get(slot);
+    }
+    _hasRawPassthrough(slot) {
+        return this._rawPassthrough.has(slot);
+    }
+    getBorder() {
+        return this.border;
+    }
+    setEffectExtent(left, top, right, bottom) {
+        this.effectExtent = { left, top, right, bottom };
+        return this;
+    }
+    getEffectExtent() {
+        return this.effectExtent;
+    }
+    setWrap(type, side, distances) {
+        this.wrap = {
+            type,
+            side,
+            distanceTop: distances?.top,
+            distanceBottom: distances?.bottom,
+            distanceLeft: distances?.left,
+            distanceRight: distances?.right,
+        };
+        return this;
+    }
+    getWrap() {
+        return this.wrap;
+    }
+    validatePositionOffset(offset, axis) {
+        if (offset === undefined)
+            return;
+        const MAX_OFFSET_EMUS = 45720000;
+        if (Math.abs(offset) > MAX_OFFSET_EMUS) {
+            throw new Error(`Invalid ${axis} position offset: ${offset} EMUs exceeds maximum of ${MAX_OFFSET_EMUS} EMUs (50 inches).`);
+        }
+    }
+    setPosition(horizontal, vertical) {
+        this.validatePositionOffset(horizontal.offset, 'horizontal');
+        this.validatePositionOffset(vertical.offset, 'vertical');
+        this.position = { horizontal, vertical };
+        return this;
+    }
+    getPosition() {
+        return this.position;
+    }
+    validatePosition() {
+        const warnings = [];
+        if (!this.position) {
+            return { isValid: true, warnings };
+        }
+        if (this.position.horizontal.offset !== undefined && this.position.horizontal.alignment) {
+            warnings.push('Horizontal position has both offset and alignment. Word will use alignment and ignore offset.');
+        }
+        if (this.position.vertical.offset !== undefined && this.position.vertical.alignment) {
+            warnings.push('Vertical position has both offset and alignment. Word will use alignment and ignore offset.');
+        }
+        if (this.position && !this.anchor) {
+            warnings.push('Position is set but anchor is not. Consider setting anchor properties for proper floating behavior.');
+        }
+        return {
+            isValid: warnings.length === 0,
+            warnings,
+        };
+    }
+    setAnchor(options) {
+        this.anchor = options;
+        return this;
+    }
+    getAnchor() {
+        return this.anchor;
+    }
+    setCrop(left, top, right, bottom) {
+        const clamp = (val) => Math.max(0, Math.min(100, val));
+        this.crop = { left: clamp(left), top: clamp(top), right: clamp(right), bottom: clamp(bottom) };
+        return this;
+    }
+    getCrop() {
+        return this.crop;
+    }
+    setEffects(options) {
+        const clamp = (val) => val !== undefined ? Math.max(-100, Math.min(100, val)) : undefined;
+        this.effects = {
+            brightness: clamp(options.brightness),
+            contrast: clamp(options.contrast),
+            grayscale: options.grayscale,
+            transparency: options.transparency !== undefined
+                ? Math.max(0, Math.min(100, options.transparency))
+                : undefined,
+        };
+        return this;
+    }
+    getEffects() {
+        return this.effects;
+    }
+    detectDPI() {
+        if (!this.imageData)
+            return undefined;
+        try {
+            if (this.extension === 'png') {
+                const physIndex = this.imageData.indexOf(Buffer.from([0x70, 0x48, 0x59, 0x73]));
+                if (physIndex !== -1 && physIndex + 12 < this.imageData.length) {
+                    const xPixelsPerMeter = this.imageData.readUInt32BE(physIndex + 4);
+                    const yPixelsPerMeter = this.imageData.readUInt32BE(physIndex + 8);
+                    const unit = this.imageData[physIndex + 12];
+                    if (unit === 1) {
+                        const dpiX = Math.round(xPixelsPerMeter * 0.0254);
+                        const dpiY = Math.round(yPixelsPerMeter * 0.0254);
+                        return Math.min(dpiX, dpiY);
+                    }
+                }
+            }
+            else if (this.extension === 'jpg' || this.extension === 'jpeg') {
+                let offset = 2;
+                while (offset < this.imageData.length) {
+                    if (this.imageData[offset] !== 0xff)
+                        break;
+                    const marker = this.imageData[offset + 1];
+                    if (marker === 0xe0) {
+                        const length = this.imageData.readUInt16BE(offset + 2);
+                        if (length >= 16 &&
+                            this.imageData.slice(offset + 4, offset + 9).toString('ascii') === 'JFIF\0') {
+                            const units = this.imageData[offset + 11];
+                            const xDensity = this.imageData.readUInt16BE(offset + 12);
+                            const yDensity = this.imageData.readUInt16BE(offset + 14);
+                            if (units === 1)
+                                return Math.min(xDensity, yDensity);
+                            if (units === 2)
+                                return Math.min(Math.round(xDensity * 2.54), Math.round(yDensity * 2.54));
+                        }
+                        offset += 2 + length;
+                        continue;
+                    }
+                    offset += 2 + this.imageData.readUInt16BE(offset + 2);
+                }
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            defaultLogger.warn(`DPI detection failed: ${message}`);
+        }
+        return undefined;
+    }
+    isFloating() {
+        return !!this.anchor || !!this.position;
+    }
+    floatTopLeft(marginTop = 0, marginLeft = 0) {
+        this.setPosition({ anchor: 'page', offset: marginLeft }, { anchor: 'page', offset: marginTop });
+        this.setAnchor({
+            behindDoc: false,
+            locked: false,
+            layoutInCell: true,
+            allowOverlap: true,
+            relativeHeight: 251658240,
+        });
+        this.setWrap('square', 'bothSides');
+        return this;
+    }
+    floatTopRight(marginTop = 0, marginRight = 0) {
+        this.setPosition({ anchor: 'page', alignment: 'right', offset: -marginRight }, { anchor: 'page', offset: marginTop });
+        this.setAnchor({
+            behindDoc: false,
+            locked: false,
+            layoutInCell: true,
+            allowOverlap: true,
+            relativeHeight: 251658240,
+        });
+        this.setWrap('square', 'bothSides');
+        return this;
+    }
+    floatCenter() {
+        this.setPosition({ anchor: 'page', alignment: 'center' }, { anchor: 'page', alignment: 'center' });
+        this.setAnchor({
+            behindDoc: false,
+            locked: false,
+            layoutInCell: true,
+            allowOverlap: true,
+            relativeHeight: 251658240,
+        });
+        this.setWrap('square', 'bothSides');
+        return this;
+    }
+    setBehindText(behind = true) {
+        if (this.anchor) {
+            this.anchor.behindDoc = behind;
+        }
+        else {
+            this.setAnchor({
+                behindDoc: behind,
+                locked: false,
+                layoutInCell: true,
+                allowOverlap: true,
+                relativeHeight: 251658240,
+            });
+        }
+        return this;
+    }
+    setBorder(thicknessOrOptions = 2) {
+        if (typeof thicknessOrOptions === 'number') {
+            this.border = { width: thicknessOrOptions };
+        }
+        else {
+            this.border = { ...thicknessOrOptions };
+            delete this.border._fromParsed;
+        }
+        this._rawPassthrough.delete('zero-width-ln');
+        this._rawPassthrough.delete('spPr-noFill');
+        const borderEmu = this.border.width * UNITS.EMUS_PER_POINT;
+        const halfBorderEmu = Math.ceil(borderEmu / 2);
+        if (!this.effectExtent) {
+            this.effectExtent = { left: 0, top: 0, right: 0, bottom: 0 };
+        }
+        this.effectExtent.left = Math.max(this.effectExtent.left, halfBorderEmu);
+        this.effectExtent.top = Math.max(this.effectExtent.top, halfBorderEmu);
+        this.effectExtent.right = Math.max(this.effectExtent.right, halfBorderEmu);
+        this.effectExtent.bottom = Math.max(this.effectExtent.bottom, halfBorderEmu);
+        return this;
+    }
+    removeBorder() {
+        this.border = undefined;
+        this._rawPassthrough.delete('zero-width-ln');
+        return this;
+    }
+    applyTwoPixelBlackBorder() {
+        return this.setBorder(2);
+    }
+    toXML() {
+        const isFloating = this.isFloating();
+        const extent = XMLBuilder.wp('extent', {
+            cx: this.width.toString(),
+            cy: this.height.toString(),
+        });
+        const blipChildren = [];
+        if (this.effects?.brightness !== undefined || this.effects?.contrast !== undefined) {
+            const lumAttrs = {};
+            if (this.effects.brightness !== undefined) {
+                lumAttrs.bright = Math.round(this.effects.brightness * 1000).toString();
+            }
+            if (this.effects.contrast !== undefined) {
+                lumAttrs.contrast = Math.round(this.effects.contrast * 1000).toString();
+            }
+            blipChildren.push(XMLBuilder.aSelf('lum', lumAttrs));
+        }
+        if (this.effects?.grayscale) {
+            blipChildren.push(XMLBuilder.aSelf('grayscl'));
+        }
+        if (this.effects?.transparency !== undefined && this.effects.transparency > 0) {
+            const amt = Math.round((100 - this.effects.transparency) * 1000);
+            blipChildren.push(XMLBuilder.aSelf('alphaModFix', { amt: amt.toString() }));
+        }
+        if (this._rawPassthrough.has('blip-effects')) {
+            blipChildren.push({
+                name: '__rawXml',
+                rawXml: this._rawPassthrough.get('blip-effects'),
+            });
+        }
+        if (this._rawPassthrough.has('blip-extLst')) {
+            blipChildren.push({
+                name: '__rawXml',
+                rawXml: this._rawPassthrough.get('blip-extLst'),
+            });
+        }
+        else if (this.svgRelationshipId) {
+            blipChildren.push({
+                name: '__rawXml',
+                rawXml: `<a:extLst><a:ext uri="{96DAC541-7B7A-43D3-8B79-37D633B846F1}"><asvg:svgBlip xmlns:asvg="http://schemas.microsoft.com/office/drawing/2016/SVG/main" r:embed="${this.svgRelationshipId}"/></a:ext></a:extLst>`,
+            });
+        }
+        const blipAttrs = {
+            cstate: this.compressionState,
+        };
+        if (this.isLinked) {
+            blipAttrs['r:link'] = this.relationshipId;
+        }
+        else {
+            blipAttrs['r:embed'] = this.relationshipId;
+        }
+        const blip = blipChildren.length > 0
+            ? XMLBuilder.a('blip', blipAttrs, blipChildren)
+            : XMLBuilder.a('blip', blipAttrs);
+        const xfrmAttrs = (() => {
+            const attrs = {};
+            if (this.rotation > 0)
+                attrs.rot = Math.round(this.rotation * 60000).toString();
+            if (this.flipH)
+                attrs.flipH = '1';
+            if (this.flipV)
+                attrs.flipV = '1';
+            return Object.keys(attrs).length > 0 ? attrs : undefined;
+        })();
+        const xfrm = XMLBuilder.a('xfrm', xfrmAttrs, [
+            XMLBuilder.a('off', { x: '0', y: '0' }),
+            XMLBuilder.a('ext', { cx: this.width.toString(), cy: this.height.toString() }),
+        ]);
+        const spPrChildren = [xfrm];
+        if (this._rawPassthrough.has('geometry')) {
+            spPrChildren.push({
+                name: '__rawXml',
+                rawXml: this._rawPassthrough.get('geometry'),
+            });
+        }
+        else {
+            spPrChildren.push(XMLBuilder.a('prstGeom', { prst: this.presetGeometry }, [XMLBuilder.a('avLst')]));
+        }
+        if (this.border) {
+            spPrChildren.push(XMLBuilder.a('noFill'));
+        }
+        else if (this._rawPassthrough.has('spPr-noFill')) {
+            spPrChildren.push(XMLBuilder.a('noFill'));
+        }
+        if (this.border) {
+            const ptToEmu = 12700;
+            const widthEmu = this.border.width * ptToEmu;
+            const lnAttrs = { w: widthEmu.toString() };
+            if (this.border.cap)
+                lnAttrs.cap = this.border.cap;
+            if (this.border.compound)
+                lnAttrs.cmpd = this.border.compound;
+            if (this.border.alignment)
+                lnAttrs.algn = this.border.alignment;
+            const lnChildren = [];
+            if (this.border.rawFillXml) {
+                lnChildren.push({ name: '__rawXml', rawXml: this.border.rawFillXml });
+            }
+            else if (this.border.fill) {
+                const colorChildren = [];
+                if (this.border.fill.modifiers) {
+                    for (const mod of this.border.fill.modifiers) {
+                        colorChildren.push(XMLBuilder.aSelf(mod.name, { val: mod.val }));
+                    }
+                }
+                const colorEl = colorChildren.length > 0
+                    ? XMLBuilder.a(this.border.fill.type, { val: this.border.fill.value }, colorChildren)
+                    : XMLBuilder.a(this.border.fill.type, { val: this.border.fill.value });
+                lnChildren.push(XMLBuilder.a('solidFill', undefined, [colorEl]));
+            }
+            else if (!this.border._fromParsed) {
+                lnChildren.push(XMLBuilder.a('solidFill', undefined, [XMLBuilder.a('schemeClr', { val: 'tx1' })]));
+            }
+            if (this.border.dashPattern) {
+                lnChildren.push(XMLBuilder.aSelf('prstDash', { val: this.border.dashPattern }));
+            }
+            if (this.border.join === 'round') {
+                lnChildren.push(XMLBuilder.aSelf('round'));
+            }
+            else if (this.border.join === 'bevel') {
+                lnChildren.push(XMLBuilder.aSelf('bevel'));
+            }
+            else if (this.border.join === 'miter') {
+                const miterAttrs = {};
+                if (this.border.miterLimit)
+                    miterAttrs.lim = this.border.miterLimit.toString();
+                lnChildren.push(XMLBuilder.aSelf('miter', miterAttrs));
+            }
+            if (this.border.headEnd) {
+                lnChildren.push(XMLBuilder.aSelf('headEnd', this.border.headEnd));
+            }
+            if (this.border.tailEnd) {
+                lnChildren.push(XMLBuilder.aSelf('tailEnd', this.border.tailEnd));
+            }
+            spPrChildren.push(XMLBuilder.a('ln', lnAttrs, lnChildren));
+        }
+        if (!this.border && this._rawPassthrough.has('zero-width-ln')) {
+            spPrChildren.push({
+                name: '__rawXml',
+                rawXml: this._rawPassthrough.get('zero-width-ln'),
+            });
+        }
+        if (this._rawPassthrough.has('spPr-effects')) {
+            spPrChildren.push({
+                name: '__rawXml',
+                rawXml: this._rawPassthrough.get('spPr-effects'),
+            });
+        }
+        const cNvPrChildren = [];
+        if (this._rawPassthrough.has('cNvPr-extra')) {
+            cNvPrChildren.push({
+                name: '__rawXml',
+                rawXml: this._rawPassthrough.get('cNvPr-extra'),
+            });
+        }
+        const cNvPr = cNvPrChildren.length > 0
+            ? XMLBuilder.pic('cNvPr', {
+                id: this.picNonVisualProps.id,
+                name: this.picNonVisualProps.name,
+                descr: this.picNonVisualProps.descr,
+            }, cNvPrChildren)
+            : XMLBuilder.pic('cNvPr', {
+                id: this.picNonVisualProps.id,
+                name: this.picNonVisualProps.name,
+                descr: this.picNonVisualProps.descr,
+            });
+        const picLocksAttrs = {};
+        for (const [key, val] of Object.entries(this.picLocks)) {
+            if (val)
+                picLocksAttrs[key] = '1';
+        }
+        const blipFillAttrs = {};
+        if (this.blipFillDpi !== undefined)
+            blipFillAttrs.dpi = this.blipFillDpi.toString();
+        if (this.blipFillRotWithShape !== undefined)
+            blipFillAttrs.rotWithShape = this.blipFillRotWithShape ? '1' : '0';
+        const blipFillChildren = [blip];
+        if (this.crop) {
+            blipFillChildren.push(XMLBuilder.a('srcRect', {
+                l: Math.round(this.crop.left * 1000).toString(),
+                t: Math.round(this.crop.top * 1000).toString(),
+                r: Math.round(this.crop.right * 1000).toString(),
+                b: Math.round(this.crop.bottom * 1000).toString(),
+            }));
+        }
+        if (this._rawPassthrough.has('blipFill-extra')) {
+            blipFillChildren.push({
+                name: '__rawXml',
+                rawXml: this._rawPassthrough.get('blipFill-extra'),
+            });
+        }
+        else {
+            blipFillChildren.push(XMLBuilder.a('stretch', undefined, [XMLBuilder.a('fillRect')]));
+        }
+        const blipFillAttrsObj = Object.keys(blipFillAttrs).length > 0 ? blipFillAttrs : undefined;
+        const graphicData = XMLBuilder.a('graphicData', { uri: 'http://schemas.openxmlformats.org/drawingml/2006/picture' }, [
+            XMLBuilder.pic('pic', undefined, [
+                XMLBuilder.pic('nvPicPr', undefined, [
+                    cNvPr,
+                    XMLBuilder.pic('cNvPicPr', undefined, [
+                        XMLBuilder.a('picLocks', Object.keys(picLocksAttrs).length > 0 ? picLocksAttrs : undefined),
+                    ]),
+                ]),
+                XMLBuilder.pic('blipFill', blipFillAttrsObj, blipFillChildren),
+                XMLBuilder.pic('spPr', { bwMode: this.bwMode }, spPrChildren),
+            ]),
+        ]);
+        const graphic = XMLBuilder.a('graphic', undefined, [graphicData]);
+        const buildDocPr = (idVal) => {
+            const attrs = { id: idVal, name: this.name, descr: this.description };
+            if (this.title)
+                attrs.title = this.title;
+            if (this.hidden)
+                attrs.hidden = '1';
+            const children = [];
+            if (this._rawPassthrough.has('docPr-extra')) {
+                children.push({
+                    name: '__rawXml',
+                    rawXml: this._rawPassthrough.get('docPr-extra'),
+                });
+            }
+            return children.length > 0
+                ? XMLBuilder.wp('docPr', attrs, children)
+                : XMLBuilder.wp('docPr', attrs);
+        };
+        const buildCNvGraphicFramePr = () => {
+            return XMLBuilder.wp('cNvGraphicFramePr', undefined, [
+                XMLBuilder.a('graphicFrameLocks', {
+                    'xmlns:a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
+                    noChangeAspect: this.noChangeAspect ? '1' : '0',
+                }),
+            ]);
+        };
+        if (isFloating) {
+            const positionHChildren = [];
+            if (this.position?.horizontal.alignment) {
+                positionHChildren.push(XMLBuilder.wp('align', undefined, [this.position.horizontal.alignment]));
+            }
+            else {
+                positionHChildren.push(XMLBuilder.wp('posOffset', undefined, [
+                    (this.position?.horizontal.offset || 0).toString(),
+                ]));
+            }
+            const positionH = XMLBuilder.wp('positionH', { relativeFrom: this.position?.horizontal.anchor || 'page' }, positionHChildren);
+            const positionVChildren = [];
+            if (this.position?.vertical.alignment) {
+                positionVChildren.push(XMLBuilder.wp('align', undefined, [this.position.vertical.alignment]));
+            }
+            else {
+                positionVChildren.push(XMLBuilder.wp('posOffset', undefined, [(this.position?.vertical.offset || 0).toString()]));
+            }
+            const positionV = XMLBuilder.wp('positionV', { relativeFrom: this.position?.vertical.anchor || 'page' }, positionVChildren);
+            const floatEffectExt = this.effectExtent || { left: 0, top: 0, right: 0, bottom: 0 };
+            const effectExtentElement = XMLBuilder.wp('effectExtent', {
+                t: floatEffectExt.top.toString(),
+                r: floatEffectExt.right.toString(),
+                b: floatEffectExt.bottom.toString(),
+                l: floatEffectExt.left.toString(),
+            });
+            const anchorChildren = [positionH, positionV, extent, effectExtentElement];
+            if (this.wrap) {
+                const wrapAttrs = {};
+                if (this.wrap.distanceTop !== undefined)
+                    wrapAttrs.distT = this.wrap.distanceTop;
+                if (this.wrap.distanceBottom !== undefined)
+                    wrapAttrs.distB = this.wrap.distanceBottom;
+                if (this.wrap.distanceLeft !== undefined)
+                    wrapAttrs.distL = this.wrap.distanceLeft;
+                if (this.wrap.distanceRight !== undefined)
+                    wrapAttrs.distR = this.wrap.distanceRight;
+                if (this.wrap.side)
+                    wrapAttrs.wrapText = this.wrap.side;
+                let wrapElementName;
+                switch (this.wrap.type) {
+                    case 'square':
+                        wrapElementName = 'wrapSquare';
+                        break;
+                    case 'tight':
+                        wrapElementName = 'wrapTight';
+                        break;
+                    case 'through':
+                        wrapElementName = 'wrapThrough';
+                        break;
+                    case 'topAndBottom':
+                        wrapElementName = 'wrapTopAndBottom';
+                        break;
+                    case 'none':
+                        wrapElementName = 'wrapNone';
+                        break;
+                    default:
+                        wrapElementName = 'wrapSquare';
+                }
+                const wrapChildren = [];
+                if (this._rawPassthrough.has('wrap-polygon')) {
+                    wrapChildren.push({
+                        name: '__rawXml',
+                        rawXml: this._rawPassthrough.get('wrap-polygon'),
+                    });
+                }
+                else if (wrapElementName === 'wrapTight' || wrapElementName === 'wrapThrough') {
+                    wrapChildren.push({
+                        name: 'wp:wrapPolygon',
+                        attributes: { edited: '0' },
+                        children: [
+                            { name: 'wp:start', attributes: { x: '0', y: '0' }, selfClosing: true },
+                            { name: 'wp:lineTo', attributes: { x: '21600', y: '0' }, selfClosing: true },
+                            { name: 'wp:lineTo', attributes: { x: '21600', y: '21600' }, selfClosing: true },
+                            { name: 'wp:lineTo', attributes: { x: '0', y: '21600' }, selfClosing: true },
+                            { name: 'wp:lineTo', attributes: { x: '0', y: '0' }, selfClosing: true },
+                        ],
+                    });
+                }
+                anchorChildren.push(wrapChildren.length > 0
+                    ? XMLBuilder.wp(wrapElementName, wrapAttrs, wrapChildren)
+                    : XMLBuilder.wp(wrapElementName, wrapAttrs));
+            }
+            else {
+                anchorChildren.push(XMLBuilder.wp('wrapNone', {}));
+            }
+            anchorChildren.push(buildDocPr(this.docPrId));
+            anchorChildren.push(buildCNvGraphicFramePr());
+            anchorChildren.push(graphic);
+            if (this._rawPassthrough.has('anchor-extra')) {
+                anchorChildren.push({
+                    name: '__rawXml',
+                    rawXml: this._rawPassthrough.get('anchor-extra'),
+                });
+            }
+            const anchorAttrs = {
+                behindDoc: this.anchor?.behindDoc ? 1 : 0,
+                locked: this.anchor?.locked ? 1 : 0,
+                layoutInCell: this.anchor?.layoutInCell ? 1 : 0,
+                allowOverlap: this.anchor?.allowOverlap ? 1 : 0,
+                relativeHeight: this.anchor?.relativeHeight,
+                simplePos: this.anchor?.simplePos ? '1' : '0',
+                distT: (this.anchor?.distT ?? 0).toString(),
+                distB: (this.anchor?.distB ?? 0).toString(),
+                distL: (this.anchor?.distL ?? 0).toString(),
+                distR: (this.anchor?.distR ?? 0).toString(),
+            };
+            if (this.hidden)
+                anchorAttrs.hidden = '1';
+            anchorChildren.unshift(XMLBuilder.wp('simplePos', { x: '0', y: '0' }));
+            return XMLBuilder.w('drawing', undefined, [
+                XMLBuilder.wp('anchor', anchorAttrs, anchorChildren),
+            ]);
+        }
+        else {
+            const effectExt = this.effectExtent || { left: 0, top: 0, right: 0, bottom: 0 };
+            return XMLBuilder.w('drawing', undefined, [
+                XMLBuilder.wp('inline', {
+                    distT: this.inlineDistT.toString(),
+                    distB: this.inlineDistB.toString(),
+                    distL: this.inlineDistL.toString(),
+                    distR: this.inlineDistR.toString(),
+                }, [
+                    extent,
+                    XMLBuilder.wp('effectExtent', {
+                        t: effectExt.top.toString(),
+                        r: effectExt.right.toString(),
+                        b: effectExt.bottom.toString(),
+                        l: effectExt.left.toString(),
+                    }),
+                    buildDocPr(this.docPrId.toString()),
+                    buildCNvGraphicFramePr(),
+                    graphic,
+                ]),
+            ]);
+        }
+    }
+}
+//# sourceMappingURL=Image.js.map