@gmickel/gno 1.45.1 → 2.0.0

package/vendor/converters/officeparser/dist/utils/xmlUtils.d.ts

@@ -0,0 +1,163 @@
+/**
+ * XML Parsing Utilities
+ *
+ * Provides helper functions for parsing and navigating XML documents.
+ * Used extensively by OOXML parsers (DOCX, XLSX, PPTX) and OpenOffice parsers (ODT, ODP, ODS).
+ *
+ * OOXML (Office Open XML) is an XML-based format used by Microsoft Office.
+ * Documents are ZIP archives containing multiple XML files describing structure, content, and formatting.
+ *
+ * @module xmlUtils
+ */
+import { OfficeMetadata } from '../types';
+/**
+ * Type guard for Element nodes.
+ */
+export declare const isElement: (node: Node) => node is Element;
+/**
+ * Parses an XML string into a DOM Document object.
+ *
+ * Uses the @xmldom/xmldom library to parse XML strings in a Node.js environment.
+ *
+ * @param xml - The XML content as a string
+ * @param options - Optional parser settings (e.g., enable locators for source mapping)
+ * @returns A Document object that can be queried using standard DOM methods
+ */
+export declare const parseXmlString: (xml: string, options?: {
+    locator?: boolean;
+}) => Document;
+/**
+ * Gets all elements with a specific tag name and returns them as an array.
+ *
+ * This is a convenience wrapper around the DOM API's getElementsByTagName method
+ * that converts the HTMLCollection/NodeList to a proper JavaScript array for easier manipulation.
+ *
+ * @param element - The element or document to search within
+ * @param tagName - The tag name to search for (e.g., 'w:t', 'w:p', 'item')
+ * @returns An array of matching elements (empty array if none found)
+ * @example
+ * ```typescript
+ * const paragraphs = getElementsByTagName(doc, 'w:p');
+ * paragraphs.forEach(p => console.log(p.textContent));
+ * ```
+ */
+export declare const getElementsByTagName: (element: Element | Document, tagName: string) => Element[];
+export declare const serializeXml: (node: Node, options?: {
+    preserveWhitespace?: boolean;
+}) => string;
+/**
+ * Attempts to extract the original raw substring from the source XML for a given node.
+ * Requires the document to have been parsed with { locator: true }.
+ *
+ * @param node - The DOM node to extract source for
+ * @param sourceXml - The original XML source string
+ * @returns The raw XML substring, or undefined if it cannot be reliably determined
+ */
+export declare const getSourceSubstring: (node: any, sourceXml: string) => string | undefined;
+/**
+ * High-level helper to get raw content for a node based on OfficeParserConfig.
+ *
+ * @param node - The DOM node
+ * @param sourceXml - The original source XML string
+ * @param config - The parser configuration
+ * @returns The raw content string (serialized or original)
+ */
+export declare const getRawContent: (node: Node, sourceXml: string, config: {
+    serializeRawContent?: boolean;
+    preserveXmlWhitespace?: boolean;
+}) => string;
+/**
+ * Gets the first element with the specified tag name within a parent element.
+ *
+ * @param parent - The parent element or document to search within
+ * @param tagName - The tag name to search for
+ * @returns The first matching element, or undefined if none found
+ */
+export declare const getFirstElementByTagName: (parent: Element | Document, tagName: string) => Element | undefined;
+/**
+ * Gets the value of an attribute from an element.
+ *
+ * @param element - The element to get the attribute from
+ * @param attrName - The name of the attribute
+ * @returns The attribute value or undefined if not set
+ */
+export declare const getAttribute: (element: Element, attrName: string) => string | undefined;
+/**
+ * Gets direct child elements with a specific tag name.
+ * Unlike getElementsByTagName, this does not search recursively.
+ *
+ * @param parent - The parent element
+ * @param tagName - The tag name to search for
+ * @returns An array of matching direct child elements
+ */
+export declare const getDirectChildren: (parent: Element, tagName: string) => Element[];
+/**
+ * Parses OOXML document metadata from the docProps/core.xml file.
+ *
+ * OOXML documents (DOCX, XLSX, PPTX) store metadata in a standard location:
+ * `docProps/core.xml` within the ZIP archive.
+ *
+ * This file follows the Dublin Core metadata standard with OOXML-specific extensions.
+ * Common metadata elements:
+ * - dc:title - Document title
+ * - dc:creator - Original author
+ * - cp:lastModifiedBy - User who last modified the document
+ * - dcterms:created - Creation timestamp
+ * - dcterms:modified - Last modification timestamp
+ *
+ * @param xmlContent - The raw XML content string from docProps/core.xml
+ * @returns An OfficeMetadata object with extracted properties (empty object if parsing fails)
+ * @example
+ * ```typescript
+ * const coreXml = files.find(f => f.path === 'docProps/core.xml').content.toString();
+ * const metadata = parseOfficeMetadata(coreXml);
+ *
+ * console.log(metadata.author); // "John Smith"
+ * console.log(metadata.title); // "Annual Report"
+ * console.log(metadata.created); // Date object
+ * ```
+ *
+ * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oe376/6c085e39-c695-4f83-91e8-3f277bb4e111
+ */
+export declare const parseOfficeMetadata: (xmlContent: string) => OfficeMetadata;
+/**
+ * Parses OOXML custom document properties from `docProps/custom.xml`.
+ *
+ * Custom properties are user-defined key/value pairs that authors can attach to OOXML documents
+ * (DOCX, XLSX, PPTX). They are stored in `docProps/custom.xml` inside the ZIP archive.
+ *
+ * Property values are typed using the `vt:` namespace (docPropsVTypes):
+ * - `vt:lpwstr` / `vt:lpstr` / `vt:bstr` → string
+ * - `vt:bool` → boolean
+ * - `vt:i1`..`vt:i8`, `vt:int`, `vt:r4`, `vt:r8`, `vt:decimal` → number
+ * - `vt:filetime` / `vt:date` → Date
+ *
+ * @param xmlContent - Raw XML string from `docProps/custom.xml`
+ * @returns A record of property name → typed value (empty object if none found)
+ * @example
+ * ```typescript
+ * const customXml = files.find(f => f.path === 'docProps/custom.xml').content.toString();
+ * const props = parseOOXMLCustomProperties(customXml);
+ * console.log(props['Department']); // "Engineering"
+ * console.log(props['Priority']);   // 1  (number)
+ * console.log(props['Reviewed']);   // true (boolean)
+ * ```
+ */
+export declare const parseOOXMLCustomProperties: (xmlContent: string) => Record<string, string | number | boolean | Date>;
+/**
+ * Parses OOXML application properties from `docProps/app.xml`.
+ *
+ * Application properties contain document statistics and application settings.
+ *
+ * @param xmlContent - Raw XML string from `docProps/app.xml`
+ * @returns A record of property name -> typed value
+ */
+export declare const parseOOXMLAppProperties: (xmlContent: string) => Record<string, string | number | boolean>;
+/**
+ * Decodes XML entities (standard named entities, decimal, and hexadecimal entities) in a string.
+ * Useful when parsing content with regular expressions instead of a full DOM parser.
+ *
+ * @param text - The XML-encoded string
+ * @returns The decoded string
+ */
+export declare const decodeXmlEntities: (text: string) => string;

package/vendor/converters/officeparser/dist/utils/xmlUtils.js

@@ -0,0 +1,461 @@
+"use strict";
+/**
+ * XML Parsing Utilities
+ *
+ * Provides helper functions for parsing and navigating XML documents.
+ * Used extensively by OOXML parsers (DOCX, XLSX, PPTX) and OpenOffice parsers (ODT, ODP, ODS).
+ *
+ * OOXML (Office Open XML) is an XML-based format used by Microsoft Office.
+ * Documents are ZIP archives containing multiple XML files describing structure, content, and formatting.
+ *
+ * @module xmlUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeXmlEntities = exports.parseOOXMLAppProperties = exports.parseOOXMLCustomProperties = exports.parseOfficeMetadata = exports.getDirectChildren = exports.getAttribute = exports.getFirstElementByTagName = exports.getRawContent = exports.getSourceSubstring = exports.serializeXml = exports.getElementsByTagName = exports.parseXmlString = exports.isElement = void 0;
+const xmldom_1 = require("@xmldom/xmldom");
+const dateUtils_js_1 = require("./dateUtils.js");
+/**
+ * Type guard for Element nodes.
+ */
+const isElement = (node) => {
+    return node.nodeType === 1;
+};
+exports.isElement = isElement;
+/**
+ * Parses an XML string into a DOM Document object.
+ *
+ * Uses the @xmldom/xmldom library to parse XML strings in a Node.js environment.
+ *
+ * @param xml - The XML content as a string
+ * @param options - Optional parser settings (e.g., enable locators for source mapping)
+ * @returns A Document object that can be queried using standard DOM methods
+ */
+const parseXmlString = (xml, options = {}) => {
+    const parser = new xmldom_1.DOMParser(options);
+    // @xmldom/xmldom 0.9.x is strict: a UTF-8 BOM (U+FEFF) prepended to the
+    // XML string causes a fatalError because the XML declaration is no longer
+    // at position 0. Strip it before parsing.
+    const sanitized = xml.charCodeAt(0) === 0xFEFF ? xml.slice(1) : xml.trim();
+    return parser.parseFromString(sanitized, "text/xml");
+};
+exports.parseXmlString = parseXmlString;
+/**
+ * Gets all elements with a specific tag name and returns them as an array.
+ *
+ * This is a convenience wrapper around the DOM API's getElementsByTagName method
+ * that converts the HTMLCollection/NodeList to a proper JavaScript array for easier manipulation.
+ *
+ * @param element - The element or document to search within
+ * @param tagName - The tag name to search for (e.g., 'w:t', 'w:p', 'item')
+ * @returns An array of matching elements (empty array if none found)
+ * @example
+ * ```typescript
+ * const paragraphs = getElementsByTagName(doc, 'w:p');
+ * paragraphs.forEach(p => console.log(p.textContent));
+ * ```
+ */
+const getElementsByTagName = (element, tagName) => {
+    const results = Array.from(element.getElementsByTagName(tagName));
+    // Resilience: If prefixed tag (e.g., 'dc:title') not found, try local name (e.g., 'title')
+    if (results.length === 0 && tagName.includes(':')) {
+        const localName = tagName.split(':').pop();
+        return Array.from(element.getElementsByTagName(localName));
+    }
+    return results;
+};
+exports.getElementsByTagName = getElementsByTagName;
+/**
+ * Serializes a DOM Node (Document, Element, etc.) back into an XML string.
+ * This is cross-platform and works in both Node.js and Browser environments.
+ *
+ * @param node - The DOM node to serialize
+ * @param options - Serialization options
+ * @returns The XML string representation
+ */
+const serializer = new xmldom_1.XMLSerializer();
+const serializeXml = (node, options = {}) => {
+    // Note: xmldom's XMLSerializer doesn't natively support a 'pretty' or 'preserve' 
+    // flag in a way that matches all user expectations, but it defaults to 
+    // preserving structure. Formatting (indentation) is usually handled by the 
+    // parser's initial whitespace handling.
+    // @ts-ignore - xmldom's Node is compatible with the global Node interface
+    return serializer.serializeToString(node);
+};
+exports.serializeXml = serializeXml;
+/**
+ * Attempts to extract the original raw substring from the source XML for a given node.
+ * Requires the document to have been parsed with { locator: true }.
+ *
+ * @param node - The DOM node to extract source for
+ * @param sourceXml - The original XML source string
+ * @returns The raw XML substring, or undefined if it cannot be reliably determined
+ */
+const getSourceSubstring = (node, sourceXml) => {
+    if (!node || typeof node.lineNumber !== 'number' || typeof node.columnNumber !== 'number') {
+        return undefined;
+    }
+    // Convert line/column to absolute index
+    const lines = sourceXml.split('\n');
+    let startIdx = 0;
+    for (let i = 0; i < node.lineNumber - 1; i++) {
+        startIdx += lines[i].length + 1; // +1 for newline
+    }
+    startIdx += node.columnNumber - 1;
+    // To find the end of the node, we look for the closing tag.
+    // This is a heuristic approach that works well for simple structured nodes (p, tbl, etc.)
+    // but might be complex for overlapping namespaces or malformed XML.
+    if ((0, exports.isElement)(node)) {
+        const tagName = node.tagName;
+        const closingTag = `</${tagName}>`;
+        const endIdx = sourceXml.indexOf(closingTag, startIdx);
+        if (endIdx !== -1) {
+            return sourceXml.substring(startIdx, endIdx + closingTag.length);
+        }
+        // Self-closing tag handling (e.g., <w:p/>)
+        const selfClosingEnd = sourceXml.indexOf('/>', startIdx);
+        const nextOpenTag = sourceXml.indexOf('<', startIdx + 1);
+        if (selfClosingEnd !== -1 && (nextOpenTag === -1 || selfClosingEnd < nextOpenTag)) {
+            return sourceXml.substring(startIdx, selfClosingEnd + 2);
+        }
+    }
+    return undefined;
+};
+exports.getSourceSubstring = getSourceSubstring;
+/**
+ * High-level helper to get raw content for a node based on OfficeParserConfig.
+ *
+ * @param node - The DOM node
+ * @param sourceXml - The original source XML string
+ * @param config - The parser configuration
+ * @returns The raw content string (serialized or original)
+ */
+const getRawContent = (node, sourceXml, config) => {
+    if (config.serializeRawContent === false) {
+        const original = (0, exports.getSourceSubstring)(node, sourceXml);
+        if (original)
+            return original;
+    }
+    return (0, exports.serializeXml)(node, { preserveWhitespace: config.preserveXmlWhitespace });
+};
+exports.getRawContent = getRawContent;
+/**
+ * Gets the first element with the specified tag name within a parent element.
+ *
+ * @param parent - The parent element or document to search within
+ * @param tagName - The tag name to search for
+ * @returns The first matching element, or undefined if none found
+ */
+const getFirstElementByTagName = (parent, tagName) => {
+    const elements = parent.getElementsByTagName(tagName);
+    if (elements && elements.length > 0) {
+        return elements[0];
+    }
+    return undefined;
+};
+exports.getFirstElementByTagName = getFirstElementByTagName;
+/**
+ * Gets the value of an attribute from an element.
+ *
+ * @param element - The element to get the attribute from
+ * @param attrName - The name of the attribute
+ * @returns The attribute value or undefined if not set
+ */
+const getAttribute = (element, attrName) => {
+    const attr = element.getAttribute(attrName);
+    return attr !== null ? attr : undefined;
+};
+exports.getAttribute = getAttribute;
+/**
+ * Gets direct child elements with a specific tag name.
+ * Unlike getElementsByTagName, this does not search recursively.
+ *
+ * @param parent - The parent element
+ * @param tagName - The tag name to search for
+ * @returns An array of matching direct child elements
+ */
+const getDirectChildren = (parent, tagName) => {
+    const result = [];
+    if (!parent.childNodes)
+        return result;
+    for (let i = 0; i < parent.childNodes.length; i++) {
+        const child = parent.childNodes[i];
+        if ((0, exports.isElement)(child) && child.tagName === tagName) {
+            result.push(child);
+        }
+    }
+    return result;
+};
+exports.getDirectChildren = getDirectChildren;
+/**
+ * Parses OOXML document metadata from the docProps/core.xml file.
+ *
+ * OOXML documents (DOCX, XLSX, PPTX) store metadata in a standard location:
+ * `docProps/core.xml` within the ZIP archive.
+ *
+ * This file follows the Dublin Core metadata standard with OOXML-specific extensions.
+ * Common metadata elements:
+ * - dc:title - Document title
+ * - dc:creator - Original author
+ * - cp:lastModifiedBy - User who last modified the document
+ * - dcterms:created - Creation timestamp
+ * - dcterms:modified - Last modification timestamp
+ *
+ * @param xmlContent - The raw XML content string from docProps/core.xml
+ * @returns An OfficeMetadata object with extracted properties (empty object if parsing fails)
+ * @example
+ * ```typescript
+ * const coreXml = files.find(f => f.path === 'docProps/core.xml').content.toString();
+ * const metadata = parseOfficeMetadata(coreXml);
+ *
+ * console.log(metadata.author); // "John Smith"
+ * console.log(metadata.title); // "Annual Report"
+ * console.log(metadata.created); // Date object
+ * ```
+ *
+ * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oe376/6c085e39-c695-4f83-91e8-3f277bb4e111
+ */
+const parseOfficeMetadata = (xmlContent) => {
+    // Step 1: Parse the XML content into a DOM document
+    const xml = (0, exports.parseXmlString)(xmlContent);
+    const metadata = {};
+    // Check for OOXML Core Properties
+    const coreProperties = (0, exports.getElementsByTagName)(xml, "cp:coreProperties")[0];
+    if (coreProperties) {
+        metadata.nativeProperties = {};
+        for (let i = 0; i < coreProperties.childNodes.length; i++) {
+            const child = coreProperties.childNodes[i];
+            if ((0, exports.isElement)(child)) {
+                metadata.nativeProperties[child.tagName] = child.textContent;
+            }
+        }
+        // Step 3: Extract title (Dublin Core element)
+        const title = (0, exports.getElementsByTagName)(coreProperties, "dc:title")[0];
+        if (title && title.textContent)
+            metadata.title = title.textContent;
+        // Step 4: Extract author/creator (Dublin Core element)
+        const author = (0, exports.getElementsByTagName)(coreProperties, "dc:creator")[0];
+        if (author && author.textContent)
+            metadata.author = author.textContent;
+        // Step 5: Extract last modifier (OOXML Core Properties element)
+        const lastModifiedBy = (0, exports.getElementsByTagName)(coreProperties, "cp:lastModifiedBy")[0];
+        if (lastModifiedBy && lastModifiedBy.textContent)
+            metadata.lastModifiedBy = lastModifiedBy.textContent;
+        // Step 6: Extract creation date (Dublin Core Terms element)
+        const created = (0, exports.getElementsByTagName)(coreProperties, "dcterms:created")[0];
+        if (created && created.textContent)
+            metadata.created = (0, dateUtils_js_1.parseOfficeDate)(created.textContent);
+        // Step 7: Extract last modification date (Dublin Core Terms element)
+        const modified = (0, exports.getElementsByTagName)(coreProperties, "dcterms:modified")[0];
+        if (modified && modified.textContent)
+            metadata.modified = (0, dateUtils_js_1.parseOfficeDate)(modified.textContent);
+        // Step 8: Extract description and subject (Dublin Core elements)
+        const description = (0, exports.getElementsByTagName)(coreProperties, "dc:description")[0];
+        if (description && description.textContent)
+            metadata.description = description.textContent;
+        const subject = (0, exports.getElementsByTagName)(coreProperties, "dc:subject")[0];
+        if (subject && subject.textContent)
+            metadata.subject = subject.textContent;
+        const keywords = (0, exports.getElementsByTagName)(coreProperties, "cp:keywords")[0];
+        if (keywords && keywords.textContent)
+            metadata.keywords = keywords.textContent;
+        return metadata;
+    }
+    // Check for ODF Meta
+    const officeMeta = (0, exports.getElementsByTagName)(xml, "office:meta")[0];
+    if (officeMeta) {
+        metadata.nativeProperties = {};
+        for (let i = 0; i < officeMeta.childNodes.length; i++) {
+            const child = officeMeta.childNodes[i];
+            if ((0, exports.isElement)(child)) {
+                metadata.nativeProperties[child.tagName] = child.textContent;
+            }
+        }
+        const title = (0, exports.getElementsByTagName)(officeMeta, "dc:title")[0];
+        if (title && title.textContent)
+            metadata.title = title.textContent;
+        const author = (0, exports.getElementsByTagName)(officeMeta, "dc:creator")[0];
+        if (author && author.textContent)
+            metadata.author = author.textContent;
+        const description = (0, exports.getElementsByTagName)(officeMeta, "dc:description")[0];
+        if (description && description.textContent)
+            metadata.description = description.textContent;
+        const subject = (0, exports.getElementsByTagName)(officeMeta, "dc:subject")[0];
+        if (subject && subject.textContent)
+            metadata.subject = subject.textContent;
+        const keywordElements = (0, exports.getElementsByTagName)(officeMeta, "meta:keyword");
+        if (keywordElements.length > 0) {
+            metadata.keywords = keywordElements.map(k => k.textContent).filter(Boolean).join(', ');
+        }
+        const created = (0, exports.getElementsByTagName)(officeMeta, "meta:creation-date")[0];
+        if (created && created.textContent)
+            metadata.created = (0, dateUtils_js_1.parseOfficeDate)(created.textContent);
+        const modified = (0, exports.getElementsByTagName)(officeMeta, "dc:date")[0];
+        if (modified && modified.textContent)
+            metadata.modified = (0, dateUtils_js_1.parseOfficeDate)(modified.textContent);
+        // Extract user-defined custom properties (meta:user-defined)
+        const userDefined = (0, exports.getElementsByTagName)(officeMeta, "meta:user-defined");
+        if (userDefined.length > 0) {
+            const customProperties = {};
+            for (const el of userDefined) {
+                const name = el.getAttribute("meta:name");
+                if (!name || !el.textContent)
+                    continue;
+                const valueType = el.getAttribute("meta:value-type") || "string";
+                const raw = el.textContent;
+                if (valueType === "boolean") {
+                    customProperties[name] = raw.toLowerCase() === "true";
+                }
+                else if (valueType === "float") {
+                    const num = Number(raw);
+                    if (!isNaN(num))
+                        customProperties[name] = num;
+                }
+                else if (valueType === "date" || valueType === "time") {
+                    const date = (0, dateUtils_js_1.parseOfficeDate)(raw);
+                    if (date)
+                        customProperties[name] = date;
+                    else
+                        customProperties[name] = raw;
+                }
+                else {
+                    customProperties[name] = raw;
+                }
+            }
+            if (Object.keys(customProperties).length > 0) {
+                metadata.customProperties = customProperties;
+            }
+        }
+    }
+    return metadata;
+};
+exports.parseOfficeMetadata = parseOfficeMetadata;
+/**
+ * Parses OOXML custom document properties from `docProps/custom.xml`.
+ *
+ * Custom properties are user-defined key/value pairs that authors can attach to OOXML documents
+ * (DOCX, XLSX, PPTX). They are stored in `docProps/custom.xml` inside the ZIP archive.
+ *
+ * Property values are typed using the `vt:` namespace (docPropsVTypes):
+ * - `vt:lpwstr` / `vt:lpstr` / `vt:bstr` → string
+ * - `vt:bool` → boolean
+ * - `vt:i1`..`vt:i8`, `vt:int`, `vt:r4`, `vt:r8`, `vt:decimal` → number
+ * - `vt:filetime` / `vt:date` → Date
+ *
+ * @param xmlContent - Raw XML string from `docProps/custom.xml`
+ * @returns A record of property name → typed value (empty object if none found)
+ * @example
+ * ```typescript
+ * const customXml = files.find(f => f.path === 'docProps/custom.xml').content.toString();
+ * const props = parseOOXMLCustomProperties(customXml);
+ * console.log(props['Department']); // "Engineering"
+ * console.log(props['Priority']);   // 1  (number)
+ * console.log(props['Reviewed']);   // true (boolean)
+ * ```
+ */
+const parseOOXMLCustomProperties = (xmlContent) => {
+    const xml = (0, exports.parseXmlString)(xmlContent);
+    const result = {};
+    const properties = (0, exports.getElementsByTagName)(xml, "property");
+    for (const prop of properties) {
+        const name = prop.getAttribute("name");
+        if (!name)
+            continue;
+        // The value is the first child element (typed using vt: namespace)
+        for (let i = 0; i < prop.childNodes.length; i++) {
+            const child = prop.childNodes[i];
+            if (child.nodeType !== 1)
+                continue; // skip non-elements
+            const el = child;
+            const tag = el.tagName || '';
+            const text = el.textContent || '';
+            if (/vt:lpwstr|vt:lpstr|vt:bstr/.test(tag)) {
+                result[name] = text;
+            }
+            else if (/vt:bool/.test(tag)) {
+                result[name] = text.toLowerCase() === 'true';
+            }
+            else if (/vt:(i[1248]|ui[1248]|int|uint|r4|r8|decimal)/.test(tag)) {
+                const num = Number(text);
+                if (!isNaN(num))
+                    result[name] = num;
+            }
+            else if (/vt:filetime|vt:date/.test(tag)) {
+                const date = (0, dateUtils_js_1.parseOfficeDate)(text);
+                if (date)
+                    result[name] = date;
+                else
+                    result[name] = text;
+            }
+            else if (text) {
+                // Fallback: store as string for any other vt: type
+                result[name] = text;
+            }
+            break; // only one value element per property
+        }
+    }
+    return result;
+};
+exports.parseOOXMLCustomProperties = parseOOXMLCustomProperties;
+/**
+ * Parses OOXML application properties from `docProps/app.xml`.
+ *
+ * Application properties contain document statistics and application settings.
+ *
+ * @param xmlContent - Raw XML string from `docProps/app.xml`
+ * @returns A record of property name -> typed value
+ */
+const parseOOXMLAppProperties = (xmlContent) => {
+    const xml = (0, exports.parseXmlString)(xmlContent);
+    const result = {};
+    const appProperties = (0, exports.getElementsByTagName)(xml, "Properties")[0];
+    if (appProperties) {
+        for (let i = 0; i < appProperties.childNodes.length; i++) {
+            const child = appProperties.childNodes[i];
+            if ((0, exports.isElement)(child)) {
+                const text = child.textContent || '';
+                if (text.toLowerCase() === 'true')
+                    result[child.tagName] = true;
+                else if (text.toLowerCase() === 'false')
+                    result[child.tagName] = false;
+                else if (!isNaN(Number(text)) && text.trim() !== '')
+                    result[child.tagName] = Number(text);
+                else
+                    result[child.tagName] = text;
+            }
+        }
+    }
+    return result;
+};
+exports.parseOOXMLAppProperties = parseOOXMLAppProperties;
+/**
+ * Decodes XML entities (standard named entities, decimal, and hexadecimal entities) in a string.
+ * Useful when parsing content with regular expressions instead of a full DOM parser.
+ *
+ * @param text - The XML-encoded string
+ * @returns The decoded string
+ */
+const decodeXmlEntities = (text) => {
+    return text.replace(/&([^;]+);/g, (match, entity) => {
+        if (entity.startsWith('#')) {
+            if (entity[1] === 'x' || entity[1] === 'X') {
+                const hex = entity.slice(2);
+                const code = parseInt(hex, 16);
+                return (!isNaN(code) && code >= 0 && code <= 0x10FFFF) ? String.fromCodePoint(code) : match;
+            }
+            else {
+                const dec = entity.slice(1);
+                const code = parseInt(dec, 10);
+                return (!isNaN(code) && code >= 0 && code <= 0x10FFFF) ? String.fromCodePoint(code) : match;
+            }
+        }
+        switch (entity) {
+            case 'amp': return '&';
+            case 'lt': return '<';
+            case 'gt': return '>';
+            case 'quot': return '"';
+            case 'apos': return "'";
+            default: return match;
+        }
+    });
+};
+exports.decodeXmlEntities = decodeXmlEntities;