@opencraw/office-reader 0.0.2

package/dist/src/ooxml-package/ooxml-package.client.d.ts

@@ -0,0 +1,47 @@
+/**
+ * How much a package may inflate to. fflate sizes each entry by the size its
+ * zip header declares, and never inflates past it: a header that lies about a
+ * bomb gets a truncated entry, not gigabytes. Capping the declared sizes is
+ * therefore enough.
+ */
+export interface PackageLimits {
+    /** Bytes one entry may declare. Default 256 MiB. */
+    entryBytes?: number;
+    /** Bytes the entries read from one file may declare together. Default 512 MiB. */
+    totalBytes?: number;
+}
+/** An Office Open XML package: a zip of XML parts, read part by part. */
+export declare class OoxmlPackage {
+    private readonly bytes;
+    private readonly entries;
+    private readonly limits;
+    /**
+     * Opens a package, refusing what is not one with the reason: a legacy or
+     * password-protected Office file (both are OLE compound files), an
+     * OpenDocument file, anything else that is not a zip.
+     *
+     * @param bytes - The file.
+     * @param limits - How much it may inflate to.
+     * @returns The package; no part is inflated yet.
+     * @throws OfficeReadError
+     */
+    static open(bytes: Uint8Array, limits?: PackageLimits): OoxmlPackage;
+    private declared;
+    /**
+     * Entries by part key: part names are case-insensitive (OPC), and some
+     * generators store `xl\\sharedstrings.xml` for `xl/sharedStrings.xml`.
+     */
+    private constructor();
+    /** The names of every part, as stored. */
+    get names(): string[];
+    has(name: string): boolean;
+    /**
+     * Inflates one part as UTF-8 text.
+     *
+     * @param name - The part, as stored (`xl/workbook.xml`).
+     * @returns The text; empty when the part is missing.
+     * @throws OfficeReadError: `too-large` past the limits, `malformed` when the part does not inflate.
+     */
+    text(name: string): string;
+}
+//# sourceMappingURL=ooxml-package.client.d.ts.map

package/dist/src/ooxml-package/relationships.mapper.d.ts

@@ -0,0 +1,27 @@
+import type { OoxmlPackage } from './ooxml-package.client.js';
+/** A link from one part to another, from the part's `_rels/<part>.rels`. */
+export interface Relationship {
+    id: string;
+    /** The type's last segment (`worksheet`, `sharedStrings`, `slide`): the transitional and strict namespaces differ only before it. */
+    type: string;
+    /** The target part's name within the package (`xl/worksheets/sheet1.xml`). */
+    target: string;
+}
+/**
+ * The relationships of a part, targets resolved to part names. External
+ * targets (hyperlinks) are left out.
+ *
+ * @param pkg - The package.
+ * @param part - The part (`xl/workbook.xml`), or `''` for the package's own.
+ * @returns The relationships by id.
+ */
+export declare function relationshipsOf(pkg: OoxmlPackage, part: string): Map<string, Relationship>;
+/**
+ * The first relationship of a type.
+ *
+ * @param relationships - A part's relationships.
+ * @param type - The type's last segment.
+ * @returns It, or `undefined`.
+ */
+export declare function relationshipOfType(relationships: ReadonlyMap<string, Relationship>, type: string): Relationship | undefined;
+//# sourceMappingURL=relationships.mapper.d.ts.map

package/dist/src/ooxml-package/xml-walk.algorithm.d.ts

@@ -0,0 +1,37 @@
+/** Callbacks for {@link walkXml}; element names arrive without their namespace prefix. */
+export interface XmlHandlers {
+    open?: (name: string, attributes: Record<string, string>) => void;
+    text?: (text: string) => void;
+    close?: (name: string) => void;
+}
+/**
+ * Walks an XML part as a stream of events, never building a tree, so a sheet
+ * of a million cells costs its text, not a DOM. htmlparser2 does no DTD
+ * processing: entities a document declares are not expanded (no "billion
+ * laughs") and no external entity is fetched (no XXE); only the XML built-ins
+ * and numeric references decode.
+ *
+ * Element names lose their prefix (`x:c`, `p:sp` → `c`, `sp`): generators
+ * choose prefixes freely. Attributes keep theirs; read a namespaced one with
+ * {@link namespacedAttribute}.
+ *
+ * @param xml - The part's text.
+ * @param handlers - What to do on each event.
+ */
+export declare function walkXml(xml: string, handlers: XmlHandlers): void;
+/**
+ * An attribute in a namespace whatever its prefix (`r:id`, `ns1:id`).
+ *
+ * @param attributes - The element's attributes.
+ * @param name - The local name (`id`).
+ * @returns The value, or `undefined`.
+ */
+export declare function namespacedAttribute(attributes: Record<string, string>, name: string): string | undefined;
+/**
+ * Whether an XML boolean attribute is on (`1`, `true`, `on`).
+ *
+ * @param value - The attribute's value.
+ * @returns Whether it is set.
+ */
+export declare function isOn(value: string | undefined): boolean;
+//# sourceMappingURL=xml-walk.algorithm.d.ts.map

package/dist/src/presentation/chart.mapper.d.ts

@@ -0,0 +1,13 @@
+import type { ValueMode } from '../spreadsheet/index.js';
+import type { SlideChart } from './deck.model.js';
+/**
+ * Reads a chart part: its type, title and series, from the values the chart
+ * caches next to its formulas (`c:strCache`, `c:numCache`), so the embedded
+ * workbook is never needed.
+ *
+ * @param xml - The chart part.
+ * @param mode - `typed`: values as numbers (`null` where missing); `text`: as text.
+ * @returns The chart.
+ */
+export declare function readChart(xml: string, mode: ValueMode): SlideChart<number | null | string>;
+//# sourceMappingURL=chart.mapper.d.ts.map

package/dist/src/presentation/deck.model.d.ts

@@ -0,0 +1,56 @@
+import type { Sheet } from '../spreadsheet/index.js';
+/** A text box on a slide, in points from the slide's top-left corner. */
+export interface SlideShape {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Its paragraphs joined by line breaks. */
+    text: string;
+    /** The placeholder it fills (`title`, `body`, `subTitle`…), when it fills one. */
+    placeholder?: string;
+}
+/** One series of a chart, from the values the chart keeps with it (its cache). */
+export interface ChartSeries<Value = number | null> {
+    name: string;
+    categories: string[];
+    /** One per category; `typed`: numbers, `null` where a point is missing; `text`: shortest round-trip text, `''` where missing. */
+    values: Value[];
+}
+/** A chart on a slide. */
+export interface SlideChart<Value = number | null> {
+    /** `bar`, `line`, `pie`, `area`, `scatter`, `doughnut`… (the chart element's name without `Chart`). */
+    type: string;
+    title?: string;
+    series: ChartSeries<Value>[];
+}
+/** One slide. */
+export interface Slide<Value = number | null> {
+    /** Its position in the presentation, from 1. */
+    number: number;
+    /** The text of its title placeholder. */
+    title?: string;
+    /** Hidden in a slideshow. */
+    hidden: boolean;
+    /** Its text boxes in reading order (top to bottom, left to right); slide numbers, dates and footers left out. */
+    shapes: SlideShape[];
+    /** Its tables, as sheets: `name` is `table 1`, `table 2`…; merged cells in `merges`. */
+    tables: Sheet<string>[];
+    charts: SlideChart<Value>[];
+    /** The speaker notes. */
+    notes: string;
+}
+/** A presentation read into slides. */
+export interface Deck<Value = number | null> {
+    /** The slide size, in points. */
+    width: number;
+    height: number;
+    slides: Slide<Value>[];
+}
+/** Which slides to read: numbers (from 1), a pattern on titles, or a test. */
+export type SlideFilter = number[] | RegExp | ((slide: {
+    number: number;
+    title: string;
+    hidden: boolean;
+}) => boolean);
+//# sourceMappingURL=deck.model.d.ts.map

package/dist/src/presentation/index.d.ts

@@ -0,0 +1,6 @@
+export { readPptx } from './read-pptx.use-case.js';
+export type { ReadPptxOptions } from './read-pptx.use-case.js';
+export type { Deck, Slide, SlideShape, SlideChart, ChartSeries, SlideFilter } from './deck.model.js';
+export { OfficeReadError } from '../read-error/index.js';
+export type { OfficeReadErrorCode } from '../read-error/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/presentation/notes.mapper.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The speaker notes of a notes-slide part: the text of its body placeholder
+ * (the slide image and the slide number placeholders are left out).
+ *
+ * @param xml - The notes-slide part.
+ * @returns The notes, paragraphs joined by line breaks.
+ */
+export declare function readNotes(xml: string): string;
+//# sourceMappingURL=notes.mapper.d.ts.map

package/dist/src/presentation/placeholder-geometry.mapper.d.ts

@@ -0,0 +1,53 @@
+/** A rectangle in EMU (English Metric Units: 12 700 per point). */
+export interface Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Which placeholder a shape fills. */
+export interface PlaceholderKey {
+    type: string;
+    idx?: string;
+}
+/** Where a layout or a master puts its placeholders. */
+export interface PlaceholderBoxes {
+    byIdx: Map<string, Box>;
+    byType: Map<string, Box>;
+}
+/**
+ * The positioned placeholders of a slide layout or master. A slide's title or
+ * body usually carries no position of its own: it inherits it from the
+ * placeholder with the same index in its layout, else the same type, else the
+ * master's.
+ *
+ * @param xml - The layout or master part.
+ * @returns Its placeholder boxes.
+ */
+export declare function placeholderBoxes(xml: string): PlaceholderBoxes;
+/**
+ * Where an unpositioned placeholder sits: its layout's placeholder with the
+ * same index, else the same type, else the master's of that type.
+ *
+ * @param key - The placeholder.
+ * @param layout - The slide's layout.
+ * @param master - The layout's master.
+ * @returns The box, or `undefined` when neither places it.
+ */
+export declare function inheritedBox(key: PlaceholderKey, layout: PlaceholderBoxes, master: PlaceholderBoxes): Box | undefined;
+/**
+ * Reads `a:off` and `a:ext` into a box.
+ *
+ * @param name - The element's local name.
+ * @param attributes - Its attributes.
+ * @param box - The box to fill.
+ */
+export declare function readGeometry(name: string, attributes: Record<string, string>, box: Partial<Box>): void;
+/**
+ * Whether a box has all four numbers.
+ *
+ * @param box - A box being read.
+ * @returns Whether it is complete.
+ */
+export declare function isBox(box: Partial<Box> | undefined): box is Box;
+//# sourceMappingURL=placeholder-geometry.mapper.d.ts.map

package/dist/src/presentation/read-pptx.use-case.d.ts

@@ -0,0 +1,32 @@
+import type { PackageLimits } from '../ooxml-package/index.js';
+import type { OfficeSource } from '../source-bytes/index.js';
+import type { ValueMode } from '../spreadsheet/index.js';
+import type { Deck, SlideFilter } from './deck.model.js';
+/** How to read a presentation. */
+export interface ReadPptxOptions {
+    /** Which slides to read; default all. */
+    slides?: SlideFilter;
+    /** `typed` (default): chart values as numbers; `text`: as text. */
+    values?: ValueMode;
+    /** Read speaker notes; default true. */
+    notes?: boolean;
+    /** Read charts; default true. */
+    charts?: boolean;
+    /** How much the file may inflate to. */
+    limits?: PackageLimits;
+}
+/**
+ * Reads a `.pptx` presentation (also `.pptm`, `.ppsx`): every slide's text
+ * boxes with their positions, its tables, its charts' data and its notes.
+ * Slides come in presentation order, not file order.
+ *
+ * @param source - A path, bytes, a Blob or a stream (see {@link OfficeSource}).
+ * @param options - Which slides, which value mode, what to leave out, which limits.
+ * @returns The deck.
+ * @throws OfficeReadError for a file that is not a readable presentation: `legacy-format` (`.ppt`), `encrypted`, `unsupported-format` (`.odp`), `not-pptx`, `too-large`…
+ */
+export declare function readPptx(source: OfficeSource, options: ReadPptxOptions & {
+    values: 'text';
+}): Promise<Deck<string>>;
+export declare function readPptx(source: OfficeSource, options?: ReadPptxOptions): Promise<Deck>;
+//# sourceMappingURL=read-pptx.use-case.d.ts.map

package/dist/src/presentation/slide.mapper.d.ts

@@ -0,0 +1,24 @@
+import type { Sheet } from '../spreadsheet/index.js';
+import type { SlideShape } from './deck.model.js';
+import type { Box, PlaceholderKey } from './placeholder-geometry.mapper.js';
+/** What a slide part holds, before its charts and notes are read. */
+export interface SlideContent {
+    title?: string;
+    hidden: boolean;
+    shapes: SlideShape[];
+    tables: Sheet<string>[];
+    /** The relationship ids of its charts. */
+    chartIds: string[];
+}
+/**
+ * Reads a slide part: its text boxes with their positions (group transforms
+ * applied; a placeholder without a position of its own takes the one
+ * `placeholderBox` gives), its tables with their merged cells, the ids of its
+ * charts, its title and whether it is hidden.
+ *
+ * @param xml - The slide part.
+ * @param placeholderBox - Where an unpositioned placeholder sits (from the layout and master).
+ * @returns The content.
+ */
+export declare function readSlide(xml: string, placeholderBox: (key: PlaceholderKey) => Box | undefined): SlideContent;
+//# sourceMappingURL=slide.mapper.d.ts.map

package/dist/src/read-error/index.d.ts

@@ -0,0 +1,3 @@
+export { OfficeReadError } from './office-read.error.js';
+export type { OfficeReadErrorCode } from './office-read.error.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/read-error/office-read.error.d.ts

@@ -0,0 +1,29 @@
+/** Why a file could not be read. */
+export type OfficeReadErrorCode = 
+/** The source is not something bytes can be read from (an `http:` URL, a number…). */
+'bad-source' | 
+/** The bytes are not a zip package, nor a legacy Office file. */
+'not-zip' | 
+/** An entry, or the entries read together, declare more bytes than the limits allow. */
+'too-large' | 
+/** A legacy binary Office file (`.xls`, `.ppt`, `.doc`). */
+'legacy-format' | 
+/** A password-protected Office file. */
+'encrypted' | 
+/** An OpenDocument file (`.ods`, `.odp`). */
+'unsupported-format' | 
+/** A zip package that is not a spreadsheet. */
+'not-xlsx' | 
+/** A zip package that is not a presentation. */
+'not-pptx' | 
+/** A part the package needs is missing or malformed. */
+'malformed';
+/** A file `office-reader` cannot read, with a `code` to branch on and a message that says what to do. */
+export declare class OfficeReadError extends Error {
+    readonly code: OfficeReadErrorCode;
+    readonly name = "OfficeReadError";
+    constructor(code: OfficeReadErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+//# sourceMappingURL=office-read.error.d.ts.map

package/dist/src/source-bytes/index.d.ts

@@ -0,0 +1,3 @@
+export { readSource } from './read-source.client.js';
+export type { OfficeSource } from './read-source.client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/source-bytes/read-source.client.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where a file comes from: a path or a `file:` URL (Node only), bytes in any
+ * binary form, a `Blob` or `File`, a web `ReadableStream`, or any async
+ * iterable of chunks (Node streams included). A string is always a path.
+ */
+export type OfficeSource = string | URL | Uint8Array | ArrayBuffer | ArrayBufferView | Blob | ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+/**
+ * Reads a source into one `Uint8Array`. Only a path or a `file:` URL touches
+ * the file system, through a dynamic import, so the package runs in browsers,
+ * workers and edge runtimes too. Fetching is the caller's job: an `http:` URL
+ * is refused.
+ *
+ * @param source - The file.
+ * @returns Its bytes.
+ * @throws OfficeReadError (`bad-source`) for anything else.
+ */
+export declare function readSource(source: OfficeSource): Promise<Uint8Array>;
+//# sourceMappingURL=read-source.client.d.ts.map

package/dist/src/spreadsheet/cell-value.algorithm.d.ts

@@ -0,0 +1,47 @@
+import type { CellValue, ValueMode } from './workbook.model.js';
+/** A cell as the sheet stores it. */
+export interface StoredCell {
+    /** The `t` attribute: `n` (default), `s`, `str`, `inlineStr`, `b`, `e`, `d`. */
+    type: string;
+    /** The `<v>` text, or the inline string. */
+    value: string;
+    /** How its number format reads it. */
+    format: NumberFormatKind;
+}
+/** What a number format makes of a number: a date, a time of day, or a plain number. */
+export type NumberFormatKind = 'number' | 'date' | 'time';
+/** What reading a cell needs besides the cell. */
+export interface CellContext {
+    sharedStrings: readonly string[];
+    date1904: boolean;
+}
+/**
+ * A stored cell as a typed value.
+ *
+ * @param cell - The cell.
+ * @param context - Shared strings and the date system.
+ * @returns The value; `null` for an empty cell.
+ */
+export declare function typedValue(cell: StoredCell, context: CellContext): CellValue;
+/**
+ * A stored cell as canonical text: numbers in their shortest round-trip form
+ * (`78.6`, not `78.599999999999994`), dates as ISO (`2026-06-01`, or
+ * `2026-06-01T09:30:00` with a time, `09:30:00` for a time of day), booleans
+ * as `true`/`false`, errors as written, `''` when empty. Display formats are
+ * not applied: a percentage stays a fraction (`0.125`).
+ *
+ * @param cell - The cell.
+ * @param context - Shared strings and the date system.
+ * @returns The text.
+ */
+export declare function textValue(cell: StoredCell, context: CellContext): string;
+/**
+ * Reads a cell in the mode asked for.
+ *
+ * @param cell - The cell.
+ * @param context - Shared strings and the date system.
+ * @param mode - `typed` or `text`.
+ * @returns The value.
+ */
+export declare function cellValue(cell: StoredCell, context: CellContext, mode: ValueMode): CellValue;
+//# sourceMappingURL=cell-value.algorithm.d.ts.map

package/dist/src/spreadsheet/index.d.ts

@@ -0,0 +1,6 @@
+export { readXlsx } from './read-xlsx.use-case.js';
+export type { ReadXlsxOptions } from './read-xlsx.use-case.js';
+export type { CellValue, Sheet, Workbook, ValueMode, SheetFilter } from './workbook.model.js';
+export { OfficeReadError } from '../read-error/index.js';
+export type { OfficeReadErrorCode } from '../read-error/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/spreadsheet/number-formats.mapper.d.ts

@@ -0,0 +1,10 @@
+import type { NumberFormatKind } from './cell-value.algorithm.js';
+/**
+ * What each cell style (`s`, an index into `cellXfs`) makes of a number, from
+ * `styles.xml`: only dates and times need telling apart from numbers.
+ *
+ * @param stylesXml - The styles part; empty when the workbook has none.
+ * @returns The kind per style index.
+ */
+export declare function formatKinds(stylesXml: string): NumberFormatKind[];
+//# sourceMappingURL=number-formats.mapper.d.ts.map

package/dist/src/spreadsheet/read-xlsx.use-case.d.ts

@@ -0,0 +1,27 @@
+import type { PackageLimits } from '../ooxml-package/index.js';
+import type { OfficeSource } from '../source-bytes/index.js';
+import type { SheetFilter, ValueMode, Workbook } from './workbook.model.js';
+/** How to read a workbook. */
+export interface ReadXlsxOptions {
+    /** Which sheets to read; default all. Unselected sheets are never inflated. */
+    sheets?: SheetFilter;
+    /** `typed` (default): numbers, booleans, dates as values; `text`: every cell as canonical text. */
+    values?: ValueMode;
+    /** How much the file may inflate to. */
+    limits?: PackageLimits;
+}
+/**
+ * Reads an `.xlsx` (or `.xlsm`) workbook: every worksheet's cells, with the
+ * merged ranges and hidden rows a person would see. Formulas give their
+ * cached value; nothing is evaluated. Display formats are not applied.
+ *
+ * @param source - A path, bytes, a Blob or a stream (see {@link OfficeSource}).
+ * @param options - Which sheets, which value mode, which limits.
+ * @returns The workbook.
+ * @throws OfficeReadError for a file that is not a readable workbook: `legacy-format` (`.xls`), `encrypted`, `unsupported-format` (`.ods`), `not-xlsx`, `too-large`…
+ */
+export declare function readXlsx(source: OfficeSource, options: ReadXlsxOptions & {
+    values: 'text';
+}): Promise<Workbook<string>>;
+export declare function readXlsx(source: OfficeSource, options?: ReadXlsxOptions): Promise<Workbook>;
+//# sourceMappingURL=read-xlsx.use-case.d.ts.map

package/dist/src/spreadsheet/shared-strings.mapper.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The shared string table: the text of every `<si>`, rich-text runs joined.
+ * Phonetic guides (`<rPh>`, the furigana over Japanese text) are not part of
+ * the text and are left out.
+ *
+ * @param xml - The shared strings part; empty when the workbook has none.
+ * @returns The strings, by index.
+ */
+export declare function sharedStrings(xml: string): string[];
+//# sourceMappingURL=shared-strings.mapper.d.ts.map

package/dist/src/spreadsheet/workbook.model.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A cell as `values: 'typed'` reads it: text, a number, a boolean, a date
+ * (a `Date` holding the wall-clock time as UTC: spreadsheets have no time
+ * zones), `null` when empty, or an error (`#DIV/0!`).
+ */
+export type CellValue = string | number | boolean | Date | null | {
+    error: string;
+};
+/** One worksheet: its cells as stored, plus what a person sees differently (hidden rows, merged ranges). */
+export interface Sheet<Cell = CellValue> {
+    name: string;
+    /** Hidden or very hidden in the workbook. */
+    hidden: boolean;
+    /** Top to bottom from row 1; each row runs to its last stored cell (rows can be ragged). */
+    rows: Cell[][];
+    /** Hidden rows, 0-based. */
+    hiddenRows: number[];
+    /** Merged ranges as A1 references (`B10:B13`); a range's value sits in its top-left cell only, as the file stores it. */
+    merges: string[];
+}
+/** A workbook read into sheets. */
+export interface Workbook<Cell = CellValue> {
+    /** Whether the workbook counts dates from 1904 (old Mac Excel) instead of 1900. */
+    date1904: boolean;
+    /** The worksheets, in workbook order (chart sheets are left out). */
+    sheets: Sheet<Cell>[];
+}
+/** `typed`: numbers, booleans, dates as values; `text`: every cell as canonical text. */
+export type ValueMode = 'typed' | 'text';
+/** Which sheets to read: a name, a pattern, or a test. Unselected sheets are never inflated. */
+export type SheetFilter = string | RegExp | ((sheet: {
+    name: string;
+    hidden: boolean;
+}) => boolean);
+//# sourceMappingURL=workbook.model.d.ts.map

package/dist/src/spreadsheet/worksheet.mapper.d.ts

@@ -0,0 +1,23 @@
+import type { CellContext, NumberFormatKind } from './cell-value.algorithm.js';
+import type { CellValue, ValueMode } from './workbook.model.js';
+/** A worksheet part, read. */
+export interface WorksheetContent {
+    rows: CellValue[][];
+    hiddenRows: number[];
+    merges: string[];
+}
+/**
+ * Reads a worksheet part as a stream: rows of cells (formulas give their
+ * cached value, never evaluated), hidden rows and merged ranges. A row or a
+ * cell without its reference (some generators leave `r` out) follows the one
+ * before it.
+ *
+ * @param xml - The worksheet part.
+ * @param context - Shared strings, number format kinds and the date system.
+ * @param mode - `typed` or `text`.
+ * @returns The content.
+ */
+export declare function readWorksheet(xml: string, context: CellContext & {
+    formats: readonly NumberFormatKind[];
+}, mode: ValueMode): WorksheetContent;
+//# sourceMappingURL=worksheet.mapper.d.ts.map

package/dist/xlsx.d.ts

@@ -0,0 +1 @@
+export * from "./src/spreadsheet/index.js";

package/dist/xlsx.esm.js

@@ -0,0 +1,5 @@
+export { r as readXlsx } from './read-xlsx.use-case.esm.js';
+export { O as OfficeReadError } from './read-source.client.esm.js';
+import 'fflate';
+import 'htmlparser2';
+//# sourceMappingURL=xlsx.esm.js.map

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@opencraw/office-reader",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "./dist/index.esm.js",
+  "module": "./dist/index.esm.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "default": "./dist/index.esm.js"
+    },
+    "./xlsx": {
+      "types": "./dist/src/spreadsheet/index.d.ts",
+      "import": "./dist/xlsx.esm.js",
+      "default": "./dist/xlsx.esm.js"
+    },
+    "./pptx": {
+      "types": "./dist/src/presentation/index.d.ts",
+      "import": "./dist/pptx.esm.js",
+      "default": "./dist/pptx.esm.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.d.ts.map",
+    "!**/*.js.map"
+  ],
+  "dependencies": {
+    "fflate": "^0.8.3",
+    "htmlparser2": "^10.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Reads Office files (.xlsx workbooks, .pptx presentations) into plain objects: cells with merged ranges and hidden rows, slides with positioned text, tables and chart data. No Node built-ins beyond reading a path: runs in Node, browsers, workers and edge runtimes.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/russoedu/open.craw.git",
+    "directory": "packages/office-reader"
+  },
+  "keywords": [
+    "xlsx",
+    "excel",
+    "spreadsheet",
+    "pptx",
+    "powerpoint",
+    "presentation",
+    "office",
+    "ooxml",
+    "reader",
+    "parser",
+    "json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "sideEffects": false,
+  "nx": {
+    "targets": {
+      "e2e": {
+        "executor": "nx:run-commands",
+        "dependsOn": [
+          "build"
+        ],
+        "options": {
+          "command": "tsc -p tsconfig.e2e.json && jest --config jest.e2e.config.cts",
+          "cwd": "packages/office-reader"
+        }
+      }
+    }
+  }
+}