@bendyline/squisq-formats 1.2.3 → 1.3.1

package/dist/epub/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/epub/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/html/index.d.ts

@@ -1,3 +1,275 @@
+import { Doc, Theme } from '@bendyline/squisq/schemas';
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
+
+/**
+ * HTML Template Generation for SquisqPlayer Exports
+ *
+ * Generates complete, self-contained HTML documents that load the SquisqPlayer
+ * IIFE bundle and render a Doc as either an interactive slideshow or a static
+ * scrollable document.
+ *
+ * Two variants:
+ * 1. **Inline** — All JS, CSS, and images are embedded in the HTML (single file).
+ * 2. **External** — JS is referenced via `<script src>`, images via relative paths.
+ */
+
+interface HtmlExportOptions {
+    /** The IIFE player bundle source code (from @bendyline/squisq-react/standalone-source) */
+    playerScript: string;
+    /**
+     * Map of relative image paths (as they appear in the Doc) to binary image data.
+     * For inline HTML export, these are converted to base64 data URIs.
+     * For ZIP export, these are written as separate files.
+     */
+    images?: Map<string, ArrayBuffer>;
+    /**
+     * Map of audio segment identifiers to binary audio data.
+     * Keys should match the audio segment `name` or `url` fields in the Doc.
+     * Only used in ZIP exports — single HTML uses timer-based playback.
+     */
+    audio?: Map<string, ArrayBuffer>;
+    /** Rendering mode: 'slideshow' (interactive, default) or 'static' (scrollable) */
+    mode?: 'slideshow' | 'static';
+    /** HTML page title (default: 'Squisq Document') */
+    title?: string;
+    /** Auto-play slideshow on load (default: false) */
+    autoPlay?: boolean;
+    /**
+     * Squisq theme ID to apply (e.g., 'documentary', 'cinematic').
+     * When set, the theme is assigned to the Doc before rendering,
+     * so the SquisqPlayer renders with that theme's colors and typography.
+     */
+    themeId?: string;
+}
+/**
+ * Collect all relative image paths referenced in a Doc's layers and template blocks.
+ * Returns a Set of unique relative paths that need to be resolved.
+ */
+declare function collectImagePaths(doc: Doc): Set<string>;
+
+/**
+ * Image Utilities for HTML Export
+ *
+ * Browser-compatible helpers for converting image data to base64 data URIs
+ * and inferring MIME types from filenames.
+ */
+/**
+ * Infer a MIME type from a filename's extension.
+ * Returns 'application/octet-stream' for unknown types.
+ */
+declare function inferMimeType(filename: string): string;
+/**
+ * Convert an ArrayBuffer to a base64-encoded data URI string.
+ *
+ * @param buffer - The binary image data
+ * @param mimeType - MIME type (e.g., 'image/jpeg'). If not provided, defaults to
+ *   'application/octet-stream'.
+ * @returns A `data:` URI string
+ */
+declare function arrayBufferToBase64DataUrl(buffer: ArrayBuffer, mimeType: string): string;
+/**
+ * Extract the filename from a path or URL (strips directory and query).
+ *
+ * @example
+ *   extractFilename('images/hero.jpg') // 'hero.jpg'
+ *   extractFilename('https://example.com/photo.png?v=2') // 'photo.png'
+ */
+declare function extractFilename(path: string): string;
+
+/**
+ * Plain HTML Export — semantic, player-free
+ *
+ * Renders a MarkdownDocument to a self-contained HTML string. Unlike
+ * `docToHtml` (which bundles the SquisqPlayer IIFE and renders SVG block
+ * cards), this output is what a reader-mode tool would produce: semantic
+ * `<h1>`/`<p>`/`<ul>`/etc. with a small embedded stylesheet, no JS, no
+ * runtime path-rewriting. Drives both the "Page" preview tab in the
+ * editor and the plain-style branch of the export dialog so what users
+ * see live matches the file they download.
+ *
+ * Image URLs default to the markdown's own paths. Pass `images` to
+ * substitute a different value per source URL — typically pre-resolved
+ * blob URLs (live preview) or data URIs (single-file export).
+ */
+
+interface PlainHtmlExportOptions {
+    /** Document title — populates `<title>` and is HTML-escaped. */
+    title?: string;
+    /**
+     * Substitution map for image `src` URLs. Keys are the URL exactly as
+     * it appears in the markdown source; values are the URL to emit in
+     * the rendered `<img src>`. URLs not present in the map fall through
+     * unchanged (so external `https://…` references still work).
+     */
+    images?: Map<string, string>;
+    /**
+     * Substitution map for anchor `href` URLs. Keys are the URL exactly
+     * as it appears in the markdown source (e.g. `'resume.md'`,
+     * `'resume.md#experience'`); values are the URL to emit. URLs not in
+     * the map pass through unchanged. Used by the recursive bundle
+     * exporter to rewrite `.md` references to `.html` so a static export
+     * of a linked document tree is internally browsable.
+     */
+    links?: Map<string, string>;
+    /**
+     * Optional Squisq theme. When provided, the rendered page uses the
+     * theme's colors and typography, and any Google-hosted fonts the
+     * theme references are loaded via a `<link>` to fonts.googleapis.com
+     * so the face renders correctly without host preloads.
+     *
+     * When omitted, the function falls back (in order) to {@link themeId}
+     * and then to `doc.frontmatter.themeId` — so an authored
+     * `themeId: warm-earth` in the doc's frontmatter styles the export
+     * automatically, without the caller having to wire theme resolution
+     * themselves.
+     */
+    theme?: Theme;
+    /**
+     * Optional theme id (e.g. `'warm-earth'`, `'gezellig'`). Convenient
+     * for hosts whose export dialog tracks themes by id — they can pass
+     * the id straight through instead of resolving to a `Theme` object.
+     * When both `theme` and `themeId` are provided, `theme` wins.
+     */
+    themeId?: string;
+    /**
+     * Optional FontAwesome CSS text to inline into the rendered page,
+     * replacing the default cross-origin `<link>` to cdnjs. Required for
+     * sandboxed iframe previews where tracking prevention or stricter
+     * origin policies can silently drop cross-origin font fetches —
+     * inlining keeps the icons resolvable purely from same-origin
+     * resources. Hosts typically gather this string by scraping
+     * `document.styleSheets` for `@font-face` rules whose family starts
+     * with `"Font Awesome"`. The CDN `<link>` is only emitted when this
+     * option is not provided.
+     */
+    iconsCss?: string;
+}
+/**
+ * Render a parsed markdown document as a complete, semantic HTML page.
+ *
+ * When `options.theme` is provided, the output adopts the theme's
+ * colors and typography. Google-hosted fonts referenced by the theme
+ * are loaded via a single `<link>` to fonts.googleapis.com so the page
+ * renders consistently when opened standalone.
+ */
+declare function markdownDocToPlainHtml(doc: MarkdownDocument, options?: PlainHtmlExportOptions): string;
+
+/**
+ * Recursive plain-HTML bundle export.
+ *
+ * `markdownDocsToPlainHtmlBundle` starts from a single entry markdown
+ * file, walks its relative `[…](other.md)` links, recursively pulls in
+ * any sibling/child documents (scope-limited to the entry doc's
+ * directory tree), renders every visited file via
+ * `markdownDocToPlainHtml`, rewrites cross-doc references from `.md`
+ * to `.html`, and ships everything as a single ZIP.
+ *
+ * The function is provider-agnostic — callers pass `readDocument` and
+ * `readBinary` callbacks that resolve relative paths against whatever
+ * storage they use (`FileSystemContentContainer`, `MemoryContent-
+ * Container`, in-memory map for tests, …). Failure to read any
+ * discovered file aborts the whole export with a thrown error.
+ */
+
+interface PlainHtmlBundleOptions {
+    /** Entry document path relative to the container root (e.g. `'home.md'`). */
+    entryPath: string;
+    /** Reads a UTF-8 markdown file from the container. Returns null when absent. */
+    readDocument: (path: string) => Promise<string | null>;
+    /** Reads a binary asset (image) from the container. Returns null when absent. */
+    readBinary: (path: string) => Promise<ArrayBuffer | null>;
+    /** Optional document title for the entry. Others derive from filename. */
+    title?: string;
+    /** Optional theme applied uniformly to every page. Overrides {@link themeId}. */
+    theme?: Theme;
+    /**
+     * Optional theme id (e.g. `'warm-earth'`, `'gezellig'`). Resolved via
+     * `resolveTheme` and applied to every page. Convenient for callers
+     * that track themes by id (like the host export dialog) without
+     * having to resolve to a `Theme` object first. When both `theme` and
+     * `themeId` are supplied, `theme` wins.
+     */
+    themeId?: string;
+    /** Maximum recursion depth (default: unlimited; cycles always handled). */
+    maxDepth?: number;
+    /**
+     * Emit the entry doc as `index.html` (preserving its parent directory)
+     * instead of `<basename>.html`. Cross-doc links pointing at the entry
+     * also rewrite to `index.html`, so a sibling `resume.md → home.md`
+     * link doesn't 404 after the rename. Convenient for static-site
+     * deploys where the landing page must be named `index.html`.
+     * Default: false.
+     */
+    entryAsIndex?: boolean;
+}
+/**
+ * Render an entry markdown document and every reachable sibling/child
+ * `.md` document it links to, bundled as a single ZIP with plain-HTML
+ * pages, per-document asset folders, and cross-doc `<a href>`
+ * references rewritten from `.md` to `.html`.
+ */
+declare function markdownDocsToPlainHtmlBundle(options: PlainHtmlBundleOptions): Promise<Blob>;
+/**
+ * Collect every `<a>`-style link URL referenced in a document. Markdown
+ * `link` nodes plus any raw HTML `<a href>` tags. Returns the raw URLs
+ * as authored, so callers can use them as both the linkMap *key* and
+ * the basis for resolution.
+ */
+declare function collectLinkRefs(doc: MarkdownDocument): Set<string>;
+
+/**
+ * Recursive rendered-HTML bundle export.
+ *
+ * `markdownDocsToHtmlBundle` is the rendered-pipeline counterpart of
+ * `markdownDocsToPlainHtmlBundle`. Starting from a single entry markdown
+ * file, it walks every relative `[…](other.md)` link, builds a Doc for
+ * each visited page via `markdownToDoc`, rewrites cross-doc link URLs
+ * inside the Doc tree from `.md` → relative `.html`, then renders each
+ * Doc to a SquisqPlayer-backed HTML page sharing one `squisq-player.js`.
+ * Images preserve their authored relative paths so per-doc folders
+ * (`resume_files/hero.png`, etc.) sit beside the rendered HTML.
+ *
+ * The rewrite happens on the Doc, *before* JSON serialization, because
+ * the rendered HTML embeds the Doc as JSON and SquisqPlayer emits the
+ * `<a href>` at runtime — there is no post-render link rewrite hook in
+ * the player path.
+ */
+interface HtmlBundleOptions {
+    /** Entry document path relative to the container root (e.g. `'home.md'`). */
+    entryPath: string;
+    /** Reads a UTF-8 markdown file from the container. Returns null when absent. */
+    readDocument: (path: string) => Promise<string | null>;
+    /** Reads a binary asset (image) from the container. Returns null when absent. */
+    readBinary: (path: string) => Promise<ArrayBuffer | null>;
+    /** SquisqPlayer IIFE bundle. Written once as `squisq-player.js` in the zip. */
+    playerScript: string;
+    /** Optional document title for the entry. Other pages derive from filename. */
+    title?: string;
+    /** Theme id applied uniformly to every page. */
+    themeId?: string;
+    /** Rendering mode for every page (default: 'static' — scrollable, link-friendly). */
+    mode?: 'slideshow' | 'static';
+    /** Maximum recursion depth (default: unlimited; cycles always handled). */
+    maxDepth?: number;
+    /**
+     * Emit the entry doc as `index.html` (preserving its parent directory)
+     * instead of `<basename>.html`. Cross-doc links pointing at the entry
+     * also rewrite to `index.html`, so a sibling `resume.md → home.md`
+     * link doesn't 404 after the rename. Convenient for static-site
+     * deploys where the landing page must be named `index.html`.
+     * Default: false.
+     */
+    entryAsIndex?: boolean;
+}
+/**
+ * Render an entry markdown document and every reachable sibling/child
+ * `.md` document it links to, bundled as a single ZIP with one rendered
+ * HTML page per doc, per-document asset folders, a shared
+ * `squisq-player.js`, and cross-doc `<a href>` references rewritten
+ * from `.md` to `.html` inside each Doc's serialized AST.
+ */
+declare function markdownDocsToHtmlBundle(options: HtmlBundleOptions): Promise<Blob>;
+
 /**
  * HTML Export Module — @bendyline/squisq-formats/html
  *
@@ -28,10 +300,8 @@
  * const zipBlob = await docToHtmlZip(doc, { playerScript: PLAYER_BUNDLE, images, audio });
  * ```
  */
-import type { Doc } from '@bendyline/squisq/schemas';
-import { type HtmlExportOptions } from './htmlTemplate.js';
-export type { HtmlExportOptions };
-export interface HtmlZipExportOptions extends HtmlExportOptions {
+
+interface HtmlZipExportOptions extends HtmlExportOptions {
     /**
      * Map of audio segment identifiers to binary audio data.
      * Keys should match the audio segment `name` or `url` fields in the Doc.
@@ -60,7 +330,7 @@ export interface HtmlZipExportOptions extends HtmlExportOptions {
  * const blob = new Blob([html], { type: 'text/html' });
  * ```
  */
-export declare function docToHtml(doc: Doc, options: HtmlExportOptions): string;
+declare function docToHtml(doc: Doc, options: HtmlExportOptions): string;
 /**
  * Export a Doc as a ZIP archive containing HTML, JS, images, and optionally audio.
  *
@@ -92,7 +362,6 @@ export declare function docToHtml(doc: Doc, options: HtmlExportOptions): string;
  * const url = URL.createObjectURL(blob);
  * ```
  */
-export declare function docToHtmlZip(doc: Doc, options: HtmlZipExportOptions): Promise<Blob>;
-export { collectImagePaths } from './htmlTemplate.js';
-export { inferMimeType, arrayBufferToBase64DataUrl, extractFilename } from './imageUtils.js';
-//# sourceMappingURL=index.d.ts.map
+declare function docToHtmlZip(doc: Doc, options: HtmlZipExportOptions): Promise<Blob>;
+
+export { type HtmlBundleOptions, type HtmlExportOptions, type HtmlZipExportOptions, type PlainHtmlBundleOptions, type PlainHtmlExportOptions, arrayBufferToBase64DataUrl, collectImagePaths, collectLinkRefs, docToHtml, docToHtmlZip, extractFilename, inferMimeType, markdownDocToPlainHtml, markdownDocsToHtmlBundle, markdownDocsToPlainHtmlBundle };

package/dist/html/index.js

@@ -1,138 +1,27 @@
-/**
- * HTML Export Module — @bendyline/squisq-formats/html
- *
- * Exports squisq documents as self-contained HTML files or ZIP archives.
- *
- * Two export modes:
- *
- * 1. **Single HTML** (`docToHtml`) — Everything embedded in one file:
- *    - SquisqPlayer IIFE bundle inlined in `<script>`
- *    - Images base64-encoded as data URIs
- *    - Timer-based playback (no audio — too large for inline)
- *
- * 2. **ZIP Archive** (`docToHtmlZip`) — Multi-file package:
- *    - `index.html` referencing external `squisq-player.js`
- *    - `squisq-player.js` — the IIFE bundle
- *    - `images/` — extracted image files
- *    - `audio/` — optional audio segment files (enables full playback)
- *
- * @example
- * ```ts
- * import { PLAYER_BUNDLE } from '@bendyline/squisq-react/standalone-source';
- * import { docToHtml, docToHtmlZip } from '@bendyline/squisq-formats/html';
- *
- * // Single HTML file
- * const html = docToHtml(doc, { playerScript: PLAYER_BUNDLE, images });
- *
- * // ZIP archive
- * const zipBlob = await docToHtmlZip(doc, { playerScript: PLAYER_BUNDLE, images, audio });
- * ```
- */
-import JSZip from 'jszip';
-import { generateInlineHtml, generateExternalHtml, } from './htmlTemplate.js';
-import { extractFilename } from './imageUtils.js';
-// ── Single HTML Export ─────────────────────────────────────────────
-/**
- * Export a Doc as a single, self-contained HTML file.
- *
- * The player JS is embedded inline, images are base64-encoded as data URIs,
- * and playback uses a timer (no audio) for compact file size.
- *
- * @param doc - The Doc to export
- * @param options - Export options (must include `playerScript`)
- * @returns Complete HTML document as a string
- *
- * @example
- * ```ts
- * const html = docToHtml(myDoc, {
- *   playerScript: PLAYER_BUNDLE,
- *   images: imageMap,
- *   title: 'My Document',
- *   mode: 'slideshow',
- * });
- * const blob = new Blob([html], { type: 'text/html' });
- * ```
- */
-export function docToHtml(doc, options) {
-    return generateInlineHtml(doc, options);
-}
-// ── ZIP Archive Export ─────────────────────────────────────────────
-/**
- * Export a Doc as a ZIP archive containing HTML, JS, images, and optionally audio.
- *
- * The archive structure:
- * ```
- * document.zip
- * ├── index.html           # HTML page referencing squisq-player.js
- * ├── squisq-player.js     # Standalone IIFE bundle
- * ├── images/              # Extracted image files
- * │   ├── hero.jpg
- * │   └── ...
- * └── audio/               # Optional audio segment files
- *     ├── intro.mp3
- *     └── ...
- * ```
- *
- * @param doc - The Doc to export
- * @param options - Export options (must include `playerScript`)
- * @returns A Promise resolving to a ZIP Blob
- *
- * @example
- * ```ts
- * const blob = await docToHtmlZip(myDoc, {
- *   playerScript: PLAYER_BUNDLE,
- *   images: imageMap,
- *   audio: audioMap,
- * });
- * // Trigger browser download
- * const url = URL.createObjectURL(blob);
- * ```
- */
-export async function docToHtmlZip(doc, options) {
-    const { playerScript, images, audio, mode = 'slideshow', title, autoPlay } = options;
-    const zip = new JSZip();
-    // 1. Add player JS as a separate file
-    zip.file('squisq-player.js', playerScript);
-    // 2. Add images to images/ folder and build path mapping
-    const imagePathMap = {};
-    if (images) {
-        for (const [originalPath, buffer] of images.entries()) {
-            const filename = extractFilename(originalPath);
-            const zipPath = `images/${filename}`;
-            zip.file(zipPath, buffer);
-            imagePathMap[originalPath] = zipPath;
-        }
-    }
-    // 3. Add audio to audio/ folder and build path mapping
-    const audioPathMap = {};
-    if (audio) {
-        for (const [segmentKey, buffer] of audio.entries()) {
-            const filename = extractFilename(segmentKey);
-            // Ensure .mp3 extension
-            const finalName = filename.includes('.') ? filename : `${filename}.mp3`;
-            const zipPath = `audio/${finalName}`;
-            zip.file(zipPath, buffer);
-            audioPathMap[segmentKey] = zipPath;
-        }
-    }
-    // 4. Generate HTML that references external files
-    const html = generateExternalHtml(doc, {
-        playerScriptPath: 'squisq-player.js',
-        imagePathMap: Object.keys(imagePathMap).length > 0 ? imagePathMap : undefined,
-        audioPathMap: Object.keys(audioPathMap).length > 0 ? audioPathMap : undefined,
-        mode,
-        title,
-        autoPlay,
-    });
-    zip.file('index.html', html);
-    // 5. Generate ZIP blob
-    return zip.generateAsync({
-        type: 'blob',
-        compression: 'DEFLATE',
-        compressionOptions: { level: 6 },
-    });
-}
-// ── Re-exports ─────────────────────────────────────────────────────
-export { collectImagePaths } from './htmlTemplate.js';
-export { inferMimeType, arrayBufferToBase64DataUrl, extractFilename } from './imageUtils.js';
+import {
+  collectImagePaths,
+  collectLinkRefs,
+  docToHtml,
+  docToHtmlZip,
+  markdownDocToPlainHtml,
+  markdownDocsToHtmlBundle,
+  markdownDocsToPlainHtmlBundle
+} from "../chunk-33YRFXZZ.js";
+import {
+  arrayBufferToBase64DataUrl,
+  extractFilename,
+  inferMimeType
+} from "../chunk-A3FHLTY5.js";
+export {
+  arrayBufferToBase64DataUrl,
+  collectImagePaths,
+  collectLinkRefs,
+  docToHtml,
+  docToHtmlZip,
+  extractFilename,
+  inferMimeType,
+  markdownDocToPlainHtml,
+  markdownDocsToHtmlBundle,
+  markdownDocsToPlainHtmlBundle
+};
 //# sourceMappingURL=index.js.map

package/dist/html/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/html/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -1,38 +1,9 @@
-/**
- * @bendyline/squisq-formats
- *
- * Format converters for squisq documents. Converts between squisq's
- * MarkdownDocument / Doc and various file formats via Office Open XML.
- *
- * Supported formats:
- * - **DOCX** — Microsoft Word (import + export) ✅
- * - **PDF**  — Portable Document Format (import + export) ✅
- * - **PPTX** — Microsoft PowerPoint (export ✅, import planned)
- * - **XLSX** — Microsoft Excel (planned)
- *
- * All converters run in the browser — no server or native binaries required.
- * The shared `ooxml/` subpath export provides reusable OOXML infrastructure.
- *
- * @example
- * ```ts
- * // Import from root
- * import { markdownDocToDocx, docxToMarkdownDoc } from '@bendyline/squisq-formats';
- *
- * // Or import from subpath
- * import { markdownDocToDocx } from '@bendyline/squisq-formats/docx';
- * import { createPackage } from '@bendyline/squisq-formats/ooxml';
- * ```
- */
-export { markdownDocToDocx, docToDocx, docxToMarkdownDoc, docxToDoc } from './docx/index.js';
-export type { DocxExportOptions, DocxImportOptions } from './docx/index.js';
-export { markdownDocToPptx, docToPptx, pptxToMarkdownDoc, pptxToDoc } from './pptx/index.js';
-export type { PptxExportOptions, PptxImportOptions } from './pptx/index.js';
-export { markdownDocToXlsx, docToXlsx, xlsxToMarkdownDoc, xlsxToDoc } from './xlsx/index.js';
-export type { XlsxExportOptions, XlsxImportOptions } from './xlsx/index.js';
-export { markdownDocToPdf, docToPdf, pdfToMarkdownDoc, pdfToDoc, configurePdfWorker, } from './pdf/index.js';
-export type { PdfExportOptions, PdfImportOptions } from './pdf/index.js';
-export { docToHtml, docToHtmlZip, collectImagePaths } from './html/index.js';
-export type { HtmlExportOptions, HtmlZipExportOptions } from './html/index.js';
-export { markdownDocToEpub, docToEpub } from './epub/index.js';
-export type { EpubExportOptions } from './epub/index.js';
-//# sourceMappingURL=index.d.ts.map
+export { DocxExportOptions, DocxImportOptions, docToDocx, docxToDoc, docxToMarkdownDoc, markdownDocToDocx } from './docx/index.js';
+export { PptxExportOptions, PptxImportOptions, docToPptx, markdownDocToPptx, pptxToDoc, pptxToMarkdownDoc } from './pptx/index.js';
+export { XlsxExportOptions, XlsxImportOptions, docToXlsx, markdownDocToXlsx, xlsxToDoc, xlsxToMarkdownDoc } from './xlsx/index.js';
+export { PdfExportOptions, PdfImportOptions, configurePdfWorker, docToPdf, markdownDocToPdf, pdfToDoc, pdfToMarkdownDoc } from './pdf/index.js';
+export { HtmlExportOptions, HtmlZipExportOptions, collectImagePaths, docToHtml, docToHtmlZip } from './html/index.js';
+export { EpubExportOptions, docToEpub, markdownDocToEpub } from './epub/index.js';
+import '@bendyline/squisq/schemas';
+import '@bendyline/squisq/markdown';
+import '@bendyline/squisq/storage';

package/dist/index.js

@@ -1,38 +1,63 @@
-/**
- * @bendyline/squisq-formats
- *
- * Format converters for squisq documents. Converts between squisq's
- * MarkdownDocument / Doc and various file formats via Office Open XML.
- *
- * Supported formats:
- * - **DOCX** — Microsoft Word (import + export) ✅
- * - **PDF**  — Portable Document Format (import + export) ✅
- * - **PPTX** — Microsoft PowerPoint (export ✅, import planned)
- * - **XLSX** — Microsoft Excel (planned)
- *
- * All converters run in the browser — no server or native binaries required.
- * The shared `ooxml/` subpath export provides reusable OOXML infrastructure.
- *
- * @example
- * ```ts
- * // Import from root
- * import { markdownDocToDocx, docxToMarkdownDoc } from '@bendyline/squisq-formats';
- *
- * // Or import from subpath
- * import { markdownDocToDocx } from '@bendyline/squisq-formats/docx';
- * import { createPackage } from '@bendyline/squisq-formats/ooxml';
- * ```
- */
-// DOCX (fully implemented)
-export { markdownDocToDocx, docToDocx, docxToMarkdownDoc, docxToDoc } from './docx/index.js';
-// PPTX (export implemented, import stub)
-export { markdownDocToPptx, docToPptx, pptxToMarkdownDoc, pptxToDoc } from './pptx/index.js';
-// XLSX (stub)
-export { markdownDocToXlsx, docToXlsx, xlsxToMarkdownDoc, xlsxToDoc } from './xlsx/index.js';
-// PDF (fully implemented)
-export { markdownDocToPdf, docToPdf, pdfToMarkdownDoc, pdfToDoc, configurePdfWorker, } from './pdf/index.js';
-// HTML (fully implemented)
-export { docToHtml, docToHtmlZip, collectImagePaths } from './html/index.js';
-// EPUB (export)
-export { markdownDocToEpub, docToEpub } from './epub/index.js';
+import {
+  docToDocx,
+  docxToDoc,
+  docxToMarkdownDoc,
+  markdownDocToDocx
+} from "./chunk-UDS45KUJ.js";
+import {
+  docToPptx,
+  markdownDocToPptx,
+  pptxToDoc,
+  pptxToMarkdownDoc
+} from "./chunk-VN2KEOYB.js";
+import {
+  docToXlsx,
+  markdownDocToXlsx,
+  xlsxToDoc,
+  xlsxToMarkdownDoc
+} from "./chunk-67KIJHV2.js";
+import "./chunk-YN5HFCEW.js";
+import "./chunk-7DEUGIOO.js";
+import {
+  configurePdfWorker,
+  docToPdf,
+  markdownDocToPdf,
+  pdfToDoc,
+  pdfToMarkdownDoc
+} from "./chunk-S3Y7H2BK.js";
+import {
+  collectImagePaths,
+  docToHtml,
+  docToHtmlZip
+} from "./chunk-33YRFXZZ.js";
+import {
+  docToEpub,
+  markdownDocToEpub
+} from "./chunk-ERZ627GR.js";
+import "./chunk-U4MRIFKL.js";
+import "./chunk-A3FHLTY5.js";
+export {
+  collectImagePaths,
+  configurePdfWorker,
+  docToDocx,
+  docToEpub,
+  docToHtml,
+  docToHtmlZip,
+  docToPdf,
+  docToPptx,
+  docToXlsx,
+  docxToDoc,
+  docxToMarkdownDoc,
+  markdownDocToDocx,
+  markdownDocToEpub,
+  markdownDocToPdf,
+  markdownDocToPptx,
+  markdownDocToXlsx,
+  pdfToDoc,
+  pdfToMarkdownDoc,
+  pptxToDoc,
+  pptxToMarkdownDoc,
+  xlsxToDoc,
+  xlsxToMarkdownDoc
+};
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,2BAA2B;AAC3B,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG7F,yCAAyC;AACzC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG7F,cAAc;AACd,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG7F,0BAA0B;AAC1B,OAAO,EACL,gBAAgB,EAChB,QAAQ,EACR,gBAAgB,EAChB,QAAQ,EACR,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAGxB,2BAA2B;AAC3B,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAG7E,gBAAgB;AAChB,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}