visio-react-viewer 0.0.2 → 0.1.1

package/dist/third-party/Inter-OFL.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/types/packages/bindings/src/common.d.ts

@@ -0,0 +1,29 @@
+import { mountViewer, type MountedViewer } from '../../../src/binding.js';
+import { eventKeys, propertyKeys, type ViewerCallbacks, type ViewerOptions, type ViewerProperties } from '../../../src/contract.js';
+/** Framework props permit undefined; omitted values preserve the shared binding's state. */
+export type ViewerProps = {
+    [K in keyof ViewerProperties]?: ViewerProperties[K] | undefined;
+} & {
+    events?: ViewerCallbacks | undefined;
+};
+export type ViewerHandle = Pick<MountedViewer, 'element' | 'controller' | 'load' | 'applyEdits' | 'replacePlainText' | 'undo' | 'redo' | 'cancelEdit' | 'exportVsdx' | 'fit' | 'setLayerVisibility' | 'resetLayerVisibility' | 'exportSvg' | 'createPrintSnapshot'>;
+/** One mapping for every property and event, shared by every framework adapter. */
+export declare function viewerOptions(props: ViewerProps): ViewerOptions;
+/**
+ * Native props are snapshots, while the browser binding accepts explicit patches. Forward only
+ * changed properties so a callback/class update cannot undo an imperative load or user zoom.
+ */
+export declare function mountFrameworkViewer(container: HTMLElement, initial: ViewerOptions): MountedViewer;
+/** Lazy imperative methods reject both before mount and after unmount. */
+export declare function viewerHandle(current: () => MountedViewer | undefined): ViewerHandle;
+/** Native framework emits and callback-map props share one complete event inventory. */
+export declare function withEventEmitter(props: ViewerProps, emit: (name: keyof ViewerCallbacks, value: unknown) => void): ViewerOptions;
+export { mountViewer };
+export type { MountedViewer, ViewerCallbacks, ViewerOptions, ViewerProperties };
+export { eventKeys, propertyKeys };
+export type { ViewerEvents, VsdxSource } from '../../../src/contract.js';
+export { ViewerController, type ViewerState } from '../../../src/controller.js';
+export type { SvgExportOptions, SvgExportResult } from '../../../src/export-svg.js';
+export type { CurrentPagePrintSnapshotOptions, PrintSnapshot, PrintSnapshotPage, PrintSnapshotOptions, PrintSnapshotLimits, PrintSnapshotUsage, } from '../../../src/print-snapshot.js';
+export type { ViewerEditState, VsdxExportResult } from '../../../src/document-history.js';
+export type { VisioEdit, VisioGeometryEdit } from 'ooxml-core/visio';

package/dist/types/packages/bindings/src/react.d.ts

@@ -0,0 +1,10 @@
+import { type CSSProperties } from 'react';
+import { type ViewerHandle, type ViewerProps } from './common.js';
+export interface VisioViewerProps extends ViewerProps {
+    className?: string | undefined;
+    style?: CSSProperties | undefined;
+    'aria-label'?: string | undefined;
+}
+/** React owns only the host and lifecycle; the shared element owns all viewer behavior. */
+export declare const VisioViewer: import("react").ForwardRefExoticComponent<VisioViewerProps & import("react").RefAttributes<ViewerHandle>>;
+export type { ViewerHandle, ViewerCallbacks, ViewerOptions, ViewerEvents, ViewerEditState, VsdxExportResult, } from './common.js';

package/dist/types/packages/react/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../../../src/index.js';
+export * from 'visio-core';
+export * from '../../bindings/src/react.js';

package/dist/types/src/arrowheads.d.ts

@@ -0,0 +1,3 @@
+import type { VisioStyle } from 'ooxml-core/visio';
+/** Common Visio line/triangle and concave arrow styles. Sizes remain a documented visual approximation. */
+export declare function applyArrowheads(path: SVGPathElement, style: VisioStyle, defs: SVGDefsElement, warnings: Set<string>): void;

package/dist/types/src/binding.d.ts

@@ -0,0 +1,27 @@
+import type { VisioEdit } from 'ooxml-core/visio';
+import type { ViewerOptions, VsdxSource } from './contract.js';
+import { type VisioViewerElement } from './viewer-element.js';
+import type { ViewerController } from './controller.js';
+import type { SvgExportOptions, SvgExportResult } from './export-svg.js';
+import type { CurrentPagePrintSnapshotOptions, PrintSnapshot } from './print-snapshot.js';
+import type { VsdxExportResult } from './document-history.js';
+export interface MountedViewer {
+    readonly element: VisioViewerElement;
+    readonly controller: ViewerController;
+    update(options: ViewerOptions): void;
+    load(source: VsdxSource): Promise<void>;
+    applyEdits(edits: readonly VisioEdit[]): Promise<void>;
+    replacePlainText(pageId: string, shapeId: string, text: string): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    cancelEdit(): void;
+    exportVsdx(): VsdxExportResult;
+    fit(): void;
+    setLayerVisibility(pageId: string, layerId: string, visible: boolean | null): void;
+    resetLayerVisibility(pageId?: string): void;
+    exportSvg(options?: SvgExportOptions): SvgExportResult;
+    createPrintSnapshot(options?: CurrentPagePrintSnapshotOptions): PrintSnapshot;
+    destroy(): void;
+}
+/** One client-only lifecycle adapter; framework wrappers forward to this implementation. */
+export declare function mountViewer(container: HTMLElement, initial?: ViewerOptions): MountedViewer;

package/dist/types/src/contract.d.ts

@@ -0,0 +1,32 @@
+import type { VisioDocument } from 'ooxml-core/visio';
+export interface ViewerProperties {
+    document: VisioDocument | null;
+    pageIndex: number;
+    zoom: number;
+    showToolbar: boolean;
+}
+export interface ViewerEvents {
+    'document-load': VisioDocument;
+    'document-change': {
+        document: VisioDocument;
+        dirty: boolean;
+        kind: 'edit' | 'undo' | 'redo';
+    };
+    'document-error': Error;
+    'page-change': number;
+    'zoom-change': number;
+    'shape-select': {
+        id: string;
+        name: string;
+        pageId?: string;
+    } | null;
+}
+export type ViewerCallbacks = {
+    [K in keyof ViewerEvents]?: (detail: ViewerEvents[K]) => void;
+};
+export declare const propertyKeys: readonly ["document", "pageIndex", "zoom", "showToolbar"];
+export declare const eventKeys: readonly ["document-load", "document-change", "document-error", "page-change", "zoom-change", "shape-select"];
+export type VsdxSource = ArrayBuffer | Uint8Array | Blob;
+export interface ViewerOptions extends Partial<ViewerProperties> {
+    events?: ViewerCallbacks;
+}

package/dist/types/src/controller.d.ts

@@ -0,0 +1,66 @@
+import { type ViewerEditState, type VsdxExportResult } from './document-history.js';
+import { type CancellableEditor } from './worker-editor.js';
+import { type VisioDocument, type VisioEdit } from 'ooxml-core/visio';
+import { type LayerVisibilityOverride } from './viewer-layers.js';
+import type { CancellableParser } from './worker-parser.js';
+import type { ViewerEvents } from './contract.js';
+import { type TextSearchState } from './document-text-search.js';
+export interface ViewerState {
+    readonly document: VisioDocument | null;
+    readonly edit: ViewerEditState;
+    readonly pageIndex: number;
+    readonly zoom: number;
+    readonly loading: boolean;
+    readonly error: Error | null;
+    readonly search: TextSearchState;
+    /** Viewer-only display overrides, independent of saved model and print policy. */
+    readonly layerVisibilityOverrides: readonly LayerVisibilityOverride[];
+    readonly selectedShape: {
+        id: string;
+        name: string;
+        pageId?: string;
+    } | null;
+}
+type Parser = CancellableParser;
+type EventListener = <K extends keyof ViewerEvents>(name: K, detail: ViewerEvents[K]) => void;
+export declare class ViewerController {
+    #private;
+    private readonly parser;
+    private readonly listenerError;
+    private readonly editor;
+    constructor(parser?: Parser, listenerError?: (error: unknown) => void, editor?: CancellableEditor);
+    get state(): ViewerState;
+    /** Accepted document replacements, including the same object, invalidate captured artifacts. */
+    get documentGeneration(): number;
+    /** Accepted source/model replacements invalidate drafts; edit/undo/redo keep this source epoch. */
+    get sourceGeneration(): number;
+    subscribe(listener: (state: ViewerState) => void): () => void;
+    onEvent(listener: EventListener): () => void;
+    setDocument(document: VisioDocument | null): void;
+    setPage(index: number): void;
+    setZoom(zoom: number): void;
+    selectShape(shape: ViewerState['selectedShape']): void;
+    /** Override one source-page layer for viewing. null restores its saved display flag. */
+    setLayerVisibility(pageId: string, layerId: string, visible: boolean | null): void;
+    /** Reset a source page, or all pages when omitted. Does not modify the document. */
+    resetLayerVisibility(pageId?: string): void;
+    /** Search does not change the page or selection until explicit result navigation. */
+    setSearchQuery(query: string): void;
+    selectSearchResult(index: number): void;
+    nextSearchResult(): void;
+    previousSearchResult(): void;
+    load(bytes: Uint8Array | ArrayBuffer): Promise<void>;
+    /** Reading bytes shares the same request epoch and error state as parsing them. */
+    loadSource(read: () => Uint8Array | ArrayBuffer | Promise<Uint8Array | ArrayBuffer>): Promise<void>;
+    cancelLoad(): void;
+    destroy(): void;
+    /** Replace one source-backed local plain-text target. Core decides target support. */
+    replacePlainText(pageId: string, shapeId: string, text: string): Promise<void>;
+    /** Atomic source-backed edits. Core owns protection, dependency and target validation. */
+    applyEdits(edits: readonly VisioEdit[]): Promise<void>;
+    undo(): Promise<void>;
+    redo(): Promise<void>;
+    cancelEdit(): void;
+    exportVsdx(): VsdxExportResult;
+}
+export {};

package/dist/types/src/demo-document.d.ts

@@ -0,0 +1,3 @@
+import type { VisioDocument } from 'ooxml-core/visio';
+/** Original sample scene, not a Visio-authored reference fixture. */
+export declare const demoDocument: VisioDocument;

package/dist/types/src/diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { VisioDiagnostic } from 'ooxml-core/visio';
+export interface CompatibilityNote {
+    message: string;
+    count: number;
+    severity: 'info' | 'warning';
+}
+/** Presentation-only grouping keeps repeated per-shape diagnostics readable without losing counts. */
+export declare function compatibilityNotes(diagnostics: readonly VisioDiagnostic[], renderWarnings?: readonly string[]): CompatibilityNote[];
+export declare function compatibilityText(note: CompatibilityNote): string;

package/dist/types/src/document-history.d.ts

@@ -0,0 +1,42 @@
+/** Source snapshots only. No document model is serialized by the viewer. */
+export interface EditDiagnostic {
+    readonly code: string;
+    readonly message: string;
+}
+export interface VsdxExportResult {
+    bytes: Uint8Array;
+    dirty: boolean;
+    diagnostics: readonly EditDiagnostic[];
+}
+export interface ViewerEditState {
+    readonly sourceAvailable: boolean;
+    readonly busy: boolean;
+    readonly dirty: boolean;
+    readonly canUndo: boolean;
+    readonly canRedo: boolean;
+    readonly historyTruncated: boolean;
+    readonly error: Error | null;
+    readonly diagnostics: readonly EditDiagnostic[];
+}
+export declare const EMPTY_EDIT_STATE: ViewerEditState;
+export declare const EDIT_HISTORY_LIMITS: Readonly<{
+    maxBytes: number;
+    maxEntries: 20;
+}>;
+export interface SourceSnapshot {
+    readonly bytes: Uint8Array;
+    readonly diagnostics: readonly EditDiagnostic[];
+}
+/** Private controller-owned bytes; transient worker copies and models are separate from this budget. */
+export declare class DocumentHistory {
+    #private;
+    readonly original: SourceSnapshot;
+    constructor(bytes: Uint8Array);
+    get current(): SourceSnapshot;
+    get undoTarget(): SourceSnapshot | undefined;
+    get redoTarget(): SourceSnapshot | undefined;
+    get state(): ViewerEditState;
+    append(bytes: Uint8Array, diagnostics: readonly EditDiagnostic[]): void;
+    move(target: SourceSnapshot): void;
+    export(): VsdxExportResult;
+}

package/dist/types/src/document-text-search.d.ts

@@ -0,0 +1,44 @@
+import type { VisioDocument, VisioShape } from 'ooxml-core/visio';
+/** UTF-16 character bounds, applied before copying or case conversion. */
+export declare const TEXT_SEARCH_LIMITS: Readonly<{
+    queryCharacters: 256;
+    results: 500;
+    indexedCharacters: 2000000;
+    shapeCharacters: 32768;
+    previewCharacters: 160;
+    shapes: 25000;
+    depth: 64;
+}>;
+export interface TextSearchResult {
+    readonly pageIndex: number;
+    readonly pageId: string;
+    readonly pageName: string;
+    readonly shapeId: string;
+    readonly shapeName: string;
+    /** Bounded start-of-text preview, not a match offset or highlighted excerpt. */
+    readonly preview: string;
+}
+export interface TextSearchState {
+    readonly query: string;
+    readonly results: readonly TextSearchResult[];
+    /** -1 until the user explicitly navigates, or after manual page/shape selection. */
+    readonly activeIndex: number;
+    readonly indexTruncated: boolean;
+    readonly resultsTruncated: boolean;
+}
+interface SearchEntry {
+    readonly result: TextSearchResult;
+    readonly foldedText: string;
+}
+export interface DocumentTextIndex {
+    readonly entries: readonly SearchEntry[];
+    readonly truncated: boolean;
+}
+export declare const EMPTY_TEXT_SEARCH: TextSearchState;
+/** Index canonical text for the current display state. No XML, DOM or layout parsing. */
+export declare function indexDocumentText(model: VisioDocument | null, isVisible?: (shape: VisioShape) => boolean): DocumentTextIndex;
+export declare function validateSearchQuery(query: string): void;
+/** One match per shape, literal ECMAScript lowercase comparison; no regex or language collation. */
+export declare function searchDocumentText(index: DocumentTextIndex, query: string): TextSearchState;
+export declare function textSearchStatus(search: TextSearchState): string;
+export {};

package/dist/types/src/edit-commands.d.ts

@@ -0,0 +1,3 @@
+import type { VisioEdit } from 'ooxml-core/visio';
+/** Bound cloning and strip arbitrary host properties. Semantic validation belongs to core. */
+export declare function snapshotEdits(edits: readonly VisioEdit[]): VisioEdit[];

package/dist/types/src/edit-error.d.ts

@@ -0,0 +1,4 @@
+/** Core error codes remain visible for a refused transaction; document content is plain text. */
+export declare function editErrorMessage(error: unknown): string;
+/** Superseded worker/load operations are cancellation, not a refused document edit. */
+export declare function isEditCancellation(error: unknown): boolean;

package/dist/types/src/edit-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/export-svg.d.ts

@@ -0,0 +1,25 @@
+import { type VisioDocument, type VisioPage } from 'ooxml-core/visio';
+import { type CompatibilityNote } from './diagnostics.js';
+export declare const MAX_SVG_EXPORT_BYTES: number;
+export interface SvgExportOptions {
+    /** UTF-8 output ceiling. May lower, but never raise, the 16 MiB safety limit. */
+    maxBytes?: number;
+}
+export interface SvgExportResult {
+    readonly svg: string;
+    readonly byteLength: number;
+    readonly pageIndex: number;
+    readonly pageName: string;
+    /** Saved page dimensions in inches, independent of viewport zoom. */
+    readonly width: number;
+    readonly height: number;
+    readonly diagnostics: CompatibilityNote[];
+}
+/**
+ * Export one page through the shared renderer, including its resolved backgrounds.
+ * Requires a browser DOM at call time, never uploads, downloads or mutates viewer state.
+ * Conservative preflight limits can reject a page whose eventual serialization would be smaller.
+ */
+export declare function exportPageSvg(model: VisioDocument, pageIndex?: number, options?: SvgExportOptions): SvgExportResult;
+/** @internal Call only after canonical scene validation. Shared conservative allocation preflight. */
+export declare function estimatePageSvgBytes(model: VisioDocument, page: VisioPage, maxBytes: number): number;

package/dist/types/src/foreign-vector-budget.d.ts

@@ -0,0 +1,24 @@
+import { type VisioForeignVector } from 'ooxml-core/visio';
+/** UI allocation limits, charged for every instance, including repeated shared resources. */
+export declare const FOREIGN_VECTOR_SCENE_LIMITS: Readonly<{
+    maxNodes: 100000;
+    maxCommands: 400000;
+    maxOperands: 1000000;
+}>;
+export interface ForeignVectorResource {
+    readonly vector: VisioForeignVector;
+    readonly nodes: number;
+    readonly commands: number;
+    readonly operands: number;
+    readonly svgBytes: number;
+    readonly validationWork: number;
+}
+/** Count work only after canonical validation. Interpretation and safety remain in core. */
+export declare function inspectForeignVectorResource(source: unknown): ForeignVectorResource;
+/** Invocation-local budget. Never trusts frozen host objects or caches across calls. */
+export declare class ForeignVectorBudget {
+    private nodes;
+    private commands;
+    private operands;
+    take(source: unknown): ForeignVectorResource;
+}

package/dist/types/src/index.d.ts

@@ -0,0 +1,14 @@
+export { ViewerController, type ViewerState } from './controller.js';
+export { mountViewer, type MountedViewer } from './binding.js';
+export { VisioViewerElement, registerVisioViewer } from './viewer-element.js';
+export { renderPage, type RenderResult, type RenderOptions } from './render-svg.js';
+export { exportPageSvg, MAX_SVG_EXPORT_BYTES, type SvgExportOptions, type SvgExportResult, } from './export-svg.js';
+export { createPrintSnapshot, PRINT_SNAPSHOT_LIMITS, type PrintSnapshot, type PrintSnapshotPage, type PrintSnapshotOptions, type PrintSnapshotLimits, type PrintSnapshotUsage, type CurrentPagePrintSnapshotOptions, } from './print-snapshot.js';
+export { eventKeys, propertyKeys, type ViewerProperties, type ViewerEvents, type ViewerCallbacks, type ViewerOptions, type VsdxSource, } from './contract.js';
+export type { VisioDocument, VisioPage, VisioShape, VisioDiagnostic } from 'ooxml-core/visio';
+export { createWorkerParser, type CancellableParser } from './worker-parser.js';
+export { compatibilityNotes, compatibilityText, type CompatibilityNote } from './diagnostics.js';
+export { TEXT_SEARCH_LIMITS, type TextSearchResult, type TextSearchState, } from './document-text-search.js';
+export { VIEWER_LAYER_LIMITS, type LayerVisibilityOverride } from './viewer-layers.js';
+export type { ViewerEditState, VsdxExportResult } from './document-history.js';
+export type { VisioEdit, VisioGeometryEdit } from 'ooxml-core/visio';

package/dist/types/src/paragraph-layout.d.ts

@@ -0,0 +1,18 @@
+import type { VisioParagraph, VisioText } from 'ooxml-core/visio';
+import { type TextLayoutBudget, type MeasureText, type TextLine } from './text-layout.js';
+export interface PositionedLine extends TextLine {
+    x: number;
+    y: number;
+    availableWidth: number;
+    align: VisioParagraph['horizontalAlign'];
+    direction: 'ltr' | 'rtl';
+    last: boolean;
+    bullet?: NonNullable<VisioParagraph['bullet']> & {
+        x: number;
+    };
+}
+export interface ParagraphLayout {
+    lines: PositionedLine[];
+    height: number;
+}
+export declare function layoutParagraphs(text: VisioText, measure?: MeasureText, budget?: TextLayoutBudget): ParagraphLayout;

package/dist/types/src/parse-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/print-snapshot.d.ts

@@ -0,0 +1,87 @@
+import { type VisioDocument } from 'ooxml-core/visio';
+import type { CompatibilityNote } from './diagnostics.js';
+/** Application guardrails, not printer capabilities or Microsoft Visio limits. */
+export declare const PRINT_SNAPSHOT_LIMITS: Readonly<{
+    maxPages: 32;
+    maxTotalBytes: number;
+    maxPageBytes: number;
+    maxShapeInstances: 100000;
+    maxGeometryInstances: 100000;
+    maxPathCharacters: 16000000;
+    maxTextCharacters: 1000000;
+    maxTextRuns: 100000;
+    maxImageBytes: number;
+    maxUniqueImagePixels: 64000000;
+    maxImageInstancePixels: 256000000;
+    maxVectorNodes: 100000;
+    maxVectorCommands: 400000;
+    maxVectorOperands: 1000000;
+    maxPageAxisCssPixels: 4096;
+    maxPageAreaCssPixels: 16000000;
+    maxTotalAreaCssPixels: 64000000;
+    maxValidationShapeVisits: 1000000;
+    maxValidationWork: number;
+}>;
+export type PrintSnapshotLimits = {
+    -readonly [K in keyof typeof PRINT_SNAPSHOT_LIMITS]: number;
+};
+export interface PrintSnapshotOptions {
+    /** Explicit output order. Background pages are included as sheets only when selected. */
+    readonly pageIndices: readonly number[];
+    /** Positive integer limits may lower, but never raise, the hard ceilings. */
+    readonly limits?: Partial<PrintSnapshotLimits>;
+}
+/** Viewer handles always capture exactly the current page. */
+export type CurrentPagePrintSnapshotOptions = Omit<PrintSnapshotOptions, 'pageIndices'>;
+export interface PrintSnapshotPage {
+    readonly pageIndex: number;
+    readonly pageId: string;
+    readonly pageName: string;
+    /** Saved drawing dimensions, not printer paper, margins, orientation or scale. */
+    readonly drawingSize: Readonly<{
+        width: number;
+        height: number;
+        unit: 'in';
+    }>;
+    /** An isolated SVG document. Do not concatenate page trees with colliding resource IDs. */
+    readonly svg: string;
+    readonly byteLength: number;
+    readonly diagnostics: readonly Readonly<CompatibilityNote>[];
+}
+export interface PrintSnapshotUsage {
+    readonly estimatedSvgBytes: number;
+    readonly svgBytes: number;
+    readonly shapeInstances: number;
+    readonly geometryInstances: number;
+    readonly pathCharacters: number;
+    readonly textCharacters: number;
+    readonly textRuns: number;
+    /** Raw resources counted once per byte identity per output page, including backgrounds. */
+    readonly imageBytes: number;
+    readonly uniqueImagePixels: number;
+    readonly imageInstancePixels: number;
+    /** Includes all clip reference expansions and repeated/background vector instances. */
+    readonly vectorNodes: number;
+    readonly vectorCommands: number;
+    readonly vectorOperands: number;
+    readonly totalAreaCssPixels: number;
+    readonly validationShapeVisits: number;
+    /** Conservative bytes, characters and records across validation and the private copy pass. */
+    readonly validationWork: number;
+}
+export interface PrintSnapshot {
+    readonly appearance: 'saved-display';
+    readonly pageIndices: readonly number[];
+    readonly pages: readonly PrintSnapshotPage[];
+    readonly byteLength: number;
+    readonly limits: Readonly<PrintSnapshotLimits>;
+    readonly usage: PrintSnapshotUsage;
+    readonly limitations: readonly string[];
+}
+/**
+ * Synchronously prepare bounded, immutable page artifacts through the shared SVG renderer.
+ * Requires its DOM/serializer, but never mounts nodes, downloads, fetches, opens frames or prints.
+ * Canonical scene/raster validation is repeated on every call. No source object is frozen.
+ * Conservative budgets include hidden content and can reject otherwise exportable individual pages.
+ */
+export declare function createPrintSnapshot(model: VisioDocument, options: PrintSnapshotOptions): PrintSnapshot;

package/dist/types/src/render-fill.d.ts

@@ -0,0 +1,2 @@
+import type { VisioStyle } from 'ooxml-core/visio';
+export declare function fillPaint(style: VisioStyle, defs: SVGDefsElement): string;

package/dist/types/src/render-foreign-vector-shape.d.ts

@@ -0,0 +1,4 @@
+import type { VisioShape } from 'ooxml-core/visio';
+import type { ForeignVectorBudget } from './foreign-vector-budget.js';
+/** Core supplies shape-local placement; converter coordinates have a downward Y axis. */
+export declare function renderForeignVectorShape(shape: VisioShape, budget: ForeignVectorBudget): SVGGElement | undefined;

package/dist/types/src/render-foreign-vector.d.ts

@@ -0,0 +1,3 @@
+import { ForeignVectorBudget } from './foreign-vector-budget.js';
+/** Render an independently validated inert scene. Never forwards source tags, IDs or attributes. */
+export declare function renderForeignVector(source: unknown, owner?: Document, budget?: ForeignVectorBudget): SVGSVGElement;

package/dist/types/src/render-image.d.ts

@@ -0,0 +1,4 @@
+import type { VisioShape } from 'ooxml-core/visio';
+import type { RenderResources } from './render-resources.js';
+/** URLs are created only from bounded embedded raster bytes, never from document strings. */
+export declare function renderImage(shape: VisioShape, resources: RenderResources): SVGGElement | undefined;

package/dist/types/src/render-resources.d.ts

@@ -0,0 +1,10 @@
+import type { VisioImage } from 'ooxml-core/visio';
+/** One reference per shared core image resource, with explicit per-render disposal. */
+export declare class RenderResources {
+    #private;
+    private readonly definitions?;
+    constructor(definitions?: SVGDefsElement | undefined);
+    get portable(): boolean;
+    imageUrl(image: VisioImage): string;
+    dispose(): void;
+}

package/dist/types/src/render-svg.d.ts

@@ -0,0 +1,17 @@
+import { type VisioDocument, type VisioPage, type VisioMatrix } from 'ooxml-core/visio';
+import { type LayerVisibilityOverride } from './viewer-layers.js';
+export declare function svgElement<K extends keyof SVGElementTagNameMap>(name: K): SVGElementTagNameMap[K];
+export declare function safeColor(value: string, fallback?: string): string;
+export declare function matrix(value: VisioMatrix): string;
+export interface RenderResult {
+    svg: SVGSVGElement;
+    warnings: string[];
+    dispose(): void;
+}
+export interface RenderOptions {
+    /** Static output embeds rasters and omits viewer selection semantics. Prefer exportPageSvg for bounded serialization. */
+    static?: boolean;
+    /** Optional viewer display state. Export/print snapshot APIs deliberately use saved display. */
+    layerVisibilityOverrides?: readonly LayerVisibilityOverride[];
+}
+export declare function renderPage(model: VisioDocument, page: VisioPage, options?: RenderOptions): RenderResult;

package/dist/types/src/render-text.d.ts

@@ -0,0 +1,4 @@
+import type { VisioText } from 'ooxml-core/visio';
+import type { TextLayoutBudget } from './text-layout.js';
+/** Browser-font layout is approximate until compared with the licensed Visio reference corpus. */
+export declare function renderText(text: VisioText, warnings: Set<string>, budget?: TextLayoutBudget): SVGGElement;

package/dist/types/src/scene-details.d.ts

@@ -0,0 +1,7 @@
+import type { VisioShape } from 'ooxml-core/visio';
+export interface DetailBudget {
+    rows: number;
+    characters: number;
+}
+/** Runtime model checks prevent implicit DOM stringification of host-provided objects. */
+export declare function assertShapeDetails(shape: VisioShape, budget: DetailBudget): void;

package/dist/types/src/scene-validation.d.ts

@@ -0,0 +1,4 @@
+import { type VisioDocument } from 'ooxml-core/visio';
+export declare const MAX_INPUT_BYTES: number;
+/** Defensive display limits also protect callers supplying their own typed scenes. */
+export declare function assertViewableDocument(model: VisioDocument): void;