@bevel-software/platform-core-backend 0.11.2 → 0.12.1

package/dist/modules/workspace/file-readers/image-read.js

@@ -0,0 +1,108 @@
+/**
+ * `read_file` image support: which files come back as a native MCP image
+ * content block instead of text, the size cap that keeps the encoded payload
+ * under what Claude-family clients accept, and the self-describing note that
+ * rides beside the image so the transcript still says what was read.
+ *
+ * Deliberately dependency-free: dimensions are parsed straight from the
+ * container headers (PNG/GIF/JPEG) rather than through a native image library.
+ * No downscaling in this increment — `sharp` is a heavy native dependency, so
+ * an oversized image gets an honest refusal telling the caller to downscale
+ * locally or upload a smaller export.
+ */
+import { fileExtension } from './doc-extract.types.js';
+/** The image types `read_file` returns as a native MCP image content block. `.svg` is TEXT and stays on the text path. */
+const IMAGE_MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    // GIF passes through whole under the same cap; clients render the first frame.
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+};
+/** The extensions the `ImageReader` registers for — exactly the map above. */
+export const IMAGE_EXTENSIONS = Object.keys(IMAGE_MIME_BY_EXT);
+/** Is this a file `read_file` should return as an image? */
+export function isImageFile(path) {
+    return fileExtension(path) in IMAGE_MIME_BY_EXT;
+}
+/** The MCP mime type for an image path — call only after `isImageFile`. */
+export function imageMimeType(path) {
+    return IMAGE_MIME_BY_EXT[fileExtension(path)];
+}
+/**
+ * Cap on the RAW bytes of an image `read_file` will return.
+ *
+ * The arithmetic: Claude-family clients reject a base64 image payload around
+ * 5 MB encoded (5 * 1024 * 1024 = 5,242,880 chars). Base64 inflates by 4/3,
+ * so the raw ceiling for that limit is 5,242,880 * 3/4 = 3,932,160 bytes. We
+ * cap at 3.5 MiB raw = 3,670,016 bytes, which encodes to
+ * ceil(3,670,016 / 3) * 4 = 4,893,356 base64 chars (~4.67 MiB) — under the
+ * reject line with headroom for the JSON envelope the sentinel travels in.
+ */
+export const IMAGE_MAX_RAW_BYTES = 3.5 * 1024 * 1024; // = 3,670,016
+/**
+ * Best-effort dimensions straight from the header bytes: PNG (IHDR), GIF
+ * (logical screen descriptor), JPEG (SOFn scan). WebP is left dimensionless —
+ * its three sub-formats (VP8/VP8L/VP8X) each encode size differently, and the
+ * note is honest without it. Returns undefined on anything unexpected; never
+ * throws (a corrupt image must still be delivered or refused, not 500).
+ */
+export function imageDimensions(bytes) {
+    try {
+        // PNG: 8-byte signature, then the IHDR chunk — width/height at 16/20 (BE).
+        if (bytes.length >= 24 && bytes.readUInt32BE(0) === 0x89504e47 && bytes.toString('latin1', 12, 16) === 'IHDR') {
+            return { width: bytes.readUInt32BE(16), height: bytes.readUInt32BE(20) };
+        }
+        // GIF: the FULL "GIF87a"/"GIF89a" signature, then the logical screen
+        // size at 6/8 (LE) — a bare "GIF" prefix is not a GIF header.
+        if (bytes.length >= 10) {
+            const sig = bytes.toString('latin1', 0, 6);
+            if (sig === 'GIF87a' || sig === 'GIF89a') {
+                return { width: bytes.readUInt16LE(6), height: bytes.readUInt16LE(8) };
+            }
+        }
+        // JPEG: walk the marker segments to the first SOFn frame header.
+        if (bytes.length >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+            let i = 2;
+            while (i + 9 < bytes.length) {
+                if (bytes[i] !== 0xff) {
+                    i += 1; // stray fill byte — resync
+                    continue;
+                }
+                const marker = bytes[i + 1];
+                // Standalone markers (no length field): padding, restarts, SOI/EOI.
+                if (marker === 0xff) {
+                    i += 1;
+                    continue;
+                }
+                if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd9)) {
+                    i += 2;
+                    continue;
+                }
+                // SOFn (C0–CF except the non-frame C4/C8/CC): height at +5, width at +7.
+                if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                    return { height: bytes.readUInt16BE(i + 5), width: bytes.readUInt16BE(i + 7) };
+                }
+                i += 2 + bytes.readUInt16BE(i + 2);
+            }
+        }
+    }
+    catch {
+        // Truncated/corrupt header — the note simply omits dimensions.
+    }
+    return undefined;
+}
+/** The one-line note emitted as a text block beside the image, so the transcript names what it shows. */
+export function imageNote(path, mime, sizeBytes, dims) {
+    const dimsPart = dims ? `, ${dims.width}×${dims.height} px` : '';
+    return `[image: ${path} — ${mime}, ${sizeBytes} bytes${dimsPart}]`;
+}
+/** The honest refusal for an image over {@link IMAGE_MAX_RAW_BYTES} — returned as the file's text content. */
+export function oversizedImageNotice(path, mime, sizeBytes) {
+    return (`[${path} is a ${mime} image of ${sizeBytes} bytes — too large to return over MCP. The cap is ` +
+        `${IMAGE_MAX_RAW_BYTES} bytes (3.5 MiB) of raw image data, because base64 encoding inflates it by 4/3 and ` +
+        'Claude-family clients reject images near 5 MB encoded. Downscale the image locally or upload a smaller ' +
+        'export, then read that file instead.]');
+}
+//# sourceMappingURL=image-read.js.map

package/dist/modules/workspace/file-readers/image-read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-read.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/image-read.ts"],"names":[],"mappings":"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"}

package/dist/modules/workspace/file-readers/image-reader.d.ts

@@ -0,0 +1,19 @@
+import type { FileReader, ReadResult } from './file-reader.js';
+/**
+ * FileReader over the image types `read_file` returns as a native MCP image
+ * content block (`.svg` is text and stays on the text path). Within the raw
+ * cap the read yields the picture itself (base64 + mime + the self-describing
+ * note); over it, the honest downscale refusal — see image-read.ts for the
+ * cap arithmetic and header-parsing details.
+ *
+ * No `greppableText`: a picture is never text-searchable. And images stay
+ * `textEditable` — the write tools only refuse formats whose reads are lossy
+ * EXTRACTIONS (documents); an image read is the real bytes, and image writes
+ * were never gated.
+ */
+export declare class ImageReader implements FileReader {
+    readonly extensions: readonly string[];
+    readonly textEditable = true;
+    read(bytes: Buffer, path: string): Promise<ReadResult>;
+}
+//# sourceMappingURL=image-reader.d.ts.map

package/dist/modules/workspace/file-readers/image-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-reader.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/image-reader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAU/D;;;;;;;;;;;GAWG;AACH,qBAAa,WAAY,YAAW,UAAU;IAC5C,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAoB;IAC1D,QAAQ,CAAC,YAAY,QAAQ;IAEvB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAY7D"}

package/dist/modules/workspace/file-readers/image-reader.js

@@ -0,0 +1,30 @@
+import { IMAGE_EXTENSIONS, IMAGE_MAX_RAW_BYTES, imageDimensions, imageMimeType, imageNote, oversizedImageNotice, } from './image-read.js';
+/**
+ * FileReader over the image types `read_file` returns as a native MCP image
+ * content block (`.svg` is text and stays on the text path). Within the raw
+ * cap the read yields the picture itself (base64 + mime + the self-describing
+ * note); over it, the honest downscale refusal — see image-read.ts for the
+ * cap arithmetic and header-parsing details.
+ *
+ * No `greppableText`: a picture is never text-searchable. And images stay
+ * `textEditable` — the write tools only refuse formats whose reads are lossy
+ * EXTRACTIONS (documents); an image read is the real bytes, and image writes
+ * were never gated.
+ */
+export class ImageReader {
+    extensions = IMAGE_EXTENSIONS;
+    textEditable = true;
+    async read(bytes, path) {
+        const mime = imageMimeType(path);
+        if (bytes.length > IMAGE_MAX_RAW_BYTES) {
+            return { kind: 'refusal', message: oversizedImageNotice(path, mime, bytes.length) };
+        }
+        return {
+            kind: 'image',
+            data: bytes.toString('base64'),
+            mimeType: mime,
+            note: imageNote(path, mime, bytes.length, imageDimensions(bytes)),
+        };
+    }
+}
+//# sourceMappingURL=image-reader.js.map

package/dist/modules/workspace/file-readers/image-reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-reader.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/image-reader.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,eAAe,EACf,aAAa,EACb,SAAS,EACT,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,WAAW;IACb,UAAU,GAAsB,gBAAgB,CAAC;IACjD,YAAY,GAAG,IAAI,CAAC;IAE7B,KAAK,CAAC,IAAI,CAAC,KAAa,EAAE,IAAY;QACpC,MAAM,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,KAAK,CAAC,MAAM,GAAG,mBAAmB,EAAE,CAAC;YACvC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;QACtF,CAAC;QACD,OAAO;YACL,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC;YAC9B,QAAQ,EAAE,IAAI;YACd,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;SAClE,CAAC;IACJ,CAAC;CACF"}

package/dist/modules/workspace/file-readers/odf-text.d.ts

@@ -0,0 +1,26 @@
+export declare function odfParagraphText(paragraphXml: string): string;
+/**
+ * The `<text:p>` / `<text:h>` paragraph bodies of an XML fragment, in DOCUMENT
+ * order (headings interleaved with paragraphs, as written). Self-closing
+ * elements (an empty paragraph) yield ''. `<text:page-number>` and friends do
+ * not count as paragraphs.
+ */
+export declare function odfParagraphBlocks(xml: string): string[];
+/** Non-empty paragraph texts of an ODF fragment — what odp slides/notes render. */
+export declare function odfParagraphLines(xml: string): string[];
+/**
+ * `content.xml` of an ODF package or a typed could-not-parse failure message
+ * (`kind` names the extension for the message, e.g. '.odt').
+ *
+ * Bounded: the entry's DECLARED uncompressed size is checked against
+ * `MAX_DOC_PART_BYTES` (50 MB) before anything inflates, so a zip bomb is a
+ * typed refusal, never an allocation.
+ */
+export declare function readOdfContentXml(bytes: Buffer, kind: '.odt' | '.odp' | '.ods'): {
+    ok: true;
+    xml: string;
+} | {
+    ok: false;
+    message: string;
+};
+//# sourceMappingURL=odf-text.d.ts.map

package/dist/modules/workspace/file-readers/odf-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"odf-text.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/odf-text.ts"],"names":[],"mappings":"AAuCA,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAoC7D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAExD;AAGD,mFAAmF;AACnF,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAOvD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAC7B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAa5D"}

package/dist/modules/workspace/file-readers/odf-text.js

@@ -0,0 +1,116 @@
+import AdmZip from 'adm-zip';
+import { Parser } from 'htmlparser2';
+import { attrByLocalName, localElementBlocks, localName, zipEntryOversize } from './ooxml-text.js';
+/**
+ * ODF (OpenDocument) text helpers shared by the odt/odp/ods extractors.
+ *
+ * Elements are matched by LOCAL name — `p`, not `text:p`. A prefix is the
+ * document's own choice, and naming `text:` literally meant an ODF file that
+ * defaulted the namespace, or bound it to any other prefix, extracted as
+ * empty. This module used to answer that by REWRITING every non-conventional
+ * prefix across the whole of `content.xml` before scanning it, a pass that had
+ * to be bounded against crafted alias lists and could still corrupt ordinary
+ * paragraph text that happened to look like an alias. Matching local names
+ * needs none of it.
+ */
+/**
+ * The text of one ODF paragraph (`<text:p>` / `<text:h>` content). Character
+ * data is concatenated with NO separator — formatting runs (`<text:span>`)
+ * split words exactly like OOXML runs do, so ignoring the span tags joins them
+ * back. Three ODF whitespace elements are REAL characters and render as such:
+ *
+ *  - `<text:tab/>`          → a tab
+ *  - `<text:line-break/>`   → a newline
+ *  - `<text:s text:c="N"/>` → N spaces (no `text:c` attribute = 1)
+ *
+ * Read through the parser, so entities decode, CDATA sections are the text
+ * they hold rather than markup, and a comment is not paragraph content.
+ */
+/**
+ * Cap on the characters the whitespace ELEMENTS may add to ONE paragraph.
+ * Each `<text:s text:c="N"/>` is clamped on its own below, but nothing else
+ * bounds how many such elements a paragraph may hold — a content.xml well
+ * under the 50 MB part limit could still expand to gigabytes of spaces. The
+ * budget caps the SUM per paragraph; real layout whitespace is nowhere near it.
+ */
+const MAX_PARAGRAPH_WHITESPACE_CHARS = 10_000;
+export function odfParagraphText(paragraphXml) {
+    let out = '';
+    let whitespaceBudget = MAX_PARAGRAPH_WHITESPACE_CHARS;
+    const parser = new Parser({
+        onopentag(name, attributes) {
+            const local = localName(name);
+            if (local === 'tab') {
+                if (whitespaceBudget > 0) {
+                    out += '\t';
+                    whitespaceBudget--;
+                }
+            }
+            else if (local === 'line-break') {
+                if (whitespaceBudget > 0) {
+                    out += '\n';
+                    whitespaceBudget--;
+                }
+            }
+            else if (local === 's') {
+                const raw = attrByLocalName(attributes, 'c');
+                const count = raw !== undefined ? parseInt(raw, 10) : 1;
+                // Bounded defensively — a corrupt attribute must not balloon the
+                // extraction — and again by the per-paragraph budget above.
+                const spaces = Math.min(Number.isFinite(count) ? Math.min(Math.max(count, 0), 1000) : 1, whitespaceBudget);
+                out += ' '.repeat(spaces);
+                whitespaceBudget -= spaces;
+            }
+        },
+        ontext(text) {
+            out += text;
+        },
+    }, { xmlMode: true, decodeEntities: true });
+    parser.write(paragraphXml);
+    parser.end();
+    return out;
+}
+/**
+ * The `<text:p>` / `<text:h>` paragraph bodies of an XML fragment, in DOCUMENT
+ * order (headings interleaved with paragraphs, as written). Self-closing
+ * elements (an empty paragraph) yield ''. `<text:page-number>` and friends do
+ * not count as paragraphs.
+ */
+export function odfParagraphBlocks(xml) {
+    return localElementBlocks(xml, ['p', 'h']).map((e) => e.body ?? '');
+}
+/** Non-empty paragraph texts of an ODF fragment — what odp slides/notes render. */
+export function odfParagraphLines(xml) {
+    const out = [];
+    for (const p of odfParagraphBlocks(xml)) {
+        const text = odfParagraphText(p);
+        if (text.trim() !== '')
+            out.push(text);
+    }
+    return out;
+}
+/**
+ * `content.xml` of an ODF package or a typed could-not-parse failure message
+ * (`kind` names the extension for the message, e.g. '.odt').
+ *
+ * Bounded: the entry's DECLARED uncompressed size is checked against
+ * `MAX_DOC_PART_BYTES` (50 MB) before anything inflates, so a zip bomb is a
+ * typed refusal, never an allocation.
+ */
+export function readOdfContentXml(bytes, kind) {
+    try {
+        const zip = new AdmZip(bytes);
+        const entry = zip.getEntry('content.xml');
+        if (!entry) {
+            return { ok: false, message: `could not be parsed as a ${kind} (no content.xml inside the archive)` };
+        }
+        const oversize = zipEntryOversize(entry);
+        if (oversize)
+            return { ok: false, message: `could not be extracted as a ${kind} (${oversize})` };
+        return { ok: true, xml: entry.getData().toString('utf8') };
+    }
+    catch (err) {
+        return { ok: false, message: `could not be parsed as a ${kind} (${err.message})` };
+    }
+}
+//# sourceMappingURL=odf-text.js.map

package/dist/modules/workspace/file-readers/odf-text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"odf-text.js","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/odf-text.ts"],"names":[],"mappings":"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"}

package/dist/modules/workspace/file-readers/ooxml-text.d.ts

@@ -0,0 +1,172 @@
+import type AdmZip from 'adm-zip';
+/**
+ * Decompression bounds for the document extractors (OOXML, ODF and — as a
+ * plain byte cap — PDF). A zip's central directory declares each entry's
+ * UNCOMPRESSED size, so a zip bomb (a few KB that inflate to gigabytes) is
+ * detectable BEFORE any inflation happens; 50 MB of XML is far beyond any
+ * real office document part (a huge deck's slide parts run to single-digit
+ * MB) while staying well inside what a server can afford to decode.
+ * `MAX_DOC_TOTAL_BYTES` additionally bounds the SUM of the parts a multi-part
+ * extraction reads (pptx slides/notes, xlsx sheet parts) at 200 MB.
+ */
+export declare const MAX_DOC_PART_BYTES: number;
+export declare const MAX_DOC_TOTAL_BYTES: number;
+/**
+ * The typed-failure fragment for a zip entry whose DECLARED uncompressed size
+ * exceeds {@link MAX_DOC_PART_BYTES}, or null when the entry is within bounds.
+ * Checked against the central-directory header BEFORE `getData()` inflates
+ * anything, so an oversized (or bomb) entry costs nothing.
+ */
+export declare function zipEntryOversize(entry: AdmZip.IZipEntry): string | null;
+export declare const XML_NCNAME: string;
+/**
+ * One tag's attributes as `name → raw value` tokens, in document order. A
+ * real left-to-right tokenizer, not a regex probe: quoted values (either
+ * quote style, whitespace around `=` tolerated) are skipped over WHOLE, so a
+ * `target='…'`-looking sequence INSIDE another attribute's value can never
+ * be mistaken for an attribute of its own. Values are RAW (entities not
+ * decoded); a malformed tail (unterminated quote) simply ends the scan.
+ */
+export declare function xmlAttrTokens(tagXml: string): Array<{
+    name: string;
+    value: string;
+}>;
+/**
+ * The value of attribute `name` inside one tag's text, or undefined. Exact
+ * (prefix-included) name match over the {@link xmlAttrTokens} scan — see there
+ * for the quoting guarantees. The value is returned RAW (entities not
+ * decoded); callers decode where display matters.
+ */
+export declare function xmlAttrValue(tagXml: string, name: string): string | undefined;
+/**
+ * Like {@link xmlAttrValue}, but matching the attribute's LOCAL name — the
+ * part after any namespace prefix. For parsers that scan by local element
+ * name (OPC `.rels` parts, whose producer is free to prefix the relationship
+ * namespace) and must accept `r:Target` wherever `Target` is meant.
+ */
+export declare function xmlAttrValueByLocalName(tagXml: string, localName: string): string | undefined;
+/**
+ * Decode the five XML named entities plus numeric (`&#65;` / `&#x41;`)
+ * references. Decimal references admit ONLY decimal digits and hex digits only
+ * after `#x` — a malformed `&#12A;` must stay literal text, not be consumed
+ * with `parseInt` silently stopping at the `A` and emitting U+000C.
+ */
+export declare function decodeXmlEntities(s: string): string;
+/** One element found by {@link xmlElementBlocks}. */
+/** One element found by {@link xmlElementBlocks}. */
+export interface XmlElementBlock {
+    /** The qualified name as written, e.g. `w:p` — which of `names` matched. */
+    name: string;
+    /** The element's attributes. Values are RAW (entities not decoded). */
+    attributes: Record<string, string>;
+    /** The body between `>` and the matching close tag; undefined when self-closing. */
+    body: string | undefined;
+    /** Index of the element's opening `<` in the scanned string. */
+    start: number;
+    /** One past the element's final `>` (as far as the parse got, for a block cut short by the depth cap). */
+    end: number;
+}
+/**
+ * How deep the element stack may go before a part is given up on.
+ *
+ * Real office XML nests a few dozen levels. A crafted part can nest as deep as
+ * it has bytes, and the parser's own cost climbs faster than linearly once the
+ * stack is enormous: measured on unclosed `<a:p>` openers, 40 k deep took
+ * 136 ms and 80 k took 2.7 s. A 50 MB part could spell millions. So the depth
+ * is bounded far above any real document and far below where that curve bites.
+ *
+ * On reaching it the parse stops and what was found is returned — including
+ * the element still open, whose body is taken as far as the parse got, so a
+ * paragraph holding real text before the crafted tail still yields that text.
+ */
+export declare const MAX_ELEMENT_DEPTH = 1000;
+/**
+ * Thrown to stop the parse at {@link MAX_ELEMENT_DEPTH}; never escapes an
+ * extractor (also shared by `email-text.ts`'s HTML strip).
+ */
+export declare const TOO_DEEP: unique symbol;
+/**
+ * The `<name …>…</name>` and self-closing `<name …/>` elements named by
+ * `names`, in document order, at ANY depth — but never descending into a
+ * match, since a match nested inside another is part of that one's body
+ * rather than a block of its own.
+ *
+ * Parsing is `htmlparser2` in XML mode, which is the point of this function.
+ * What stood here before was a hand-rolled scanner, and the lexical rules it
+ * had to know kept turning out to be one rule short: a `>` inside a quoted
+ * attribute value, a `/` that only ends a name as part of `/>`, a `</w:p>`
+ * written inside a comment or a CDATA section, a namespace prefix outside
+ * ASCII. Each gap was a real defect, several were reachable from an uploaded
+ * file, and the fixes needed their own bookkeeping — a tag-end memo, a section
+ * index, caps on both — which then had defects of their own. All of that is
+ * the parser's job here, and it is code with far more mileage than ours.
+ *
+ * Bodies are RAW slices of `xml` (entities not decoded), because the callers
+ * re-scan them for nested elements and decode only the text they keep.
+ */
+/** The part of a qualified XML name after its namespace prefix. */
+export declare function localName(qualified: string): string;
+/**
+ * The value of the attribute whose LOCAL name is `want`, or undefined.
+ * Namespace DECLARATIONS are not attributes and never answer for one.
+ */
+export declare function attrByLocalName(attributes: Record<string, string>, want: string): string | undefined;
+/**
+ * {@link xmlElementBlocks}, matching each element's LOCAL name instead of the
+ * qualified one — `p` finds `<w:p>`, `<a:p>` and an unprefixed `<p>` alike.
+ *
+ * Prefixes are a document's own choice: XML binds them to namespace URIs, and
+ * a producer may bind any prefix it likes or default the namespace and use
+ * none. Naming `a:p` or `text:p` literally therefore read only the documents
+ * whose authors happened to pick the usual prefix — a valid deck using `d:p`
+ * for DrawingML extracted as EMPTY, and an ODT that defaulted the text
+ * namespace found no paragraphs at all. Matching the local name reads both,
+ * and replaces the prefix-rewriting pass the ODF readers used to run over
+ * every document to paper over the same problem.
+ */
+export declare function localElementBlocks(xml: string, localNames: readonly string[]): XmlElementBlock[];
+/**
+ * {@link localElementBlocks} as a WALK: `visit` receives each element as its
+ * close tag is reached, and returning true STOPS the scan — the input past
+ * that element is never parsed and no block is materialized beyond it. For
+ * callers with a cap (the ods row walk): collecting every block into an array
+ * before consulting the cap let an accepted document allocate its whole
+ * expansion first.
+ */
+export declare function walkLocalElementBlocks(xml: string, localNames: readonly string[], visit: (block: XmlElementBlock) => boolean | void): void;
+/**
+ * `xml` with every element named by `localNames` (matched on its LOCAL name)
+ * removed WHOLE — open tag through matching close tag — by the parsed block
+ * boundaries. The structural counterpart to string replacement, which deleted
+ * every occurrence of a block's serialized BODY: a slide whose visible text
+ * happened to serialize identically to its notes lost that text too.
+ */
+export declare function removeLocalElements(xml: string, localNames: readonly string[]): string;
+export declare function xmlElementBlocks(xml: string, names: Iterable<string>, 
+/** Overrides name matching — {@link localElementBlocks} matches local names with it. */
+matches?: (name: string) => boolean, 
+/**
+ * Streaming hook — see {@link walkLocalElementBlocks}. When given, each
+ * block is handed to it INSTEAD of being accumulated (the return value is
+ * then an empty array), and returning true stops the scan.
+ */
+visit?: (block: XmlElementBlock) => boolean | void): XmlElementBlock[];
+/**
+ * The text of one OOXML paragraph: every `<w:t>`/`<a:t>` run's character
+ * content, concatenated with NO separator — Word/PowerPoint split runs
+ * mid-word on formatting boundaries, so any separator would break words apart.
+ * `tag` is the run tag ('w:t' for docx, 'a:t' for pptx). A self-closing
+ * `<w:t/>` is an empty run and contributes nothing, exactly as it did when
+ * the pattern simply failed to match it.
+ */
+export declare function paragraphRunText(paragraphXml: string, localTag: string): string;
+/**
+ * Split an XML fragment into its `<{tag}>…</{tag}>` blocks, in document order.
+ * A self-closing `<{tag}/>` yields '' — an EMPTY block, which is what an empty
+ * `<w:p/>` paragraph or `<w:tc/>` cell means. See {@link xmlElementBlocks} for
+ * the non-nesting and quoting guarantees.
+ */
+/** {@link xmlBlocks} by LOCAL name — see {@link localElementBlocks} for why. */
+export declare function localBlocks(xml: string, local: string): string[];
+export declare function xmlBlocks(xml: string, tag: string): string[];
+//# sourceMappingURL=ooxml-text.d.ts.map

package/dist/modules/workspace/file-readers/ooxml-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ooxml-text.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/file-readers/ooxml-text.ts"],"names":[],"mappings":"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"}