omni-viewer-core 0.1.0

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

@@ -0,0 +1,12 @@
+import type { PptColorScheme, PptPictureAsset, PptPresentationMetrics, PptRecord, PptTextBlock } from './pptBinaryTypes.js';
+export declare function normalizeBuildSlidesArgs(slideRecords: PptRecord[], pictures: PptPictureAsset[], outlineTextByPersistId: Map<number, PptTextBlock[]>, defaultColorScheme: PptColorScheme | null, masterRecordOrPresentationMetrics: PptRecord | PptPresentationMetrics | null, presentationMetricsOrWidth: PptPresentationMetrics | number | null, widthPxOrHeight: number, heightPxOrPicturesById?: number | Map<number, PptPictureAsset>, picturesByIdMaybe?: Map<number, PptPictureAsset>): {
+    slideRecords: PptRecord[];
+    pictures: PptPictureAsset[];
+    outlineTextByPersistId: Map<number, PptTextBlock[]>;
+    defaultColorScheme: PptColorScheme | null;
+    masterRecord: PptRecord | null;
+    presentationMetrics: PptPresentationMetrics | null;
+    widthPx: number;
+    heightPx: number;
+    picturesById?: Map<number, PptPictureAsset>;
+};

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

@@ -0,0 +1,40 @@
+export function normalizeBuildSlidesArgs(slideRecords, pictures, outlineTextByPersistId, defaultColorScheme, masterRecordOrPresentationMetrics, presentationMetricsOrWidth, widthPxOrHeight, heightPxOrPicturesById, picturesByIdMaybe) {
+    const isPresentationMetrics = (value) => !!value
+        && typeof value === 'object'
+        && 'rawWidth' in value
+        && 'rawHeight' in value;
+    const isPptRecord = (value) => !!value
+        && typeof value === 'object'
+        && 'recType' in value
+        && 'payload' in value;
+    const masterRecord = isPptRecord(masterRecordOrPresentationMetrics)
+        ? masterRecordOrPresentationMetrics
+        : null;
+    const presentationMetrics = isPptRecord(masterRecordOrPresentationMetrics)
+        ? (isPresentationMetrics(presentationMetricsOrWidth) ? presentationMetricsOrWidth : null)
+        : (isPresentationMetrics(masterRecordOrPresentationMetrics)
+            ? masterRecordOrPresentationMetrics
+            : (isPresentationMetrics(presentationMetricsOrWidth) ? presentationMetricsOrWidth : null));
+    const widthPx = typeof heightPxOrPicturesById === 'number'
+        ? widthPxOrHeight
+        : typeof presentationMetricsOrWidth === 'number'
+            ? presentationMetricsOrWidth
+            : widthPxOrHeight;
+    const heightPx = typeof heightPxOrPicturesById === 'number'
+        ? heightPxOrPicturesById
+        : widthPxOrHeight;
+    const picturesById = heightPxOrPicturesById instanceof Map
+        ? heightPxOrPicturesById
+        : picturesByIdMaybe;
+    return {
+        slideRecords,
+        pictures,
+        outlineTextByPersistId,
+        defaultColorScheme,
+        masterRecord,
+        presentationMetrics,
+        widthPx,
+        heightPx,
+        picturesById
+    };
+}

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

@@ -0,0 +1,4 @@
+import { Buffer } from 'buffer';
+import type { CfbParseResult, PptRecord } from './pptBinaryTypes.js';
+export declare function parseCfb(file: Buffer): CfbParseResult;
+export declare function parseRecords(buffer: Buffer, start: number, end: number): PptRecord[];

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

@@ -0,0 +1,174 @@
+// @ts-nocheck -- upstream VS Code parser predates exactOptionalPropertyTypes.
+import { Buffer } from 'buffer';
+const FREESECT = 0xffffffff;
+const ENDOFCHAIN = 0xfffffffe;
+export function parseCfb(file) {
+    if (file.length < 512) {
+        throw new Error('Invalid CFB file: too small.');
+    }
+    const signature = file.slice(0, 8).toString('hex');
+    if (signature !== 'd0cf11e0a1b11ae1') {
+        throw new Error('Invalid CFB signature.');
+    }
+    const sectorShift = file.readUInt16LE(30);
+    const miniSectorShift = file.readUInt16LE(32);
+    const sectorSize = 1 << sectorShift;
+    const miniSectorSize = 1 << miniSectorShift;
+    const numFatSectors = file.readUInt32LE(44);
+    const firstDirSector = file.readInt32LE(48);
+    const miniCutoff = file.readUInt32LE(56);
+    const firstMiniFatSector = file.readInt32LE(60);
+    const numMiniFatSectors = file.readUInt32LE(64);
+    const firstDifatSector = file.readInt32LE(68);
+    const numDifatSectors = file.readUInt32LE(72);
+    const readSector = (sid) => {
+        const offset = (sid + 1) * sectorSize;
+        if (offset < 0 || offset + sectorSize > file.length) {
+            return Buffer.alloc(0);
+        }
+        return file.slice(offset, offset + sectorSize);
+    };
+    const difat = [];
+    for (let i = 0; i < 109; i++) {
+        const sid = file.readInt32LE(76 + i * 4);
+        if (sid !== -1)
+            difat.push(sid);
+    }
+    let nextDifat = firstDifatSector;
+    for (let i = 0; i < numDifatSectors && nextDifat !== ENDOFCHAIN && nextDifat !== -1; i++) {
+        const sec = readSector(nextDifat);
+        if (sec.length === 0)
+            break;
+        const entriesPerSector = sectorSize / 4 - 1;
+        for (let j = 0; j < entriesPerSector; j++) {
+            const sid = sec.readInt32LE(j * 4);
+            if (sid !== -1)
+                difat.push(sid);
+        }
+        nextDifat = sec.readInt32LE(sectorSize - 4);
+    }
+    const fatSectors = difat.slice(0, numFatSectors);
+    const fat = [];
+    fatSectors.forEach((sid) => {
+        const sec = readSector(sid);
+        if (sec.length === 0) {
+            return;
+        }
+        for (let i = 0; i < sectorSize; i += 4) {
+            fat.push(sec.readInt32LE(i));
+        }
+    });
+    const readChain = (startSid) => {
+        if (startSid < 0 || startSid === ENDOFCHAIN) {
+            return Buffer.alloc(0);
+        }
+        const chunks = [];
+        const seen = new Set();
+        let sid = startSid;
+        while (sid >= 0 && sid !== ENDOFCHAIN && sid !== FREESECT) {
+            if (seen.has(sid) || sid >= fat.length) {
+                break;
+            }
+            seen.add(sid);
+            const sec = readSector(sid);
+            if (sec.length === 0) {
+                break;
+            }
+            chunks.push(sec);
+            sid = fat[sid];
+        }
+        return Buffer.concat(chunks);
+    };
+    const dirStream = readChain(firstDirSector);
+    const entries = [];
+    for (let off = 0; off + 128 <= dirStream.length; off += 128) {
+        const nameLength = dirStream.readUInt16LE(off + 64);
+        const rawName = dirStream.slice(off, off + Math.max(0, nameLength - 2));
+        entries.push({
+            name: rawName.toString('utf16le').split('\u0000').join(''),
+            type: dirStream.readUInt8(off + 66),
+            leftId: dirStream.readInt32LE(off + 68),
+            rightId: dirStream.readInt32LE(off + 72),
+            childId: dirStream.readInt32LE(off + 76),
+            startSector: dirStream.readInt32LE(off + 116),
+            size: dirStream.readUInt32LE(off + 124) > 0 ? Number(dirStream.readUInt32LE(off + 120)) : dirStream.readUInt32LE(off + 120)
+        });
+    }
+    const root = entries.find((entry) => entry.type === 5);
+    const miniStream = root ? readChain(root.startSector).slice(0, root.size) : Buffer.alloc(0);
+    const miniFatStream = readChain(firstMiniFatSector);
+    const miniFat = [];
+    for (let off = 0; off + 4 <= numMiniFatSectors * sectorSize && off + 4 <= miniFatStream.length; off += 4) {
+        miniFat.push(miniFatStream.readInt32LE(off));
+    }
+    const readMiniChain = (startMiniSid, size) => {
+        if (startMiniSid < 0) {
+            return Buffer.alloc(0);
+        }
+        const chunks = [];
+        const seen = new Set();
+        let sid = startMiniSid;
+        while (sid >= 0 && sid !== ENDOFCHAIN && sid !== FREESECT) {
+            if (seen.has(sid) || sid >= miniFat.length) {
+                break;
+            }
+            seen.add(sid);
+            const start = sid * miniSectorSize;
+            const end = start + miniSectorSize;
+            if (start < 0 || end > miniStream.length) {
+                break;
+            }
+            chunks.push(miniStream.slice(start, end));
+            sid = miniFat[sid];
+        }
+        return Buffer.concat(chunks).slice(0, size);
+    };
+    const byName = new Map();
+    entries.forEach((entry) => {
+        if (entry.name) {
+            byName.set(entry.name, entry);
+        }
+    });
+    return {
+        getStream: (name) => {
+            const entry = byName.get(name);
+            if (!entry || entry.type !== 2) {
+                return null;
+            }
+            if (entry.size < miniCutoff && root) {
+                return readMiniChain(entry.startSector, entry.size);
+            }
+            return readChain(entry.startSector).slice(0, entry.size);
+        }
+    };
+}
+export function parseRecords(buffer, start, end) {
+    const records = [];
+    let offset = start;
+    while (offset + 8 <= end && offset + 8 <= buffer.length) {
+        const verInst = buffer.readUInt16LE(offset);
+        const recVer = verInst & 0x000f;
+        const recInstance = (verInst >> 4) & 0x0fff;
+        const recType = buffer.readUInt16LE(offset + 2);
+        const length = buffer.readUInt32LE(offset + 4);
+        const payloadOffset = offset + 8;
+        const payloadEnd = payloadOffset + length;
+        if (payloadEnd > end || payloadEnd > buffer.length) {
+            break;
+        }
+        const record = {
+            recType,
+            recInstance,
+            recVer,
+            length,
+            payloadOffset,
+            payload: buffer.slice(payloadOffset, payloadEnd)
+        };
+        if (recVer === 0x0f) {
+            record.children = parseRecords(buffer, payloadOffset, payloadEnd);
+        }
+        records.push(record);
+        offset = payloadEnd;
+    }
+    return records;
+}

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

@@ -0,0 +1,125 @@
+export interface CfbEntry {
+    name: string;
+    type: number;
+    leftId: number;
+    rightId: number;
+    childId: number;
+    startSector: number;
+    size: number;
+}
+export interface CfbParseResult {
+    getStream(name: string): Buffer | null;
+}
+export interface PptRecord {
+    recType: number;
+    recInstance: number;
+    recVer: number;
+    length: number;
+    payloadOffset: number;
+    payload: Buffer;
+    children?: PptRecord[];
+}
+export interface PptShapeBounds {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface PptTextBlock {
+    text: string;
+    textType?: number;
+    placeholderType?: number;
+    bounds?: PptShapeBounds;
+    color?: string;
+    fontSizePx?: number;
+    fillColor?: string;
+    borderColor?: string;
+    borderWidthPx?: number;
+    fillVisible?: boolean;
+    borderVisible?: boolean;
+    spContainerIndex?: number;
+}
+export interface PptTextGroup {
+    blocks: PptTextBlock[];
+    placeholderType?: number;
+    bounds?: PptShapeBounds;
+    fillColor?: string;
+    borderColor?: string;
+    borderWidthPx?: number;
+    fillVisible?: boolean;
+    borderVisible?: boolean;
+    spContainerIndex?: number;
+}
+export interface PptVisualSlot {
+    placeholderType?: number;
+    bounds?: PptShapeBounds;
+    fillColor?: string;
+    borderColor?: string;
+    imageRefId?: number;
+    isTextSlot?: boolean;
+    borderWidthPx?: number;
+    fillVisible?: boolean;
+    borderVisible?: boolean;
+    spContainerIndex?: number;
+}
+export interface PptColorScheme {
+    backgroundColor?: string;
+    textColor?: string;
+    titleColor?: string;
+    fillColor?: string;
+}
+export interface PptSlideLayoutInfo {
+    geom: number;
+    placeholders: number[];
+}
+export interface PptPictureAsset {
+    mime: string;
+    base64: string;
+    pictureIndex?: number;
+}
+export interface PptSlideElementParagraph {
+    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;
+    }>;
+}
+export interface PptSlideElement {
+    type: 'text' | 'image' | 'shape';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zIndex: number;
+    isTitle?: boolean;
+    paragraphs?: PptSlideElementParagraph[];
+    src?: string;
+    fillColor?: string;
+    borderColor?: string;
+    borderWidthPx?: number;
+    textStylePreset?: string;
+    rotateDeg?: number;
+}
+export interface PptSlideModel {
+    slideNumber: number;
+    widthPx: number;
+    heightPx: number;
+    backgroundColor: string;
+    elements: PptSlideElement[];
+}
+export interface PptPresentationMetrics {
+    widthPx: number;
+    heightPx: number;
+    rawWidth: number;
+    rawHeight: number;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import type { PptPictureAsset, PptPresentationMetrics, PptRecord, PptSlideModel, PptTextBlock } from './pptBinaryTypes.js';
+type ApplyMasterBackgroundImage = (elements: PptSlideModel['elements'], masterRecord: PptRecord | null, picturesById: Map<number, PptPictureAsset> | undefined, presentationMetrics: PptPresentationMetrics | null, slideWidth: number, slideHeight: number) => void;
+export declare function applyActivityProcessLayoutImpl(elements: PptSlideModel['elements'], styledShapeBlocks: PptTextBlock[], masterRecord: PptRecord | null, picturesById: Map<number, PptPictureAsset> | undefined, presentationMetrics: PptPresentationMetrics | null, slideWidth: number, slideHeight: number, applyMasterBackgroundImage: ApplyMasterBackgroundImage): void;
+export declare function applyMathPlayLetterLayoutImpl(elements: PptSlideModel['elements'], slideWidth: number, slideHeight: number): void;
+export declare function applyActivityListTableLayoutImpl(elements: PptSlideModel['elements'], slideWidth: number, slideHeight: number): void;
+export declare function applyClosingPracticeLayoutImpl(elements: PptSlideModel['elements'], masterRecord: PptRecord | null, picturesById: Map<number, PptPictureAsset> | undefined, presentationMetrics: PptPresentationMetrics | null, slideWidth: number, slideHeight: number, applyMasterBackgroundImage: ApplyMasterBackgroundImage): void;
+export declare function applyDialoguePhotoLayoutImpl(elements: PptSlideModel['elements'], slideWidth: number, slideHeight: number): void;
+export declare function applyMathIntroLayoutImpl(elements: PptSlideModel['elements'], picturesById: Map<number, PptPictureAsset> | undefined, slideWidth: number, slideHeight: number): void;
+export {};