docxmlater 0.1.0

package/dist/core/Document.js

@@ -0,0 +1,980 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Document = void 0;
+const ZipHandler_1 = require("../zip/ZipHandler");
+const types_1 = require("../zip/types");
+const Paragraph_1 = require("../elements/Paragraph");
+const Table_1 = require("../elements/Table");
+const Section_1 = require("../elements/Section");
+const ImageManager_1 = require("../elements/ImageManager");
+const HeaderFooterManager_1 = require("../elements/HeaderFooterManager");
+const Hyperlink_1 = require("../elements/Hyperlink");
+const TableOfContents_1 = require("../elements/TableOfContents");
+const TableOfContentsElement_1 = require("../elements/TableOfContentsElement");
+const BookmarkManager_1 = require("../elements/BookmarkManager");
+const Revision_1 = require("../elements/Revision");
+const RevisionManager_1 = require("../elements/RevisionManager");
+const CommentManager_1 = require("../elements/CommentManager");
+const Run_1 = require("../elements/Run");
+const XMLBuilder_1 = require("../xml/XMLBuilder");
+const XMLParser_1 = require("../xml/XMLParser");
+const StylesManager_1 = require("../formatting/StylesManager");
+const NumberingManager_1 = require("../formatting/NumberingManager");
+const RelationshipManager_1 = require("./RelationshipManager");
+class ImageRun {
+    constructor(image) {
+        this.image = image;
+    }
+    toXML() {
+        const drawing = this.image.toXML();
+        return {
+            name: 'w:r',
+            children: [drawing]
+        };
+    }
+}
+class Document {
+    constructor(zipHandler, options = {}, initDefaults = true) {
+        this.bodyElements = [];
+        this.parseErrors = [];
+        this.zipHandler = zipHandler || new ZipHandler_1.ZipHandler();
+        this.properties = options.properties || {};
+        this.maxMemoryUsagePercent = options.maxMemoryUsagePercent ?? 80;
+        this.strictParsing = options.strictParsing ?? false;
+        this.stylesManager = StylesManager_1.StylesManager.create();
+        this.numberingManager = NumberingManager_1.NumberingManager.create();
+        this.section = Section_1.Section.createLetter();
+        this.imageManager = ImageManager_1.ImageManager.create();
+        this.relationshipManager = RelationshipManager_1.RelationshipManager.create();
+        this.headerFooterManager = HeaderFooterManager_1.HeaderFooterManager.create();
+        this.bookmarkManager = BookmarkManager_1.BookmarkManager.create();
+        this.revisionManager = RevisionManager_1.RevisionManager.create();
+        this.commentManager = CommentManager_1.CommentManager.create();
+        if (initDefaults) {
+            this.relationshipManager.addStyles();
+            this.relationshipManager.addNumbering();
+        }
+    }
+    static create(options) {
+        const doc = new Document(undefined, options);
+        doc.initializeRequiredFiles();
+        return doc;
+    }
+    static async load(filePath, options) {
+        const zipHandler = new ZipHandler_1.ZipHandler();
+        await zipHandler.load(filePath);
+        const doc = new Document(zipHandler, options, false);
+        await doc.parseDocument();
+        return doc;
+    }
+    static async loadFromBuffer(buffer, options) {
+        const zipHandler = new ZipHandler_1.ZipHandler();
+        await zipHandler.loadFromBuffer(buffer);
+        const doc = new Document(zipHandler, options, false);
+        await doc.parseDocument();
+        return doc;
+    }
+    initializeRequiredFiles() {
+        this.zipHandler.addFile(types_1.DOCX_PATHS.CONTENT_TYPES, this.generateContentTypes());
+        this.zipHandler.addFile(types_1.DOCX_PATHS.RELS, this.generateRels());
+        this.zipHandler.addFile(types_1.DOCX_PATHS.DOCUMENT, this.generateDocumentXml());
+        this.zipHandler.addFile('word/_rels/document.xml.rels', this.relationshipManager.generateXml());
+        this.zipHandler.addFile(types_1.DOCX_PATHS.STYLES, this.stylesManager.generateStylesXml());
+        this.zipHandler.addFile(types_1.DOCX_PATHS.NUMBERING, this.numberingManager.generateNumberingXml());
+        this.zipHandler.addFile(types_1.DOCX_PATHS.CORE_PROPS, this.generateCoreProps());
+        this.zipHandler.addFile(types_1.DOCX_PATHS.APP_PROPS, this.generateAppProps());
+    }
+    async parseDocument() {
+        const docXml = this.zipHandler.getFileAsString(types_1.DOCX_PATHS.DOCUMENT);
+        if (!docXml) {
+            throw new Error('Invalid document: word/document.xml not found');
+        }
+        this.parseRelationships();
+        this.parseProperties();
+        this.parseBodyElements(docXml);
+    }
+    parseBodyElements(docXml) {
+        this.bodyElements = [];
+        try {
+            XMLParser_1.XMLParser.validateSize(docXml);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.parseErrors.push({ element: 'document', error: err });
+            if (this.strictParsing) {
+                throw err;
+            }
+            return;
+        }
+        const bodyContent = XMLParser_1.XMLParser.extractBody(docXml);
+        if (!bodyContent) {
+            return;
+        }
+        const paragraphXmls = XMLParser_1.XMLParser.extractElements(bodyContent, 'w:p');
+        for (const paraXml of paragraphXmls) {
+            const paragraph = this.parseParagraph(paraXml);
+            if (paragraph) {
+                this.bodyElements.push(paragraph);
+            }
+        }
+        const hasTable = bodyContent.includes('<w:tbl');
+        if (hasTable) {
+            const err = new Error('Document contains tables which are not yet fully supported in Phase 2. Tables will be ignored.');
+            this.parseErrors.push({ element: 'table', error: err });
+            if (this.strictParsing) {
+                throw err;
+            }
+        }
+    }
+    parseParagraph(paraXml) {
+        try {
+            const paragraph = new Paragraph_1.Paragraph();
+            this.parseParagraphProperties(paraXml, paragraph);
+            const runXmls = XMLParser_1.XMLParser.extractElements(paraXml, 'w:r');
+            for (const runXml of runXmls) {
+                const run = this.parseRun(runXml);
+                if (run) {
+                    paragraph.addRun(run);
+                }
+            }
+            return paragraph;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.parseErrors.push({ element: 'paragraph', error: err });
+            if (this.strictParsing) {
+                throw new Error(`Failed to parse paragraph: ${err.message}`);
+            }
+            return null;
+        }
+    }
+    parseParagraphProperties(paraXml, paragraph) {
+        const pPrMatch = paraXml.match(/<w:pPr[^>]*>([\s\S]*?)<\/w:pPr>/);
+        if (!pPrMatch || !pPrMatch[1]) {
+            return;
+        }
+        const pPr = pPrMatch[1];
+        const alignMatch = pPr.match(/<w:jc\s+w:val="([^"]+)"/);
+        if (alignMatch && alignMatch[1]) {
+            const alignment = alignMatch[1];
+            paragraph.setAlignment(alignment);
+        }
+        const styleMatch = pPr.match(/<w:pStyle\s+w:val="([^"]+)"/);
+        if (styleMatch && styleMatch[1]) {
+            paragraph.setStyle(styleMatch[1]);
+        }
+        const indMatch = pPr.match(/<w:ind([^>]+)\/>/);
+        if (indMatch && indMatch[1]) {
+            const indStr = indMatch[1];
+            const leftMatch = indStr.match(/w:left="(\d+)"/);
+            const rightMatch = indStr.match(/w:right="(\d+)"/);
+            const firstLineMatch = indStr.match(/w:firstLine="(\d+)"/);
+            if (leftMatch && leftMatch[1]) {
+                paragraph.setLeftIndent(parseInt(leftMatch[1], 10));
+            }
+            if (rightMatch && rightMatch[1]) {
+                paragraph.setRightIndent(parseInt(rightMatch[1], 10));
+            }
+            if (firstLineMatch && firstLineMatch[1]) {
+                paragraph.setFirstLineIndent(parseInt(firstLineMatch[1], 10));
+            }
+        }
+        const spacingMatch = pPr.match(/<w:spacing([^>]+)\/>/);
+        if (spacingMatch && spacingMatch[1]) {
+            const spacingStr = spacingMatch[1];
+            const beforeMatch = spacingStr.match(/w:before="(\d+)"/);
+            const afterMatch = spacingStr.match(/w:after="(\d+)"/);
+            const lineMatch = spacingStr.match(/w:line="(\d+)"/);
+            if (beforeMatch && beforeMatch[1]) {
+                paragraph.setSpaceBefore(parseInt(beforeMatch[1], 10));
+            }
+            if (afterMatch && afterMatch[1]) {
+                paragraph.setSpaceAfter(parseInt(afterMatch[1], 10));
+            }
+            if (lineMatch && lineMatch[1]) {
+                const lineRule = spacingStr.match(/w:lineRule="([^"]+)"/);
+                paragraph.setLineSpacing(parseInt(lineMatch[1], 10), lineRule && lineRule[1] ? lineRule[1] : undefined);
+            }
+        }
+        if (pPr.includes('<w:keepNext'))
+            paragraph.setKeepNext(true);
+        if (pPr.includes('<w:keepLines'))
+            paragraph.setKeepLines(true);
+        if (pPr.includes('<w:pageBreakBefore'))
+            paragraph.setPageBreakBefore(true);
+    }
+    parseRun(runXml) {
+        try {
+            const text = XMLBuilder_1.XMLBuilder.unescapeXml(XMLParser_1.XMLParser.extractText(runXml));
+            const run = new Run_1.Run(text);
+            this.parseRunProperties(runXml, run);
+            return run;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.parseErrors.push({ element: 'run', error: err });
+            if (this.strictParsing) {
+                throw new Error(`Failed to parse run: ${err.message}`);
+            }
+            return null;
+        }
+    }
+    parseRunProperties(runXml, run) {
+        const rPrMatch = runXml.match(/<w:rPr[^>]*>([\s\S]*?)<\/w:rPr>/);
+        if (!rPrMatch || !rPrMatch[1]) {
+            return;
+        }
+        const rPr = rPrMatch[1];
+        if (rPr.includes('<w:b/>') || rPr.includes('<w:b ')) {
+            run.setBold(true);
+        }
+        if (rPr.includes('<w:i/>') || rPr.includes('<w:i ')) {
+            run.setItalic(true);
+        }
+        const underlineMatch = rPr.match(/<w:u\s+w:val="([^"]+)"/);
+        if (underlineMatch && underlineMatch[1]) {
+            const underlineStyle = underlineMatch[1];
+            run.setUnderline(underlineStyle);
+        }
+        else if (rPr.includes('<w:u/>')) {
+            run.setUnderline(true);
+        }
+        if (rPr.includes('<w:strike/>') || rPr.includes('<w:strike ')) {
+            run.setStrike(true);
+        }
+        const vertAlignMatch = rPr.match(/<w:vertAlign\s+w:val="([^"]+)"/);
+        if (vertAlignMatch && vertAlignMatch[1]) {
+            if (vertAlignMatch[1] === 'subscript') {
+                run.setSubscript(true);
+            }
+            else if (vertAlignMatch[1] === 'superscript') {
+                run.setSuperscript(true);
+            }
+        }
+        const fontMatch = rPr.match(/<w:rFonts[^>]+w:ascii="([^"]+)"/);
+        if (fontMatch && fontMatch[1]) {
+            run.setFont(fontMatch[1]);
+        }
+        const sizeMatch = rPr.match(/<w:sz\s+w:val="(\d+)"/);
+        if (sizeMatch && sizeMatch[1]) {
+            const halfPoints = parseInt(sizeMatch[1], 10);
+            run.setSize(halfPoints / 2);
+        }
+        const colorMatch = rPr.match(/<w:color\s+w:val="([^"]+)"/);
+        if (colorMatch && colorMatch[1]) {
+            run.setColor(colorMatch[1]);
+        }
+        const highlightMatch = rPr.match(/<w:highlight\s+w:val="([^"]+)"/);
+        if (highlightMatch && highlightMatch[1]) {
+            const highlightColor = highlightMatch[1];
+            run.setHighlight(highlightColor);
+        }
+        if (rPr.includes('<w:smallCaps/>') || rPr.includes('<w:smallCaps ')) {
+            run.setSmallCaps(true);
+        }
+        if (rPr.includes('<w:caps/>') || rPr.includes('<w:caps ')) {
+            run.setAllCaps(true);
+        }
+    }
+    parseRelationships() {
+        const relsPath = 'word/_rels/document.xml.rels';
+        const relsXml = this.zipHandler.getFileAsString(relsPath);
+        if (relsXml) {
+            this.relationshipManager = RelationshipManager_1.RelationshipManager.fromXml(relsXml);
+        }
+        else {
+            this.relationshipManager.addStyles();
+            this.relationshipManager.addNumbering();
+        }
+    }
+    parseProperties() {
+        const coreXml = this.zipHandler.getFileAsString(types_1.DOCX_PATHS.CORE_PROPS);
+        if (!coreXml) {
+            return;
+        }
+        const extractTag = (xml, tag) => {
+            const match = xml.match(new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`));
+            return match && match[1] ? XMLBuilder_1.XMLBuilder.unescapeXml(match[1]) : undefined;
+        };
+        this.properties = {
+            title: extractTag(coreXml, 'dc:title'),
+            subject: extractTag(coreXml, 'dc:subject'),
+            creator: extractTag(coreXml, 'dc:creator'),
+            keywords: extractTag(coreXml, 'cp:keywords'),
+            description: extractTag(coreXml, 'dc:description'),
+            lastModifiedBy: extractTag(coreXml, 'cp:lastModifiedBy'),
+        };
+        const revisionStr = extractTag(coreXml, 'cp:revision');
+        if (revisionStr) {
+            this.properties.revision = parseInt(revisionStr, 10);
+        }
+        const createdStr = extractTag(coreXml, 'dcterms:created');
+        if (createdStr) {
+            this.properties.created = new Date(createdStr);
+        }
+        const modifiedStr = extractTag(coreXml, 'dcterms:modified');
+        if (modifiedStr) {
+            this.properties.modified = new Date(modifiedStr);
+        }
+    }
+    addParagraph(paragraph) {
+        this.bodyElements.push(paragraph);
+        return this;
+    }
+    createParagraph(text) {
+        const para = new Paragraph_1.Paragraph();
+        if (text) {
+            para.addText(text);
+        }
+        this.bodyElements.push(para);
+        return para;
+    }
+    addTable(table) {
+        this.bodyElements.push(table);
+        return this;
+    }
+    createTable(rows, columns) {
+        const table = new Table_1.Table(rows, columns);
+        this.bodyElements.push(table);
+        return table;
+    }
+    addTableOfContents(toc) {
+        const tocElement = toc instanceof TableOfContentsElement_1.TableOfContentsElement
+            ? toc
+            : new TableOfContentsElement_1.TableOfContentsElement(toc || TableOfContents_1.TableOfContents.createStandard());
+        this.bodyElements.push(tocElement);
+        return this;
+    }
+    createTableOfContents(title) {
+        const tocElement = TableOfContentsElement_1.TableOfContentsElement.createStandard(title);
+        return this.addTableOfContents(tocElement);
+    }
+    getParagraphs() {
+        return this.bodyElements.filter((el) => el instanceof Paragraph_1.Paragraph);
+    }
+    getTables() {
+        return this.bodyElements.filter((el) => el instanceof Table_1.Table);
+    }
+    getTableOfContentsElements() {
+        return this.bodyElements.filter((el) => el instanceof TableOfContentsElement_1.TableOfContentsElement);
+    }
+    getBodyElements() {
+        return [...this.bodyElements];
+    }
+    getParagraphCount() {
+        return this.getParagraphs().length;
+    }
+    getTableCount() {
+        return this.getTables().length;
+    }
+    clearParagraphs() {
+        this.bodyElements = [];
+        return this;
+    }
+    setProperties(properties) {
+        this.properties = { ...this.properties, ...properties };
+        return this;
+    }
+    getProperties() {
+        return { ...this.properties };
+    }
+    async save(filePath) {
+        const tempPath = `${filePath}.tmp.${Date.now()}`;
+        try {
+            this.checkMemoryThreshold();
+            await this.imageManager.loadAllImageData();
+            this.checkMemoryThreshold();
+            const sizeInfo = this.estimateSize();
+            if (sizeInfo.warning) {
+                console.warn(`DocXML Warning: ${sizeInfo.warning}`);
+            }
+            this.processHyperlinks();
+            this.updateDocumentXml();
+            this.updateStylesXml();
+            this.updateNumberingXml();
+            this.updateCoreProps();
+            this.saveImages();
+            this.saveHeaders();
+            this.saveFooters();
+            this.saveComments();
+            this.updateRelationships();
+            this.updateContentTypesWithImagesHeadersFootersAndComments();
+            await this.zipHandler.save(tempPath);
+            const { promises: fs } = await Promise.resolve().then(() => __importStar(require('fs')));
+            await fs.rename(tempPath, filePath);
+        }
+        catch (error) {
+            try {
+                const { promises: fs } = await Promise.resolve().then(() => __importStar(require('fs')));
+                await fs.unlink(tempPath);
+            }
+            catch {
+            }
+            throw error;
+        }
+        finally {
+            this.imageManager.releaseAllImageData();
+        }
+    }
+    async toBuffer() {
+        try {
+            this.checkMemoryThreshold();
+            await this.imageManager.loadAllImageData();
+            this.checkMemoryThreshold();
+            const sizeInfo = this.estimateSize();
+            if (sizeInfo.warning) {
+                console.warn(`DocXML Warning: ${sizeInfo.warning}`);
+            }
+            this.processHyperlinks();
+            this.updateDocumentXml();
+            this.updateStylesXml();
+            this.updateNumberingXml();
+            this.updateCoreProps();
+            this.saveImages();
+            this.saveHeaders();
+            this.saveFooters();
+            this.saveComments();
+            this.updateRelationships();
+            this.updateContentTypesWithImagesHeadersFootersAndComments();
+            return await this.zipHandler.toBuffer();
+        }
+        finally {
+            this.imageManager.releaseAllImageData();
+        }
+    }
+    updateDocumentXml() {
+        const xml = this.generateDocumentXml();
+        this.zipHandler.updateFile(types_1.DOCX_PATHS.DOCUMENT, xml);
+    }
+    updateCoreProps() {
+        const xml = this.generateCoreProps();
+        this.zipHandler.updateFile(types_1.DOCX_PATHS.CORE_PROPS, xml);
+    }
+    updateStylesXml() {
+        const xml = this.stylesManager.generateStylesXml();
+        this.zipHandler.updateFile(types_1.DOCX_PATHS.STYLES, xml);
+    }
+    updateNumberingXml() {
+        const xml = this.numberingManager.generateNumberingXml();
+        this.zipHandler.updateFile(types_1.DOCX_PATHS.NUMBERING, xml);
+    }
+    generateContentTypes() {
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+  <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
+  <Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>
+  <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
+  <Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
+</Types>`;
+    }
+    generateRels() {
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
+  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
+</Relationships>`;
+    }
+    generateDocumentXml() {
+        const bodyXmls = [];
+        for (const element of this.bodyElements) {
+            const xml = element.toXML();
+            if (Array.isArray(xml)) {
+                bodyXmls.push(...xml);
+            }
+            else {
+                bodyXmls.push(xml);
+            }
+        }
+        bodyXmls.push(this.section.toXML());
+        return XMLBuilder_1.XMLBuilder.createDocument(bodyXmls);
+    }
+    generateCoreProps() {
+        const now = new Date();
+        const created = this.properties.created || now;
+        const modified = this.properties.modified || now;
+        const formatDate = (date) => {
+            return date.toISOString();
+        };
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties"
+                   xmlns:dc="http://purl.org/dc/elements/1.1/"
+                   xmlns:dcterms="http://purl.org/dc/terms/"
+                   xmlns:dcmitype="http://purl.org/dc/dcmitype/"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <dc:title>${XMLBuilder_1.XMLBuilder.escapeXmlText(this.properties.title || '')}</dc:title>
+  <dc:subject>${XMLBuilder_1.XMLBuilder.escapeXmlText(this.properties.subject || '')}</dc:subject>
+  <dc:creator>${XMLBuilder_1.XMLBuilder.escapeXmlText(this.properties.creator || 'DocXML')}</dc:creator>
+  <cp:keywords>${XMLBuilder_1.XMLBuilder.escapeXmlText(this.properties.keywords || '')}</cp:keywords>
+  <dc:description>${XMLBuilder_1.XMLBuilder.escapeXmlText(this.properties.description || '')}</dc:description>
+  <cp:lastModifiedBy>${XMLBuilder_1.XMLBuilder.escapeXmlText(this.properties.lastModifiedBy || this.properties.creator || 'DocXML')}</cp:lastModifiedBy>
+  <cp:revision>${this.properties.revision || 1}</cp:revision>
+  <dcterms:created xsi:type="dcterms:W3CDTF">${formatDate(created)}</dcterms:created>
+  <dcterms:modified xsi:type="dcterms:W3CDTF">${formatDate(modified)}</dcterms:modified>
+</cp:coreProperties>`;
+    }
+    generateAppProps() {
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties"
+            xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">
+  <Application>DocXML</Application>
+  <DocSecurity>0</DocSecurity>
+  <ScaleCrop>false</ScaleCrop>
+  <Company></Company>
+  <LinksUpToDate>false</LinksUpToDate>
+  <SharedDoc>false</SharedDoc>
+  <HyperlinksChanged>false</HyperlinksChanged>
+  <AppVersion>0.1.0</AppVersion>
+</Properties>`;
+    }
+    getStylesManager() {
+        return this.stylesManager;
+    }
+    addStyle(style) {
+        this.stylesManager.addStyle(style);
+        return this;
+    }
+    getStyle(styleId) {
+        return this.stylesManager.getStyle(styleId);
+    }
+    hasStyle(styleId) {
+        return this.stylesManager.hasStyle(styleId);
+    }
+    getZipHandler() {
+        return this.zipHandler;
+    }
+    getNumberingManager() {
+        return this.numberingManager;
+    }
+    createBulletList(levels = 3, bullets) {
+        return this.numberingManager.createBulletList(levels, bullets);
+    }
+    createNumberedList(levels = 3, formats) {
+        return this.numberingManager.createNumberedList(levels, formats);
+    }
+    createMultiLevelList() {
+        return this.numberingManager.createMultiLevelList();
+    }
+    getSection() {
+        return this.section;
+    }
+    setSection(section) {
+        this.section = section;
+        return this;
+    }
+    setPageSize(width, height, orientation) {
+        this.section.setPageSize(width, height, orientation);
+        return this;
+    }
+    setPageOrientation(orientation) {
+        this.section.setOrientation(orientation);
+        return this;
+    }
+    setMargins(margins) {
+        this.section.setMargins(margins);
+        return this;
+    }
+    setHeader(header) {
+        const relationship = this.relationshipManager.addHeader(`${header.getFilename(1)}`);
+        this.headerFooterManager.registerHeader(header, relationship.getId());
+        this.section.setHeaderReference('default', relationship.getId());
+        return this;
+    }
+    setFirstPageHeader(header) {
+        this.section.setTitlePage(true);
+        const relationship = this.relationshipManager.addHeader(`${header.getFilename(this.headerFooterManager.getHeaderCount() + 1)}`);
+        this.headerFooterManager.registerHeader(header, relationship.getId());
+        this.section.setHeaderReference('first', relationship.getId());
+        return this;
+    }
+    setEvenPageHeader(header) {
+        const relationship = this.relationshipManager.addHeader(`${header.getFilename(this.headerFooterManager.getHeaderCount() + 1)}`);
+        this.headerFooterManager.registerHeader(header, relationship.getId());
+        this.section.setHeaderReference('even', relationship.getId());
+        return this;
+    }
+    setFooter(footer) {
+        const relationship = this.relationshipManager.addFooter(`${footer.getFilename(1)}`);
+        this.headerFooterManager.registerFooter(footer, relationship.getId());
+        this.section.setFooterReference('default', relationship.getId());
+        return this;
+    }
+    setFirstPageFooter(footer) {
+        this.section.setTitlePage(true);
+        const relationship = this.relationshipManager.addFooter(`${footer.getFilename(this.headerFooterManager.getFooterCount() + 1)}`);
+        this.headerFooterManager.registerFooter(footer, relationship.getId());
+        this.section.setFooterReference('first', relationship.getId());
+        return this;
+    }
+    setEvenPageFooter(footer) {
+        const relationship = this.relationshipManager.addFooter(`${footer.getFilename(this.headerFooterManager.getFooterCount() + 1)}`);
+        this.headerFooterManager.registerFooter(footer, relationship.getId());
+        this.section.setFooterReference('even', relationship.getId());
+        return this;
+    }
+    getHeaderFooterManager() {
+        return this.headerFooterManager;
+    }
+    addImage(image) {
+        const target = `media/image${this.imageManager.getImageCount() + 1}.${image.getExtension()}`;
+        const relationship = this.relationshipManager.addImage(target);
+        this.imageManager.registerImage(image, relationship.getId());
+        const para = new Paragraph_1.Paragraph();
+        const imageRun = this.createImageRun(image);
+        para.addRun(imageRun);
+        this.bodyElements.push(para);
+        return this;
+    }
+    createImageRun(image) {
+        return new ImageRun(image);
+    }
+    getImageManager() {
+        return this.imageManager;
+    }
+    getRelationshipManager() {
+        return this.relationshipManager;
+    }
+    processHyperlinks() {
+        const paragraphs = this.getParagraphs();
+        const headers = this.headerFooterManager.getAllHeaders();
+        const footers = this.headerFooterManager.getAllFooters();
+        for (const header of headers) {
+            for (const element of header.header.getElements()) {
+                if (element instanceof Paragraph_1.Paragraph) {
+                    this.processHyperlinksInParagraph(element);
+                }
+            }
+        }
+        for (const footer of footers) {
+            for (const element of footer.footer.getElements()) {
+                if (element instanceof Paragraph_1.Paragraph) {
+                    this.processHyperlinksInParagraph(element);
+                }
+            }
+        }
+        for (const para of paragraphs) {
+            this.processHyperlinksInParagraph(para);
+        }
+    }
+    processHyperlinksInParagraph(paragraph) {
+        const content = paragraph.getContent();
+        for (const item of content) {
+            if (item instanceof Hyperlink_1.Hyperlink && item.isExternal() && !item.getRelationshipId()) {
+                const url = item.getUrl();
+                if (url) {
+                    const relationship = this.relationshipManager.addHyperlink(url);
+                    item.setRelationshipId(relationship.getId());
+                }
+            }
+        }
+    }
+    saveImages() {
+        const images = this.imageManager.getAllImages();
+        for (const entry of images) {
+            const imageData = entry.image.getImageData();
+            if (imageData && imageData.length > 0) {
+                const path = `word/media/${entry.filename}`;
+                this.zipHandler.addFile(path, imageData);
+            }
+        }
+    }
+    saveHeaders() {
+        const headers = this.headerFooterManager.getAllHeaders();
+        for (const entry of headers) {
+            const xml = entry.header.toXML();
+            const path = `word/${entry.filename}`;
+            this.zipHandler.addFile(path, xml);
+        }
+    }
+    saveFooters() {
+        const footers = this.headerFooterManager.getAllFooters();
+        for (const entry of footers) {
+            const xml = entry.footer.toXML();
+            const path = `word/${entry.filename}`;
+            this.zipHandler.addFile(path, xml);
+        }
+    }
+    updateRelationships() {
+        const xml = this.relationshipManager.generateXml();
+        this.zipHandler.updateFile('word/_rels/document.xml.rels', xml);
+    }
+    saveComments() {
+        if (this.commentManager.getCount() > 0) {
+            const xml = this.commentManager.generateCommentsXml();
+            this.zipHandler.addFile('word/comments.xml', xml);
+            this.relationshipManager.addComments();
+        }
+    }
+    updateContentTypesWithImagesHeadersFootersAndComments() {
+        const contentTypes = this.generateContentTypesWithImagesHeadersFootersAndComments();
+        this.zipHandler.updateFile(types_1.DOCX_PATHS.CONTENT_TYPES, contentTypes);
+    }
+    generateContentTypesWithImagesHeadersFootersAndComments() {
+        const images = this.imageManager.getAllImages();
+        const headers = this.headerFooterManager.getAllHeaders();
+        const footers = this.headerFooterManager.getAllFooters();
+        const hasComments = this.commentManager.getCount() > 0;
+        const extensions = new Set();
+        for (const entry of images) {
+            extensions.add(entry.image.getExtension());
+        }
+        let xml = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n';
+        xml += '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">\n';
+        xml += '  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>\n';
+        xml += '  <Default Extension="xml" ContentType="application/xml"/>\n';
+        for (const ext of extensions) {
+            const mimeType = ImageManager_1.ImageManager.getMimeType(ext);
+            xml += `  <Default Extension="${ext}" ContentType="${mimeType}"/>\n`;
+        }
+        xml += '  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>\n';
+        xml += '  <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>\n';
+        xml += '  <Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>\n';
+        for (const entry of headers) {
+            xml += `  <Override PartName="/word/${entry.filename}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml"/>\n`;
+        }
+        for (const entry of footers) {
+            xml += `  <Override PartName="/word/${entry.filename}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/>\n`;
+        }
+        if (hasComments) {
+            xml += '  <Override PartName="/word/comments.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>\n';
+        }
+        xml += '  <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>\n';
+        xml += '  <Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>\n';
+        xml += '</Types>';
+        return xml;
+    }
+    getBookmarkManager() {
+        return this.bookmarkManager;
+    }
+    createBookmark(name) {
+        return this.bookmarkManager.createBookmark(name);
+    }
+    createHeadingBookmark(headingText) {
+        return this.bookmarkManager.createHeadingBookmark(headingText);
+    }
+    getBookmark(name) {
+        return this.bookmarkManager.getBookmark(name);
+    }
+    hasBookmark(name) {
+        return this.bookmarkManager.hasBookmark(name);
+    }
+    addBookmarkToParagraph(paragraph, bookmarkOrName) {
+        const bookmark = typeof bookmarkOrName === 'string'
+            ? this.createBookmark(bookmarkOrName)
+            : bookmarkOrName;
+        paragraph.addBookmark(bookmark);
+        return bookmark;
+    }
+    getRevisionManager() {
+        return this.revisionManager;
+    }
+    createInsertion(author, content, date) {
+        const revision = Revision_1.Revision.createInsertion(author, content, date);
+        return this.revisionManager.register(revision);
+    }
+    createDeletion(author, content, date) {
+        const revision = Revision_1.Revision.createDeletion(author, content, date);
+        return this.revisionManager.register(revision);
+    }
+    createRevisionFromText(type, author, text, date) {
+        const revision = Revision_1.Revision.fromText(type, author, text, date);
+        return this.revisionManager.register(revision);
+    }
+    trackInsertion(paragraph, author, text, date) {
+        const revision = this.createRevisionFromText('insert', author, text, date);
+        paragraph.addRevision(revision);
+        return revision;
+    }
+    trackDeletion(paragraph, author, text, date) {
+        const revision = this.createRevisionFromText('delete', author, text, date);
+        paragraph.addRevision(revision);
+        return revision;
+    }
+    isTrackingChanges() {
+        return this.revisionManager.isTrackingChanges();
+    }
+    getRevisionStats() {
+        return this.revisionManager.getStats();
+    }
+    getCommentManager() {
+        return this.commentManager;
+    }
+    createComment(author, content, initials) {
+        return this.commentManager.createComment(author, content, initials);
+    }
+    createReply(parentCommentId, author, content, initials) {
+        return this.commentManager.createReply(parentCommentId, author, content, initials);
+    }
+    getComment(id) {
+        return this.commentManager.getComment(id);
+    }
+    getAllComments() {
+        return this.commentManager.getAllComments();
+    }
+    addCommentToParagraph(paragraph, commentOrAuthor, content, initials) {
+        const comment = typeof commentOrAuthor === 'string'
+            ? this.createComment(commentOrAuthor, content, initials)
+            : commentOrAuthor;
+        paragraph.addComment(comment);
+        return comment;
+    }
+    getCommentStats() {
+        return this.commentManager.getStats();
+    }
+    hasNoComments() {
+        return this.commentManager.isEmpty();
+    }
+    hasComments() {
+        return !this.commentManager.isEmpty();
+    }
+    getCommentThread(commentId) {
+        return this.commentManager.getCommentThread(commentId);
+    }
+    findCommentsByText(searchText) {
+        return this.commentManager.findCommentsByText(searchText);
+    }
+    getRecentComments(count) {
+        return this.commentManager.getRecentComments(count);
+    }
+    hasNoRevisions() {
+        return this.revisionManager.isEmpty();
+    }
+    hasRevisions() {
+        return !this.revisionManager.isEmpty();
+    }
+    getRecentRevisions(count) {
+        return this.revisionManager.getRecentRevisions(count);
+    }
+    findRevisionsByText(searchText) {
+        return this.revisionManager.findRevisionsByText(searchText);
+    }
+    getAllInsertions() {
+        return this.revisionManager.getAllInsertions();
+    }
+    getAllDeletions() {
+        return this.revisionManager.getAllDeletions();
+    }
+    getParseWarnings() {
+        return [...this.parseErrors];
+    }
+    checkMemoryThreshold() {
+        const { heapUsed, heapTotal } = process.memoryUsage();
+        const usagePercent = (heapUsed / heapTotal) * 100;
+        if (usagePercent > this.maxMemoryUsagePercent) {
+            throw new Error(`Memory usage critical (${usagePercent.toFixed(1)}% of ${(heapTotal / 1024 / 1024).toFixed(0)}MB heap). ` +
+                `Cannot process document safely. Consider:\n` +
+                `- Reducing document size\n` +
+                `- Optimizing/compressing images\n` +
+                `- Splitting into multiple documents\n` +
+                `- Increasing Node.js heap size (--max-old-space-size)`);
+        }
+    }
+    estimateSize() {
+        const paragraphCount = this.getParagraphCount();
+        const tableCount = this.getTableCount();
+        const imageCount = this.imageManager.getImageCount();
+        const estimatedXml = (paragraphCount * 200) + (tableCount * 1000) + 50000;
+        const imageBytes = this.imageManager.getTotalSize();
+        const totalBytes = estimatedXml + imageBytes;
+        const totalMB = totalBytes / (1024 * 1024);
+        const WARNING_MB = 50;
+        const ERROR_MB = 100;
+        let warning;
+        if (totalMB > ERROR_MB) {
+            warning = `Document size (${totalMB.toFixed(1)}MB) exceeds recommended maximum of ${ERROR_MB}MB. ` +
+                `This may cause memory issues. Consider splitting into multiple documents or optimizing images.`;
+        }
+        else if (totalMB > WARNING_MB) {
+            warning = `Document size (${totalMB.toFixed(1)}MB) exceeds ${WARNING_MB}MB. ` +
+                `Large documents may take longer to process and use significant memory.`;
+        }
+        return {
+            paragraphs: paragraphCount,
+            tables: tableCount,
+            images: imageCount,
+            estimatedXmlBytes: estimatedXml,
+            imageBytes,
+            totalEstimatedBytes: totalBytes,
+            totalEstimatedMB: parseFloat(totalMB.toFixed(2)),
+            warning,
+        };
+    }
+    dispose() {
+        this.bodyElements = [];
+        this.parseErrors = [];
+        this.stylesManager = StylesManager_1.StylesManager.create();
+        this.numberingManager = NumberingManager_1.NumberingManager.create();
+        this.imageManager.clear();
+        this.imageManager.releaseAllImageData();
+        this.relationshipManager = RelationshipManager_1.RelationshipManager.create();
+        this.headerFooterManager = HeaderFooterManager_1.HeaderFooterManager.create();
+        this.bookmarkManager.clear();
+        this.revisionManager.clear();
+        this.commentManager.clear();
+    }
+    getSizeStats() {
+        const estimate = this.estimateSize();
+        const warnings = [];
+        if (estimate.warning) {
+            warnings.push(estimate.warning);
+        }
+        const formatBytes = (bytes) => {
+            if (bytes < 1024)
+                return `${bytes} B`;
+            if (bytes < 1024 * 1024)
+                return `${(bytes / 1024).toFixed(1)} KB`;
+            return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+        };
+        return {
+            elements: {
+                paragraphs: estimate.paragraphs,
+                tables: estimate.tables,
+                images: estimate.images,
+            },
+            size: {
+                xml: formatBytes(estimate.estimatedXmlBytes),
+                images: formatBytes(estimate.imageBytes),
+                total: formatBytes(estimate.totalEstimatedBytes),
+            },
+            warnings,
+        };
+    }
+}
+exports.Document = Document;
+//# sourceMappingURL=Document.js.map