@bendyline/squisq-formats 1.3.0 → 1.4.0

package/dist/docx/index.d.ts

@@ -1,23 +1,136 @@
+import { Doc } from '@bendyline/squisq/schemas';
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
+import { ContentContainer } from '@bendyline/squisq/storage';
+
 /**
- * @bendyline/squisq-formats DOCX Module
+ * DOCX Export
  *
- * Import and export squisq documents (MarkdownDocument / Doc)
- * to/from Microsoft Word .docx files (Office Open XML WordprocessingML).
+ * Converts a squisq MarkdownDocument (or Doc) into a .docx file
+ * by generating WordprocessingML XML and assembling the OOXML package.
  *
- * All operations run in the browser — no server required.
+ * No third-party docx library — all XML is generated directly using
+ * the shared ooxml/ infrastructure of this package.
  *
  * @example
  * ```ts
- * import {
- *   markdownDocToDocx,
- *   docToDocx,
- *   docxToMarkdownDoc,
- *   docxToDoc,
- * } from '@bendyline/squisq-formats/docx';
+ * import { parseMarkdown } from '@bendyline/squisq/markdown';
+ * import { markdownDocToDocx } from '@bendyline/squisq-formats/docx';
+ *
+ * const md = parseMarkdown('# Hello\n\nWorld **bold** text');
+ * const blob = await markdownDocToDocx(md);
+ * ```
+ */
+
+/**
+ * Options for DOCX export.
+ */
+interface DocxExportOptions {
+    /** Document title (appears in core properties) */
+    title?: string;
+    /** Document author */
+    author?: string;
+    /** Document description */
+    description?: string;
+    /** Default body font family. Default: "Calibri" */
+    defaultFont?: string;
+    /** Default body font size in points. Default: 11 */
+    defaultFontSize?: number;
+    /**
+     * Squisq theme ID to apply (e.g., 'documentary', 'cinematic').
+     * When set, overrides fonts with the theme's typography and applies
+     * the theme's primary color to headings.
+     */
+    themeId?: string;
+    /**
+     * Pre-resolved image data keyed by image URL/path as it appears in the
+     * markdown source. When provided, images are embedded in the .docx file
+     * as binary parts instead of emitting placeholder text.
+     */
+    images?: Map<string, {
+        data: ArrayBuffer | Uint8Array;
+        contentType: string;
+    }>;
+}
+/**
+ * Convert a MarkdownDocument to a .docx Blob.
+ *
+ * @param doc - The parsed markdown document
+ * @param options - Export options
+ * @returns An ArrayBuffer containing the .docx file
+ */
+declare function markdownDocToDocx(doc: MarkdownDocument, options?: DocxExportOptions): Promise<ArrayBuffer>;
+/**
+ * Convert a squisq Doc to a .docx Blob.
+ *
+ * Convenience wrapper that converts Doc → MarkdownDocument → DOCX.
+ *
+ * @param doc - The squisq Doc
+ * @param options - Export options
+ * @returns An ArrayBuffer containing the .docx file
+ */
+declare function docToDocx(doc: Doc, options?: DocxExportOptions): Promise<ArrayBuffer>;
+
+/**
+ * DOCX Import
+ *
+ * Parses a .docx file (Office Open XML WordprocessingML) and converts
+ * its content into a squisq MarkdownDocument (or Doc).
+ *
+ * Uses JSZip + DOMParser to read the archive and parse the XML — no
+ * third-party docx library. Handles headings, paragraphs, inline
+ * formatting (bold, italic, strikethrough), hyperlinks, lists, tables,
+ * blockquotes, code blocks, images, and footnotes.
+ *
+ * @example
+ * ```ts
+ * import { docxToMarkdownDoc } from '@bendyline/squisq-formats/docx';
+ *
+ * const response = await fetch('document.docx');
+ * const data = await response.arrayBuffer();
+ * const doc = await docxToMarkdownDoc(data);
  * ```
  */
-export { markdownDocToDocx, docToDocx } from './export.js';
-export type { DocxExportOptions } from './export.js';
-export { docxToMarkdownDoc, docxToDoc, docxToContainer } from './import.js';
-export type { DocxImportOptions } from './import.js';
-//# sourceMappingURL=index.d.ts.map
+
+/**
+ * Options for DOCX import.
+ */
+interface DocxImportOptions {
+    /**
+     * Whether to extract embedded images as base64 data URIs.
+     * When false, images are represented as `[Image]` placeholders.
+     * Default: false
+     */
+    extractImages?: boolean;
+}
+/**
+ * Convert a .docx file to a MarkdownDocument.
+ *
+ * @param data - The raw .docx file as ArrayBuffer or Blob
+ * @param options - Import options
+ * @returns A MarkdownDocument representing the document content
+ */
+declare function docxToMarkdownDoc(data: ArrayBuffer | Blob, options?: DocxImportOptions): Promise<MarkdownDocument>;
+/**
+ * Convert a .docx file to a squisq Doc.
+ *
+ * Convenience wrapper: DOCX → MarkdownDocument → Doc.
+ *
+ * @param data - The raw .docx file as ArrayBuffer or Blob
+ * @param options - Import options
+ * @returns A squisq Doc
+ */
+declare function docxToDoc(data: ArrayBuffer | Blob, options?: DocxImportOptions): Promise<Doc>;
+/**
+ * Convert a .docx file to a ContentContainer with markdown + extracted images.
+ *
+ * The container will contain:
+ * - The primary markdown document (index.md)
+ * - Any embedded images under images/ (e.g., images/image1.png)
+ *
+ * @param data - The raw .docx file as ArrayBuffer or Blob
+ * @param options - Import options
+ * @returns A ContentContainer with the document and its media
+ */
+declare function docxToContainer(data: ArrayBuffer | Blob, options?: DocxImportOptions): Promise<ContentContainer>;
+
+export { type DocxExportOptions, type DocxImportOptions, docToDocx, docxToContainer, docxToDoc, docxToMarkdownDoc, markdownDocToDocx };

package/dist/docx/index.js

@@ -1,23 +1,20 @@
-/**
- * @bendyline/squisq-formats DOCX Module
- *
- * Import and export squisq documents (MarkdownDocument / Doc)
- * to/from Microsoft Word .docx files (Office Open XML WordprocessingML).
- *
- * All operations run in the browser — no server required.
- *
- * @example
- * ```ts
- * import {
- *   markdownDocToDocx,
- *   docToDocx,
- *   docxToMarkdownDoc,
- *   docxToDoc,
- * } from '@bendyline/squisq-formats/docx';
- * ```
- */
-// Export
-export { markdownDocToDocx, docToDocx } from './export.js';
-// Import
-export { docxToMarkdownDoc, docxToDoc, docxToContainer } from './import.js';
+import {
+  docToDocx,
+  docxToContainer,
+  docxToDoc,
+  docxToMarkdownDoc,
+  markdownDocToDocx
+} from "../chunk-BJQIJ4S4.js";
+import "../chunk-6M7Z25LA.js";
+import "../chunk-PN52A5AA.js";
+import "../chunk-QSE7EWE7.js";
+import "../chunk-U4MRIFKL.js";
+import "../chunk-FMOIGA5T.js";
+export {
+  docToDocx,
+  docxToContainer,
+  docxToDoc,
+  docxToMarkdownDoc,
+  markdownDocToDocx
+};
 //# sourceMappingURL=index.js.map

package/dist/docx/index.js.map

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

package/dist/epub/index.d.ts

@@ -1,20 +1,75 @@
+import { AudioSegment, Doc } from '@bendyline/squisq/schemas';
+import { MarkdownDocument } from '@bendyline/squisq/markdown';
+
 /**
- * @bendyline/squisq-formats EPUB Module
+ * EPUB 3 Export
  *
- * Export squisq documents (MarkdownDocument / Doc) to EPUB 3 e-book files.
+ * Converts a MarkdownDocument (or Doc) to an EPUB 3 file (.epub).
  *
- * Content is split into chapters at H1/H2 heading boundaries. Images
- * referenced in the markdown are embedded in the archive when provided
- * via the `images` option.
+ * An EPUB is a ZIP archive containing XHTML chapter files, images,
+ * a package manifest (content.opf), and a navigation document (toc.xhtml).
+ * Content is split into chapters at H1/H2 heading boundaries.
+ *
+ * Uses JSZip for packaging (already a dependency), escapeXml from the
+ * OOXML utils, and image utilities from the HTML exporter.
  *
  * @example
  * ```ts
- * import { markdownDocToEpub, docToEpub } from '@bendyline/squisq-formats/epub';
+ * import { markdownDocToEpub } from '@bendyline/squisq-formats/epub';
  *
- * const epub = await markdownDocToEpub(markdownDoc, { title: 'My Book' });
- * const epub2 = await docToEpub(doc, { author: 'Jane Doe' });
+ * const epub = await markdownDocToEpub(markdownDoc, {
+ *   title: 'My Book',
+ *   author: 'Jane Doe',
+ * });
  * ```
  */
-export { markdownDocToEpub, docToEpub } from './export.js';
-export type { EpubExportOptions } from './export.js';
-//# sourceMappingURL=index.d.ts.map
+
+interface EpubExportOptions {
+    /** Book title (default: 'Untitled') */
+    title?: string;
+    /** Author name */
+    author?: string;
+    /** Book description / summary */
+    description?: string;
+    /** BCP-47 language code (default: 'en') */
+    language?: string;
+    /** Publisher name */
+    publisher?: string;
+    /** Squisq theme ID for CSS styling */
+    themeId?: string;
+    /** Pre-resolved image data keyed by relative path as it appears in the markdown */
+    images?: Map<string, ArrayBuffer>;
+    /** Cover image data (JPEG or PNG) */
+    coverImage?: ArrayBuffer;
+    /**
+     * Audio narration data keyed by segment src/name.
+     * When provided alongside audioSegments, EPUB 3 Media Overlays (SMIL)
+     * are generated for synchronized audio playback.
+     */
+    audio?: Map<string, ArrayBuffer>;
+    /**
+     * Audio segment metadata (from Doc.audio.segments).
+     * Required together with `audio` to generate Media Overlays.
+     * Each segment's duration and startTime are used to build SMIL timing.
+     */
+    audioSegments?: AudioSegment[];
+    /** Total document duration in seconds (used for Media Overlay metadata) */
+    totalDuration?: number;
+}
+/**
+ * Convert a MarkdownDocument to an EPUB 3 file.
+ *
+ * Chapters are split at H1/H2 heading boundaries. All referenced images
+ * (provided via `options.images`) are embedded in the archive.
+ */
+declare function markdownDocToEpub(doc: MarkdownDocument, options?: EpubExportOptions): Promise<ArrayBuffer>;
+/**
+ * Convert a squisq Doc to an EPUB 3 file.
+ *
+ * Convenience wrapper: Doc → MarkdownDocument → EPUB.
+ * When the Doc has audio segments and `options.audio` is provided,
+ * EPUB 3 Media Overlays are generated for narrated playback.
+ */
+declare function docToEpub(doc: Doc, options?: EpubExportOptions): Promise<ArrayBuffer>;
+
+export { type EpubExportOptions, docToEpub, markdownDocToEpub };

package/dist/epub/index.js

@@ -1,19 +1,12 @@
-/**
- * @bendyline/squisq-formats EPUB Module
- *
- * Export squisq documents (MarkdownDocument / Doc) to EPUB 3 e-book files.
- *
- * Content is split into chapters at H1/H2 heading boundaries. Images
- * referenced in the markdown are embedded in the archive when provided
- * via the `images` option.
- *
- * @example
- * ```ts
- * import { markdownDocToEpub, docToEpub } from '@bendyline/squisq-formats/epub';
- *
- * const epub = await markdownDocToEpub(markdownDoc, { title: 'My Book' });
- * const epub2 = await docToEpub(doc, { author: 'Jane Doe' });
- * ```
- */
-export { markdownDocToEpub, docToEpub } from './export.js';
+import {
+  docToEpub,
+  markdownDocToEpub
+} from "../chunk-ON232HJR.js";
+import "../chunk-PN52A5AA.js";
+import "../chunk-U4MRIFKL.js";
+import "../chunk-A3FHLTY5.js";
+export {
+  docToEpub,
+  markdownDocToEpub
+};
 //# sourceMappingURL=index.js.map

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,312 @@
+import { Doc, Theme } from '@bendyline/squisq/schemas';
+import { HtmlPolicy, 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;
+    /**
+     * Raw HTML policy. Defaults to `sanitize`, which removes unsafe tags,
+     * event handlers, and executable URL schemes before emitting HTML.
+     */
+    htmlPolicy?: HtmlPolicy;
+}
+/**
+ * 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 Import Module — @bendyline/squisq-formats/html
+ *
+ * Converts an HTML document (or fragment) into a squisq `MarkdownDocument`.
+ * Built on the existing `parseHtmlToNodes` (parse5-backed) + `sanitizeHtmlNodes`
+ * from `@bendyline/squisq/markdown`, so no new dependency is introduced.
+ *
+ * The primary consumer is email: HTML mail bodies are hostile input, so the
+ * parse is sanitized by default (scripts/styles/event handlers/dangerous URLs
+ * stripped) before the tree is walked into markdown nodes.
+ *
+ * Two entry points mirror the docx/pdf importers:
+ *   - `htmlToMarkdownDoc(data, options?)` → `MarkdownDocument`
+ *   - `htmlToMarkdown(html, options?)` → markdown string (convenience for the
+ *     string-in/string-out path email body conversion needs)
+ */
+
+interface HtmlImportOptions {
+    /**
+     * Strip scripts / styles / event handlers / dangerous URLs before walking
+     * the tree. Default `true` — HTML email is untrusted; only disable for
+     * trusted input where you want raw fidelity.
+     */
+    sanitize?: boolean;
+}
+/** Parse HTML into a squisq `MarkdownDocument`. */
+declare function htmlToMarkdownDocSync(html: string, options?: HtmlImportOptions): MarkdownDocument;
+/** Async, ArrayBuffer-accepting entry mirroring docx/pdf importers. */
+declare function htmlToMarkdownDoc(data: ArrayBuffer | Uint8Array | string, options?: HtmlImportOptions): Promise<MarkdownDocument>;
+/** Convenience string→string conversion (used for email HTML bodies). */
+declare function htmlToMarkdown(html: string, options?: HtmlImportOptions): string;
+
 /**
  * HTML Export Module — @bendyline/squisq-formats/html
  *
@@ -28,10 +337,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 +367,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,13 +399,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';
-export { markdownDocToPlainHtml } from './plainHtml.js';
-export type { PlainHtmlExportOptions } from './plainHtml.js';
-export { markdownDocsToPlainHtmlBundle, collectLinkRefs } from './plainHtmlBundle.js';
-export type { PlainHtmlBundleOptions } from './plainHtmlBundle.js';
-export { markdownDocsToHtmlBundle } from './docsHtmlBundle.js';
-export type { HtmlBundleOptions } from './docsHtmlBundle.js';
-//# sourceMappingURL=index.d.ts.map
+declare function docToHtmlZip(doc: Doc, options: HtmlZipExportOptions): Promise<Blob>;
+
+export { type HtmlBundleOptions, type HtmlExportOptions, type HtmlImportOptions, type HtmlZipExportOptions, type PlainHtmlBundleOptions, type PlainHtmlExportOptions, arrayBufferToBase64DataUrl, collectImagePaths, collectLinkRefs, docToHtml, docToHtmlZip, extractFilename, htmlToMarkdown, htmlToMarkdownDoc, htmlToMarkdownDocSync, inferMimeType, markdownDocToPlainHtml, markdownDocsToHtmlBundle, markdownDocsToPlainHtmlBundle };