ooxml-core 1.24.0 → 1.24.1

package/dist/pptx/chunks/index-C3xhAMSa.d.ts

@@ -0,0 +1,837 @@
+import { r as TextSegment } from "./text-D49FKllA.js";
+import { m as PptxElement } from "./elements-iUzpAeqR.js";
+import { C as PptxSlide, d as PptxData } from "./text-operations-CfLVZ7DK.js";
+import "./index-nKQ4s7FA.js";
+//#region pptx/converter/types.d.ts
+/**
+ * Platform adapter for file system operations.
+ *
+ * Consumers must provide an implementation of this interface
+ * when using the converter with file output (writing markdown
+ * and extracting media to disk).
+ *
+ * For in-memory-only conversion (just getting the markdown string),
+ * no adapter is required.
+ */
+interface FileSystemAdapter {
+  /**
+   * Writes a UTF-8 text file at the given path, creating or overwriting as needed.
+   * @param path - Absolute or relative path for the output file.
+   * @param content - Text content to write.
+   */
+  writeFile(path: string, content: string): Promise<void>;
+  /**
+   * Writes a binary file (e.g. an extracted image) at the given path.
+   * @param path - Absolute or relative path for the output file.
+   * @param data - Raw binary content as a typed array.
+   */
+  writeBinaryFile(path: string, data: Uint8Array): Promise<void>;
+  /**
+   * Creates a directory (and any missing parents) at the given path.
+   * Should be a no-op if the directory already exists.
+   * @param path - Absolute or relative path for the directory.
+   */
+  createFolder(path: string): Promise<void>;
+}
+/**
+ * Options shared by all document converters, controlling output paths,
+ * media extraction folder names, and metadata inclusion.
+ */
+interface ConversionOptions {
+  /** Optional file path to write the generated markdown. When omitted, only the string is returned. */
+  outputPath?: string;
+  /** Name of the sub-folder (relative to outputDir) where extracted media will be stored. */
+  mediaFolderName: string;
+  /** When true, a YAML front-matter block with document metadata is prepended to the output. */
+  includeMetadata: boolean;
+}
+/**
+ * Summary of a completed conversion, including statistics about
+ * the generated output and extracted media.
+ */
+interface ConversionResult {
+  /** Whether the conversion completed without errors. */
+  success: boolean;
+  /** Path where the markdown output was written. */
+  outputPath: string;
+  /** Character length of the generated markdown string. */
+  markdownLength: number;
+  /** Number of images extracted and saved to the media folder. */
+  imagesExtracted: number;
+  /** Absolute path to the media folder, or null if no images were extracted. */
+  mediaFolder: string | null;
+  /** Allows additional converter-specific metadata fields. */
+  [key: string]: unknown;
+}
+//#endregion
+//#region pptx/converter/media-context.d.ts
+/**
+ * Parses a Base64-encoded `data:` URL and returns the decoded binary
+ * content along with a suitable file extension.
+ *
+ * @param dataUrl - A complete `data:` URL in the form `data:<mime>;base64,<payload>`.
+ * @returns An object with `bytes` (the decoded binary data) and `ext` (the file extension).
+ * @throws Error if the data URL does not match the expected `data:<mime>;base64,<payload>` format.
+ *
+ * @example
+ * ```ts
+ * const { bytes, ext } = dataUrlToMediaBytes('data:image/png;base64,iVBOR...');
+ * // bytes: Uint8Array of PNG data
+ * // ext: 'png'
+ * ```
+ */
+declare function dataUrlToMediaBytes(dataUrl: string): {
+  bytes: Uint8Array;
+  ext: string;
+};
+/**
+ * Generates a deterministic, zero-padded filename for an extracted image.
+ *
+ * @param index - The 1-based ordinal of the image within the conversion session.
+ * @param ext - File extension (with or without leading dot).
+ * @returns A filename like `"image-001.png"`.
+ *
+ * @example
+ * ```ts
+ * generateMediaFilename(7, 'jpg'); // "image-007.jpg"
+ * ```
+ */
+declare function generateMediaFilename(index: number, ext: string): string;
+/**
+ * Manages the extraction and persistence of media files (images) during
+ * a PPTX-to-Markdown conversion session.
+ *
+ * Each `MediaContext` tracks a running count of saved images and ensures
+ * the target media directory is lazily created on first write. When no
+ * {@link FileSystemAdapter} is provided, filenames are still generated
+ * (for in-memory usage) but nothing is written to disk.
+ */
+declare class MediaContext {
+  private readonly folderName;
+  private readonly fs?;
+  /** Running counter used to assign unique sequential filenames. */
+  private imageIndex;
+  /** Whether the media output directory has been created yet. */
+  private initialized;
+  /** Fully resolved path to the media output directory. */
+  private readonly resolvedMediaDir;
+  /**
+   * @param outputDir - Root output directory for the conversion.
+   * @param folderName - Sub-folder name for media files (e.g. `"media"`).
+   * @param fs - Optional file system adapter; omit for in-memory-only conversion.
+   */
+  constructor(outputDir: string, folderName: string, fs?: FileSystemAdapter | undefined);
+  /** Returns the total number of images saved so far in this session. */
+  get totalImages(): number;
+  /** Returns the absolute path to the media output directory. */
+  get mediaDir(): string;
+  /**
+   * Decodes a Base64 `data:` URL, saves the image to disk (if a FS adapter
+   * is available), and returns a relative path suitable for embedding in markdown.
+   *
+   * @param dataUrl - The Base64-encoded data URL of the image.
+   * @param prefix - Optional filename prefix (e.g. `"slide3"`) for disambiguation.
+   * @returns A relative path like `"./media/slide3-image-001.png"`.
+   * @throws Error if the data URL is malformed.
+   */
+  saveImage(dataUrl: string, prefix?: string): Promise<string>;
+  /**
+   * Saves raw image bytes to disk and returns a relative path for markdown embedding.
+   *
+   * @param bytes - Raw binary content of the image.
+   * @param ext - File extension (e.g. `"png"`, `"jpg"`).
+   * @param prefix - Optional filename prefix for disambiguation.
+   * @returns A relative path like `"./media/image-001.png"`.
+   */
+  saveImageBytes(bytes: Uint8Array, ext: string, prefix?: string): Promise<string>;
+  /**
+   * Lazily creates the media output directory on the first call.
+   * Subsequent calls are no-ops.
+   */
+  private ensureInitialized;
+}
+//#endregion
+//#region pptx/converter/base.d.ts
+/**
+ * Normalises a file path by trimming whitespace and converting
+ * backslashes to forward slashes for cross-platform consistency.
+ *
+ * @param pathValue - The raw file path string.
+ * @returns The normalised path with forward slashes.
+ *
+ * @example
+ * ```ts
+ * normalizePath('  C:\\Users\\docs\\file.md  ');
+ * // "C:/Users/docs/file.md"
+ * ```
+ */
+declare function normalizePath(pathValue: string): string;
+/**
+ * Extracts the directory portion of a file path (everything before the
+ * last `/` separator).
+ *
+ * @param filePath - A file path (backslashes are normalised automatically).
+ * @returns The parent directory, `"."` if there is no separator, or `"/"` for root paths.
+ *
+ * @example
+ * ```ts
+ * getDirectory('/home/user/doc.md'); // "/home/user"
+ * getDirectory('file.txt');          // "."
+ * ```
+ */
+declare function getDirectory(filePath: string): string;
+/**
+ * Derives a `.md` output path from a source file path when no explicit
+ * output path has been provided. Simply replaces the source extension
+ * with `.md`.
+ *
+ * @param sourcePath - Original source file path (e.g. `"presentation.pptx"`).
+ * @param explicitPath - An explicit output path; if provided, it is returned as-is.
+ * @returns The derived markdown path, the explicit path, or `undefined` if both inputs are absent.
+ *
+ * @example
+ * ```ts
+ * deriveOutputPath('slides.pptx', undefined); // "slides.md"
+ * deriveOutputPath('slides.pptx', '/tmp/out.md'); // "/tmp/out.md"
+ * ```
+ */
+declare function deriveOutputPath(sourcePath: string | undefined, explicitPath: string | undefined): string | undefined;
+/**
+ * Abstract base class for document-to-Markdown converters.
+ *
+ * Provides shared infrastructure for media extraction ({@link MediaContext}),
+ * YAML front-matter generation, and file output. Concrete subclasses implement
+ * the {@link convert} method to handle a specific document type.
+ *
+ * @typeParam TSource - The parsed document data structure that this converter consumes.
+ */
+declare abstract class DocumentConverter<TSource> {
+  protected readonly outputDir: string;
+  protected readonly options: ConversionOptions;
+  protected readonly fs?: FileSystemAdapter | undefined;
+  /** Shared context for extracting and saving media (images) during conversion. */
+  protected readonly mediaContext: MediaContext;
+  /**
+   * @param outputDir - Root directory for all output files (markdown + media).
+   * @param options - Conversion options (output path, media folder name, metadata flag).
+   * @param fs - Optional file system adapter for writing files to disk.
+   */
+  protected constructor(outputDir: string, options: ConversionOptions, fs?: FileSystemAdapter | undefined);
+  /**
+   * Converts the given source document into a Markdown string.
+   *
+   * @param source - The parsed document data to convert.
+   * @returns The generated Markdown content.
+   */
+  abstract convert(source: TSource): Promise<string>;
+  /**
+   * Builds a YAML front-matter block from a key-value metadata dictionary.
+   * String values are quoted; numeric values are emitted bare.
+   *
+   * @param metadata - Key-value pairs to include in the front matter.
+   * @returns A complete front-matter string (including `---` delimiters and trailing blank lines).
+   */
+  protected buildFrontMatter(metadata: Record<string, string | number>): string;
+  /**
+   * Writes the generated markdown content to an output file using the
+   * configured {@link FileSystemAdapter}.
+   *
+   * @param content - The markdown string to write.
+   * @param outputPath - Destination file path.
+   * @throws Error if no `FileSystemAdapter` was provided at construction time.
+   */
+  protected writeOutput(content: string, outputPath: string): Promise<void>;
+}
+//#endregion
+//#region pptx/converter/PptxMarkdownConverter.d.ts
+/**
+ * Options specific to PPTX-to-Markdown conversion, extending the base
+ * {@link ConversionOptions} with presentation-aware settings.
+ */
+interface PptxConverterOptions extends ConversionOptions {
+  /** Human-readable name of the source file, used in front-matter metadata. */
+  sourceName: string;
+  /** Whether to append speaker notes (as blockquotes) below each slide. */
+  includeSpeakerNotes: boolean;
+  /**
+   * Optional 1-based slide range to limit conversion to a subset of the deck.
+   * Omit or leave fields undefined to convert all slides.
+   */
+  slideRange?: {
+    /** First slide to include (1-based, default 1). */
+    start?: number;
+    /** Last slide to include (1-based, default = last slide). */
+    end?: number;
+  };
+  /**
+   * When true, emit clean semantic markdown instead of CSS-positioned HTML.
+   * Default is false (positioned HTML layout for slide fidelity).
+   */
+  semanticMode?: boolean;
+}
+/**
+ * Converts a parsed {@link PptxData} presentation into a Markdown document.
+ *
+ * This is the primary entry point for PPTX-to-Markdown conversion. It
+ * orchestrates slide processing, media extraction, metadata generation,
+ * and output assembly. Each slide element type is handled by a dedicated
+ * {@link ElementProcessor} registered in the internal registry.
+ *
+ * @example
+ * ```ts
+ * const converter = new PptxMarkdownConverter('/output', {
+ *   sourceName: 'deck.pptx',
+ *   includeSpeakerNotes: true,
+ *   mediaFolderName: 'media',
+ *   includeMetadata: true,
+ * });
+ * const markdown = await converter.convert(pptxData);
+ * ```
+ */
+declare class PptxMarkdownConverter extends DocumentConverter<PptxData> {
+  /** Renderer for rich-text segments (bold, italic, hyperlinks, etc.). */
+  private readonly textRenderer;
+  /** Registry mapping element types to their dedicated processors. */
+  private readonly registry;
+  /** Delegate responsible for converting individual slides. */
+  private readonly slideProcessor;
+  /** Number of slides actually converted (after applying the slide range filter). */
+  private convertedSlides;
+  /** Total number of slides in the source presentation. */
+  private totalSlides;
+  /**
+   * @param outputDir - Root directory for output files.
+   * @param options - PPTX-specific conversion options.
+   * @param fs - Optional file system adapter for writing media to disk.
+   */
+  constructor(outputDir: string, options: PptxConverterOptions, fs?: FileSystemAdapter);
+  /** Returns the number of images extracted and saved during conversion. */
+  get imagesExtracted(): number;
+  /** Returns the media directory path, or `null` if no images were extracted. */
+  get mediaDir(): string | null;
+  /** Returns the number of slides that were actually converted. */
+  get slidesConverted(): number;
+  /** Returns the total number of slides in the source presentation. */
+  get presentationSlides(): number;
+  /**
+   * Converts the full PPTX presentation (or a slide subset) into Markdown.
+   *
+   * The conversion pipeline:
+   * 1. Resolves the slide range and selects the target slides.
+   * 2. Processes each slide through {@link SlideProcessor}, producing markdown sections.
+   * 3. Inserts section headings when slides belong to named sections.
+   * 4. Optionally prepends YAML front-matter with document metadata.
+   * 5. Appends header/footer information if present.
+   * 6. Writes the output file if an `outputPath` was configured.
+   *
+   * @param source - The parsed PPTX data structure.
+   * @returns The complete Markdown string.
+   */
+  convert(source: PptxData): Promise<string>;
+  /**
+   * Registers all element-type processors into the internal registry.
+   * Each processor handles one or more {@link PptxElement} types
+   * (text, image, table, chart, etc.).
+   */
+  private registerProcessors;
+  /**
+   * Assembles a YAML front-matter block containing presentation metadata
+   * such as title, author, slide count, theme, dimensions, and more.
+   *
+   * @param source - The parsed PPTX data.
+   * @returns A YAML front-matter string (including `---` delimiters).
+   */
+  private buildPptxFrontMatter;
+  /**
+   * Populates metadata entries from OPC core properties (title, author, subject, etc.).
+   *
+   * @param meta - The metadata dictionary to populate.
+   * @param props - Core document properties from the PPTX file.
+   */
+  private addCoreProperties;
+  /**
+   * Populates metadata entries from application-level properties
+   * (application name, editing time, word/paragraph counts).
+   *
+   * @param meta - The metadata dictionary to populate.
+   * @param props - Application properties from the PPTX file.
+   */
+  private addAppProperties;
+  /**
+   * Adds presentation-level metadata (custom properties, show type, theme,
+   * security warnings, embedded fonts, custom shows) to the front-matter dictionary.
+   *
+   * @param meta - The metadata dictionary to populate.
+   * @param source - The full parsed PPTX data.
+   */
+  private addPresentationMeta;
+  /**
+   * Renders the presentation-level header/footer settings (header text,
+   * footer text, date/time, slide numbers) into a pipe-delimited markdown string.
+   *
+   * @param hf - Header/footer configuration from the presentation.
+   * @returns A formatted string, or an empty string if no header/footer data is present.
+   */
+  private renderHeaderFooter;
+  /**
+   * Resolves and clamps the user-specified slide range to valid bounds.
+   * Defaults to the full deck if no range is configured.
+   *
+   * @param totalSlides - Total number of slides in the presentation.
+   * @returns A 1-based `{ start, end }` range guaranteed to be within bounds.
+   */
+  private resolveRange;
+  /** Casts the base `options` to the PPTX-specific options type. */
+  private getOptions;
+}
+//#endregion
+//#region pptx/converter/elements/ElementProcessor.d.ts
+interface ElementProcessorContext {
+  mediaContext: MediaContext;
+  slideNumber: number;
+  /** Slide canvas width in CSS pixels (for layout positioning). */
+  slideWidth: number;
+  /** Slide canvas height in CSS pixels (for layout positioning). */
+  slideHeight: number;
+  /** Scale factor applied to the layout container (for font/image sizing). */
+  layoutScale?: number;
+  /**
+   * When true, processors should emit clean markdown instead of HTML.
+   * Tables become markdown tables, images use `![alt](path)` syntax,
+   * and text uses markdown formatting (not `<strong>`, `<em>`, etc.).
+   */
+  semanticMode?: boolean;
+  processElements: (elements: PptxElement[]) => Promise<string[]>;
+}
+interface ElementProcessor {
+  readonly supportedTypes: ReadonlyArray<PptxElement['type']>;
+  process(element: PptxElement, ctx: ElementProcessorContext): Promise<string | null>;
+}
+declare class ElementProcessorRegistry {
+  private readonly processors;
+  register(processor: ElementProcessor): void;
+  getProcessor(type: PptxElement['type']): ElementProcessor | null;
+  processElement(element: PptxElement, ctx: ElementProcessorContext): Promise<string | null>;
+  private buildActionAnnotation;
+}
+//#endregion
+//#region pptx/converter/TextSegmentRenderer.d.ts
+/**
+ * Options controlling how text segments are rendered.
+ */
+interface TextSegmentRenderOptions {
+  paragraphIndents?: Array<{
+    marginLeft?: number;
+    indent?: number;
+  }>;
+  slideNumber?: number;
+  dateTimeText?: string;
+  inlineMode?: boolean;
+  disableLists?: boolean;
+  disableAlignment?: boolean;
+  /**
+   * When true, emit HTML formatting tags instead of Markdown syntax.
+   */
+  htmlFormatting?: boolean;
+}
+declare class TextSegmentRenderer {
+  private readonly ommlConverter;
+  render(segments: TextSegment[], options?: TextSegmentRenderOptions): string;
+  renderInline(segments: TextSegment[], options?: TextSegmentRenderOptions): string;
+  plainText(segments: TextSegment[], options?: TextSegmentRenderOptions): string;
+  private groupParagraphs;
+  private renderParagraph;
+  private renderSegment;
+  private resolvePlainSegmentText;
+  private resolveFieldSegment;
+  private wrapCode;
+  private renderLinkDestination;
+  private escapeLinkTitle;
+  private escapeMarkdown;
+  private escapeHtml;
+}
+//#endregion
+//#region pptx/converter/SlideProcessor.d.ts
+/**
+ * Options controlling how a single slide is processed into Markdown.
+ */
+interface SlideProcessorOptions {
+  /** Whether to include speaker notes below the slide content. */
+  includeSpeakerNotes: boolean;
+  /** Slide canvas width in CSS pixels (used for layout positioning). */
+  slideWidth: number;
+  /** Slide canvas height in CSS pixels (used for layout positioning). */
+  slideHeight: number;
+  /** When true, emit clean semantic markdown instead of positioned HTML. */
+  semanticMode?: boolean;
+}
+/**
+ * Converts a single {@link PptxSlide} into a Markdown section.
+ */
+declare class SlideProcessor {
+  private readonly registry;
+  private readonly mediaContext;
+  private readonly textRenderer;
+  /** Delegate for rendering slide-level metadata sections. */
+  private readonly metadataRenderer;
+  /**
+   * @param registry - Registry of element-type processors.
+   * @param mediaContext - Shared media extraction context.
+   * @param textRenderer - Renderer for rich-text segments.
+   */
+  constructor(registry: ElementProcessorRegistry, mediaContext: MediaContext, textRenderer: TextSegmentRenderer);
+  /** Processes a slide into a complete Markdown section. */
+  processSlide(slide: PptxSlide, options: SlideProcessorOptions): Promise<string>;
+  /**
+   * Builds the Markdown heading line for a slide, including its number,
+   * detected title text, and flags (hidden, layout name).
+   */
+  private buildHeading;
+  /**
+   * Returns an HTML `<img>` for the slide background that can be
+   * placed as the bottom-most layer inside the positioned container.
+   */
+  private renderBackgroundHtml;
+  /** Detects the slide's title from placeholder or first text element. */
+  private detectTitle;
+  /**
+   * Extracts the placeholder type from an element, if present.
+   */
+  private getPlaceholderType;
+  /** Processes elements as clean semantic markdown. */
+  private processElementsSemantic;
+  /** Processes elements using CSS absolute positioning. */
+  private processElementsWithLayout;
+  /** Sorts elements into natural reading order (top-to-bottom, left-to-right). */
+  private sortElementsByReadingOrder;
+}
+//#endregion
+//#region pptx/converter/SlideMetadataRenderer.d.ts
+/**
+ * Renders slide-level metadata sections (transition, animations,
+ * warnings, comments, speaker notes) into Markdown strings.
+ */
+declare class SlideMetadataRenderer {
+  private readonly textRenderer;
+  constructor(textRenderer: TextSegmentRenderer);
+  /**
+   * Renders the slide transition effect as a short metadata line.
+   */
+  renderTransition(slide: PptxSlide): string;
+  /**
+   * Renders the slide's animation effects grouped by click sequence.
+   */
+  renderAnimations(slide: PptxSlide): string;
+  /**
+   * Renders any compatibility warnings for the slide.
+   */
+  renderWarnings(slide: PptxSlide): string;
+  /**
+   * Renders any review comments attached to the slide.
+   */
+  renderComments(slide: PptxSlide): string;
+  /**
+   * Renders the slide's speaker notes as a Markdown blockquote.
+   */
+  renderNotes(slide: PptxSlide): string;
+  /**
+   * Groups animations by click sequence. Each `onClick` trigger starts
+   * a new group; `withPrevious` and `afterPrevious` are appended to the
+   * current group.
+   */
+  private groupByClickSequence;
+  /**
+   * Converts legacy animation data into the NativeAnimationLike shape.
+   */
+  private mapLegacyAnimations;
+  /**
+   * Produces a human-readable summary of a single animation effect.
+   */
+  private summariseAnimation;
+}
+//#endregion
+//#region pptx/converter/svg-text-lines.d.ts
+type SvgTextMeasurer = (text: string, font: {
+  family: string;
+  size: number;
+  bold: boolean;
+  italic: boolean;
+}) => number;
+//#endregion
+//#region pptx/converter/SvgExporter.d.ts
+/**
+ * Options controlling SVG export behaviour.
+ */
+interface SvgExportOptions {
+  /** Include hidden slides when exporting all. Default `false`. */
+  includeHidden?: boolean;
+  /** Slide indices to export (0-based). If omitted, all slides are exported. */
+  slideIndices?: number[];
+  /** Default font family when the element does not specify one. */
+  defaultFontFamily?: string;
+  /** Default font size in points when the element does not specify one. */
+  defaultFontSize?: number;
+  /** Optional host font metrics. Headless exports fall back to measured font tables. */
+  measureText?: SvgTextMeasurer;
+}
+/**
+ * Pure-TypeScript SVG exporter for parsed PPTX data.
+ *
+ * Generates well-formed SVG XML strings without any DOM dependency.
+ *
+ * @example
+ * ```ts
+ * const svgs = SvgExporter.exportAll(pptxData);
+ * for (const [i, svg] of svgs.entries()) {
+ *   fs.writeFileSync(`slide_${i + 1}.svg`, svg);
+ * }
+ * ```
+ */
+declare class SvgExporter {
+  /**
+   * Export a single slide to an SVG XML string.
+   *
+   * @param slide  - The parsed slide.
+   * @param width  - SVG viewport width (pixels).
+   * @param height - SVG viewport height (pixels).
+   * @param options - Optional export settings.
+   * @returns A complete SVG document as a string.
+   */
+  static exportSlide(slide: PptxSlide, width: number, height: number, options?: SvgExportOptions): string;
+  /**
+   * Export all (or selected) slides to SVG XML strings.
+   *
+   * @param data    - The fully parsed PPTX data.
+   * @param options - Optional export settings.
+   * @returns An array of SVG strings (one per exported slide).
+   */
+  static exportAll(data: PptxData, options?: SvgExportOptions): string[];
+}
+//#endregion
+//#region pptx/converter/json/json-document.d.ts
+/**
+ * The `pptx-viewer-json` document format: a portable, versioned,
+ * self-contained JSON representation of a parsed presentation
+ * ({@link PptxData}). Binary payloads are embedded (base64), so a document
+ * round-trips standalone without the original `.pptx` archive.
+ *
+ * Top-level shape (version 1):
+ *
+ * ```json
+ * {
+ *   "format": "pptx-viewer-json",
+ *   "version": 1,
+ *   "generator": "pptx-viewer-core",
+ *   "createdAt": "2026-01-01T00:00:00.000Z",
+ *   "slideCount": 3,
+ *   "assets": { "count": 2, "totalBytes": 51234 },
+ *   "presentation": { "width": 960, "height": 540, ... },
+ *   "slides": [ { "id": "...", "elements": [ ... ] }, ... ]
+ * }
+ * ```
+ *
+ * Field coverage mirrors the canonical inventories
+ * (`SLIDE_FIELD_KIND` / `ELEMENT_FIELD_KIND`) plus a TypeScript-enforced
+ * presentation-level key list, so no model field is silently dropped.
+ */
+/** Discriminating marker stored in the top-level `format` field. */
+declare const PPTX_JSON_FORMAT = "pptx-viewer-json";
+/** Current (and only) supported document version. */
+declare const PPTX_JSON_VERSION = 1;
+/** Suggested file extension for exported documents. */
+declare const PPTX_JSON_FILE_EXTENSION = ".json";
+/** MIME type used when downloading an exported document. */
+declare const PPTX_JSON_MIME_TYPE = "application/json";
+/** Size accounting for binary assets embedded in the document. */
+interface PptxJsonAssetStats {
+  /** Number of embedded binary assets (base64 data URLs + raw byte fields). */
+  count: number;
+  /** Total decoded byte size of all embedded binary assets. */
+  totalBytes: number;
+}
+/** A parsed and shape-validated `pptx-viewer-json` document. */
+interface PptxJsonDocument {
+  format: typeof PPTX_JSON_FORMAT;
+  version: typeof PPTX_JSON_VERSION;
+  /** Producer identifier (informational, ignored on import). */
+  generator?: string;
+  /** ISO-8601 export timestamp (informational, ignored on import). */
+  createdAt?: string;
+  /** Convenience copy of `slides.length`; validated on import. */
+  slideCount: number;
+  /** Embedded-asset size accounting computed at export time. */
+  assets: PptxJsonAssetStats;
+  /** Presentation-level fields of `PptxData` (everything except `slides`). */
+  presentation: Record<string, unknown>;
+  /** JSON-encoded slides (see `SLIDE_FIELD_KIND` / `ELEMENT_FIELD_KIND`). */
+  slides: Array<Record<string, unknown>>;
+}
+/**
+ * Cheap text-level sniff: the text is a JSON object (leading `{` after
+ * optional whitespace) and carries the `pptx-viewer-json` format marker.
+ * Full validation happens in `parsePptxJsonDocument`.
+ */
+declare function isPptxJsonText(text: string): boolean;
+/**
+ * Byte-level sniff + decode: returns the decoded text when the buffer looks
+ * like a `pptx-viewer-json` document, or `null` for anything else (e.g. a
+ * ZIP/OLE2 `.pptx`). Safe to call on arbitrary binary input.
+ */
+declare function decodePptxJsonText(data: ArrayBuffer | Uint8Array): string | null;
+//#endregion
+//#region pptx/converter/json/json-binary-codec.d.ts
+/**
+ * Deep value codec for the `pptx-viewer-json` format.
+ *
+ * `PptxData` is almost entirely JSON-native, but a handful of fields carry
+ * raw bytes (`Uint8Array`: presentation thumbnails, embedded font binaries,
+ * embedded chart workbooks). This codec walks a value tree and:
+ *
+ * - encodes every `Uint8Array` as a tagged object `{ "$bytes": "<base64>" }`
+ *   so the document stays valid, self-contained JSON,
+ * - escapes original object keys starting with `$` (prefixing one extra `$`)
+ *   so a coincidental `{ $bytes: ... }` in source data can never be
+ *   mis-decoded, and
+ * - accounts embedded binary assets (tagged byte fields plus base64
+ *   `data:` URLs already stored as strings, e.g. `imageData`/`mediaData`).
+ */
+/** Mutable accumulator for embedded-asset size accounting. */
+interface JsonAssetAccumulator {
+  count: number;
+  totalBytes: number;
+}
+/** Encode raw bytes to base64 (Node `Buffer` when available, else `btoa`). */
+declare function bytesToBase64(bytes: Uint8Array): string;
+/** Decode base64 text to raw bytes (Node `Buffer` when available, else `atob`). */
+declare function base64ToBytes(base64: string): Uint8Array;
+/**
+ * Recursively encode a model value into a JSON-safe value.
+ * `undefined` entries inside objects are dropped (matching `JSON.stringify`).
+ */
+declare function encodeJsonValue(value: unknown, stats?: JsonAssetAccumulator): unknown;
+/** Recursively decode a JSON value produced by {@link encodeJsonValue}. */
+declare function decodeJsonValue(value: unknown): unknown;
+//#endregion
+//#region pptx/converter/json/presentation-field-keys.d.ts
+/**
+ * Canonical inventory of the presentation-level fields of {@link PptxData}
+ * (everything except `slides`, which the JSON document stores as its own
+ * top-level array).
+ *
+ * Mirrors the pattern of `ELEMENT_FIELD_KIND` / `SLIDE_FIELD_KIND`
+ * (`core/types/collaboration-field-schema.ts`): typed as
+ * `Record<keyof Omit<PptxData, 'slides'>, true>` so TypeScript forces this
+ * list to be updated whenever `PptxData` gains or loses a field, turning
+ * "forgot to serialize a new presentation field" into a compile error
+ * instead of silent JSON data loss.
+ */
+declare const PRESENTATION_FIELD_KEYS: Record<keyof Omit<PptxData, 'slides'>, true>;
+/** Ordered list of the presentation-level field names. */
+declare const PRESENTATION_FIELD_NAMES: ReadonlyArray<string>;
+//#endregion
+//#region pptx/converter/json/json-serializer.d.ts
+/** Options for {@link buildPptxJsonDocument}. */
+interface PptxJsonSerializeOptions {
+  /** Producer identifier written into the `generator` field. */
+  generator?: string;
+  /**
+   * Whether to stamp `createdAt` with the current time. Defaults to `true`;
+   * disable for byte-stable output (e.g. snapshot tests).
+   */
+  includeTimestamp?: boolean;
+}
+/**
+ * Serialize a parsed presentation into a versioned, self-contained
+ * `pptx-viewer-json` document. Binary payloads (thumbnails, embedded fonts,
+ * chart workbooks) are embedded as tagged base64; images and media already
+ * live in the model as base64 data URLs and are carried verbatim. Field
+ * coverage is driven by the canonical inventories (`SLIDE_FIELD_KIND`,
+ * `ELEMENT_FIELD_KIND`, `PRESENTATION_FIELD_KEYS`) so no model field is
+ * silently dropped.
+ */
+declare function buildPptxJsonDocument(data: PptxData, options?: PptxJsonSerializeOptions): PptxJsonDocument;
+/** Serialize a presentation straight to JSON text. */
+declare function serializePptxToJson(data: PptxData, options?: PptxJsonSerializeOptions & {
+  pretty?: boolean;
+}): string;
+//#endregion
+//#region pptx/converter/json/json-deserializer.d.ts
+/** Error thrown when a candidate document fails `pptx-viewer-json` validation. */
+declare class PptxJsonFormatError extends Error {
+  constructor(message: string);
+}
+/**
+ * Validate an arbitrary parsed JSON value as a `pptx-viewer-json` document.
+ * Performs structural narrowing only (no `any`, no blind casts on the
+ * envelope): the format marker, version, slide array, per-slide element
+ * arrays, and per-element `type` discriminants are all checked.
+ */
+declare function parsePptxJsonDocument(value: unknown): PptxJsonDocument;
+/** Parse and validate JSON text as a `pptx-viewer-json` document. */
+declare function parsePptxJson(text: string): PptxJsonDocument;
+/**
+ * Rebuild a {@link PptxData} model from a validated document. Field coverage
+ * mirrors serialization: only fields present in the canonical inventories are
+ * accepted, and tagged binary payloads are decoded back to `Uint8Array`.
+ */
+declare function pptxDataFromJsonDocument(document: PptxJsonDocument): PptxData;
+/** Convenience: parse, validate, and rebuild in one step. */
+declare function deserializePptxFromJson(text: string): PptxData;
+//#endregion
+//#region pptx/converter/json/PptxJsonConverter.d.ts
+/** Options for a {@link PptxJsonConverter} instance. */
+interface PptxJsonConverterOptions extends PptxJsonSerializeOptions {
+  /** Pretty-print JSON output with 2-space indentation. */
+  pretty?: boolean;
+}
+/**
+ * Converts a parsed {@link PptxData} presentation to and from the portable
+ * `pptx-viewer-json` document format.
+ *
+ * Sibling of {@link PptxMarkdownConverter}: where the markdown converter
+ * produces a lossy human-readable rendition, this converter produces a
+ * lossless (model-level), versioned, self-contained JSON document that can
+ * be re-imported without the original `.pptx` archive.
+ *
+ * @example
+ * ```ts
+ * const converter = new PptxJsonConverter({ generator: 'my-app' });
+ * const json = converter.toJson(pptxData);
+ * const roundTripped = converter.fromJson(json);
+ * ```
+ */
+declare class PptxJsonConverter {
+  private readonly options;
+  constructor(options?: PptxJsonConverterOptions);
+  /** Serialize a presentation into a structured JSON document. */
+  toDocument(data: PptxData): PptxJsonDocument;
+  /** Serialize a presentation straight to JSON text. */
+  toJson(data: PptxData): string;
+  /** Validate an arbitrary parsed JSON value as a document. */
+  parseDocument(value: unknown): PptxJsonDocument;
+  /** Rebuild the presentation model from JSON text (parse + validate). */
+  fromJson(text: string): PptxData;
+  /** Rebuild the presentation model from a validated document. */
+  fromDocument(document: PptxJsonDocument): PptxData;
+  /** Static counterpart of {@link fromJson}. */
+  static fromJson(text: string): PptxData;
+  /** Static counterpart of {@link toJson}. */
+  static toJson(data: PptxData, options?: PptxJsonConverterOptions): string;
+  /** Parse and validate JSON text as a document without rebuilding the model. */
+  static parse(text: string): PptxJsonDocument;
+  /** Cheap text-level sniff for the format marker. */
+  static isPptxJsonText(text: string): boolean;
+  /** Byte-level sniff + decode; `null` for non-JSON (e.g. ZIP) input. */
+  static decodeText(data: ArrayBuffer | Uint8Array): string | null;
+}
+/**
+ * Overlay an imported presentation onto a freshly loaded base presentation
+ * (typically a blank one generated for JSON import): every presentation-level
+ * field defined on `imported` wins, fields it lacks keep the base value (so a
+ * blank deck's theme scaffolding survives when the document carries none),
+ * and the slide array is replaced wholesale. Mutates and returns `base`.
+ */
+declare function applyImportedPptxData(base: PptxData, imported: PptxData): PptxData;
+//#endregion
+export { SlideProcessor as A, generateMediaFilename as B, PptxJsonAssetStats as C, SvgExportOptions as D, isPptxJsonText as E, deriveOutputPath as F, ConversionResult as H, getDirectory as I, normalizePath as L, PptxConverterOptions as M, PptxMarkdownConverter as N, SvgExporter as O, DocumentConverter as P, MediaContext as R, PPTX_JSON_VERSION as S, decodePptxJsonText as T, FileSystemAdapter as U, ConversionOptions as V, decodeJsonValue as _, deserializePptxFromJson as a, PPTX_JSON_FORMAT as b, pptxDataFromJsonDocument as c, serializePptxToJson as d, PRESENTATION_FIELD_KEYS as f, bytesToBase64 as g, base64ToBytes as h, PptxJsonFormatError as i, SlideProcessorOptions as j, SlideMetadataRenderer as k, PptxJsonSerializeOptions as l, JsonAssetAccumulator as m, PptxJsonConverterOptions as n, parsePptxJson as o, PRESENTATION_FIELD_NAMES as p, applyImportedPptxData as r, parsePptxJsonDocument as s, PptxJsonConverter as t, buildPptxJsonDocument as u, encodeJsonValue as v, PptxJsonDocument as w, PPTX_JSON_MIME_TYPE as x, PPTX_JSON_FILE_EXTENSION as y, dataUrlToMediaBytes as z };
+//# sourceMappingURL=index-C3xhAMSa.d.ts.map