omni-viewer-core 0.1.0

package/dist/parsers/ppt-binary/vscode.d.ts

@@ -0,0 +1,4 @@
+import type { SlideDeck } from '../slide-model.js';
+import type { ParseOptions, ParseOutcome } from '../types.js';
+/** Full VS Code legacy PowerPoint parser adapted from a file path to bytes. */
+export declare function parsePptBinaryVscode(input: Uint8Array, options?: ParseOptions): Promise<ParseOutcome<SlideDeck>>;

package/dist/parsers/ppt-binary/vscode.js

@@ -0,0 +1,12 @@
+import { PptBinaryParser } from './vscode-parser.js';
+/** Full VS Code legacy PowerPoint parser adapted from a file path to bytes. */
+export async function parsePptBinaryVscode(input, options = {}) { const started = Date.now(), diagnostics = []; if (options.signal?.aborted)
+    return { result: { status: 'failed', failure: { code: 'aborted', retryable: true, messageKey: 'diag.aborted' }, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: 0 } }; if (input.byteLength > (options.limits?.maxInputBytes ?? 50 * 1024 * 1024))
+    return { result: { status: 'failed', failure: { code: 'limit-exceeded', retryable: false, messageKey: 'diag.limit-exceeded.input' }, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: Date.now() - started } }; try {
+    const parsed = await PptBinaryParser.parse(input);
+    const slides = parsed.slides;
+    return { result: { status: 'ok', document: { slides, totalSlides: parsed.totalSlides, ...(slides[0] ? { slideSize: { widthPx: slides[0].widthPx, heightPx: slides[0].heightPx } } : {}) }, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: Date.now() - started } };
+}
+catch {
+    return { result: { status: 'failed', failure: { code: 'invalid-format', retryable: false, messageKey: 'diag.ppt.invalid-format' }, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: Date.now() - started } };
+} }

package/dist/parsers/pptx/index.d.ts

@@ -0,0 +1,15 @@
+import { type ParseOptions, type ParseOutcome } from '../types.js';
+import type { SlideDeck } from '../slide-model.js';
+export * from '../slide-model.js';
+export interface PptxZipReader {
+    list(): Promise<readonly string[]>;
+    text(path: string): Promise<string | undefined>;
+    bytes(path: string): Promise<Uint8Array | undefined>;
+    close?(): void | Promise<void>;
+}
+export interface PptxParserDeps {
+    openZip(data: Uint8Array, options?: ParseOptions): Promise<PptxZipReader>;
+}
+export { openPptxZip } from './zip-reader.js';
+export { parsePptxVscode } from './vscode.js';
+export declare function parsePptx(input: Uint8Array, deps: PptxParserDeps, options?: ParseOptions): Promise<ParseOutcome<SlideDeck>>;

package/dist/parsers/pptx/index.js

@@ -0,0 +1,88 @@
+// @ts-nocheck -- OOXML's sparse optional attributes are normalized at the public boundary.
+import { DEFAULT_LIMITS, LimitTracker } from '../types.js';
+export * from '../slide-model.js';
+export { openPptxZip } from './zip-reader.js';
+export { parsePptxVscode } from './vscode.js';
+const EMU_PER_PX = 9525;
+const DEFAULT_SIZE = { widthPx: 1280, heightPx: 720 };
+const attr = (tag, name) => new RegExp(`(?:^|\\s)${name}="([^"]*)"`).exec(tag)?.[1];
+const xmlText = (value) => value.replace(/<a:br\s*\/?\s*>/g, '\n').replace(/<[^>]+>/g, '').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&').replace(/&quot;/g, '"').replace(/&apos;/g, "'");
+function relationships(xml, part) { const out = new Map(); const dir = part.slice(0, part.lastIndexOf('/')); for (const tag of xml.match(/<Relationship\b[^>]*>/g) ?? []) {
+    const id = attr(tag, 'Id'), target = attr(tag, 'Target');
+    if (!id || !target || target.startsWith('http:') || target.startsWith('https:'))
+        continue;
+    const pieces = `${dir}/${target}`.split('/');
+    const resolved = [];
+    for (const p of pieces) {
+        if (p === '..')
+            resolved.pop();
+        else if (p !== '.' && p)
+            resolved.push(p);
+    }
+    out.set(id, resolved.join('/'));
+} return out; }
+function transform(block) { const xfrm = /<a:xfrm\b[^>]*>([\s\S]*?)<\/a:xfrm>/.exec(block)?.[0] ?? ''; const off = /<a:off\b[^>]*>/.exec(xfrm)?.[0] ?? ''; const ext = /<a:ext\b[^>]*>/.exec(xfrm)?.[0] ?? ''; return { x: Number(attr(off, 'x') ?? 0) / EMU_PER_PX, y: Number(attr(off, 'y') ?? 0) / EMU_PER_PX, width: Number(attr(ext, 'cx') ?? 0) / EMU_PER_PX, height: Number(attr(ext, 'cy') ?? 0) / EMU_PER_PX, rotateDeg: Number(attr(/<a:xfrm\b[^>]*>/.exec(xfrm)?.[0] ?? '', 'rot') ?? 0) / 60000 }; }
+function color(block, fallback) { const value = /<a:srgbClr\b[^>]*val="([0-9A-Fa-f]{6})"/.exec(block)?.[1]; return value ? `#${value.toLowerCase()}` : fallback; }
+function paragraphs(block) { return (block.match(/<a:p\b[\s\S]*?<\/a:p>/g) ?? []).map(p => { const runs = (p.match(/<a:r\b[\s\S]*?<\/a:r>/g) ?? []).map(r => { const text = xmlText(/<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(r)?.[1] ?? ''); const rpr = /<a:rPr\b[^>]*>/.exec(r)?.[0] ?? ''; return { text, ...(attr(rpr, 'sz') ? { fontSizePx: Number(attr(rpr, 'sz')) / 75 } : {}), ...(attr(rpr, 'b') === '1' ? { bold: true } : {}), ...(attr(rpr, 'i') === '1' ? { italic: true } : {}), ...(color(r) ? { color: color(r) } : {}) }; }); const ppr = /<a:pPr\b[^>]*>/.exec(p)?.[0] ?? ''; const text = runs.length ? runs.map(r => r.text).join('') : xmlText(/<a:t\b[^>]*>([\s\S]*?)<\/a:t>/.exec(p)?.[1] ?? ''); return { text, level: Number(attr(ppr, 'lvl') ?? 0), ...(/<a:bu(?:Char|AutoNum)\b/.test(p) ? { bullet: true } : {}), ...(attr(ppr, 'algn') ? { align: attr(ppr, 'algn') } : {}), runs }; }).filter(p => p.text.length > 0); }
+async function parseSlide(zip, path, n, size) { const xml = await zip.text(path) ?? ''; const relPath = `${path.slice(0, path.lastIndexOf('/'))}/_rels/${path.slice(path.lastIndexOf('/') + 1)}.rels`; const rels = relationships(await zip.text(relPath) ?? '', path); const elements = []; let z = 0; for (const block of xml.match(/<p:(?:sp|pic|graphicFrame)\b[\s\S]*?<\/p:(?:sp|pic|graphicFrame)>/g) ?? []) {
+    const frame = transform(block);
+    const common = { ...frame, zIndex: z++ };
+    if (block.startsWith('<p:pic')) {
+        const rid = /<a:blip\b[^>]*r:embed="([^"]+)"/.exec(block)?.[1];
+        const target = rid ? rels.get(rid) : undefined;
+        const data = target ? await zip.bytes(target) : undefined;
+        if (data) {
+            let binary = '';
+            for (const b of data)
+                binary += String.fromCharCode(b);
+            const ext = target?.split('.').pop()?.toLowerCase();
+            const mime = ext === 'png' ? 'image/png' : ext === 'svg' ? 'image/svg+xml' : 'image/jpeg';
+            elements.push({ ...common, type: 'image', src: `data:${mime};base64,${btoa(binary)}` });
+        }
+        continue;
+    }
+    if (block.startsWith('<p:graphicFrame')) {
+        const rows = (block.match(/<a:tr\b[\s\S]*?<\/a:tr>/g) ?? []).map(r => (r.match(/<a:tc\b[\s\S]*?<\/a:tc>/g) ?? []).map(c => xmlText((c.match(/<a:t\b[^>]*>([\s\S]*?)<\/a:t>/g) ?? []).join(' '))));
+        if (rows.length)
+            elements.push({ ...common, type: 'table', tableRows: rows });
+        continue;
+    }
+    const ps = paragraphs(block);
+    const geom = /<a:prstGeom\b[^>]*prst="([^"]+)"/.exec(block)?.[1];
+    if (ps.length)
+        elements.push({ ...common, type: 'text', paragraphs: ps, isTitle: /<p:ph\b[^>]*type="(?:title|ctrTitle)"/i.test(block) });
+    else
+        elements.push({ ...common, type: 'shape', presetGeom: geom, fillColor: color(block, 'transparent'), borderColor: color(/<a:ln\b[\s\S]*?<\/a:ln>/.exec(block)?.[0] ?? '') });
+} return { slideNumber: n, ...size, backgroundColor: color(/<p:bg\b[\s\S]*?<\/p:bg>/.exec(xml)?.[0] ?? '', '#ffffff') ?? '#ffffff', elements }; }
+export async function parsePptx(input, deps, options = {}) { const started = Date.now(), diagnostics = []; if (input.byteLength > (options.limits?.maxInputBytes ?? 50 * 1024 * 1024))
+    return { result: { status: 'failed', failure: { code: 'limit-exceeded', retryable: false, messageKey: 'diag.limit-exceeded.input' }, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: Date.now() - started } }; let zip; try {
+    zip = await deps.openZip(input, options);
+    const presentation = await zip.text('ppt/presentation.xml');
+    if (!presentation)
+        throw new Error('presentation');
+    const sz = /<p:sldSz\b[^>]*>/.exec(presentation)?.[0] ?? '';
+    const size = attr(sz, 'cx') && attr(sz, 'cy') ? { widthPx: Number(attr(sz, 'cx')) / EMU_PER_PX, heightPx: Number(attr(sz, 'cy')) / EMU_PER_PX } : DEFAULT_SIZE;
+    const rels = relationships(await zip.text('ppt/_rels/presentation.xml.rels') ?? '', 'ppt/presentation.xml');
+    let paths = (presentation.match(/<p:sldId\b[^>]*r:id="([^"]+)"/g) ?? []).map(t => rels.get(/r:id="([^"]+)"/.exec(t)?.[1] ?? '')).filter((x) => !!x);
+    if (!paths.length)
+        paths = (await zip.list()).filter(x => /^ppt\/slides\/slide\d+\.xml$/i.test(x)).sort((a, b) => Number(/slide(\d+)/i.exec(a)?.[1]) - Number(/slide(\d+)/i.exec(b)?.[1]));
+    const tracker = new LimitTracker({ ...DEFAULT_LIMITS, ...options.limits }, options.signal);
+    const slides = [];
+    for (const path of paths) {
+        tracker.addEntries(1);
+        const violation = tracker.checkpoint();
+        if (violation) {
+            diagnostics.push({ severity: 'warning', code: 'limit-exceeded', messageKey: violation.kind === 'aborted' ? 'diag.aborted' : 'diag.ppt.limit-exceeded' });
+            break;
+        }
+        slides.push(await parseSlide(zip, path, slides.length + 1, size));
+    }
+    const deck = { slides, totalSlides: slides.length, slideSize: size };
+    return { result: { status: slides.length === paths.length ? 'ok' : 'partial', document: deck, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: Date.now() - started } };
+}
+catch {
+    return { result: { status: 'failed', failure: { code: 'invalid-format', retryable: false, messageKey: 'diag.ppt.invalid-format' }, diagnostics }, execution: { workerUsed: false, hardLimitEnforced: false, elapsedMillis: Date.now() - started } };
+}
+finally {
+    await zip?.close?.();
+} }

package/dist/parsers/pptx/vscode-parser.d.ts

@@ -0,0 +1,167 @@
+interface ParsedElement {
+    type: 'text' | 'image' | 'table' | 'chart' | 'shape';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotateDeg?: number;
+    zIndex: number;
+    sourcePriority: number;
+    placeholderKey?: string;
+    isTitle?: boolean;
+    paragraphs?: Array<{
+        text: string;
+        level: number;
+        bullet?: boolean;
+        align?: string;
+        fontSizePx?: number;
+        bold?: boolean;
+        italic?: boolean;
+        color?: string;
+        runs?: Array<{
+            text: string;
+            fontSizePx?: number;
+            bold?: boolean;
+            italic?: boolean;
+            color?: string;
+        }>;
+    }>;
+    src?: string;
+    srcRect?: {
+        l: number;
+        t: number;
+        r: number;
+        b: number;
+    };
+    vectorFallback?: boolean;
+    tableRows?: string[][];
+    chartKind?: string;
+    chartTitle?: string;
+    chartData?: {
+        kind: 'stackedColumn' | 'line';
+        categories: string[];
+        series: Array<{
+            name: string;
+            color: string;
+            values: number[];
+            valueFormat?: string;
+            dataLabel?: {
+                showValue?: boolean;
+                numFmt?: string;
+                fontSizePx?: number;
+                color?: string;
+            };
+        }>;
+        gapWidth?: number;
+        overlap?: number;
+        legend?: {
+            position?: string;
+            fontSizePx?: number;
+            color?: string;
+            align?: string;
+        };
+        categoryAxis?: {
+            numFmt?: string;
+            fontSizePx?: number;
+            color?: string;
+            lineColor?: string;
+        };
+        valueAxis?: {
+            numFmt?: string;
+            fontSizePx?: number;
+            color?: string;
+            lineColor?: string;
+            gridColor?: string;
+            majorUnit?: number;
+            min?: number;
+            max?: number;
+            crossesAt?: number;
+        };
+    };
+    fillColor?: string;
+    borderColor?: string;
+    customSvgPath?: string;
+    presetGeom?: string;
+    headEnd?: string;
+    tailEnd?: string;
+    flipH?: boolean;
+    flipV?: boolean;
+    hasGeometry?: boolean;
+    hiddenPromptText?: boolean;
+}
+export declare class PptxXmlParser {
+    static parse(input: Uint8Array): Promise<{
+        slides: Array<{
+            slideNumber: number;
+            widthPx: number;
+            heightPx: number;
+            backgroundColor: string;
+            elements: ParsedElement[];
+        }>;
+        totalSlides: number;
+    }>;
+    private static parseSingleSlide;
+    private static mergeWithPlaceholderInheritance;
+    private static mergePlaceholderElement;
+    private static hasValidGeometry;
+    private static mergeParagraphStyles;
+    private static extractElementsFromPart;
+    private static collectBlocks;
+    private static findNextTagIndex;
+    private static parseShapeBlock;
+    private static parsePictureBlock;
+    private static parseGraphicFrameBlock;
+    private static extractTableRows;
+    private static extractTextParagraphs;
+    private static parseGeometry;
+    private static parseGroupTransform;
+    private static combineTransforms;
+    private static applyTransform;
+    private static parseTheme;
+    private static extractBackgroundColor;
+    private static extractFillColor;
+    private static stripNestedBlocks;
+    private static extractLineColor;
+    private static extractColorFromXml;
+    private static isTitleShape;
+    private static getPlaceholderKey;
+    private static normalizePlaceholderType;
+    private static getPlaceholderType;
+    private static getSlideSize;
+    private static getOrderedSlidePaths;
+    private static getRelationships;
+    private static toRelsPath;
+    private static resolvePath;
+    private static readZipText;
+    private static extractBalancedTag;
+    private static extractTagBlock;
+    private static getAttr;
+    private static parseOptionalBoolAttr;
+    private static emuToPx;
+    private static decodeXmlEntities;
+    private static extractParagraphLevelStyle;
+    private static buildColorContext;
+    private static parseMasterClrMap;
+    private static parseClrMapOverride;
+    private static parseChartData;
+    private static parseLineChartData;
+    private static parseSeriesDataLabel;
+    private static parseCategoryAxis;
+    private static parseValueAxis;
+    private static parseLegend;
+    private static parseTxPrStyle;
+    private static extractChartPoints;
+    private static extractChartNumericPoints;
+    private static padValues;
+    private static parseCustomGeometryPath;
+    private static extractPathPoint;
+    private static mapPresetColorName;
+    private static applyColorTransforms;
+    private static hexToRgb;
+    private static rgbToHex;
+    private static parseNumber;
+    private static isPlaceholderPromptText;
+    private static resolveImageTarget;
+    private static getMimeTypeByExtension;
+}
+export {};