@eternalheart/angular-file-preview 1.6.5

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export declare const VERSION = "1.6.4";
+export { FilePreviewModal } from './file-preview-modal';
+export { FilePreviewEmbed } from './file-preview-embed';
+export { FilePreviewContent } from './file-preview-content';
+export type { PreviewFile, PreviewFileLink, PreviewFileInput, FileType, PreviewState, ToolbarAction, CustomRenderer, CustomRendererContext, CustomRendererEventPayload, RequestHandler, RequestInitFactory, RequestOptions, Fetcher, ShouldFetchAsBlob, } from './types';
+export { normalizeFile, normalizeFiles, getFileType, configurePdfWorker, SUPPORTED_FILE_TYPES, } from './fp-core';
+export type { PdfWorkerOptions } from './fp-core';
+export type { Locale, Messages, Translator, Theme } from './fp-core';
+export { LocaleService } from './di/locale.service';
+export { ThemeService } from './di/theme.service';
+export { RequestService } from './di/request.service';

package/lib/renderers/Audio/index.d.ts

@@ -0,0 +1,74 @@
+import { formatTime } from '../../fp-core';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class AudioRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileName: import("@angular/core").InputSignal<string>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly destroyRef;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    protected readonly formatTime: typeof formatTime;
+    protected readonly Math: Math;
+    protected readonly playIcon: import("lucide-angular").LucideIconData;
+    protected readonly pauseIcon: import("lucide-angular").LucideIconData;
+    protected readonly skipBackIcon: import("lucide-angular").LucideIconData;
+    protected readonly skipForwardIcon: import("lucide-angular").LucideIconData;
+    protected readonly repeatIcon: import("lucide-angular").LucideIconData;
+    private readonly player;
+    protected readonly isPlaying: import("@angular/core").WritableSignal<boolean>;
+    protected readonly isLoop: import("@angular/core").WritableSignal<boolean>;
+    protected readonly currentTime: import("@angular/core").WritableSignal<number>;
+    protected readonly duration: import("@angular/core").WritableSignal<number>;
+    protected readonly volume: import("@angular/core").WritableSignal<number>;
+    protected readonly isMuted: import("@angular/core").WritableSignal<boolean>;
+    protected readonly error: import("@angular/core").WritableSignal<string | null>;
+    protected readonly togglePlay: () => void;
+    protected readonly toggleMute: () => void;
+    protected readonly toggleLoop: () => void;
+    readonly showVolume: import("@angular/core").WritableSignal<boolean>;
+    readonly isCompact: import("@angular/core").WritableSignal<boolean>;
+    readonly controlScale: import("@angular/core").WritableSignal<number>;
+    readonly isDragging: import("@angular/core").WritableSignal<boolean>;
+    readonly dragTime: import("@angular/core").WritableSignal<number>;
+    private readonly containerRef;
+    private readonly volumeRef;
+    private readonly audioEl;
+    private volumeHideTimer;
+    private resizeObserver;
+    private bindRaf;
+    private readonly vinylBase;
+    private readonly vinylHeightBase;
+    protected readonly displayTime: import("@angular/core").Signal<number>;
+    protected readonly progress: import("@angular/core").Signal<number>;
+    private readonly vinylScale;
+    private readonly finalVinylScale;
+    protected readonly volumeIcon: import("@angular/core").Signal<import("lucide-angular").LucideIconData>;
+    protected readonly timeRowClass: import("@angular/core").Signal<"afp-flex afp-justify-between afp-text-fg-tertiary afp-text-[10px] afp-mt-1.5" | "afp-flex afp-justify-between afp-text-fg-tertiary afp-text-xs afp-mt-2.5">;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    protected skip(seconds: number): void;
+    protected onProgressPointerDown(): void;
+    protected onProgressInput(e: Event): void;
+    protected onProgressPointerUp(e: Event): void;
+    protected onVolumeInput(e: Event): void;
+    protected handleVolumeEnter(): void;
+    protected handleVolumeLeave(): void;
+    protected vinylBoxStyle(): string;
+    protected glowStyle(): string;
+    protected vinylStyle(): string;
+    protected labelStyle(): string;
+    protected spindleStyle(): string;
+    protected tonearmStyle(): string;
+    protected panelStyle(): string;
+    protected progressFillStyle(): string;
+    protected playBtnStyle(): string;
+    protected volumePopupStyle(): string;
+    protected volumeFillStyle(): string;
+    private checkSize;
+    private readonly handleClickOutside;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudioRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AudioRenderer, "afp-audio-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Cad/index.d.ts

@@ -0,0 +1,45 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class CadRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    file: import("@angular/core").InputSignal<File | undefined>;
+    fileName: import("@angular/core").InputSignal<string | undefined>;
+    private readonly locale;
+    private readonly request;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    private readonly container;
+    private readonly toolbarEmitter;
+    private readonly mounted;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly wireframe: import("@angular/core").WritableSignal<boolean>;
+    readonly showGrid: import("@angular/core").WritableSignal<boolean>;
+    readonly showAxes: import("@angular/core").WritableSignal<boolean>;
+    private scene;
+    private camera;
+    private renderer;
+    private controls;
+    private model;
+    private grid;
+    private axes;
+    private animationId;
+    private abortController;
+    private isCleanedUp;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    private getExtension;
+    private resetView;
+    private toggleWireframe;
+    private toggleGrid;
+    private toggleAxes;
+    private disposeMaterial;
+    private disposeThreeResources;
+    private initScene;
+    private loadModel;
+    private readonly handleResize;
+    private cleanup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CadRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CadRenderer, "afp-cad-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "file": { "alias": "file"; "required": false; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Cad/toolbar.d.ts

@@ -0,0 +1,15 @@
+import type { Translator } from '../../fp-core';
+import type { ToolbarGroup } from '../toolbar.types';
+export interface CadToolbarContext {
+    cadRef: {
+        resetView: () => void;
+        toggleWireframe: () => void;
+        toggleGrid: () => void;
+        toggleAxes: () => void;
+    } | null;
+    wireframe: boolean;
+    showGrid: boolean;
+    showAxes: boolean;
+    t: Translator;
+}
+export declare function getCadToolbarGroups(ctx: CadToolbarContext): ToolbarGroup[];

package/lib/renderers/Csv/index.d.ts

@@ -0,0 +1,26 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class CsvRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileName: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly destroyRef;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    private readonly container;
+    private sheetData;
+    private resizeObserver;
+    private resizeTimeout;
+    private lastDimensions;
+    private urlWatchStarted;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    private calculateDimensions;
+    private mountSpreadsheet;
+    private loadCsv;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CsvRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CsvRenderer, "afp-csv-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Doc/index.d.ts

@@ -0,0 +1,19 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class DocRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly sanitizer;
+    private readonly t;
+    readonly html: import("@angular/core").WritableSignal<string>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    protected trust(html: string): import("@angular/platform-browser").SafeHtml;
+    private loadDoc;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocRenderer, "afp-doc-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Docx/index.d.ts

@@ -0,0 +1,42 @@
+import { type DocxTheme } from '../../fp-core';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class DocxRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly sanitizer;
+    private readonly t;
+    readonly html: import("@angular/core").WritableSignal<string>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly pages: import("@angular/core").WritableSignal<string[]>;
+    readonly theme: import("@angular/core").WritableSignal<DocxTheme>;
+    private readonly measureRef;
+    protected readonly pageGap = 24;
+    protected readonly contentStyle: import("@angular/core").Signal<Record<string, string>>;
+    protected readonly measureStyle: import("@angular/core").Signal<{
+        position: string;
+        visibility: string;
+        width: string;
+        pointerEvents: string;
+    }>;
+    protected readonly pageBoxStyle: {
+        width: string;
+        maxWidth: string;
+        minHeight: string;
+        background: string;
+        boxShadow: string;
+        flexShrink: number;
+        padding: string;
+    };
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    protected trust(html: string): import("@angular/platform-browser").SafeHtml;
+    readonly displayPages: import("@angular/core").Signal<string[]>;
+    private loadDocx;
+    private paginate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocxRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DocxRenderer, "afp-docx-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Epub/index.d.ts

@@ -0,0 +1,57 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+interface TocItem {
+    label: string;
+    href: string;
+    subitems?: TocItem[];
+}
+export declare class EpubRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly request;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    private readonly viewer;
+    protected readonly xIcon: import("lucide-angular").LucideIconData;
+    protected readonly a4Width = 794;
+    readonly currentChapter: import("@angular/core").WritableSignal<number>;
+    readonly totalChapters: import("@angular/core").WritableSignal<number>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly isFullWidth: import("@angular/core").WritableSignal<boolean>;
+    readonly toc: import("@angular/core").WritableSignal<TocItem[]>;
+    readonly showToc: import("@angular/core").WritableSignal<boolean>;
+    readonly activeTocHref: import("@angular/core").WritableSignal<string>;
+    private readonly mounted;
+    private book;
+    private rendition;
+    private totalLocations;
+    private lastCfi;
+    private resizeObserver;
+    private resizeTimeout;
+    private lastDimensions;
+    private isInitialResize;
+    private scrollContainer;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    protected isActive(href: string): boolean;
+    protected tocButtonStyle(href: string, sub: boolean): Record<string, string>;
+    protected onTocEnter(ev: Event, href: string): void;
+    protected onTocLeave(ev: Event, href: string): void;
+    protected handleTocClick(href: string): void;
+    private prevPage;
+    private nextPage;
+    private toggleFullWidth;
+    private toggleToc;
+    private cleanup;
+    private loadEpub;
+    private doResize;
+    private setupResizeObserver;
+    private readonly onContainerScroll;
+    private reattachScrollListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EpubRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EpubRenderer, "afp-epub-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/renderers/Font/font-preview-line.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from "@angular/core";
+type RenderMode = 'fontface' | 'canvas';
+interface OpentypeFontLike {
+    getAdvanceWidth: (text: string, fontSize: number) => number;
+    getPath: (text: string, x: number, y: number, fontSize: number) => {
+        fill: string | null;
+        draw: (ctx: CanvasRenderingContext2D) => void;
+    };
+}
+export declare class FontPreviewLine {
+    font: import("@angular/core").InputSignal<OpentypeFontLike | null>;
+    text: import("@angular/core").InputSignal<string>;
+    fontSize: import("@angular/core").InputSignal<number>;
+    renderMode: import("@angular/core").InputSignal<RenderMode>;
+    theme: import("@angular/core").InputSignal<"dark" | "light">;
+    private readonly wrapper;
+    private readonly canvas;
+    private resizeObserver;
+    constructor();
+    private teardownObserver;
+    private drawCanvas;
+    private setupObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FontPreviewLine, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FontPreviewLine, "afp-font-preview-line", never, { "font": { "alias": "font"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; "fontSize": { "alias": "fontSize"; "required": true; "isSignal": true; }; "renderMode": { "alias": "renderMode"; "required": true; "isSignal": true; }; "theme": { "alias": "theme"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/renderers/Font/index.d.ts

@@ -0,0 +1,52 @@
+import type { Font as OpentypeFont } from 'opentype.js';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+interface FontMetadata {
+    family: string;
+    subfamily: string;
+    version: string;
+    designer: string;
+    glyphCount: number;
+    format: string;
+}
+type RenderMode = 'fontface' | 'canvas';
+type MetadataStatus = 'loading' | 'ready' | 'unavailable';
+export declare class FontRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly theme;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    protected readonly sizes: number[];
+    protected readonly samples: {
+        latin: string;
+        chinese: string;
+        mixed: string;
+    };
+    readonly font: import("@angular/core").WritableSignal<OpentypeFont | null>;
+    readonly metadata: import("@angular/core").WritableSignal<FontMetadata | null>;
+    readonly metadataStatus: import("@angular/core").WritableSignal<MetadataStatus>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly customText: import("@angular/core").WritableSignal<string>;
+    readonly renderMode: import("@angular/core").WritableSignal<RenderMode>;
+    readonly displayText: import("@angular/core").Signal<string>;
+    readonly showMetaPlaceholder: import("@angular/core").Signal<boolean>;
+    readonly metaPlaceholder: import("@angular/core").Signal<string>;
+    readonly effectiveRenderMode: import("@angular/core").Signal<RenderMode>;
+    readonly resolvedTheme: import("@angular/core").Signal<import("../../di/theme.service").ResolvedTheme>;
+    private fontFace;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    protected onCustomInput(ev: Event): void;
+    private releaseFontFace;
+    private detectFormat;
+    private formatLabel;
+    private loadFontFace;
+    private loadMetadata;
+    private loadFont;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FontRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FontRenderer, "afp-font-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/renderers/Image/index.d.ts

@@ -0,0 +1,79 @@
+import { ElementRef } from '@angular/core';
+import type { PreviewFile } from '../../fp-core';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+export declare class ImageRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileSize: import("@angular/core").InputSignal<number | undefined>;
+    file: import("@angular/core").InputSignal<PreviewFile | File | undefined>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly request;
+    private readonly destroyRef;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    protected readonly loader2Icon: import("lucide-angular").LucideIconData;
+    protected readonly Math: Math;
+    readonly zoom: import("@angular/core").WritableSignal<number>;
+    readonly rotation: import("@angular/core").WritableSignal<number>;
+    readonly loaded: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly decoding: import("@angular/core").WritableSignal<boolean>;
+    readonly decodeProgress: import("@angular/core").WritableSignal<number>;
+    readonly decodeError: import("@angular/core").WritableSignal<string | null>;
+    readonly imageSrc: import("@angular/core").WritableSignal<string>;
+    readonly currentPage: import("@angular/core").WritableSignal<number>;
+    readonly totalPages: import("@angular/core").WritableSignal<number>;
+    readonly position: import("@angular/core").WritableSignal<{
+        x: number;
+        y: number;
+    }>;
+    readonly isDragging: import("@angular/core").WritableSignal<boolean>;
+    readonly naturalSize: import("@angular/core").WritableSignal<{
+        width: number;
+        height: number;
+    }>;
+    private dragStart;
+    private blobUrl;
+    private fileBlobCache;
+    private loaderCache;
+    private readonly pageCache;
+    private isTouchDevice;
+    private touchStartDistance;
+    private touchStartZoom;
+    private touchStartPos;
+    private lastTapTime;
+    private listenersEl;
+    protected readonly containerRef: import("@angular/core").Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected readonly sizeText: import("@angular/core").Signal<string>;
+    protected readonly transformCss: import("@angular/core").Signal<string>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    private handleZoomIn;
+    private handleZoomOut;
+    private handleRotateRight;
+    private handleRotateLeft;
+    private handleOriginalSize;
+    private handleReset;
+    private handleFitToWidth;
+    private revokeBlobs;
+    private load;
+    protected handlePageChange(page: number): Promise<void>;
+    private clampPosition;
+    protected handleLoad(e: Event): void;
+    protected handleError(): void;
+    protected handleDoubleClick(): void;
+    private readonly handleWheelNative;
+    protected handleMouseDown(e: MouseEvent): void;
+    protected handleMouseMove(e: MouseEvent): void;
+    protected handleMouseUp(): void;
+    private readonly handleTouchStart;
+    private readonly handleTouchMove;
+    private readonly handleTouchEnd;
+    private attachListeners;
+    private detachListeners;
+    private cleanup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageRenderer, "afp-image-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileSize": { "alias": "fileSize"; "required": false; "isSignal": true; }; "file": { "alias": "file"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Json/index.d.ts

@@ -0,0 +1,61 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+interface JsonColors {
+    key: string;
+    string: string;
+    number: string;
+    keyword: string;
+    bracket: string;
+    colon: string;
+    collapsed: string;
+    arrow: string;
+}
+interface JsonChildEntry {
+    track: string | number;
+    keyName: string | undefined;
+    value: unknown;
+}
+export declare class JsonNode {
+    keyName: import("@angular/core").InputSignal<string | undefined>;
+    value: import("@angular/core").InputSignal<unknown>;
+    depth: import("@angular/core").InputSignal<number>;
+    defaultExpanded: import("@angular/core").InputSignal<boolean>;
+    private readonly locale;
+    private readonly themeService;
+    private readonly t;
+    protected readonly chevronRight: import("lucide-angular").LucideIconData;
+    protected readonly chevronDown: import("lucide-angular").LucideIconData;
+    protected readonly expanded: import("@angular/core").WritableSignal<boolean>;
+    protected readonly colors: import("@angular/core").Signal<JsonColors>;
+    protected readonly indent: import("@angular/core").Signal<number>;
+    protected readonly isComposite: import("@angular/core").Signal<boolean>;
+    protected readonly isArr: import("@angular/core").Signal<boolean>;
+    protected readonly count: import("@angular/core").Signal<number>;
+    protected readonly childEntries: import("@angular/core").Signal<JsonChildEntry[]>;
+    protected openBracket(): string;
+    protected closeBracket(): string;
+    protected collapsedLabel(): string;
+    protected isNullish(): boolean;
+    protected primitiveColor(): string;
+    protected primitiveText(): string;
+    protected toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonNode, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JsonNode, "afp-json-node", never, { "keyName": { "alias": "keyName"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "depth": { "alias": "depth"; "required": true; "isSignal": true; }; "defaultExpanded": { "alias": "defaultExpanded"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export declare class JsonRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    fileName: import("@angular/core").InputSignal<string>;
+    private readonly locale;
+    private readonly request;
+    private readonly t;
+    readonly data: import("@angular/core").WritableSignal<unknown>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    private loadJson;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JsonRenderer, "afp-json-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/renderers/Markdown/index.d.ts

@@ -0,0 +1,35 @@
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import 'katex/dist/katex.min.css';
+import * as i0 from "@angular/core";
+export declare class MarkdownRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly request;
+    private readonly themeService;
+    private readonly sanitizer;
+    private readonly injector;
+    private readonly t;
+    readonly viewMode: import("@angular/core").WritableSignal<"source" | "preview">;
+    readonly content: import("@angular/core").WritableSignal<string>;
+    readonly html: import("@angular/core").WritableSignal<string>;
+    readonly highlightedSource: import("@angular/core").WritableSignal<string>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    private readonly container;
+    readonly shikiTheme: import("@angular/core").Signal<"github-light" | "github-dark">;
+    readonly trustedHtml: import("@angular/core").Signal<import("@angular/platform-browser").SafeHtml>;
+    readonly trustedSource: import("@angular/core").Signal<import("@angular/platform-browser").SafeHtml>;
+    private readonly md;
+    private themeWatchStarted;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    private static createMarkdownIt;
+    private loadMarkdown;
+    private createCopyButton;
+    private highlightAndInjectCopyButtons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MarkdownRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MarkdownRenderer, "afp-markdown-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/lib/renderers/Mobi/index.d.ts

@@ -0,0 +1,51 @@
+import 'foliate-js/view.js';
+import type { RendererHandle } from '../base.types';
+import type { ToolbarGroup } from '../toolbar.types';
+import * as i0 from "@angular/core";
+interface TocItem {
+    label: string;
+    href?: string;
+    subitems?: TocItem[];
+}
+export declare class MobiTocList {
+    items: import("@angular/core").InputSignal<TocItem[]>;
+    activeHref: import("@angular/core").InputSignal<string>;
+    depth: import("@angular/core").InputSignal<number>;
+    select: import("@angular/core").OutputEmitterRef<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MobiTocList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MobiTocList, "afp-mobi-toc-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "activeHref": { "alias": "activeHref"; "required": false; "isSignal": true; }; "depth": { "alias": "depth"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, never, true, never>;
+}
+export declare class MobiRenderer implements RendererHandle {
+    url: import("@angular/core").InputSignal<string>;
+    private readonly emitter;
+    private readonly locale;
+    private readonly request;
+    protected readonly t: import("@eternalheart/file-preview-core").Translator;
+    private readonly host;
+    protected readonly xIcon: import("lucide-angular").LucideIconData;
+    protected readonly a4Width = 794;
+    readonly currentChapter: import("@angular/core").WritableSignal<number>;
+    readonly totalChapters: import("@angular/core").WritableSignal<number>;
+    readonly loading: import("@angular/core").WritableSignal<boolean>;
+    readonly error: import("@angular/core").WritableSignal<string | null>;
+    readonly toc: import("@angular/core").WritableSignal<TocItem[]>;
+    readonly showToc: import("@angular/core").WritableSignal<boolean>;
+    readonly activeTocHref: import("@angular/core").WritableSignal<string>;
+    readonly isFullWidth: import("@angular/core").WritableSignal<boolean>;
+    private readonly mounted;
+    private viewInstance;
+    private totalLocations;
+    constructor();
+    getToolbarGroups: () => ToolbarGroup[];
+    onToolbarChange: (listener: () => void) => () => void;
+    protected handleTocClick(href: string): void;
+    private prevPage;
+    private nextPage;
+    private toggleToc;
+    private toggleFullWidth;
+    private reportProgress;
+    private load;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MobiRenderer, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MobiRenderer, "afp-mobi-renderer", never, { "url": { "alias": "url"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+export {};