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

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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"}