manga-renderer 1.0.7 → 1.0.8

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import { LayeredCanvas } from './lib/layeredCanvas/system/layeredCanvas';
+import { ArrayLayer } from './lib/layeredCanvas/layers/arrayLayer';
+import { Book, Page, WrapMode, ReadingDirection } from './lib/book/book';
+import { FocusKeeper } from './lib/layeredCanvas/tools/focusKeeper';
+export { readEnvelope } from './lib/book/envelope';
+export { initPaperJs } from './lib/layeredCanvas/tools/draw/bubbleGraphic';
+export type { Book, Page, WrapMode, ReadingDirection };
+export declare class Renderer {
+    arrayLayer: ArrayLayer;
+    layeredCanvas: LayeredCanvas;
+    focusKeeper: FocusKeeper;
+    marks: boolean[];
+    constructor(arrayLayer: ArrayLayer, layeredCanvas: LayeredCanvas, focusKeeper: FocusKeeper, marks: boolean[]);
+    cleanup(): void;
+    focusToPage(index: number, pageScale?: number): void;
+    getScale(): number;
+}
+export declare function buildRenderer(canvas: HTMLCanvasElement, book: Book, startIndex?: number, length?: number): Renderer;
+export declare function destroyRenderer(renderer: Renderer): void;
+export declare function listFonts(book: Book): {
+    family: string;
+    weight: string;
+}[];
+export declare const localFonts: {
+    [key: string]: string;
+};
+export declare function isLocalFont(fontFamily: string): boolean;
+export declare function isGoogleFont(fontFamily: string): boolean;
+export declare function loadGoogleFont(family: string, weights?: string[]): Promise<void>;
+export declare function loadGoogleFontForCanvas(family: string, weights?: string[]): Promise<void>;
+export declare function checkCanvasFontAvailable(family: string, weight?: string, maxRetries?: number, interval?: number): Promise<boolean>;

package/dist/lib/book/book.d.ts

@@ -0,0 +1,133 @@
+import { Bubble } from '../layeredCanvas/dataModels/bubble';
+import { FrameElement, Layout, Border } from '../layeredCanvas/dataModels/frameTree';
+import { Film, FilmStack } from '../layeredCanvas/dataModels/film';
+import { Rect, Vector } from '../layeredCanvas/tools/geometry/geometry';
+import { RichChatLog, ProtocolChatLog } from './richChat';
+import { Notebook } from './notebook';
+export type Prefix = 'shortcut-' | 'paste-' | 'drop-' | 'add-in-folder-' | 'shared-' | 'initial-' | 'hiruma-' | 'weaved-' | 'envelope-';
+export type Revision = {
+    id: string;
+    revision: number;
+    prefix: Prefix;
+};
+export type Page = {
+    id: string;
+    frameTree: FrameElement;
+    bubbles: Bubble[];
+    paperSize: [number, number];
+    paperColor: string;
+    frameColor: string;
+    frameWidth: number;
+    source: any;
+};
+export type HistoryTag = 'bubble' | 'page-attribute' | "effect" | null;
+export type HistoryWeight = "light" | "heavy";
+export type HistoryEntry = {
+    pages: Page[];
+    tag: HistoryTag;
+};
+export type History = {
+    entries: HistoryEntry[];
+    cursor: number;
+};
+export type ReadingDirection = 'left-to-right' | 'right-to-left';
+export type WrapMode = 'none' | 'two-pages' | 'one-page';
+export type VideoSettings = {
+    width: number;
+    height: number;
+    moveDuration: number;
+    standardWait: number;
+    standardScale: number;
+};
+export type Book = {
+    revision: Revision;
+    pages: Page[];
+    history: History;
+    direction: ReadingDirection;
+    wrapMode: WrapMode;
+    chatLogs: RichChatLog[];
+    notebook: Notebook;
+    video?: VideoSettings;
+};
+export type SerializedPage = {
+    id: string;
+    frameTree: any;
+    bubbles: any[];
+    paperSize: [number, number];
+    paperColor: string;
+    frameColor: string;
+    frameWidth: number;
+};
+export type SerializedBook = {
+    revision: {
+        id: string;
+        revision: number;
+        prefix: Prefix;
+    };
+    pages: SerializedPage[];
+    direction: ReadingDirection;
+    wrapMode: WrapMode;
+    chatLogs: ProtocolChatLog[];
+    notebook: Notebook;
+};
+export declare function incrementRevision(revision: Revision): void;
+export declare function revisionEqual(a: Revision, b: Revision): boolean;
+export declare function getHistoryWeight(book: Book): HistoryWeight;
+export declare function addBookHistory(book: Book, tag: HistoryTag): void;
+export declare function undoBookHistory(book: Book): void;
+export declare function redoBookHistory(book: Book): void;
+export declare function commitBook(book: Book, tag: HistoryTag): void;
+export declare function revertBook(book: Book): void;
+export declare function newPage(frameTree: FrameElement, bubbles: Bubble[]): Page;
+export declare function newBook(id: string, prefix: Prefix, exampleIndex: number): Book;
+export declare function newImageBook(id: string, canvas: HTMLCanvasElement, prefix: Prefix): Book;
+export interface BookOperators {
+    hint: (r: [number, number, number, number], s: string | null) => void;
+    commit: (tag: HistoryTag) => void;
+    forceDelayedCommit(): void;
+    cancelDelayedCommit(): void;
+    revert: () => void;
+    undo: () => void;
+    redo: () => void;
+    shift: (page: Page, frameElement: FrameElement) => void;
+    unshift: (page: Page, frameElement: FrameElement) => void;
+    swap: (page: Page, frameElement0: FrameElement, frameElement1: FrameElement) => void;
+    insert: (page: Page, border: Border) => void;
+    focusFrame: (page: Page, frame: FrameElement | null, p: Vector | null) => void;
+    focusBubble: (page: Page, bubble: Bubble | null) => void;
+    viewportChanged: () => void;
+    insertPage: (index: number) => void;
+    deletePage: (index: number) => void;
+    movePages: (from: number[], to: number) => void;
+    copyPageToClipboard: (index: number) => void;
+    batchImaging: (index: number) => void;
+    editBubbles: (index: number) => void;
+    tweak: (index: number) => void;
+    chase: () => void;
+    getMarks: () => boolean[];
+    setMarks: (marks: boolean[]) => void;
+    getFocusedPage: () => Page;
+}
+export declare function clonePage(page: Page): Page;
+export declare function cloneBook(book: Book): Book;
+export type FrameContent = {
+    sourcePage: Page;
+    sourceRect: Rect;
+    filmStack: FilmStack;
+    bubbles: Bubble[];
+    prompt: string | null;
+};
+export type FrameSlot = {
+    layout: Layout;
+    page: Page;
+    pageNumber: number;
+};
+export type FrameSequence = {
+    slots: FrameSlot[];
+    contents: FrameContent[];
+};
+export declare function collectBookContents(book: Book): FrameSequence;
+export declare function collectPageContents(page: Page, pageNumber: number, dir: ReadingDirection): FrameSequence;
+export declare function dealBookContents(seq: FrameSequence, insertElement: FrameElement | null, spliceElement: FrameElement | null): void;
+export declare function swapBookContents(seq: FrameSequence, frameElement0: FrameElement, frameElement1: FrameElement): void;
+export declare function collectAllFilms(book: Book): Film[];

package/dist/lib/book/envelope.d.ts

@@ -0,0 +1,26 @@
+import { Book, WrapMode, ReadingDirection, SerializedPage } from './book';
+import { Notebook } from './notebook';
+export type EnvelopedBook = {
+    pages: SerializedPage[];
+    direction: ReadingDirection;
+    wrapMode: WrapMode;
+    images: {
+        [fileId: string]: Uint8Array;
+    };
+    notebook: Notebook | null;
+};
+export type CanvasBag = {
+    [fileId: string]: HTMLCanvasElement;
+};
+export declare function readEnvelope(blob: Blob): Promise<Book>;
+export declare function writeEnvelope(book: Book): Promise<Blob>;
+export type OldEnvelopedBook = {
+    pages: SerializedPage[];
+    direction: ReadingDirection;
+    wrapMode: WrapMode;
+    images: {
+        [fileId: string]: string;
+    };
+    notebook: Notebook | null;
+};
+export declare function readOldEnvelope(json: string): Promise<Book>;

package/dist/lib/book/imagePacking.d.ts

@@ -0,0 +1,10 @@
+import { Vector } from '../layeredCanvas/tools/geometry/geometry';
+import { FrameElement } from '../layeredCanvas/dataModels/frameTree';
+import { Bubble } from '../layeredCanvas/dataModels/bubble';
+import { Film } from '../layeredCanvas/dataModels/film';
+export declare function dryUnpackFrameImages(paperSize: Vector, markUp: any, images: string[]): Promise<void>;
+export declare function dryUnpackBubbleImages(paperSize: Vector, markUps: any[], images: string[]): Promise<void>;
+export declare function unpackFrameImages(paperSize: Vector, markUp: any, loadCanvasFunc: (imageId: string) => Promise<HTMLCanvasElement | null>): Promise<FrameElement>;
+export declare function unpackBubbleImages(paperSize: Vector, markUps: any[], loadImageFunc: (imageId: string) => Promise<HTMLCanvasElement | null>): Promise<Bubble[]>;
+export declare function packFilms(films: Film[], saveCanvasFunc: (canvas: HTMLCanvasElement) => Promise<string>): Promise<any[]>;
+export declare function unpackFilms(markUp: any, loadImageFunc: (imageId: string) => Promise<HTMLCanvasElement | null>): Promise<Film[]>;

package/dist/lib/book/layout.d.ts

@@ -0,0 +1,41 @@
+import * as t from "io-ts";
+export declare const LayoutColumn: import('typai').AnnotatedType<{
+    id: string;
+    ratio: number;
+}, {
+    id: string;
+    ratio: number;
+}, unknown>;
+export type LayoutColumn = t.TypeOf<typeof LayoutColumn>;
+export declare const LayoutRow: import('typai').AnnotatedType<{
+    columns: {
+        id: string;
+        ratio: number;
+    }[];
+    ratio: number;
+}, {
+    columns: {
+        id: string;
+        ratio: number;
+    }[];
+    ratio: number;
+}, unknown>;
+export type LayoutRow = t.TypeOf<typeof LayoutRow>;
+export declare const LayoutPage: import('typai').AnnotatedType<{
+    rows: {
+        columns: {
+            id: string;
+            ratio: number;
+        }[];
+        ratio: number;
+    }[];
+}, {
+    rows: {
+        columns: {
+            id: string;
+            ratio: number;
+        }[];
+        ratio: number;
+    }[];
+}, unknown>;
+export type LayoutPage = t.TypeOf<typeof LayoutPage>;

package/dist/lib/book/notebook.d.ts

@@ -0,0 +1,72 @@
+import * as t from "io-ts";
+export declare const Character: t.TypeC<{
+    ulid: import('typai').IgnoreType<string, string>;
+    name: t.StringC;
+    personality: t.StringC;
+    appearance: t.StringC;
+    themeColor: t.StringC;
+    portrait: import('typai').IgnoreType<any, any>;
+}>;
+export declare const Notebook: t.TypeC<{
+    theme: t.StringC;
+    characters: t.ArrayC<t.TypeC<{
+        ulid: import('typai').IgnoreType<string, string>;
+        name: t.StringC;
+        personality: t.StringC;
+        appearance: t.StringC;
+        themeColor: t.StringC;
+        portrait: import('typai').IgnoreType<any, any>;
+    }>>;
+    plot: t.StringC;
+    scenario: t.StringC;
+    storyboard: t.UnionC<[t.TypeC<{
+        format: import('typai').AnnotatedType<string, string, unknown>;
+        characters: t.ArrayC<import('typai').AnnotatedType<{
+            name: string;
+            appearance: string;
+            themeColor: string;
+        }, {
+            name: string;
+            appearance: string;
+            themeColor: string;
+        }, unknown>>;
+        pages: t.ArrayC<t.TypeC<{
+            panels: t.ArrayC<t.TypeC<{
+                composition: import('typai').AnnotatedType<string, string, unknown>;
+                camera: import('typai').AnnotatedType<string, string, unknown>;
+                bubbles: import('typai').AnnotatedType<{
+                    owner: string;
+                    speech: string;
+                    color: string;
+                    shape: string;
+                }[], {
+                    owner: string;
+                    speech: string;
+                    color: string;
+                    shape: string;
+                }[], unknown>;
+            }>>;
+            layout: import('typai').AnnotatedType<{
+                rows: {
+                    columns: {
+                        id: string;
+                        ratio: number;
+                    }[];
+                    ratio: number;
+                }[];
+            }, {
+                rows: {
+                    columns: {
+                        id: string;
+                        ratio: number;
+                    }[];
+                    ratio: number;
+                }[];
+            }, unknown>;
+        }>>;
+    }>, t.NullC]>;
+    critique: t.StringC;
+}>;
+export type Character = t.TypeOf<typeof Character>;
+export type Notebook = t.TypeOf<typeof Notebook>;
+export declare function emptyNotebook(): Notebook;

package/dist/lib/book/richChat.d.ts

@@ -0,0 +1,36 @@
+export type ProtocolChatLog = {
+    role: string;
+    content: string;
+};
+export type Role = 'system' | 'assistant' | 'user' | 'error';
+export type RichChatLog = {
+    role: Role;
+    content: RichChatContent;
+    hidden?: boolean;
+};
+export type RichChatContent = {
+    type: 'speech';
+    body: string;
+} | {
+    type: 'image';
+    body: RichChatImage;
+} | {
+    type: 'document';
+    body: RichChatDocument;
+} | {
+    type: 'error';
+    body: string;
+} | {
+    type: 'waiting';
+};
+export type RichChatImage = {
+    id: string;
+    image: HTMLImageElement;
+};
+export type RichChatDocument = {
+    id: string;
+    text: string;
+};
+export declare function richChatLogToProtocolChatLog(log: RichChatLog[]): ProtocolChatLog[];
+export declare function protocolChatLogToRichChatLog(log: ProtocolChatLog[]): RichChatLog[];
+export declare function rollback(log: RichChatLog[], role: 'user' | 'assistant'): RichChatLog[];

package/dist/lib/book/storyboard.d.ts

@@ -0,0 +1,125 @@
+import { LayoutPage, LayoutColumn, LayoutRow } from './layout';
+import * as t from "io-ts";
+declare const Format: import('typai').AnnotatedType<string, string, unknown>;
+declare const Character: import('typai').AnnotatedType<{
+    name: string;
+    appearance: string;
+    themeColor: string;
+}, {
+    name: string;
+    appearance: string;
+    themeColor: string;
+}, unknown>;
+declare const Bubble: import('typai').AnnotatedType<{
+    owner: string;
+    speech: string;
+    color: string;
+    shape: string;
+}, {
+    owner: string;
+    speech: string;
+    color: string;
+    shape: string;
+}, unknown>;
+declare const Panel: t.TypeC<{
+    composition: import('typai').AnnotatedType<string, string, unknown>;
+    camera: import('typai').AnnotatedType<string, string, unknown>;
+    bubbles: import('typai').AnnotatedType<{
+        owner: string;
+        speech: string;
+        color: string;
+        shape: string;
+    }[], {
+        owner: string;
+        speech: string;
+        color: string;
+        shape: string;
+    }[], unknown>;
+}>;
+declare const Page: t.TypeC<{
+    panels: t.ArrayC<t.TypeC<{
+        composition: import('typai').AnnotatedType<string, string, unknown>;
+        camera: import('typai').AnnotatedType<string, string, unknown>;
+        bubbles: import('typai').AnnotatedType<{
+            owner: string;
+            speech: string;
+            color: string;
+            shape: string;
+        }[], {
+            owner: string;
+            speech: string;
+            color: string;
+            shape: string;
+        }[], unknown>;
+    }>>;
+    layout: import('typai').AnnotatedType<{
+        rows: {
+            columns: {
+                id: string;
+                ratio: number;
+            }[];
+            ratio: number;
+        }[];
+    }, {
+        rows: {
+            columns: {
+                id: string;
+                ratio: number;
+            }[];
+            ratio: number;
+        }[];
+    }, unknown>;
+}>;
+declare const Storyboard: t.TypeC<{
+    format: import('typai').AnnotatedType<string, string, unknown>;
+    characters: t.ArrayC<import('typai').AnnotatedType<{
+        name: string;
+        appearance: string;
+        themeColor: string;
+    }, {
+        name: string;
+        appearance: string;
+        themeColor: string;
+    }, unknown>>;
+    pages: t.ArrayC<t.TypeC<{
+        panels: t.ArrayC<t.TypeC<{
+            composition: import('typai').AnnotatedType<string, string, unknown>;
+            camera: import('typai').AnnotatedType<string, string, unknown>;
+            bubbles: import('typai').AnnotatedType<{
+                owner: string;
+                speech: string;
+                color: string;
+                shape: string;
+            }[], {
+                owner: string;
+                speech: string;
+                color: string;
+                shape: string;
+            }[], unknown>;
+        }>>;
+        layout: import('typai').AnnotatedType<{
+            rows: {
+                columns: {
+                    id: string;
+                    ratio: number;
+                }[];
+                ratio: number;
+            }[];
+        }, {
+            rows: {
+                columns: {
+                    id: string;
+                    ratio: number;
+                }[];
+                ratio: number;
+            }[];
+        }, unknown>;
+    }>>;
+}>;
+type Format = t.TypeOf<typeof Format>;
+type Character = t.TypeOf<typeof Character>;
+type Bubble = t.TypeOf<typeof Bubble>;
+type Panel = t.TypeOf<typeof Panel>;
+type Page = t.TypeOf<typeof Page>;
+type Storyboard = t.TypeOf<typeof Storyboard>;
+export { Format, Character, Bubble, Panel, Page, Storyboard, LayoutPage, LayoutRow, LayoutColumn, };

package/dist/lib/layeredCanvas/dataModels/bubble.d.ts

@@ -0,0 +1,97 @@
+import { Vector, Rect } from '../tools/geometry/geometry';
+import { RectHandle } from '../tools/rectHandle';
+import { Film, FilmStack } from './film';
+export interface BubbleRenderInfo {
+    pathJson: string;
+    path: paper.PathItem | null;
+    unitedPath: paper.PathItem | null;
+    children: Bubble[];
+    textJson: string;
+    textCanvas: HTMLCanvasElement;
+    textCtx: CanvasRenderingContext2D;
+}
+export declare class Bubble {
+    n_p0: Vector;
+    n_p1: Vector;
+    n_offset: Vector;
+    rotation: number;
+    text: string;
+    shape: string;
+    embedded: boolean;
+    fontStyle: string;
+    fontWeight: string;
+    n_fontSize: number;
+    charSkip: number;
+    lineSkip: number;
+    fontFamily: string;
+    direction: string;
+    fontColor: string;
+    fillColor: string;
+    strokeColor: string;
+    n_strokeWidth: number;
+    outlineColor: string;
+    n_outlineWidth: number;
+    autoNewline: boolean;
+    uuid: string;
+    parent: string | null;
+    creationContext: string;
+    filmStack: FilmStack;
+    scaleLock: boolean;
+    rubySize: number;
+    rubyDistance: number;
+    optionContext: any;
+    pageNumber?: number;
+    fontRenderVersion?: number;
+    appearanceDelay?: number;
+    hidesText?: boolean;
+    prompt: string;
+    gallery: HTMLCanvasElement[];
+    renderInfo?: BubbleRenderInfo;
+    constructor();
+    reset(): void;
+    getStackTrace(): string;
+    clone(hard: boolean): Bubble;
+    copyStyleFrom(c: Bubble): void;
+    static getUnit(paperSize: Vector): number;
+    static compile(paperSize: Vector, json: any): Bubble;
+    static decompile(b: Bubble): any;
+    static getPhysicalPoint(paperSize: Vector, n_p: Vector): Vector;
+    getPhysicalRect(paperSize: Vector): Rect;
+    getPhysicalBox(paperSize: Vector): [Vector, Vector];
+    getPhysicalCenter(paperSize: Vector): Vector;
+    getPhysicalSize(paperSize: Vector): Vector;
+    getPhysicalOffset(paperSize: Vector): Vector;
+    getPhysicalFontSize(paperSize: Vector): number;
+    getPhysicalStrokeWidth(paperSize: Vector): number;
+    getPhysicalOutlineWidth(paperSize: Vector): number;
+    getPhysicalRegularizedRect(paperSize: Vector): Rect;
+    getPhysicalRegularizedBox(paperSize: Vector): [Vector, Vector];
+    hasEnoughSize(paperSize: Vector): boolean;
+    static enoughSize(size: Vector): Vector;
+    setPhysicalCenter(paperSize: Vector, p: Vector): void;
+    setPhysicalSize(paperSize: Vector, size: Vector): void;
+    setPhysicalRect(paperSize: Vector, rect: Rect): void;
+    setPhysicalFontSize(paperSize: Vector, n: number): void;
+    setPhysicalStrokeWidth(paperSize: Vector, n: number): void;
+    setPhysicalOutlineWidth(paperSize: Vector, n: number): void;
+    setPhysicalOffset(paperSize: Vector, p: Vector): void;
+    forceEnoughSize(paperSize: Vector): void;
+    contains(paperSize: Vector, p: Vector): boolean;
+    getHandleAt(paperSize: Vector, p: Vector): RectHandle | null;
+    getHandleRect(paperSize: Vector, handle: RectHandle): Rect;
+    regularized(): [Vector, Vector];
+    regularize(): void;
+    canLink(): boolean;
+    linkTo(b: Bubble): void;
+    linkedTo(b: Bubble): boolean;
+    static normalizedPosition(paperSize: Vector, p: Vector): Vector;
+    static denormalizedPosition(paperSize: Vector, p: Vector): Vector;
+    get optionSet(): any;
+    initOptions(): void;
+    static getInitialOptions(b: Bubble, sample?: boolean): any;
+    calculateFitSize(paperSize: Vector): Vector;
+}
+export declare function insertBubbleLayers(paperSize: Vector, bubble: Bubble, index: number, films: Film[]): void;
+export declare const bubbleOptionSets: {
+    [key: string]: any;
+};

package/dist/lib/layeredCanvas/dataModels/effect.d.ts

@@ -0,0 +1,25 @@
+import { Media } from './media';
+import { FloatField } from 'fastsdf';
+export declare class Effect {
+    ulid: string;
+    inputMedia: Media | null;
+    outputMedia: Media | null;
+    constructor();
+    get tag(): string;
+    clone(): Effect;
+    cleanInput(): void;
+    setOutputDirty(): void;
+    apply(inputMedia: Media): Promise<Media>;
+    decompile(): any;
+    static compile(markUp: any): OutlineEffect;
+}
+export declare class OutlineEffect extends Effect {
+    color: string;
+    width: number;
+    sharp: number;
+    rawDistanceField: FloatField | null;
+    constructor(color: string, width: number, sharp: number);
+    clone(): Effect;
+    apply(inputMedia: Media): Promise<Media>;
+    decompile(): any;
+}

package/dist/lib/layeredCanvas/dataModels/film.d.ts

@@ -0,0 +1,46 @@
+import { Vector, Rect } from '../tools/geometry/geometry';
+import { Media } from './media';
+import { Effect } from './effect';
+export declare class Film {
+    ulid: string;
+    media: Media;
+    n_scale: number;
+    n_translation: Vector;
+    rotation: number;
+    reverse: [number, number];
+    visible: boolean;
+    prompt: string | null;
+    effects: Effect[];
+    selected: boolean;
+    matrix: DOMMatrix | undefined;
+    index: number | undefined;
+    constructor(media: Media);
+    clone(): Film;
+    getPlainRect(): Rect;
+    static getShiftedScale(paperSize: Vector, media: Media, n_scale: number): number;
+    getShiftedScale(paperSize: Vector): number;
+    setShiftedScale(paperSize: Vector, scale: number): void;
+    static getShiftedTranslation(paperSize: Vector, media: Media, n_translation: Vector): Vector;
+    getShiftedTranslation(paperSize: Vector): Vector;
+    setShiftedTranslation(paperSize: Vector, translation: Vector): void;
+    static getShiftedRect(paperSize: Vector, media: Media, n_scale: number, n_translation: Vector, rotation: number): Rect;
+    getShiftedRect(paperSize: Vector): Rect;
+    makeMatrix(paperSize: Vector): DOMMatrix;
+}
+export declare class FilmStack {
+    films: Film[];
+    constructor();
+    getSelectedFilms(): Film[];
+    getOperationTargetFilms(): Film[];
+}
+export declare class FilmStackTransformer {
+    paperSize: Vector;
+    films: Film[];
+    pivot: Vector;
+    constructor(paperSize: Vector, films: Film[]);
+    scale(s: number): void;
+    rotate(q: number): void;
+}
+export declare function calculateMinimumBoundingRect(paperSize: Vector, films: Film[]): Rect | null;
+export declare function fitFilms(paperSize: Vector, constraintRect: Rect, films: Film[]): void;
+export declare function insertFilms(paperSize: Vector, constraintRect: Rect, index: number, films: Film[], targetFilms: Film[], gallery: HTMLCanvasElement[]): void;