officeparser 7.5.1 → 7.6.2

package/dist/generators/MarkdownGenerator.js

@@ -68,7 +68,10 @@ function resolveDialect(dialect) {
  */
 function resolveFallbackToHtml(fallbackToHtml) {
     const uniform = (on) => ({
+        // inlineFormatting is opt-in only: it is never enabled by the boolean form, since it changes
+        // default output. Every other field follows the boolean.
         textFormatting: on, alignment: on, anchors: on, tables: on, embeds: on, cellLineBreaks: on,
+        inlineFormatting: false,
     });
     if (fallbackToHtml === undefined || typeof fallbackToHtml === 'boolean')
         return uniform(fallbackToHtml ?? true);
@@ -80,6 +83,7 @@ function resolveFallbackToHtml(fallbackToHtml) {
         tables: fallbackToHtml.tables ?? on.tables,
         embeds: fallbackToHtml.embeds ?? on.embeds,
         cellLineBreaks: fallbackToHtml.cellLineBreaks ?? on.cellLineBreaks,
+        inlineFormatting: fallbackToHtml.inlineFormatting ?? on.inlineFormatting,
     };
 }
 /**
@@ -203,35 +207,40 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
         // Add Metadata (YAML Front Matter)
         const meta = this.effectiveMetadata;
         if (meta) {
-            output += '---\n';
-            // JSON-encode scalar values so a title/author/description containing a
-            // quote or newline can't break out of the YAML string and inject
-            // arbitrary front-matter keys. (JSON.stringify of a benign value yields
-            // the same `"..."` form as before, so normal output is unchanged.)
+            // Build the field lines first. JSON-encode scalar values so a title/author/description
+            // containing a quote or newline can't break out of the YAML string and inject arbitrary
+            // front-matter keys. (JSON.stringify of a benign value yields the same `"..."` form as
+            // before, so normal output is unchanged.)
+            let fields = '';
             if (meta.title)
-                output += `title: ${JSON.stringify(meta.title)}\n`;
+                fields += `title: ${JSON.stringify(meta.title)}\n`;
             if (meta.author)
-                output += `author: ${JSON.stringify(meta.author)}\n`;
+                fields += `author: ${JSON.stringify(meta.author)}\n`;
             const createdIso = this.toIsoDate(meta.created);
             if (createdIso)
-                output += `created: ${createdIso}\n`;
+                fields += `created: ${createdIso}\n`;
             const modifiedIso = this.toIsoDate(meta.modified);
             if (modifiedIso)
-                output += `modified: ${modifiedIso}\n`;
+                fields += `modified: ${modifiedIso}\n`;
             if (meta.description)
-                output += `description: ${JSON.stringify(meta.description)}\n`;
+                fields += `description: ${JSON.stringify(meta.description)}\n`;
             if (meta.subject)
-                output += `subject: ${JSON.stringify(meta.subject)}\n`;
+                fields += `subject: ${JSON.stringify(meta.subject)}\n`;
             if (meta.keywords)
-                output += `keywords: ${JSON.stringify(meta.keywords)}\n`;
+                fields += `keywords: ${JSON.stringify(meta.keywords)}\n`;
             if (meta.customProperties) {
                 for (const [key, val] of Object.entries(meta.customProperties)) {
                     // Strip newlines/colons from the key so it can't inject a new mapping.
                     const safeKey = String(key).replace(/[\r\n:]+/g, ' ').trim();
-                    output += `${safeKey}: ${Array.isArray(val) ? this.serializeFrontmatterArray(val) : JSON.stringify(val)}\n`;
+                    fields += `${safeKey}: ${Array.isArray(val) ? this.serializeFrontmatterArray(val) : JSON.stringify(val)}\n`;
                 }
             }
-            output += '---\n\n';
+            // Only emit the frontmatter fence when at least one field is present. Empty metadata
+            // (a bare Tiptap/HTML fragment with no <head>) would otherwise emit `---\n---`, which
+            // reparses as a setext `## ---` heading and corrupts the document on every save/reload.
+            if (fields) {
+                output += `---\n${fields}---\n\n`;
+            }
         }
         const processor = async (node, childrenOutput) => {
             // Handle Style Mapping for Markdown using the semantic mapping helper
@@ -256,6 +265,19 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     // HTML tag (e.g. <script>) when the Markdown is rendered to HTML.
                     let text = (0, sanitize_js_1.markdownEscapeText)(node.text || '');
                     if (this.config.includeFormatting && node.formatting) {
+                        // Inline code: re-wrap the RAW text in backticks. The content is literal
+                        // inside a code span, so the entity-escaped form above must not show through.
+                        // The fence is one backtick longer than the longest embedded run so an inner
+                        // backtick can't close the span early, padded when the content touches a
+                        // backtick. Done before emphasis so bold/italic wrap the span (`**`code`**`).
+                        // Previously a monospace text node emitted its bare text, dropping the code.
+                        if (node.formatting.font === 'monospace') {
+                            const raw = node.text || '';
+                            const longestRun = Math.max(0, ...(raw.match(/`+/g) || []).map(s => s.length));
+                            const fence = '`'.repeat(longestRun + 1);
+                            const pad = (raw.startsWith('`') || raw.endsWith('`')) ? ' ' : '';
+                            text = `${fence}${pad}${raw}${pad}${fence}`;
+                        }
                         const emphasisAsterisk = this.resolvedDialect.emphasisMarker === 'asterisk';
                         if (node.formatting.bold && !this.inImplicitBold)
                             text = emphasisAsterisk ? `**${text}**` : `__${text}__`;
@@ -272,6 +294,24 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                             if (node.formatting.superscript)
                                 text = `<sup>${text}</sup>`;
                         }
+                        // Inline color / highlight / font size have no Markdown syntax; emit a styled
+                        // <span> (outermost, so the inner Markdown markers survive) only when opted in,
+                        // so default output is unchanged. Values are CSS-sanitized against injection.
+                        if (this.resolvedFallbackToHtml.inlineFormatting) {
+                            const styles = [];
+                            const pushStyle = (prop, val) => {
+                                if (!val)
+                                    return;
+                                const safe = (0, sanitize_js_1.sanitizeCssValue)(val); // drops url()/expression()/<>/quotes
+                                if (safe)
+                                    styles.push(`${prop}: ${safe}`);
+                            };
+                            pushStyle('color', node.formatting.color);
+                            pushStyle('background-color', node.formatting.backgroundColor);
+                            pushStyle('font-size', node.formatting.size);
+                            if (styles.length)
+                                text = `<span style="${styles.join('; ')}">${text}</span>`;
+                        }
                     }
                     const meta = node.metadata;
                     if (meta?.wikilink && this.resolvedDialect.wikilinks) {
@@ -411,13 +451,17 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     return childrenOutput;
                 }
                 case 'break': {
-                    // A hard line break (CommonMark: two trailing spaces before the
-                    // newline) round-trips back to a distinct 'break' node on reparse;
-                    // every other breakType (including 'page', used for a thematic-break
-                    // HR) keeps emitting a bare newline, unchanged.
+                    // A hard line break (CommonMark: two trailing spaces before the newline)
+                    // round-trips back to a distinct 'break' node on reparse. A thematic break
+                    // emits `---` as its own block (the top-level loop supplies the surrounding
+                    // blank lines), so a Markdown `---` / HTML `<hr>` survives a save instead of
+                    // collapsing to whitespace. Every other breakType - notably 'page', which
+                    // Markdown has no syntax for - keeps emitting a bare newline, unchanged.
                     const meta = node.metadata;
                     if (meta?.breakType === 'carriageReturn')
                         return '  \n';
+                    if (meta?.breakType === 'thematic')
+                        return '---';
                     return '\n';
                 }
                 case 'code': {
@@ -447,17 +491,20 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                         return this.resolvedDialect.math === 'dollar' ? `$${mathInline}$` : mathInline;
                     }
                     const lang = (meta?.language || '').replace(/[\r\n`]+/g, '');
-                    // Block code if it contains a line break, else inline. Testing only for `\n`
-                    // routed a CR-only string to the inline branch, where a renderer that
-                    // normalizes `\r` to a line ending sees a blank line, the span dies, and the
-                    // remainder is exposed as raw Markdown. The fence sizing below is correct and
-                    // needs no change; code content itself is not an HTML context.
-                    if (node.text && /[\r\n]/.test(node.text)) {
+                    // A `code` node is always block-level: genuinely inline code is a monospace
+                    // text node, never a `code` node. So emit a fenced block whenever the node
+                    // carries a language OR spans multiple lines. Previously the decision keyed only
+                    // off a line break, so a single-line code node with a language - `const x = 1;`
+                    // tagged `js`, or a one-line `mermaid` diagram - collapsed to an inline span,
+                    // silently dropping both its language and its block-ness. (Testing `[\r\n]`, not
+                    // just `\n`, still routes a CR-only body to the fenced branch, where a renderer
+                    // that normalizes `\r` to a line ending would otherwise kill an inline span.)
+                    if (lang || (node.text && /[\r\n]/.test(node.text))) {
                         // Fence with one more backtick than the longest run inside the content
                         // so an embedded ``` can't close the block early and inject markup.
-                        const longestRun = Math.max(0, ...(node.text.match(/`+/g) || []).map(s => s.length));
+                        const longestRun = Math.max(0, ...((node.text || '').match(/`+/g) || []).map(s => s.length));
                         const fence = '`'.repeat(Math.max(3, longestRun + 1));
-                        return `\n${fence}${lang}\n${node.text}\n${fence}\n\n`;
+                        return `\n${fence}${lang}\n${node.text || ''}\n${fence}\n\n`;
                     }
                     else {
                         const t = node.text || '';
@@ -489,7 +536,10 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                             // into an end-of-document "### Notes" section under a [^id] marker.
                             return childrenOutput.trim();
                         }
-                        return `[^${this.getFootnoteKey(node)}]: ${childrenOutput.trim()}\n\n`;
+                        // Indent continuation lines one level so a multi-line body re-parses as a
+                        // single definition (a bare newline would end it). Single-line bodies, the
+                        // common case, are unaffected.
+                        return `[^${this.getFootnoteKey(node)}]: ${childrenOutput.trim().replace(/\n/g, '\n    ')}\n\n`;
                     }
                     return `> **Note:** ${childrenOutput.trim()}\n\n`;
                 }
@@ -498,6 +548,20 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     // save default), emit the exact single-line div MarkdownParser recognises on
                     // reimport; otherwise degrade to a plain link.
                     const meta = node.metadata;
+                    if (meta?.embedType === 'iframe') {
+                        // sanitizeUrl scheme-checks and HTML-escapes the src (hostile schemes drop
+                        // the node). The single-line <iframe> is what MarkdownParser recognises on
+                        // reimport, gated there on preserveIframes.
+                        const safe = (0, sanitize_js_1.sanitizeUrl)(meta?.url || '');
+                        if (!safe)
+                            return '';
+                        if (this.resolvedFallbackToHtml.embeds) {
+                            const w = meta?.width ? ` width="${(0, sanitize_js_1.escapeHtml)(meta.width)}"` : '';
+                            const h = meta?.height ? ` height="${(0, sanitize_js_1.escapeHtml)(meta.height)}"` : '';
+                            return `\n<iframe src="${safe}"${w}${h}></iframe>\n\n`;
+                        }
+                        return `[Embed](${(0, sanitize_js_1.sanitizeMarkdownUrl)(meta?.url || '')})\n\n`;
+                    }
                     const id = meta?.videoId || '';
                     if (this.resolvedFallbackToHtml.embeds) {
                         const width = meta?.width ? ` data-width="${(0, sanitize_js_1.escapeHtml)(meta.width)}"` : '';
@@ -569,6 +633,14 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
         for (let i = 0; i < optimizedContent.length; i++) {
             const node = optimizedContent[i];
             const nextNode = optimizedContent[i + 1];
+            // A top-level footnote/endnote note is an orphan definition (unreferenced `[^id]: ...`
+            // the MarkdownParser recovered). Collect it so it's emitted with the other definitions
+            // at the document end rather than inline before them.
+            const orphanNoteType = node.metadata?.noteType;
+            if (node.type === 'note' && (orphanNoteType === 'footnote' || orphanNoteType === 'endnote')) {
+                this.collectedNotes.push(node);
+                continue;
+            }
             let result = await this.processNodeRecursive(node, processor);
             // Ensure lists and other block elements are separated from non-similar content by a blank line
             if (nextNode) {
@@ -585,8 +657,21 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
             output += result;
         }
         if (this.collectedNotes.length > 0) {
-            let notesMd = '\n\n---\n\n### Notes\n\n';
-            for (const note of this.collectedNotes) {
+            // No decorative `---\n\n### Notes` preamble: `[^id]:` definitions are valid on their own
+            // (GitHub/Pandoc render the footnotes section and its rule automatically), and the
+            // literal heading round-tripped as a real `###` node - so every save/reload re-emitted
+            // the parsed heading AND a fresh one, growing the document unbounded. Emitting the bare
+            // definitions makes the cycle byte-stable. Behaviour change, noted in the changelog.
+            // Collapse the preceding block's trailing blank lines so exactly one blank line separates
+            // the body from the definitions (rather than the doubled `\n\n\n\n` the concatenation
+            // would otherwise leave).
+            output = output.replace(/\n+$/, '');
+            let notesMd = '\n\n';
+            // De-duplicate by node identity: a footnote referenced more than once shares a single
+            // note object (see MarkdownParser), pushed here once per reference. Emit its definition
+            // just once. Distinct notes - even two office notes that happen to share a numeric id -
+            // are separate objects and are all kept.
+            for (const note of [...new Set(this.collectedNotes)]) {
                 notesMd += await this.processNodeRecursive(note, processor);
             }
             output += notesMd;
@@ -689,6 +774,12 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
         let current = null;
         for (const node of nodes) {
             if (node.type === 'text' && current && current.type === 'text' &&
+                // A note anchors to the end of its text run and its `[^id]` marker is emitted there;
+                // merging a following run onto a note-carrying run would slide the marker past it
+                // (`Body[^1].` -> `Body.[^1]`). Keep such runs separate so the marker stays put and
+                // matches where HtmlGenerator emits it.
+                (!current.notes || current.notes.length === 0) &&
+                (!node.notes || node.notes.length === 0) &&
                 this.areFormattingEqual(node.formatting, current.formatting) &&
                 JSON.stringify(node.metadata) === JSON.stringify(current.metadata)) {
                 current.text = (current.text || '') + (node.text || '');

package/dist/generators/PdfGenerator.js

@@ -22,7 +22,10 @@ class PdfGenerator extends BaseGenerator_js_1.BaseGenerator {
         // We reuse the current configuration but ensure standalone mode is on for HTML
         const htmlGenerator = new HtmlGenerator_js_1.HtmlGenerator(this.ast, {
             ...this.config,
-            htmlConfig: { ...this.config.htmlConfig, standalone: true },
+            // Force sourceAttributes off: those data-* attributes are wire-format plumbing for
+            // structured consumers and change the mermaid shape's rendered appearance, neither of
+            // which belongs in a printed PDF.
+            htmlConfig: { ...this.config.htmlConfig, standalone: true, sourceAttributes: false },
         });
         const htmlResult = await htmlGenerator.generate();
         const html = typeof htmlResult.value === 'string' ? htmlResult.value : '';

package/dist/index.d.ts

@@ -51,10 +51,10 @@
 import { OfficeParser } from './OfficeParser.js';
 import { OfficeGenerator } from './OfficeGenerator.js';
 import { OfficeConverter } from './OfficeConverter.js';
-import { OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverterConfig, OfficeErrorType, OfficeWarningType, OfficeError, ConversionResult } from './types.js';
+import { OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, BlobLike, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverterConfig, OfficeErrorType, OfficeWarningType, OfficeError, ConversionResult, HtmlGeneratorConfig, HtmlParserConfig, MdGeneratorConfig, CsvGeneratorConfig, PdfGeneratorConfig, RtfGeneratorConfig, TextGeneratorConfig, MarkdownDialectConfig, MarkdownDialectPreset, StandaloneConfig, MetadataOverrides, FallbackToHtmlConfig, HtmlInjectionConfig, OcrConfig, DecompressionLimits, TextMetadata, TableMetadata, CodeMetadata, NoteMetadata, AdmonitionMetadata, EmbedMetadata, ChartMetadata, CommentMetadata, HeaderFooterMetadata, IndentationMetadata, ParagraphMetadata } from './types.js';
 declare const parseOffice: typeof OfficeParser.parseOffice;
 declare const terminateOcr: typeof OfficeParser.terminateOcr;
 declare const convert: typeof OfficeConverter.convert;
 declare const generate: typeof OfficeGenerator.generate;
-export { OfficeParser, parseOffice, terminateOcr, OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, OfficeGenerator, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverter, OfficeConverterConfig, convert, generate, OfficeErrorType, OfficeWarningType, OfficeError, ConversionResult, };
+export { OfficeParser, parseOffice, terminateOcr, OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, BlobLike, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, OfficeGenerator, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverter, OfficeConverterConfig, convert, generate, OfficeErrorType, OfficeWarningType, OfficeError, ConversionResult, HtmlGeneratorConfig, HtmlParserConfig, MdGeneratorConfig, CsvGeneratorConfig, PdfGeneratorConfig, RtfGeneratorConfig, TextGeneratorConfig, MarkdownDialectConfig, MarkdownDialectPreset, StandaloneConfig, MetadataOverrides, FallbackToHtmlConfig, HtmlInjectionConfig, OcrConfig, DecompressionLimits, TextMetadata, TableMetadata, CodeMetadata, NoteMetadata, AdmonitionMetadata, EmbedMetadata, ChartMetadata, CommentMetadata, HeaderFooterMetadata, IndentationMetadata, ParagraphMetadata, };
 export default OfficeParser;

package/dist/officeparser.browser.d.ts

@@ -403,6 +403,18 @@ export interface HtmlParserConfig {
 	 * Defaults to false.
 	 */
 	preserveAttributes?: boolean;
+	/**
+	 * Preserve `<iframe>` embeds that aren't recognized as a known provider (YouTube is always
+	 * recognized). By default every non-YouTube iframe is dropped, which is a deliberate security
+	 * posture other consumers rely on; set this to opt back in. `true` preserves any iframe; an
+	 * array is a hostname allowlist (an entry matches the src's host exactly or as a `.`-suffix,
+	 * so `"vimeo.com"` also matches `player.vimeo.com`). Preserved iframes become `embed` nodes
+	 * with `embedType: 'iframe'`; on generation the `src` is still scheme-checked (only http/https
+	 * survive). This also governs a raw `<iframe>` block encountered in Markdown input.
+	 *
+	 * Defaults to false.
+	 */
+	preserveIframes?: boolean | string[];
 }
 /**
  * Maps an input format string to its corresponding format-specific parser configuration, mirroring
@@ -859,6 +871,18 @@ export interface HtmlGeneratorConfig {
 	 * Granular injection points for custom HTML, scripts, and styles.
 	 */
 	injections?: HtmlInjectionConfig;
+	/**
+	 * Carry each rich node's raw source in a `data-*` attribute, with undelimited text content,
+	 * so attribute-driven structured consumers (rich-text editors, custom viewers) can rehydrate
+	 * the node from the markup rather than re-parsing the display text. Affects wikilinks
+	 * (adds `data-wikilink`/`data-target`/`data-alias`), citations (a `<span class="citation">`
+	 * carrying `data-key` instead of `<cite>`), math (the LaTeX in `data-math`, undelimited) and
+	 * mermaid (a `<div class="mermaid" data-mermaid>` instead of `<pre><code>`).
+	 *
+	 * Off by default; the default output is byte-identical to previous releases. The widened
+	 * `HtmlParser` reads every shape this emits, so output stays self-round-trippable.
+	 */
+	sourceAttributes?: boolean;
 }
 /**
  * Configuration options for PDF generation.
@@ -1074,6 +1098,14 @@ export interface FallbackToHtmlConfig {
 	embeds?: boolean;
 	/** Multi-line table cell content joined with `<br>` instead of a space. */
 	cellLineBreaks?: boolean;
+	/**
+	 * Inline text color, highlight, and font size via a `<span style="color:...;background-color:...;
+	 * font-size:...">` run, which the Markdown parser reads back. These have no Markdown syntax and
+	 * are silently lost otherwise. Unlike the other fields this is **off by default even when
+	 * `fallbackToHtml` is `true`**, because it changes default output; enable it explicitly with
+	 * `fallbackToHtml: { inlineFormatting: true }`.
+	 */
+	inlineFormatting?: boolean;
 }
 /**
  * Configuration options for Markdown generation.
@@ -1345,6 +1377,16 @@ export interface OfficeChunk {
  * Supported file types for parsing.
  */
 export type SupportedFileType = "docx" | "pptx" | "xlsx" | "odt" | "odp" | "ods" | "pdf" | "rtf" | "md" | "html" | "csv" | "epub";
+/**
+ * A structural stand-in for the web `Blob`/`File` so `parseOffice`/`convert` accept them in the
+ * browser without pulling the DOM lib into this package's types. Any object with an
+ * `arrayBuffer()` method qualifies. When `name` is present (as on a `File`) it is used only for
+ * extension-based type detection, never as a filesystem path.
+ */
+export interface BlobLike {
+	arrayBuffer(): Promise<ArrayBuffer>;
+	name?: string;
+}
 /**
  * Types of content nodes in the AST.
  */
@@ -1586,7 +1628,7 @@ export interface TableMetadata {
 	/** Unique anchor IDs for internal linking. */
 	anchorIds?: string[];
 	/**
-	 * Layout alignment of the table on the page (e.g. inscript-editor's `CustomTable`).
+	 * Layout alignment of the table on the page (e.g. an editor's custom table node).
 	 * @example 'center'
 	 */
 	align?: "left" | "center" | "right";
@@ -1631,12 +1673,12 @@ export interface ImageMetadata {
 	/** Unique anchor IDs for internal linking. */
 	anchorIds?: string[];
 	/**
-	 * Display width of the image (e.g. inscript-editor's `CustomImage`), as a CSS length or percentage.
+	 * Display width of the image (e.g. an editor's custom image node), as a CSS length or percentage.
 	 * @example "50%"
 	 */
 	width?: string;
 	/**
-	 * Layout alignment of the image (e.g. inscript-editor's `CustomImage`).
+	 * Layout alignment of the image (e.g. an editor's custom image node).
 	 * @example 'center'
 	 */
 	align?: "left" | "center" | "right";
@@ -1646,14 +1688,19 @@ export interface ImageMetadata {
  * Markdown has no native syntax for this - see `MarkdownGenerator`'s `embed` case.
  */
 export interface EmbedMetadata {
-	/** The kind of embed. Only 'youtube' is supported today; the shape is generic for future providers. */
-	embedType: "youtube";
-	/** The provider-specific video ID (e.g. the 11-character YouTube video ID). */
-	videoId: string;
-	/** The original/canonical URL of the embedded media, if known. */
+	/**
+	 * The kind of embed. 'youtube' is recognized from a `data-youtube-video` wrapper or a YouTube
+	 * iframe; 'iframe' is a generic preserved iframe (opt-in via `HtmlParserConfig.preserveIframes`).
+	 */
+	embedType: "youtube" | "iframe";
+	/** The provider-specific video ID (e.g. the 11-character YouTube video ID). Absent for generic iframes. */
+	videoId?: string;
+	/** The original/canonical URL of the embedded media, if known. For a generic iframe, its `src`. */
 	url?: string;
 	/** Display width, as a CSS length or percentage. */
 	width?: string;
+	/** Display height, as a CSS length or percentage (generic iframes). */
+	height?: string;
 	/** Layout alignment of the embed. */
 	align?: "left" | "center" | "right";
 }
@@ -1737,6 +1784,14 @@ export interface NoteMetadata {
 	anchorIds?: string[];
 	/** The slide number this note is associated with (used in PowerPoint). */
 	slideNumber?: number;
+	/**
+	 * True for a footnote/endnote definition that no reference points at (an "orphan").
+	 * The Markdown parser sets this when it recovers a `[^id]: ...` definition with no matching
+	 * `[^id]` reference so the definition is preserved rather than dropped. Generators route such
+	 * notes into their footnotes section without a citation marker, and the HTML generator omits
+	 * the (otherwise dangling) back-link.
+	 */
+	unreferenced?: boolean;
 }
 /**
  * Metadata for break nodes.
@@ -1751,8 +1806,11 @@ export interface BreakMetadata {
 	 * - 'lastRenderedPage': The editing application has inserted a soft break on the last save.
 	 * - 'textWrapping' (default, assumed when not specified): The next text will be placed on the next line.
 	 * - 'carriageReturn': An explicit carriage return (w:cr) equivalent to a hard line break.
+	 * - 'thematic': A thematic break (Markdown `---`/`***`/`___`, HTML `<hr>`) - a horizontal
+	 *   rule separating sections, distinct from a page break. Emitted as `---` in Markdown and
+	 *   `<hr>` in HTML.
 	 */
-	breakType: "column" | "page" | "lastRenderedPage" | "textWrapping" | "carriageReturn";
+	breakType: "column" | "page" | "lastRenderedPage" | "textWrapping" | "carriageReturn" | "thematic";
 	/**
 	 * Specifies the location which shall be used as the next available line when breakType
 	 * has a value of 'textWrapping'. Should be ignored for other break types.
@@ -1774,7 +1832,7 @@ export interface CodeMetadata {
 	/**
 	 * When set, this node is a LaTeX math expression rather than a code block. `node.text`
 	 * holds the bare LaTeX (delimiters excluded); 'inline' round-trips as `$...$`,
-	 * 'block' as `$$...$$`. Matches inscript-editor's math node (Roadmap Step 11.5).
+	 * 'block' as `$$...$$`. Matches attribute-driven editors' math nodes.
 	 */
 	math?: "inline" | "block";
 }
@@ -2342,7 +2400,7 @@ export declare class OfficeParser {
 	 * const text = ast.toText();
 	 * ```
 	 */
-	static parseOffice(file: string | Buffer | ArrayBuffer | Uint8Array, configOrCallback?: OfficeParserConfig | ((ast: OfficeParserAST, err?: any) => void), config?: OfficeParserConfig): Promise<OfficeParserAST>;
+	static parseOffice(file: string | Buffer | ArrayBuffer | Uint8Array | BlobLike, configOrCallback?: OfficeParserConfig | ((ast: OfficeParserAST, err?: any) => void), config?: OfficeParserConfig): Promise<OfficeParserAST>;
 	/**
 	 * Terminates all active OCR workers and cleans up resources.
 	 *
@@ -2418,7 +2476,7 @@ export declare class OfficeConverter {
 	 * });
 	 * ```
 	 */
-	static convert<F extends string | Buffer | ArrayBuffer | Uint8Array, T extends SupportedFileType = InferFileTypeFromPath<F>, D extends SupportedDestination<T> = SupportedDestination<T>>(file: F, destination: D, config?: OfficeConverterConfig<D, T>): Promise<ConversionResult<D>>;
+	static convert<F extends string | Buffer | ArrayBuffer | Uint8Array | BlobLike, T extends SupportedFileType = InferFileTypeFromPath<F>, D extends SupportedDestination<T> = SupportedDestination<T>>(file: F, destination: D, config?: OfficeConverterConfig<D, T>): Promise<ConversionResult<D>>;
 }
 export declare const parseOffice: typeof OfficeParser.parseOffice;
 export declare const terminateOcr: typeof OfficeParser.terminateOcr;