@bendyline/squisq-formats 1.3.0 → 1.4.0

package/dist/docx/import.js

@@ -1,779 +0,0 @@
-/**
- * DOCX Import
- *
- * Parses a .docx file (Office Open XML WordprocessingML) and converts
- * its content into a squisq MarkdownDocument (or Doc).
- *
- * Uses JSZip + DOMParser to read the archive and parse the XML — no
- * third-party docx library. Handles headings, paragraphs, inline
- * formatting (bold, italic, strikethrough), hyperlinks, lists, tables,
- * blockquotes, code blocks, images, and footnotes.
- *
- * @example
- * ```ts
- * import { docxToMarkdownDoc } from '@bendyline/squisq-formats/docx';
- *
- * const response = await fetch('document.docx');
- * const data = await response.arrayBuffer();
- * const doc = await docxToMarkdownDoc(data);
- * ```
- */
-import { markdownToDoc } from '@bendyline/squisq/doc';
-import { openPackage, getPartXml, getPartBinary, getPartRelationships } from '../ooxml/reader.js';
-import { NS_WML, NS_R } from '../ooxml/namespaces.js';
-import { MemoryContentContainer } from '@bendyline/squisq/storage';
-import { HEADING_STYLE_MAP, QUOTE_STYLE_IDS, CODE_STYLE_IDS, INLINE_CODE_STYLE_IDS, BULLET_NUM_FORMATS, } from './styles.js';
-/**
- * Convert a .docx file to a MarkdownDocument.
- *
- * @param data - The raw .docx file as ArrayBuffer or Blob
- * @param options - Import options
- * @returns A MarkdownDocument representing the document content
- */
-export async function docxToMarkdownDoc(data, options = {}) {
-    const pkg = await openPackage(data);
-    const ctx = await buildImportContext(pkg, options);
-    const documentXml = await getPartXml(pkg, 'word/document.xml');
-    if (!documentXml) {
-        return { type: 'document', children: [] };
-    }
-    const body = getFirstElement(documentXml, 'body');
-    if (!body) {
-        return { type: 'document', children: [] };
-    }
-    const blocks = await convertBody(body, ctx);
-    return { type: 'document', children: blocks };
-}
-/**
- * Convert a .docx file to a squisq Doc.
- *
- * Convenience wrapper: DOCX → MarkdownDocument → Doc.
- *
- * @param data - The raw .docx file as ArrayBuffer or Blob
- * @param options - Import options
- * @returns A squisq Doc
- */
-export async function docxToDoc(data, options = {}) {
-    const markdownDoc = await docxToMarkdownDoc(data, options);
-    return markdownToDoc(markdownDoc);
-}
-/**
- * Convert a .docx file to a ContentContainer with markdown + extracted images.
- *
- * The container will contain:
- * - The primary markdown document (index.md)
- * - Any embedded images under images/ (e.g., images/image1.png)
- *
- * @param data - The raw .docx file as ArrayBuffer or Blob
- * @param options - Import options
- * @returns A ContentContainer with the document and its media
- */
-export async function docxToContainer(data, options = {}) {
-    const pkg = await openPackage(data);
-    const ctx = await buildImportContext(pkg, { ...options, extractImages: true });
-    const documentXml = await getPartXml(pkg, 'word/document.xml');
-    if (!documentXml) {
-        const container = new MemoryContentContainer();
-        await container.writeDocument('');
-        return container;
-    }
-    const body = getFirstElement(documentXml, 'body');
-    if (!body) {
-        const container = new MemoryContentContainer();
-        await container.writeDocument('');
-        return container;
-    }
-    const blocks = await convertBody(body, ctx);
-    const markdownDoc = { type: 'document', children: blocks };
-    // Serialize to markdown
-    const { stringifyMarkdown } = await import('@bendyline/squisq/markdown');
-    const markdown = stringifyMarkdown(markdownDoc);
-    // Build container with markdown + images
-    const container = new MemoryContentContainer();
-    await container.writeDocument(markdown);
-    for (const [path, { data: imageData, mimeType }] of ctx.extractedImages) {
-        await container.writeFile(path, new Uint8Array(imageData), mimeType);
-    }
-    return container;
-}
-async function buildImportContext(pkg, options) {
-    const ctx = {
-        headingStyles: new Map(),
-        quoteStyles: new Set(),
-        codeStyles: new Set(),
-        inlineCodeStyles: new Set(),
-        documentRels: new Map(),
-        numbering: new Map(),
-        footnotes: new Map(),
-        pkg,
-        options,
-        extractedImages: new Map(),
-        imageCounter: 0,
-    };
-    // Initialize with built-in defaults
-    for (const [id, depth] of Object.entries(HEADING_STYLE_MAP)) {
-        ctx.headingStyles.set(id, depth);
-    }
-    for (const id of QUOTE_STYLE_IDS) {
-        ctx.quoteStyles.add(id);
-    }
-    for (const id of CODE_STYLE_IDS) {
-        ctx.codeStyles.add(id);
-    }
-    for (const id of INLINE_CODE_STYLE_IDS) {
-        ctx.inlineCodeStyles.add(id);
-    }
-    // Parse styles.xml for custom heading/quote/code mappings
-    await parseStyles(pkg, ctx);
-    // Parse document relationships
-    const rels = await getPartRelationships(pkg, 'word/document.xml');
-    for (const rel of rels) {
-        ctx.documentRels.set(rel.id, rel);
-    }
-    // Parse numbering.xml
-    await parseNumbering(pkg, ctx);
-    // Parse footnotes.xml
-    await parseFootnotes(pkg, ctx);
-    return ctx;
-}
-// ============================================
-// Styles Parsing
-// ============================================
-async function parseStyles(pkg, ctx) {
-    const doc = await getPartXml(pkg, 'word/styles.xml');
-    if (!doc)
-        return;
-    const styles = doc.getElementsByTagNameNS(NS_WML, 'style');
-    // Fallback for documents that don't use namespace prefixes properly
-    const stylesList = styles.length > 0 ? styles : doc.getElementsByTagName('style');
-    for (let i = 0; i < stylesList.length; i++) {
-        const style = stylesList[i];
-        const styleId = style.getAttributeNS(NS_WML, 'styleId') ?? style.getAttribute('w:styleId');
-        if (!styleId)
-            continue;
-        const nameEl = getFirstChildElement(style, 'name');
-        const styleName = nameEl?.getAttributeNS(NS_WML, 'val') ?? nameEl?.getAttribute('w:val') ?? '';
-        // Check if this is a heading style by name
-        const headingMatch = styleName.match(/^heading\s+(\d+)$/i);
-        if (headingMatch) {
-            const depth = parseInt(headingMatch[1], 10);
-            if (depth >= 1 && depth <= 6) {
-                ctx.headingStyles.set(styleId, depth);
-            }
-        }
-        // Check pPr > outlineLvl for heading detection
-        const pPr = getFirstChildElement(style, 'pPr');
-        if (pPr) {
-            const outlineLvl = getFirstChildElement(pPr, 'outlineLvl');
-            if (outlineLvl) {
-                const val = outlineLvl.getAttributeNS(NS_WML, 'val') ?? outlineLvl.getAttribute('w:val');
-                if (val !== null) {
-                    const depth = parseInt(val, 10) + 1;
-                    if (depth >= 1 && depth <= 6) {
-                        ctx.headingStyles.set(styleId, depth);
-                    }
-                }
-            }
-        }
-    }
-}
-// ============================================
-// Numbering Parsing
-// ============================================
-async function parseNumbering(pkg, ctx) {
-    const doc = await getPartXml(pkg, 'word/numbering.xml');
-    if (!doc)
-        return;
-    // Parse abstract numbering definitions
-    const abstractNums = new Map(); // abstractNumId → levels(ilvl → isOrdered)
-    const abstractNumEls = getAllElements(doc, 'abstractNum');
-    for (const absNum of abstractNumEls) {
-        const absId = getAttr(absNum, 'abstractNumId');
-        if (!absId)
-            continue;
-        const levels = new Map();
-        const lvlEls = getAllChildElements(absNum, 'lvl');
-        for (const lvl of lvlEls) {
-            const ilvlStr = getAttr(lvl, 'ilvl');
-            if (ilvlStr === null)
-                continue;
-            const ilvl = parseInt(ilvlStr, 10);
-            const numFmtEl = getFirstChildElement(lvl, 'numFmt');
-            const numFmt = numFmtEl ? getAttr(numFmtEl, 'val') : null;
-            const isOrdered = numFmt !== null && !BULLET_NUM_FORMATS.has(numFmt);
-            levels.set(ilvl, isOrdered);
-        }
-        abstractNums.set(absId, levels);
-    }
-    // Parse concrete num → abstractNum mappings
-    const numEls = getAllElements(doc, 'num');
-    for (const num of numEls) {
-        const numId = getAttr(num, 'numId');
-        if (!numId)
-            continue;
-        const abstractNumIdEl = getFirstChildElement(num, 'abstractNumId');
-        const absId = abstractNumIdEl ? getAttr(abstractNumIdEl, 'val') : null;
-        if (!absId)
-            continue;
-        const levels = abstractNums.get(absId);
-        if (levels) {
-            ctx.numbering.set(numId, { levels });
-        }
-    }
-}
-// ============================================
-// Footnotes Parsing
-// ============================================
-async function parseFootnotes(pkg, ctx) {
-    const doc = await getPartXml(pkg, 'word/footnotes.xml');
-    if (!doc)
-        return;
-    const footnoteEls = getAllElements(doc, 'footnote');
-    for (const fn of footnoteEls) {
-        const id = getAttr(fn, 'id');
-        const type = getAttr(fn, 'type');
-        // Skip separator and continuation separator footnotes
-        if (!id || type === 'separator' || type === 'continuationSeparator')
-            continue;
-        ctx.footnotes.set(id, fn);
-    }
-}
-// ============================================
-// Body Conversion
-// ============================================
-async function convertBody(body, ctx) {
-    const result = [];
-    const children = Array.from(body.children);
-    let i = 0;
-    while (i < children.length) {
-        const el = children[i];
-        const localName = el.localName;
-        if (localName === 'p') {
-            // Check if this is part of a list
-            const numPr = getNumPr(el);
-            if (numPr) {
-                // Collect consecutive list paragraphs
-                const { node, consumed } = await collectList(children, i, ctx);
-                result.push(node);
-                i += consumed;
-                continue;
-            }
-            const block = await convertParagraph(el, ctx);
-            if (block) {
-                result.push(block);
-            }
-            i++;
-        }
-        else if (localName === 'tbl') {
-            const table = await convertTable(el, ctx);
-            if (table)
-                result.push(table);
-            i++;
-        }
-        else {
-            // Skip unknown elements (sectPr, bookmarkStart, etc.)
-            i++;
-        }
-    }
-    // Append footnote definitions at the end
-    const footnoteNodes = await convertFootnoteDefinitions(ctx);
-    result.push(...footnoteNodes);
-    return result;
-}
-// ============================================
-// Paragraph Conversion
-// ============================================
-async function convertParagraph(el, ctx) {
-    const pPr = getFirstChildElement(el, 'pPr');
-    const styleId = getParagraphStyleId(pPr);
-    // Check for heading
-    if (styleId && ctx.headingStyles.has(styleId)) {
-        const depth = ctx.headingStyles.get(styleId);
-        const inlines = await convertRuns(el, ctx);
-        if (inlines.length === 0)
-            return null;
-        return {
-            type: 'heading',
-            depth: Math.min(Math.max(depth, 1), 6),
-            children: inlines,
-        };
-    }
-    // Check for blockquote
-    if (styleId && ctx.quoteStyles.has(styleId)) {
-        const inlines = await convertRuns(el, ctx);
-        if (inlines.length === 0)
-            return null;
-        const paragraph = { type: 'paragraph', children: inlines };
-        return { type: 'blockquote', children: [paragraph] };
-    }
-    // Check for code block
-    if (styleId && ctx.codeStyles.has(styleId)) {
-        const text = getElementTextContent(el);
-        return { type: 'code', value: text };
-    }
-    // Regular paragraph
-    const inlines = await convertRuns(el, ctx);
-    if (inlines.length === 0)
-        return null;
-    return { type: 'paragraph', children: inlines };
-}
-// ============================================
-// Run (Inline) Conversion
-// ============================================
-async function convertRuns(paragraphEl, ctx) {
-    const result = [];
-    const children = Array.from(paragraphEl.children);
-    for (const child of children) {
-        const localName = child.localName;
-        if (localName === 'r') {
-            const inlines = await convertRun(child, ctx);
-            result.push(...inlines);
-        }
-        else if (localName === 'hyperlink') {
-            const link = await convertHyperlink(child, ctx);
-            if (link)
-                result.push(link);
-        }
-        // Skip pPr, bookmarkStart, bookmarkEnd, etc.
-    }
-    return mergeAdjacentText(result);
-}
-async function convertRun(runEl, ctx) {
-    const result = [];
-    const rPr = getFirstChildElement(runEl, 'rPr');
-    const format = parseRunFormat(rPr, ctx);
-    for (const child of Array.from(runEl.children)) {
-        const localName = child.localName;
-        if (localName === 't') {
-            const text = child.textContent ?? '';
-            if (!text)
-                continue;
-            if (format.code) {
-                result.push({ type: 'inlineCode', value: text });
-            }
-            else {
-                let node = { type: 'text', value: text };
-                if (format.strike) {
-                    node = { type: 'delete', children: [node] };
-                }
-                if (format.italic) {
-                    node = { type: 'emphasis', children: [node] };
-                }
-                if (format.bold) {
-                    node = { type: 'strong', children: [node] };
-                }
-                result.push(node);
-            }
-        }
-        else if (localName === 'br') {
-            result.push({ type: 'break' });
-        }
-        else if (localName === 'footnoteReference') {
-            const fnId = getAttr(child, 'id');
-            if (fnId && fnId !== '0' && fnId !== '-1') {
-                result.push({
-                    type: 'footnoteReference',
-                    identifier: `fn${fnId}`,
-                });
-            }
-        }
-        else if (localName === 'drawing' || localName === 'pict') {
-            const img = await extractImage(child, ctx);
-            if (img)
-                result.push(img);
-        }
-    }
-    return result;
-}
-function parseRunFormat(rPr, ctx) {
-    if (!rPr)
-        return { bold: false, italic: false, strike: false, code: false };
-    const bold = hasChildElement(rPr, 'b') && !isFalseToggle(getFirstChildElement(rPr, 'b'));
-    const italic = hasChildElement(rPr, 'i') && !isFalseToggle(getFirstChildElement(rPr, 'i'));
-    const strike = hasChildElement(rPr, 'strike') && !isFalseToggle(getFirstChildElement(rPr, 'strike'));
-    // Check for inline code via character style
-    const rStyle = getFirstChildElement(rPr, 'rStyle');
-    const charStyleId = rStyle ? getAttr(rStyle, 'val') : null;
-    const isCodeStyle = charStyleId ? ctx.inlineCodeStyles.has(charStyleId) : false;
-    // Check for monospace font as a code indicator
-    const rFonts = getFirstChildElement(rPr, 'rFonts');
-    const fontName = rFonts ? (getAttr(rFonts, 'ascii') ?? getAttr(rFonts, 'hAnsi') ?? '') : '';
-    const isMonospace = /consolas|courier|mono/i.test(fontName);
-    return { bold, italic, strike, code: isCodeStyle || isMonospace };
-}
-function isFalseToggle(el) {
-    const val = getAttr(el, 'val');
-    return val === '0' || val === 'false';
-}
-// ============================================
-// Hyperlink Conversion
-// ============================================
-async function convertHyperlink(el, ctx) {
-    const rId = el.getAttributeNS(NS_R, 'id') ?? el.getAttribute('r:id');
-    let url = '';
-    if (rId) {
-        const rel = ctx.documentRels.get(rId);
-        if (rel)
-            url = rel.target;
-    }
-    // Also check for w:anchor (internal bookmarks)
-    if (!url) {
-        const anchor = el.getAttributeNS(NS_WML, 'anchor') ?? el.getAttribute('w:anchor');
-        if (anchor)
-            url = `#${anchor}`;
-    }
-    const inlines = [];
-    for (const child of Array.from(el.children)) {
-        if (child.localName === 'r') {
-            inlines.push(...(await convertRun(child, ctx)));
-        }
-    }
-    if (inlines.length === 0)
-        return null;
-    return {
-        type: 'link',
-        url,
-        children: mergeAdjacentText(inlines),
-    };
-}
-// ============================================
-// Image Extraction
-// ============================================
-async function extractImage(el, ctx) {
-    // Find <a:blip r:embed="rIdX"/> anywhere in the drawing tree
-    const blip = findDescendant(el, 'blip');
-    if (!blip) {
-        return { type: 'image', url: '', alt: 'Image' };
-    }
-    const rId = blip.getAttributeNS(NS_R, 'embed') ?? blip.getAttribute('r:embed');
-    if (!rId) {
-        return { type: 'image', url: '', alt: 'Image' };
-    }
-    const rel = ctx.documentRels.get(rId);
-    if (!rel) {
-        return { type: 'image', url: '', alt: 'Image' };
-    }
-    // Resolve the target path relative to word/
-    const target = rel.target.startsWith('/') ? rel.target.slice(1) : `word/${rel.target}`;
-    // Extract binary data from the zip
-    const data = await getPartBinary(ctx.pkg, target);
-    if (!data) {
-        return { type: 'image', url: '', alt: 'Image' };
-    }
-    // Determine extension and MIME type
-    const dot = target.lastIndexOf('.');
-    const ext = dot !== -1 ? target.slice(dot).toLowerCase() : '.png';
-    const mimeType = IMAGE_MIME_MAP[ext] ?? 'application/octet-stream';
-    // Generate a unique image path
-    ctx.imageCounter++;
-    const imagePath = `images/image${ctx.imageCounter}${ext}`;
-    // Store the extracted image data
-    ctx.extractedImages.set(imagePath, { data, mimeType });
-    // Try to extract alt text from the drawing's docPr element
-    const docPr = findDescendant(el, 'docPr');
-    const alt = docPr?.getAttribute('descr') || docPr?.getAttribute('title') || 'Image';
-    return {
-        type: 'image',
-        url: imagePath,
-        alt,
-    };
-}
-const IMAGE_MIME_MAP = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.bmp': 'image/bmp',
-    '.tiff': 'image/tiff',
-    '.tif': 'image/tiff',
-    '.svg': 'image/svg+xml',
-    '.webp': 'image/webp',
-    '.emf': 'image/emf',
-    '.wmf': 'image/wmf',
-};
-/** Recursively find the first descendant element with the given local name. */
-function findDescendant(el, localName) {
-    for (const child of Array.from(el.children)) {
-        if (child.localName === localName)
-            return child;
-        const found = findDescendant(child, localName);
-        if (found)
-            return found;
-    }
-    return null;
-}
-async function collectList(elements, startIdx, ctx) {
-    const firstNumPr = getNumPr(elements[startIdx]);
-    const { numId } = firstNumPr;
-    // Determine if ordered from numbering definition
-    const numInfo = ctx.numbering.get(numId);
-    const isOrdered = numInfo?.levels.get(0) ?? false;
-    const items = [];
-    let consumed = 0;
-    let i = startIdx;
-    while (i < elements.length) {
-        const el = elements[i];
-        if (el.localName !== 'p')
-            break;
-        const numPr = getNumPr(el);
-        if (!numPr || numPr.numId !== numId)
-            break;
-        // Convert this paragraph's inline content
-        const inlines = await convertRuns(el, ctx);
-        if (inlines.length > 0) {
-            const paragraph = { type: 'paragraph', children: inlines };
-            // Check if this is a nested list item
-            if (numPr.ilvl > firstNumPr.ilvl) {
-                // Collect nested list items
-                const nested = await collectNestedList(elements, i, ctx, firstNumPr.ilvl);
-                if (items.length > 0) {
-                    // Attach nested list to the last item
-                    const lastItem = items[items.length - 1];
-                    const nestedIsOrdered = numInfo?.levels.get(numPr.ilvl) ?? false;
-                    const nestedList = {
-                        type: 'list',
-                        ordered: nestedIsOrdered,
-                        children: nested.items,
-                    };
-                    lastItem.children.push(nestedList);
-                }
-                i += nested.consumed;
-                consumed += nested.consumed;
-                continue;
-            }
-            items.push({
-                type: 'listItem',
-                children: [paragraph],
-            });
-        }
-        i++;
-        consumed++;
-    }
-    return {
-        node: {
-            type: 'list',
-            ordered: isOrdered,
-            children: items,
-        },
-        consumed,
-    };
-}
-async function collectNestedList(elements, startIdx, ctx, parentIlvl) {
-    const items = [];
-    let consumed = 0;
-    let i = startIdx;
-    while (i < elements.length) {
-        const el = elements[i];
-        if (el.localName !== 'p')
-            break;
-        const numPr = getNumPr(el);
-        if (!numPr)
-            break;
-        if (numPr.ilvl <= parentIlvl)
-            break;
-        const inlines = await convertRuns(el, ctx);
-        if (inlines.length > 0) {
-            const paragraph = { type: 'paragraph', children: inlines };
-            items.push({ type: 'listItem', children: [paragraph] });
-        }
-        i++;
-        consumed++;
-    }
-    return { items, consumed };
-}
-function getNumPr(el) {
-    const pPr = getFirstChildElement(el, 'pPr');
-    if (!pPr)
-        return null;
-    const numPr = getFirstChildElement(pPr, 'numPr');
-    if (!numPr)
-        return null;
-    const ilvlEl = getFirstChildElement(numPr, 'ilvl');
-    const numIdEl = getFirstChildElement(numPr, 'numId');
-    const ilvlVal = ilvlEl ? getAttr(ilvlEl, 'val') : null;
-    const numIdVal = numIdEl ? getAttr(numIdEl, 'val') : null;
-    if (!numIdVal || numIdVal === '0')
-        return null; // numId 0 means "no list"
-    return {
-        numId: numIdVal,
-        ilvl: ilvlVal ? parseInt(ilvlVal, 10) : 0,
-    };
-}
-// ============================================
-// Table Conversion
-// ============================================
-async function convertTable(tblEl, ctx) {
-    const rows = [];
-    const trEls = getAllChildElements(tblEl, 'tr');
-    for (let ri = 0; ri < trEls.length; ri++) {
-        const row = await convertTableRow(trEls[ri], ctx, ri === 0);
-        rows.push(row);
-    }
-    if (rows.length === 0)
-        return null;
-    // If first row isn't explicitly a header, treat it as one anyway
-    // (Markdown tables require a header row)
-    return {
-        type: 'table',
-        children: rows,
-    };
-}
-async function convertTableRow(trEl, ctx, isHeader) {
-    const cells = [];
-    const tcEls = getAllChildElements(trEl, 'tc');
-    for (const tc of tcEls) {
-        const cell = await convertTableCell(tc, ctx, isHeader);
-        cells.push(cell);
-    }
-    return { type: 'tableRow', children: cells };
-}
-async function convertTableCell(tcEl, ctx, isHeader) {
-    const inlines = [];
-    // A cell can contain multiple paragraphs; flatten them with breaks
-    const paragraphs = getAllChildElements(tcEl, 'p');
-    for (let pi = 0; pi < paragraphs.length; pi++) {
-        if (pi > 0) {
-            inlines.push({ type: 'break' });
-        }
-        const runs = await convertRuns(paragraphs[pi], ctx);
-        inlines.push(...runs);
-    }
-    return {
-        type: 'tableCell',
-        isHeader,
-        children: mergeAdjacentText(inlines),
-    };
-}
-// ============================================
-// Footnote Definition Conversion
-// ============================================
-async function convertFootnoteDefinitions(ctx) {
-    const results = [];
-    for (const [id, el] of ctx.footnotes) {
-        const children = [];
-        const paragraphs = getAllChildElements(el, 'p');
-        for (const p of paragraphs) {
-            const inlines = await convertRuns(p, ctx);
-            if (inlines.length > 0) {
-                children.push({
-                    type: 'paragraph',
-                    children: inlines,
-                });
-            }
-        }
-        if (children.length > 0) {
-            results.push({
-                type: 'footnoteDefinition',
-                identifier: `fn${id}`,
-                children,
-            });
-        }
-    }
-    return results;
-}
-// ============================================
-// XML Helper Utilities
-// ============================================
-/**
- * Get the first element child with a given local name.
- * Handles both namespaced and non-namespaced elements.
- */
-function getFirstChildElement(parent, localName) {
-    for (const child of Array.from(parent.children ?? [])) {
-        if (child.localName === localName)
-            return child;
-    }
-    return null;
-}
-/**
- * Get all direct child elements with a given local name.
- */
-function getAllChildElements(parent, localName) {
-    const result = [];
-    for (const child of Array.from(parent.children)) {
-        if (child.localName === localName)
-            result.push(child);
-    }
-    return result;
-}
-/**
- * Get all elements with a given local name in the document.
- */
-function getAllElements(doc, localName) {
-    // Try namespace-aware first
-    const nsEls = 'getElementsByTagNameNS' in doc ? doc.getElementsByTagNameNS(NS_WML, localName) : null;
-    if (nsEls && nsEls.length > 0)
-        return Array.from(nsEls);
-    // Fallback: try with w: prefix
-    const prefixed = doc.getElementsByTagName(`w:${localName}`);
-    if (prefixed.length > 0)
-        return Array.from(prefixed);
-    // Final fallback: bare name
-    return Array.from(doc.getElementsByTagName(localName));
-}
-/**
- * Get the first element with given local name in the document or subtree.
- */
-function getFirstElement(doc, localName) {
-    const els = getAllElements(doc, localName);
-    return els.length > 0 ? els[0] : null;
-}
-/**
- * Get a w:-prefixed attribute, trying namespace-aware first then fallback.
- */
-function getAttr(el, localName) {
-    return el.getAttributeNS(NS_WML, localName) || el.getAttribute(`w:${localName}`) || null;
-}
-/**
- * Check if an element has a direct child with the given local name.
- */
-function hasChildElement(parent, localName) {
-    return getFirstChildElement(parent, localName) !== null;
-}
-/**
- * Get the paragraph style ID from a pPr element.
- */
-function getParagraphStyleId(pPr) {
-    if (!pPr)
-        return null;
-    const pStyle = getFirstChildElement(pPr, 'pStyle');
-    if (!pStyle)
-        return null;
-    return getAttr(pStyle, 'val');
-}
-/**
- * Get all text content from an element (concatenating all w:t descendants).
- */
-function getElementTextContent(el) {
-    const parts = [];
-    function walk(node) {
-        if (node.localName === 't') {
-            parts.push(node.textContent ?? '');
-        }
-        for (const child of Array.from(node.children)) {
-            walk(child);
-        }
-    }
-    walk(el);
-    return parts.join('');
-}
-/**
- * Merge adjacent MarkdownText nodes to reduce fragmentation.
- */
-function mergeAdjacentText(nodes) {
-    if (nodes.length <= 1)
-        return nodes;
-    const result = [];
-    for (const node of nodes) {
-        const prev = result[result.length - 1];
-        if (node.type === 'text' && prev?.type === 'text') {
-            // Merge into previous text node
-            prev.value += node.value;
-        }
-        else {
-            result.push(node);
-        }
-    }
-    return result;
-}
-//# sourceMappingURL=import.js.map