@opencraw/office-reader 0.0.2

package/dist/read-source.client.esm.js

@@ -0,0 +1,289 @@
+import { unzipSync, strFromU8 } from 'fflate';
+import { Parser } from 'htmlparser2';
+
+/** A file `office-reader` cannot read, with a `code` to branch on and a message that says what to do. */
+class OfficeReadError extends Error {
+  code;
+  name = 'OfficeReadError';
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+  }
+}
+
+const MIB = 1024 * 1024;
+const DEFAULT_ENTRY_BYTES = 256 * MIB;
+const DEFAULT_TOTAL_BYTES = 512 * MIB;
+/** An Office Open XML package: a zip of XML parts, read part by part. */
+class OoxmlPackage {
+  bytes;
+  entries;
+  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, limits = {}) {
+    if (isCompoundFile(bytes)) {
+      if (holdsEncryptionInfo(bytes)) throw new OfficeReadError('encrypted', 'a password-protected Office file: remove the password and save it again');
+      throw new OfficeReadError('legacy-format', 'a legacy binary Office file (.xls, .ppt, .doc): save it as .xlsx or .pptx, or export it as PDF');
+    }
+    const entries = new Map();
+    try {
+      unzipSync(bytes, {
+        filter: file => {
+          entries.set(partKey(file.name), {
+            name: file.name,
+            size: file.originalSize
+          });
+          return false;
+        }
+      });
+    } catch (error) {
+      throw new OfficeReadError('not-zip', `not an Office file: not a readable zip (${error.message})`, {
+        cause: error
+      });
+    }
+    const opened = new OoxmlPackage(bytes, entries, {
+      entryBytes: limits.entryBytes ?? DEFAULT_ENTRY_BYTES,
+      totalBytes: limits.totalBytes ?? DEFAULT_TOTAL_BYTES
+    });
+    const mimetype = opened.has('mimetype') ? opened.text('mimetype').trim() : '';
+    if (mimetype.startsWith('application/vnd.oasis.opendocument')) throw new OfficeReadError('unsupported-format', `an OpenDocument file (${mimetype}): save it as .xlsx or .pptx`);
+    return opened;
+  }
+  declared = 0;
+  /**
+   * Entries by part key: part names are case-insensitive (OPC), and some
+   * generators store `xl\\sharedstrings.xml` for `xl/sharedStrings.xml`.
+   */
+  constructor(bytes, entries, limits) {
+    this.bytes = bytes;
+    this.entries = entries;
+    this.limits = limits;
+  }
+  /** The names of every part, as stored. */
+  get names() {
+    return Array.from(this.entries.values(), entry => entry.name);
+  }
+  has(name) {
+    return this.entries.has(partKey(name));
+  }
+  /**
+   * 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) {
+    const entry = this.entries.get(partKey(name));
+    if (entry === undefined) return '';
+    if (entry.size > this.limits.entryBytes) throw new OfficeReadError('too-large', `${name} declares ${entry.size} bytes, over the ${this.limits.entryBytes}-byte entry limit`);
+    this.declared += entry.size;
+    if (this.declared > this.limits.totalBytes) throw new OfficeReadError('too-large', `the parts read declare over ${this.limits.totalBytes} bytes together`);
+    let inflated;
+    try {
+      inflated = unzipSync(this.bytes, {
+        filter: file => file.name === entry.name
+      })[entry.name];
+    } catch (error) {
+      throw new OfficeReadError('malformed', `${name} does not inflate (${error.message}): the file is damaged`, {
+        cause: error
+      });
+    }
+    return inflated === undefined ? '' : strFromU8(inflated);
+  }
+}
+/** How a part is looked up: forward slashes, no leading slash, lower case. */
+function partKey(name) {
+  return name.replaceAll('\\', '/').replace(/^\//, '').toLowerCase();
+}
+/** An OLE compound file (`D0 CF 11 E0 A1 B1 1A E1`): a legacy Office file, or an encrypted new one. */
+function isCompoundFile(bytes) {
+  const signature = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
+  return signature.every((byte, index) => bytes[index] === byte);
+}
+/** Whether a compound file holds an `EncryptionInfo` stream: an encrypted .xlsx/.pptx, not a legacy file. */
+function holdsEncryptionInfo(bytes) {
+  const name = [...'EncryptionInfo'].flatMap(char => [char.codePointAt(0) ?? 0, 0]);
+  const last = bytes.length - name.length;
+  for (let start = 0; start <= last; start += 1) {
+    if (name.every((byte, index) => bytes[start + index] === byte)) return true;
+  }
+  return false;
+}
+
+/**
+ * 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.
+ */
+function walkXml(xml, handlers) {
+  const parser = new Parser({
+    onopentag: (name, attributes) => handlers.open?.(localName(name), attributes),
+    ontext: text => handlers.text?.(text),
+    onclosetag: name => handlers.close?.(localName(name))
+  }, {
+    xmlMode: true,
+    decodeEntities: true
+  });
+  parser.write(xml);
+  parser.end();
+}
+/**
+ * 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`.
+ */
+function namespacedAttribute(attributes, name) {
+  const key = Object.keys(attributes).find(candidate => candidate.endsWith(`:${name}`) && !candidate.startsWith('xmlns'));
+  return key === undefined ? undefined : attributes[key];
+}
+/**
+ * Whether an XML boolean attribute is on (`1`, `true`, `on`).
+ *
+ * @param value - The attribute's value.
+ * @returns Whether it is set.
+ */
+function isOn(value) {
+  return value !== undefined && ['1', 'true', 'on'].includes(value);
+}
+function localName(name) {
+  const colon = name.indexOf(':');
+  return colon === -1 ? name : name.slice(colon + 1);
+}
+
+/**
+ * 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.
+ */
+function relationshipsOf(pkg, part) {
+  const directory = part.includes('/') ? part.slice(0, part.lastIndexOf('/')) : '';
+  const file = part.slice(part.lastIndexOf('/') + 1);
+  const relationships = new Map();
+  walkXml(pkg.text(`${directory === '' ? '' : `${directory}/`}_rels/${file}.rels`), {
+    open: (name, attributes) => {
+      if (name !== 'Relationship' || attributes.TargetMode === 'External' || attributes.Id === undefined || attributes.Target === undefined) return;
+      relationships.set(attributes.Id, {
+        id: attributes.Id,
+        type: (attributes.Type ?? '').split('/').at(-1) ?? '',
+        target: resolvePart(directory, attributes.Target)
+      });
+    }
+  });
+  return relationships;
+}
+/**
+ * The first relationship of a type.
+ *
+ * @param relationships - A part's relationships.
+ * @param type - The type's last segment.
+ * @returns It, or `undefined`.
+ */
+function relationshipOfType(relationships, type) {
+  for (const relationship of relationships.values()) {
+    if (relationship.type === type) return relationship;
+  }
+  return undefined;
+}
+/** A target relative to its source part's directory (`worksheets/sheet1.xml`, `../media/x.png`) or absolute (`/xl/…`). */
+function resolvePart(directory, target) {
+  const segments = target.startsWith('/') ? [] : directory.split('/').filter(segment => segment !== '');
+  for (const segment of target.split('/')) {
+    if (segment === '..') segments.pop();else if (segment !== '.' && segment !== '') segments.push(segment);
+  }
+  return segments.join('/');
+}
+
+/**
+ * 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.
+ */
+async function readSource(source) {
+  if (typeof source === 'string') return readPath(source);
+  if (source instanceof URL) {
+    if (source.protocol !== 'file:') throw new OfficeReadError('bad-source', `${source.href}: office-reader reads files, not URLs; fetch it and pass the bytes`);
+    return readPath(source);
+  }
+  if (source instanceof Uint8Array) return source;
+  if (source instanceof ArrayBuffer) return new Uint8Array(source);
+  if (ArrayBuffer.isView(source)) return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+  if (typeof Blob !== 'undefined' && source instanceof Blob) return new Uint8Array(await source.arrayBuffer());
+  if (isReadableStream(source)) return concat(await readStream(source));
+  if (isAsyncIterable(source)) return concat(await readIterable(source));
+  throw new OfficeReadError('bad-source', 'office-reader reads a path, a file: URL, bytes, a Blob, a ReadableStream or an async iterable of bytes');
+}
+async function readPath(path) {
+  const {
+    readFile
+  } = await import('node:fs/promises');
+  return new Uint8Array(await readFile(path));
+}
+function isReadableStream(value) {
+  return typeof value === 'object' && value !== null && typeof value.getReader === 'function';
+}
+function isAsyncIterable(value) {
+  return typeof value === 'object' && value !== null && typeof value[Symbol.asyncIterator] === 'function';
+}
+async function readStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  for (;;) {
+    const {
+      done,
+      value
+    } = await reader.read();
+    if (done) return chunks;
+    chunks.push(chunkOf(value));
+  }
+}
+async function readIterable(iterable) {
+  const chunks = [];
+  for await (const chunk of iterable) chunks.push(chunkOf(chunk));
+  return chunks;
+}
+function chunkOf(chunk) {
+  if (chunk instanceof Uint8Array) return chunk;
+  throw new OfficeReadError('bad-source', 'a stream of text is not a file: read it as bytes (no encoding set)');
+}
+function concat(chunks) {
+  if (chunks.length === 1) return chunks[0];
+  const bytes = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return bytes;
+}
+
+export { OfficeReadError as O, OoxmlPackage as a, relationshipOfType as b, relationshipsOf as c, isOn as i, namespacedAttribute as n, readSource as r, walkXml as w };
+//# sourceMappingURL=read-source.client.esm.js.map

package/dist/read-xlsx.use-case.esm.js

@@ -0,0 +1,381 @@
+import { w as walkXml, i as isOn, a as OoxmlPackage, r as readSource, O as OfficeReadError, b as relationshipOfType, c as relationshipsOf, n as namespacedAttribute } from './read-source.client.esm.js';
+import 'fflate';
+
+/** Built-in number formats that show a date (14–17, 22 and the East Asian ones) or a time of day (18–21, 45–47). */
+const BUILT_IN_DATES = new Set([14, 15, 16, 17, 22, 27, 28, 29, 30, 31, 34, 35, 36, 50, 51, 52, 53, 54, 57, 58]);
+const BUILT_IN_TIMES = new Set([18, 19, 20, 21, 32, 33, 45, 46, 47, 55, 56]);
+/**
+ * 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.
+ */
+function formatKinds(stylesXml) {
+  const codes = new Map();
+  const kinds = [];
+  let inCellXfs = false;
+  walkXml(stylesXml, {
+    open: (name, attributes) => {
+      if (name === 'numFmt') codes.set(Number(attributes.numFmtId), attributes.formatCode ?? '');else if (name === 'cellXfs') inCellXfs = true;else if (name === 'xf' && inCellXfs) kinds.push(kindOf(Number(attributes.numFmtId ?? 0), codes));
+    },
+    close: name => {
+      if (name === 'cellXfs') inCellXfs = false;
+    }
+  });
+  return kinds;
+}
+/**
+ * What a format code shows: a date when it has a day, month or year, a time
+ * of day when it has only hours, minutes or seconds. Quoted text, escaped
+ * characters, colours and locales (`[Red]`, `[$-409]`) are ignored; an
+ * elapsed time (`[h]:mm`) is a duration, so a number.
+ */
+function kindOf(id, codes) {
+  const code = codes.get(id);
+  if (code === undefined) {
+    if (BUILT_IN_DATES.has(id)) return 'date';
+    return BUILT_IN_TIMES.has(id) ? 'time' : 'number';
+  }
+  const firstSection = code.split(';', 1)[0];
+  if (/\[(?:h+|m+|s+)\]/i.test(firstSection)) return 'number';
+  const bare = firstSection.replaceAll(/"[^"]*"|\\.|\[[^\]]*\]/g, '').replaceAll(/am\/pm|a\/p/gi, '');
+  if (/[dy]/i.test(bare) || hasMonth(bare)) return 'date';
+  return /[hs]/i.test(bare) ? 'time' : 'number';
+}
+/** Whether a run of `m` is a month: minutes sit after an hour or before seconds (`h:mm`, `mm:ss`). */
+function hasMonth(code) {
+  for (const run of code.matchAll(/m+/gi)) {
+    const before = code.slice(0, run.index).trimEnd().at(-1)?.toLowerCase();
+    const after = code.slice(run.index + run[0].length).trimStart()[0]?.toLowerCase();
+    const minutes = before === 'h' || before === ':' || after === ':' || after === 's';
+    if (!minutes) return true;
+  }
+  return false;
+}
+
+/**
+ * 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.
+ */
+function sharedStrings(xml) {
+  const strings = [];
+  let current;
+  let inText = false;
+  let phonetic = 0;
+  walkXml(xml, {
+    open: name => {
+      if (name === 'si') current = '';else if (name === 'rPh') phonetic += 1;else if (name === 't' && phonetic === 0) inText = true;
+    },
+    text: text => {
+      if (inText && current !== undefined) current += text;
+    },
+    close: name => {
+      switch (name) {
+        case 't':
+          {
+            inText = false;
+            break;
+          }
+        case 'rPh':
+          {
+            phonetic -= 1;
+            break;
+          }
+        case 'si':
+          {
+            strings.push(current ?? '');
+            current = undefined;
+            break;
+          }
+        // No default
+      }
+    }
+  });
+  return strings;
+}
+
+const MS_PER_DAY = 86_400_000;
+/** 1970-01-01 as a 1900-system serial number. */
+const UNIX_EPOCH_SERIAL = 25_569;
+/** Days between the 1900 and the 1904 systems' day zero. */
+const DAYS_1904 = 1462;
+/**
+ * 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.
+ */
+function typedValue(cell, context) {
+  switch (cell.type) {
+    case 's':
+      {
+        return context.sharedStrings[Number(cell.value)] ?? '';
+      }
+    case 'str':
+    case 'inlineStr':
+      {
+        return cell.value;
+      }
+    case 'b':
+      {
+        return cell.value === '1' || cell.value === 'true';
+      }
+    case 'e':
+      {
+        return {
+          error: cell.value
+        };
+      }
+    case 'd':
+      {
+        const date = new Date(cell.value.endsWith('Z') || /[+-]\d\d:\d\d$/.test(cell.value) ? cell.value : `${cell.value}Z`);
+        return Number.isNaN(date.getTime()) ? cell.value : date;
+      }
+    default:
+      {
+        if (cell.value.trim() === '') return null;
+        const number = Number(cell.value);
+        if (Number.isNaN(number)) return cell.value;
+        return cell.format === 'number' ? number : dateOf(number, context.date1904);
+      }
+  }
+}
+/**
+ * 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.
+ */
+function textValue(cell, context) {
+  const value = typedValue(cell, context);
+  if (value === null) return '';
+  if (value instanceof Date) return isoText(value, cell.format === 'time' && Number(cell.value) < 1);
+  if (typeof value === 'object') return value.error;
+  return String(value);
+}
+/**
+ * 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.
+ */
+function cellValue(cell, context, mode) {
+  return mode === 'text' ? textValue(cell, context) : typedValue(cell, context);
+}
+/**
+ * A serial date as a `Date` holding the wall-clock time as UTC, rounded to the
+ * second. The 1900 system counts the 29th of February 1900 that never was
+ * (Lotus's bug, kept for compatibility): serials before it are a day early.
+ */
+function dateOf(serial, date1904) {
+  let days = date1904 ? serial + DAYS_1904 : serial;
+  if (!date1904 && serial >= 1 && serial < 60) days += 1;
+  const seconds = Math.round((days - UNIX_EPOCH_SERIAL) * (MS_PER_DAY / 1000));
+  return new Date(seconds * 1000);
+}
+function isoText(date, timeOfDay) {
+  const iso = date.toISOString();
+  if (timeOfDay) return iso.slice(11, 19);
+  return iso.slice(11, 19) === '00:00:00' ? iso.slice(0, 10) : iso.slice(0, 19);
+}
+
+/**
+ * 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.
+ */
+function readWorksheet(xml, context, mode) {
+  const rows = [];
+  const hiddenRows = [];
+  const merges = [];
+  let row = -1;
+  let column = -1;
+  let cell;
+  let capturing;
+  let phonetic = 0;
+  const finish = open => {
+    const stored = {
+      type: open.type,
+      value: open.value,
+      format: context.formats[open.style] ?? 'number'
+    };
+    rows[open.row] ??= [];
+    rows[open.row][open.column] = cellValue(stored, context, mode);
+  };
+  walkXml(xml, {
+    open: (name, attributes) => {
+      switch (name) {
+        case 'row':
+          {
+            row = attributes.r === undefined ? row + 1 : Number(attributes.r) - 1;
+            column = -1;
+            rows[row] ??= [];
+            if (isOn(attributes.hidden)) hiddenRows.push(row);
+            break;
+          }
+        case 'c':
+          {
+            const reference = attributes.r === undefined ? undefined : cellOf(attributes.r);
+            if (reference !== undefined) row = reference.row;
+            column = reference?.column ?? column + 1;
+            cell = {
+              row,
+              column,
+              type: attributes.t ?? 'n',
+              style: Number(attributes.s ?? 0),
+              value: ''
+            };
+            break;
+          }
+        case 'v':
+          {
+            if (cell !== undefined) capturing = 'value';
+            break;
+          }
+        case 'rPh':
+          {
+            phonetic += 1;
+            break;
+          }
+        case 't':
+          {
+            if (phonetic === 0 && cell?.type === 'inlineStr') capturing = 'inline';
+            break;
+          }
+        case 'mergeCell':
+          {
+            if (attributes.ref !== undefined) merges.push(attributes.ref);
+            break;
+          }
+        // No default
+      }
+    },
+    text: text => {
+      if (capturing !== undefined && cell !== undefined) cell.value += text;
+    },
+    close: name => {
+      if (name === 'v' || name === 't') {
+        capturing = undefined;
+      } else if (name === 'rPh') {
+        phonetic -= 1;
+      } else if (name === 'c' && cell !== undefined) {
+        finish(cell);
+        cell = undefined;
+      }
+    }
+  });
+  const empty = mode === 'text' ? '' : null;
+  return {
+    rows: Array.from(rows, cells => Array.from(cells ?? [], value => value ?? empty)),
+    hiddenRows,
+    merges
+  };
+}
+/** `AB12` as 0-based row and column. */
+function cellOf(reference) {
+  const match = /^\$?([A-Z]+)\$?(\d+)$/i.exec(reference);
+  if (match === null) return undefined;
+  const letters = match[1].toUpperCase();
+  let column = 0;
+  for (const letter of letters) column = column * 26 + (letter.codePointAt(0) ?? 64) - 64;
+  return {
+    row: Number(match[2]) - 1,
+    column: column - 1
+  };
+}
+
+async function readXlsx(source, options = {}) {
+  const pkg = OoxmlPackage.open(await readSource(source), options.limits);
+  const workbookPart = mainPart(pkg);
+  let date1904 = false;
+  const entries = [];
+  let isWorkbook = false;
+  walkXml(pkg.text(workbookPart), {
+    open: (name, attributes) => {
+      switch (name) {
+        case 'workbook':
+          {
+            isWorkbook = true;
+            break;
+          }
+        case 'workbookPr':
+          {
+            date1904 = isOn(attributes.date1904);
+            break;
+          }
+        case 'sheet':
+          {
+            {
+              entries.push({
+                name: attributes.name ?? '',
+                hidden: attributes.state === 'hidden' || attributes.state === 'veryHidden',
+                id: namespacedAttribute(attributes, 'id')
+              });
+              // No default
+            }
+            break;
+          }
+      }
+    }
+  });
+  if (!isWorkbook) throw new OfficeReadError('not-xlsx', `not a spreadsheet: the package's main part is ${workbookPart === '' ? 'missing' : workbookPart}${workbookPart.endsWith('presentation.xml') ? ' (a presentation: read it with readPptx)' : ''}`);
+  const relationships = relationshipsOf(pkg, workbookPart);
+  const stringsPart = relationshipOfType(relationships, 'sharedStrings')?.target;
+  const stylesPart = relationshipOfType(relationships, 'styles')?.target;
+  const context = {
+    sharedStrings: stringsPart === undefined ? [] : sharedStrings(pkg.text(stringsPart)),
+    formats: stylesPart === undefined ? [] : formatKinds(pkg.text(stylesPart)),
+    date1904
+  };
+  const selected = selector(options.sheets);
+  const sheets = [];
+  for (const entry of entries) {
+    const part = entry.id === undefined ? undefined : relationships.get(entry.id);
+    // Chart sheets, dialog sheets and macro sheets hold no cells.
+    if (part?.type !== 'worksheet' || !selected(entry)) continue;
+    const content = readWorksheet(pkg.text(part.target), context, options.values ?? 'typed');
+    sheets.push({
+      name: entry.name,
+      hidden: entry.hidden,
+      ...content
+    });
+  }
+  return {
+    date1904,
+    sheets
+  };
+}
+/** The package's main part, from its root relationships (`xl/workbook.xml` by convention, not by rule). */
+function mainPart(pkg) {
+  const main = relationshipOfType(relationshipsOf(pkg, ''), 'officeDocument')?.target;
+  if (main !== undefined) return main;
+  return pkg.has('xl/workbook.xml') ? 'xl/workbook.xml' : '';
+}
+function selector(filter) {
+  if (filter === undefined) return () => true;
+  if (typeof filter === 'string') return sheet => sheet.name === filter;
+  if (filter instanceof RegExp) return sheet => filter.test(sheet.name);
+  return filter;
+}
+
+export { readXlsx as r };
+//# sourceMappingURL=read-xlsx.use-case.esm.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+export { readXlsx } from './spreadsheet/index.js';
+export type { ReadXlsxOptions, CellValue, Sheet, Workbook, ValueMode, SheetFilter } from './spreadsheet/index.js';
+export { readPptx } from './presentation/index.js';
+export type { ReadPptxOptions, Deck, Slide, SlideShape, SlideChart, ChartSeries, SlideFilter } from './presentation/index.js';
+export { OfficeReadError } from './read-error/index.js';
+export type { OfficeReadErrorCode } from './read-error/index.js';
+export type { OfficeSource } from './source-bytes/index.js';
+export type { PackageLimits } from './ooxml-package/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,7 @@
+export { OoxmlPackage } from './ooxml-package.client.js';
+export type { PackageLimits } from './ooxml-package.client.js';
+export { walkXml, namespacedAttribute, isOn } from './xml-walk.algorithm.js';
+export type { XmlHandlers } from './xml-walk.algorithm.js';
+export { relationshipsOf, relationshipOfType } from './relationships.mapper.js';
+export type { Relationship } from './relationships.mapper.js';
+//# sourceMappingURL=index.d.ts.map