docxmlater 5.0.0 → 5.1.1

package/dist/elements/Image.js

@@ -2,8 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Image = void 0;
 const fs_1 = require("fs");
-const XMLBuilder_1 = require("../xml/XMLBuilder");
+const logger_1 = require("../utils/logger");
 const units_1 = require("../utils/units");
+const XMLBuilder_1 = require("../xml/XMLBuilder");
 class Image {
     source;
     width;
@@ -14,12 +15,36 @@ class Image {
     imageData;
     extension;
     docPrId = 1;
+    dpi = 96;
     effectExtent;
     wrap;
     position;
     anchor;
     crop;
     effects;
+    rotation = 0;
+    border;
+    static async fromFile(path, properties = {}) {
+        const image = new Image({ source: path, ...properties });
+        await image.loadImageDataForDimensions();
+        return image;
+    }
+    static async fromBuffer(buffer, properties = {}) {
+        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';
@@ -34,55 +59,86 @@ class Image {
         this.anchor = properties.anchor;
         this.crop = properties.crop;
         this.effects = properties.effects;
+        this.dpi = 96;
     }
     async loadImageDataForDimensions() {
         let tempData;
-        if (Buffer.isBuffer(this.source)) {
-            tempData = this.source;
-        }
-        else if (typeof this.source === 'string') {
-            try {
+        try {
+            if (Buffer.isBuffer(this.source)) {
+                tempData = this.source;
+            }
+            else if (typeof this.source === 'string') {
                 await fs_1.promises.access(this.source);
                 tempData = await fs_1.promises.readFile(this.source);
             }
-            catch (error) {
-                throw new Error(`Could not read image file: ${this.source}`);
+            if (tempData) {
+                this.imageData = tempData;
+                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;
+                }
             }
         }
-        if (tempData) {
-            this.imageData = tempData;
-            const dimensions = this.detectDimensions();
-            if (dimensions) {
-                this.width = dimensions.width;
-                this.height = dimensions.height;
-            }
-            if (typeof this.source === 'string') {
-                this.imageData = undefined;
-            }
+        catch (error) {
+            logger_1.defaultLogger.error(`Failed to load image for dimensions: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Image loading failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     async ensureDataLoaded() {
-        if (this.imageData) {
+        if (this.imageData)
             return;
-        }
-        if (Buffer.isBuffer(this.source)) {
-            this.imageData = this.source;
-        }
-        else if (typeof this.source === 'string') {
-            try {
+        try {
+            if (Buffer.isBuffer(this.source)) {
+                this.imageData = this.source;
+            }
+            else if (typeof this.source === 'string') {
                 await fs_1.promises.access(this.source);
                 this.imageData = await fs_1.promises.readFile(this.source);
             }
-            catch (error) {
-                throw new Error(`Failed to load image from ${this.source}: ${error instanceof Error ? error.message : error}`);
+            else {
+                throw new Error('Invalid image source');
             }
         }
+        catch (error) {
+            logger_1.defaultLogger.error(`Failed to load image data: ${error instanceof Error ? error.message : String(error)}`);
+            throw new Error(`Image data loading failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
     releaseData() {
         if (typeof this.source === 'string') {
             this.imageData = undefined;
         }
     }
+    validateImageData() {
+        if (!this.imageData || this.imageData.length === 0) {
+            return { valid: false, error: 'Empty image data' };
+        }
+        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]
+        };
+        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 = this.source.match(/\.([a-z]+)$/i);
@@ -93,225 +149,138 @@ class Image {
         return 'png';
     }
     detectDimensions() {
-        if (!this.imageData || this.imageData.length < 24) {
+        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();
         }
-        try {
-            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[0] === 0xff && this.imageData[1] === 0xd8) {
+            return this.detectJpegDimensions();
         }
-        catch (error) {
+        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();
         }
         return null;
     }
     detectPngDimensions() {
-        if (!this.imageData || this.imageData.length < 24) {
-            return null;
-        }
-        try {
-            const width = this.imageData.readUInt32BE(16);
-            const height = this.imageData.readUInt32BE(20);
-            return {
-                width: Math.round((width / 96) * 914400),
-                height: Math.round((height / 96) * 914400),
-            };
-        }
-        catch (error) {
+        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) {
+        if (!this.imageData || this.imageData.length < 10)
             return null;
-        }
-        try {
-            const width = this.imageData.readUInt16LE(6);
-            const height = this.imageData.readUInt16LE(8);
-            if (width > 0 && height > 0 && width < 65535 && height < 65535) {
-                return {
-                    width: Math.round((width / 96) * 914400),
-                    height: Math.round((height / 96) * 914400),
-                };
-            }
-        }
-        catch (error) {
-        }
+        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) {
+        if (!this.imageData || this.imageData.length < 26)
             return null;
-        }
-        try {
-            const width = this.imageData.readInt32LE(18);
-            const height = Math.abs(this.imageData.readInt32LE(22));
-            if (width > 0 && height > 0 && width < 65535 && height < 65535) {
-                return {
-                    width: Math.round((width / 96) * 914400),
-                    height: Math.round((height / 96) * 914400),
-                };
-            }
-        }
-        catch (error) {
-        }
+        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) {
+        if (!this.imageData || this.imageData.length < 14)
             return null;
-        }
-        try {
-            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 || tag === 0x100) {
-                    width = value;
-                }
-                else if (tag === 257 || tag === 0x101) {
-                    height = value;
-                }
-                if (width > 0 && height > 0) {
-                    break;
-                }
-            }
-            if (width > 0 && height > 0 && width < 65535 && height < 65535) {
-                return {
-                    width: Math.round((width / 96) * 914400),
-                    height: Math.round((height / 96) * 914400),
-                };
-            }
-        }
-        catch (error) {
-        }
+        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) {
+        if (!this.imageData || this.imageData.length < 12)
             return null;
-        }
-        try {
-            if (this.imageData[0] !== 0xff || this.imageData[1] !== 0xd8) {
-                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 <= 0xc3) ||
-                    (marker >= 0xc5 && marker <= 0xc7) ||
-                    (marker >= 0xc9 && marker <= 0xcb) ||
-                    (marker >= 0xcd && marker <= 0xcf);
-                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 && width < 65535 && height < 65535) {
-                        return {
-                            width: Math.round((width / 96) * 914400),
-                            height: Math.round((height / 96) * 914400),
-                        };
-                    }
-                }
-                if (marker === 0xda) {
-                    break;
-                }
-                if (marker === 0xd9) {
-                    break;
-                }
-                const standaloneMarker = (marker >= 0xd0 && marker <= 0xd9) || marker === 0x01;
-                if (standaloneMarker) {
-                    offset += 2;
-                    continue;
-                }
-                if (offset + 3 > this.imageData.length) {
-                    break;
-                }
-                const segmentLength = this.imageData.readUInt16BE(offset + 2);
-                if (segmentLength < 2 || offset + 2 + segmentLength > this.imageData.length) {
+        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;
-                }
-                offset += 2 + segmentLength;
-            }
-        }
-        catch (error) {
+                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;
     }
     async getImageDataAsync() {
         await this.ensureDataLoaded();
-        if (this.imageData) {
-            return this.imageData;
-        }
-        throw new Error('Failed to load image data');
+        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 await image.ensureDataLoaded() or await imageManager.loadAllImageData() first.');
-        }
+        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) {
+        if (maintainAspectRatio && this.height > 0) {
             const ratio = this.height / this.width;
             this.height = Math.round(width * ratio);
         }
@@ -319,7 +288,7 @@ class Image {
         return this;
     }
     setHeight(height, maintainAspectRatio = true) {
-        if (maintainAspectRatio) {
+        if (maintainAspectRatio && this.width > 0) {
             const ratio = this.width / this.height;
             this.width = Math.round(height * ratio);
         }
@@ -331,6 +300,14 @@ class Image {
         this.height = height;
         return this;
     }
+    async updateImageData(newSource) {
+        this.source = newSource;
+        this.imageData = undefined;
+        await this.loadImageDataForDimensions();
+        if (typeof newSource === 'string')
+            this.extension = this.detectExtension();
+        this.dpi = this.detectDPI() || 96;
+    }
     setRelationshipId(relationshipId) {
         this.relationshipId = relationshipId;
         return this;
@@ -350,17 +327,14 @@ class Image {
         return this.description;
     }
     rotate(degrees) {
-        const normalizedDegrees = ((degrees % 360) + 360) % 360;
-        this.rotation = normalizedDegrees;
-        if (normalizedDegrees === 90 || normalizedDegrees === 270) {
-            const temp = this.width;
-            this.width = this.height;
-            this.height = temp;
+        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 || 0;
+        return this.rotation;
     }
     setEffectExtent(left, top, right, bottom) {
         this.effectExtent = { left, top, right, bottom };
@@ -370,14 +344,7 @@ class Image {
         return this.effectExtent;
     }
     setWrap(type, side, distances) {
-        this.wrap = {
-            type,
-            side,
-            distanceTop: distances?.top,
-            distanceBottom: distances?.bottom,
-            distanceLeft: distances?.left,
-            distanceRight: distances?.right,
-        };
+        this.wrap = { type, side, ...distances };
         return this;
     }
     getWrap() {
@@ -399,12 +366,7 @@ class Image {
     }
     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),
-        };
+        this.crop = { left: clamp(left), top: clamp(top), right: clamp(right), bottom: clamp(bottom) };
         return this;
     }
     getCrop() {
@@ -412,440 +374,219 @@ class Image {
     }
     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,
-        };
+        this.effects = { brightness: clamp(options.brightness), contrast: clamp(options.contrast), grayscale: options.grayscale };
         return this;
     }
     getEffects() {
         return this.effects;
     }
-    isFloating() {
-        return this.anchor !== undefined || this.position !== undefined;
-    }
-    toXML() {
-        if (!this.relationshipId) {
-            throw new Error('Image must have a relationship ID before generating XML');
-        }
-        const imageElement = this.isFloating() ? this.createAnchor() : this.createInline();
-        const drawing = XMLBuilder_1.XMLBuilder.w('drawing', undefined, [imageElement]);
-        return drawing;
-    }
-    createInline() {
-        const children = [];
-        children.push({
-            name: 'wp:extent',
-            attributes: {
-                cx: this.width.toString(),
-                cy: this.height.toString(),
-            },
-            selfClosing: true,
-        });
-        const effectExt = this.effectExtent || { left: 0, top: 0, right: 0, bottom: 0 };
-        children.push({
-            name: 'wp:effectExtent',
-            attributes: {
-                l: effectExt.left.toString(),
-                t: effectExt.top.toString(),
-                r: effectExt.right.toString(),
-                b: effectExt.bottom.toString(),
-            },
-            selfClosing: true,
-        });
-        children.push({
-            name: 'wp:docPr',
-            attributes: {
-                id: this.docPrId.toString(),
-                name: this.name,
-                descr: this.description,
-            },
-            selfClosing: true,
-        });
-        children.push({
-            name: 'wp:cNvGraphicFramePr',
-            children: [
-                {
-                    name: 'a:graphicFrameLocks',
-                    attributes: {
-                        'xmlns:a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
-                        noChangeAspect: '1',
-                    },
-                    selfClosing: true,
-                },
-            ],
-        });
-        children.push(this.createGraphic());
-        return {
-            name: 'wp:inline',
-            attributes: {
-                distT: '0',
-                distB: '0',
-                distL: '0',
-                distR: '0',
-            },
-            children,
-        };
-    }
-    createGraphic() {
-        return {
-            name: 'a:graphic',
-            attributes: {
-                'xmlns:a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
-            },
-            children: [
-                {
-                    name: 'a:graphicData',
-                    attributes: {
-                        uri: 'http://schemas.openxmlformats.org/drawingml/2006/picture',
-                    },
-                    children: [this.createPicture()],
-                },
-            ],
-        };
-    }
-    createPicture() {
-        return {
-            name: 'pic:pic',
-            attributes: {
-                'xmlns:pic': 'http://schemas.openxmlformats.org/drawingml/2006/picture',
-            },
-            children: [
-                {
-                    name: 'pic:nvPicPr',
-                    children: [
-                        {
-                            name: 'pic:cNvPr',
-                            attributes: {
-                                id: this.docPrId.toString(),
-                                name: this.name,
-                                descr: this.description,
-                            },
-                            selfClosing: true,
-                        },
-                        {
-                            name: 'pic:cNvPicPr',
-                            selfClosing: true,
-                        },
-                    ],
-                },
-                {
-                    name: 'pic:blipFill',
-                    children: this.createBlipFillChildren(),
-                },
-                {
-                    name: 'pic:spPr',
-                    children: [
-                        {
-                            name: 'a:xfrm',
-                            attributes: this.getRotation() > 0 ? { rot: (this.getRotation() * 60000).toString() } : undefined,
-                            children: [
-                                {
-                                    name: 'a:off',
-                                    attributes: {
-                                        x: '0',
-                                        y: '0',
-                                    },
-                                    selfClosing: true,
-                                },
-                                {
-                                    name: 'a:ext',
-                                    attributes: {
-                                        cx: this.width.toString(),
-                                        cy: this.height.toString(),
-                                    },
-                                    selfClosing: true,
-                                },
-                            ],
-                        },
-                        {
-                            name: 'a:prstGeom',
-                            attributes: {
-                                prst: 'rect',
-                            },
-                            children: [
-                                {
-                                    name: 'a:avLst',
-                                    selfClosing: true,
-                                },
-                            ],
-                        },
-                    ],
-                },
-            ],
-        };
-    }
-    createBlipFillChildren() {
-        const children = [];
-        const blipChildren = [];
-        if (this.crop) {
-            blipChildren.push({
-                name: 'a:srcRect',
-                attributes: {
-                    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(),
-                },
-                selfClosing: true,
-            });
-        }
-        if (this.effects) {
-            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();
-            }
-            if (Object.keys(lumAttrs).length > 0) {
-                blipChildren.push({
-                    name: 'a:lum',
-                    attributes: lumAttrs,
-                    selfClosing: true,
-                });
+    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);
+                    }
+                }
             }
-            if (this.effects.grayscale) {
-                blipChildren.push({
-                    name: 'a:grayscl',
-                    selfClosing: true,
-                });
+            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);
+                }
             }
         }
-        children.push({
-            name: 'a:blip',
-            attributes: {
-                'r:embed': this.relationshipId,
-            },
-            ...(blipChildren.length > 0 ? { children: blipChildren } : { selfClosing: true }),
-        });
-        children.push({
-            name: 'a:stretch',
-            children: [
-                {
-                    name: 'a:fillRect',
-                    selfClosing: true,
-                },
-            ],
+        catch (error) {
+            logger_1.defaultLogger.warn(`DPI detection failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        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
         });
-        return children;
+        this.setWrap('square', 'bothSides');
+        return this;
     }
-    createAnchor() {
-        const children = [];
-        const anchorConfig = this.anchor || {
+    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: false,
-            relativeHeight: 251658240,
-        };
-        if (this.position) {
-            const posH = this.position.horizontal;
-            const posHChildren = [];
-            if (posH.offset !== undefined) {
-                posHChildren.push({
-                    name: 'wp:posOffset',
-                    children: [posH.offset.toString()],
-                });
-            }
-            else if (posH.alignment) {
-                posHChildren.push({
-                    name: 'wp:align',
-                    children: [posH.alignment],
-                });
-            }
-            children.push({
-                name: 'wp:positionH',
-                attributes: {
-                    relativeFrom: posH.anchor,
-                },
-                children: posHChildren,
-            });
-        }
-        if (this.position) {
-            const posV = this.position.vertical;
-            const posVChildren = [];
-            if (posV.offset !== undefined) {
-                posVChildren.push({
-                    name: 'wp:posOffset',
-                    children: [posV.offset.toString()],
-                });
-            }
-            else if (posV.alignment) {
-                posVChildren.push({
-                    name: 'wp:align',
-                    children: [posV.alignment],
-                });
-            }
-            children.push({
-                name: 'wp:positionV',
-                attributes: {
-                    relativeFrom: posV.anchor,
-                },
-                children: posVChildren,
-            });
-        }
-        children.push({
-            name: 'wp:extent',
-            attributes: {
-                cx: this.width.toString(),
-                cy: this.height.toString(),
-            },
-            selfClosing: true,
+            allowOverlap: true,
+            relativeHeight: 251658240
         });
-        const effectExt = this.effectExtent || { left: 0, top: 0, right: 0, bottom: 0 };
-        children.push({
-            name: 'wp:effectExtent',
-            attributes: {
-                l: effectExt.left.toString(),
-                t: effectExt.top.toString(),
-                r: effectExt.right.toString(),
-                b: effectExt.bottom.toString(),
-            },
-            selfClosing: true,
+        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
         });
-        if (this.wrap) {
-            children.push(this.createWrapElement());
+        this.setWrap('square', 'bothSides');
+        return this;
+    }
+    setBehindText(behind = true) {
+        if (this.anchor) {
+            this.anchor.behindDoc = behind;
         }
         else {
-            children.push({
-                name: 'wp:wrapSquare',
-                attributes: {
-                    wrapText: 'bothSides',
-                },
-                selfClosing: true,
+            this.setAnchor({
+                behindDoc: behind,
+                locked: false,
+                layoutInCell: true,
+                allowOverlap: true,
+                relativeHeight: 251658240
             });
         }
-        children.push({
-            name: 'wp:docPr',
-            attributes: {
-                id: this.docPrId.toString(),
-                name: this.name,
-                descr: this.description,
-            },
-            selfClosing: true,
-        });
-        children.push({
-            name: 'wp:cNvGraphicFramePr',
-            children: [
-                {
-                    name: 'a:graphicFrameLocks',
-                    attributes: {
-                        'xmlns:a': 'http://schemas.openxmlformats.org/drawingml/2006/main',
-                        noChangeAspect: '1',
-                    },
-                    selfClosing: true,
-                },
-            ],
-        });
-        children.push(this.createGraphic());
-        return {
-            name: 'wp:anchor',
-            attributes: {
-                distT: this.wrap?.distanceTop?.toString() || '0',
-                distB: this.wrap?.distanceBottom?.toString() || '0',
-                distL: this.wrap?.distanceLeft?.toString() || '0',
-                distR: this.wrap?.distanceRight?.toString() || '0',
-                simplePos: '0',
-                relativeHeight: anchorConfig.relativeHeight.toString(),
-                behindDoc: anchorConfig.behindDoc ? '1' : '0',
-                locked: anchorConfig.locked ? '1' : '0',
-                layoutInCell: anchorConfig.layoutInCell ? '1' : '0',
-                allowOverlap: anchorConfig.allowOverlap ? '1' : '0',
-            },
-            children,
-        };
-    }
-    createWrapElement() {
-        if (!this.wrap) {
-            return {
-                name: 'wp:wrapSquare',
-                attributes: {
-                    wrapText: 'bothSides',
-                },
-                selfClosing: true,
-            };
-        }
-        const wrapAttributes = {
-            wrapText: this.wrap.side || 'bothSides',
-        };
-        if (this.wrap.distanceTop !== undefined) {
-            wrapAttributes.distT = this.wrap.distanceTop.toString();
-        }
-        if (this.wrap.distanceBottom !== undefined) {
-            wrapAttributes.distB = this.wrap.distanceBottom.toString();
-        }
-        if (this.wrap.distanceLeft !== undefined) {
-            wrapAttributes.distL = this.wrap.distanceLeft.toString();
-        }
-        if (this.wrap.distanceRight !== undefined) {
-            wrapAttributes.distR = this.wrap.distanceRight.toString();
-        }
-        const wrapElementName = (() => {
-            switch (this.wrap.type) {
-                case 'square':
-                    return 'wp:wrapSquare';
-                case 'tight':
-                    return 'wp:wrapTight';
-                case 'through':
-                    return 'wp:wrapThrough';
-                case 'topAndBottom':
-                    return 'wp:wrapTopAndBottom';
-                case 'none':
-                    return 'wp:wrapNone';
-                default:
-                    return 'wp:wrapSquare';
-            }
-        })();
-        return {
-            name: wrapElementName,
-            attributes: wrapAttributes,
-            selfClosing: true,
-        };
-    }
-    static async fromFile(filePath, width, height) {
-        const image = new Image({
-            source: filePath,
-            width,
-            height,
-            name: filePath.split(/[/\\]/).pop() || 'image',
-        });
-        if (!width || !height) {
-            try {
-                await image.loadImageDataForDimensions();
-            }
-            catch (error) {
-            }
-        }
-        return image;
+        return this;
     }
-    static async fromBuffer(buffer, extension, width, height) {
-        const image = new Image({
-            source: buffer,
-            width,
-            height,
-            name: `image.${extension}`,
-        });
-        image.extension = extension;
-        if (!width || !height) {
-            await image.loadImageDataForDimensions();
-        }
-        return image;
+    applyTwoPixelBlackBorder() {
+        this.border = { width: 2, color: '000000' };
+        return this;
     }
-    static async create(properties) {
-        const image = new Image(properties);
-        if ((!properties.width || !properties.height) && typeof properties.source === 'string') {
-            try {
-                await image.loadImageDataForDimensions();
-            }
-            catch (error) {
-            }
+    toXML() {
+        const isFloating = this.isFloating();
+        const extent = XMLBuilder_1.XMLBuilder.cxCy('extent', this.width, this.height);
+        const blip = XMLBuilder_1.XMLBuilder.a('blip', { 'r:embed': this.relationshipId });
+        const spPrChildren = [extent];
+        spPrChildren.push(XMLBuilder_1.XMLBuilder.a('prstGeom', { prst: 'rect' }));
+        if (this.border) {
+            const pxToEmu = 9525;
+            const widthEmu = this.border.width * pxToEmu;
+            const ln = XMLBuilder_1.XMLBuilder.a('ln', { w: widthEmu.toString() }, [
+                XMLBuilder_1.XMLBuilder.a('solidFill', undefined, [
+                    XMLBuilder_1.XMLBuilder.a('srgbClr', { val: this.border.color })
+                ])
+            ]);
+            spPrChildren.push(ln);
+        }
+        const graphicData = XMLBuilder_1.XMLBuilder.a('graphicData', { uri: 'http://schemas.openxmlformats.org/drawingml/2006/picture' }, [
+            XMLBuilder_1.XMLBuilder.pic('pic', undefined, [
+                XMLBuilder_1.XMLBuilder.pic('nvPicPr', undefined, [
+                    XMLBuilder_1.XMLBuilder.pic('cNvPr', { id: this.docPrId, name: this.name, descr: this.description }),
+                    XMLBuilder_1.XMLBuilder.pic('cNvPicPr')
+                ]),
+                XMLBuilder_1.XMLBuilder.pic('blipFill', undefined, [blip]),
+                XMLBuilder_1.XMLBuilder.pic('spPr', undefined, spPrChildren)
+            ])
+        ]);
+        const graphic = XMLBuilder_1.XMLBuilder.a('graphic', undefined, [graphicData]);
+        if (isFloating) {
+            const positionHChildren = [];
+            if (this.position?.horizontal.alignment) {
+                positionHChildren.push(XMLBuilder_1.XMLBuilder.wp('align', undefined, [this.position.horizontal.alignment]));
+            }
+            else {
+                positionHChildren.push(XMLBuilder_1.XMLBuilder.wp('posOffset', undefined, [(this.position?.horizontal.offset || 0).toString()]));
+            }
+            const positionH = XMLBuilder_1.XMLBuilder.wp('positionH', { relativeFrom: this.position?.horizontal.anchor || 'page' }, positionHChildren);
+            const positionVChildren = [];
+            if (this.position?.vertical.alignment) {
+                positionVChildren.push(XMLBuilder_1.XMLBuilder.wp('align', undefined, [this.position.vertical.alignment]));
+            }
+            else {
+                positionVChildren.push(XMLBuilder_1.XMLBuilder.wp('posOffset', undefined, [(this.position?.vertical.offset || 0).toString()]));
+            }
+            const positionV = XMLBuilder_1.XMLBuilder.wp('positionV', { relativeFrom: this.position?.vertical.anchor || 'page' }, positionVChildren);
+            const anchorChildren = [
+                positionH,
+                positionV,
+                extent
+            ];
+            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';
+                }
+                anchorChildren.push(XMLBuilder_1.XMLBuilder.wp(wrapElementName, wrapAttrs));
+            }
+            anchorChildren.push(XMLBuilder_1.XMLBuilder.wp('docPr', { id: this.docPrId, name: this.name, descr: this.description }));
+            anchorChildren.push(graphic);
+            return XMLBuilder_1.XMLBuilder.w('drawing', undefined, [
+                XMLBuilder_1.XMLBuilder.wp('anchor', {
+                    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
+                }, anchorChildren)
+            ]);
         }
-        else if ((!properties.width || !properties.height) && Buffer.isBuffer(properties.source)) {
-            await image.loadImageDataForDimensions();
+        else {
+            return XMLBuilder_1.XMLBuilder.w('drawing', undefined, [
+                XMLBuilder_1.XMLBuilder.wp('inline', undefined, [
+                    extent,
+                    XMLBuilder_1.XMLBuilder.wp('docPr', { id: this.docPrId, name: this.name, descr: this.description }),
+                    graphic
+                ])
+            ]);
         }
-        return image;
     }
 }
 exports.Image = Image;