mce 0.1.0

package/dist/indexeddb/IndexeddbProvider.d.ts

@@ -0,0 +1,31 @@
+import type { ObservableEvents } from 'modern-idoc';
+import { Observable } from 'modern-idoc';
+import * as Y from 'yjs';
+export declare const PREFERRED_TRIM_SIZE = 500;
+export declare function fetchUpdates(idbPersistence: IndexeddbProvider, beforeApplyUpdatesCallback?: ((arg0: IDBObjectStore) => void) | undefined, afterApplyUpdatesCallback?: ((arg0: IDBObjectStore) => void) | undefined): Promise<IDBObjectStore>;
+export declare function storeState(idbPersistence: IndexeddbProvider, forceStore?: boolean): Promise<void>;
+export declare const clearDocument: (name: string) => Promise<void>;
+interface IndexeddbProviderEvents extends ObservableEvents {
+    synced: [db: IndexeddbProvider];
+}
+export declare class IndexeddbProvider extends Observable<IndexeddbProviderEvents> {
+    name: string;
+    doc: Y.Doc;
+    db: IDBDatabase | null;
+    synced: boolean;
+    whenSynced: Promise<IndexeddbProvider>;
+    _dbref: number;
+    _dbsize: number;
+    _destroyed: boolean;
+    _db: Promise<IDBDatabase>;
+    _storeTimeout: number;
+    _storeTimeoutId: any;
+    _storeUpdate: (update: Uint8Array, origin: any) => void;
+    constructor(name: string, doc: Y.Doc);
+    destroy(): Promise<void>;
+    clearData(): Promise<void>;
+    get<T = any>(key: IDBValidKey): Promise<T>;
+    set<T = any>(key: IDBValidKey, value: T): Promise<T>;
+    del(key: IDBValidKey): Promise<any>;
+}
+export {};

package/dist/indexeddb/index.d.ts

@@ -0,0 +1 @@
+export * from './IndexeddbProvider';

package/dist/indexeddb/indexeddb.d.ts

@@ -0,0 +1,23 @@
+export declare function rtop(request: IDBRequest): Promise<any>;
+export declare function openDB(name: string, initDB: (arg0: IDBDatabase) => any): Promise<IDBDatabase>;
+export declare function deleteDB(name: string): Promise<void>;
+export declare function createStores(db: IDBDatabase, definitions: Array<Array<string> | Array<string | IDBObjectStoreParameters | undefined>>): void;
+export declare function transact(db: IDBDatabase, stores: Array<string>, access?: 'readwrite' | 'readonly'): Array<IDBObjectStore>;
+export declare function count(store: IDBObjectStore, range?: IDBKeyRange): Promise<number>;
+export declare function get(store: IDBObjectStore, key: IDBValidKey): Promise<string | number | ArrayBuffer | Date | any[]>;
+export declare function del(store: IDBObjectStore, key: IDBValidKey): Promise<any>;
+export declare function put(store: IDBObjectStore, item: any, key?: IDBValidKey): Promise<any>;
+export declare function add(store: IDBObjectStore, item: any, key: IDBValidKey): Promise<any>;
+export declare function addAutoKey(store: IDBObjectStore, item: any): Promise<number>;
+export declare function getAll(store: IDBObjectStore, range?: IDBKeyRange, limit?: number): Promise<any[]>;
+export declare function getAllKeys(store: IDBObjectStore, range?: IDBKeyRange, limit?: number): Promise<any[]>;
+export declare function queryFirst(store: IDBObjectStore, query: IDBKeyRange | undefined, direction: 'next' | 'prev' | 'nextunique' | 'prevunique'): Promise<any>;
+export declare function getLastKey(store: IDBObjectStore, range?: IDBKeyRange): Promise<any>;
+export declare function getFirstKey(store: IDBObjectStore, range?: IDBKeyRange): Promise<any>;
+export declare function getAllKeysValues(store: IDBObjectStore, range?: IDBKeyRange, limit?: number): Promise<any[]>;
+export declare function iterate(store: IDBObjectStore, keyrange: IDBKeyRange | null, f: (arg0: any, arg1: any) => void | boolean | Promise<void | boolean>, direction?: 'next' | 'prev' | 'nextunique' | 'prevunique'): Promise<void>;
+export declare function iterateKeys(store: IDBObjectStore, keyrange: IDBKeyRange | undefined, f: (arg0: any) => void | boolean | Promise<void | boolean>, direction?: 'next' | 'prev' | 'nextunique' | 'prevunique'): Promise<void>;
+export declare function getStore(t: IDBTransaction, store: string): IDBObjectStore;
+export declare function createIDBKeyRangeBound(lower: any, upper: any, lowerOpen?: boolean, upperOpen?: boolean): IDBKeyRange;
+export declare function createIDBKeyRangeUpperBound(upper: any, upperOpen?: boolean): IDBKeyRange;
+export declare function createIDBKeyRangeLowerBound(lower: any, lowerOpen?: boolean): IDBKeyRange;

package/dist/models/Doc.d.ts

@@ -0,0 +1,57 @@
+import type { CoreObject } from 'modern-canvas';
+import type { Document, Element } from 'modern-idoc';
+import type { ModelEvents } from './Model';
+import { Node } from 'modern-canvas';
+import * as Y from 'yjs';
+import { Model } from './Model';
+interface AddElementOptions {
+    parentId?: string;
+    index?: number;
+    regenId?: boolean;
+}
+export type YElement = Y.Map<unknown> & {
+    get: ((prop: 'id') => string) & ((prop: 'name') => string) & ((prop: 'parentId') => string) & ((prop: 'style') => Y.Map<unknown>) & ((prop: 'background') => Y.Map<unknown>) & ((prop: 'shape') => Y.Map<unknown>) & ((prop: 'fill') => Y.Map<unknown>) & ((prop: 'outline') => Y.Map<unknown>) & ((prop: 'text') => Y.Map<unknown>) & ((prop: 'foreground') => Y.Map<unknown>) & ((prop: 'shadow') => Y.Map<unknown>) & ((prop: 'meta') => Y.Map<unknown>) & ((prop: 'childrenIds') => Y.Array<string>) & (<T = unknown>(prop: string) => T);
+};
+export interface YElementResult {
+    id: string;
+    element: YElement;
+}
+export declare function iElementToYElements(element: Element, parentId: string | undefined, regenId?: boolean): YElementResult[];
+export interface DocEvents extends ModelEvents {
+    history: [arg0: Y.UndoManager];
+}
+export interface Doc {
+    on: <K extends keyof DocEvents & string>(event: K, listener: (...args: DocEvents[K]) => void) => this;
+    once: <K extends keyof DocEvents & string>(event: K, listener: (...args: DocEvents[K]) => void) => this;
+    off: <K extends keyof DocEvents & string>(event: K, listener: (...args: DocEvents[K]) => void) => this;
+    emit: <K extends keyof DocEvents & string>(event: K, ...args: DocEvents[K]) => this;
+}
+export declare class Doc extends Model {
+    _yChildren: Y.Map<YElement>;
+    _yChildrenIds: Y.Array<string>;
+    name: string;
+    readonly root: Node;
+    nodeMap: Map<string, Node>;
+    get meta(): import("modern-canvas").Meta;
+    set meta(val: import("modern-canvas").Meta);
+    constructor(id?: string);
+    setProperties(properties?: Record<string, any>): this;
+    load(initFn?: () => void | Promise<void>): Promise<this>;
+    protected _isSelfTransaction(transaction: Y.Transaction): boolean;
+    protected _onChildrenChange(event: Y.YMapEvent<Y.Map<unknown>>, transaction: Y.Transaction): void;
+    reset(): this;
+    init(): void;
+    protected _addElement(element: Element, options?: AddElementOptions): Node;
+    addElement(element: Element, options?: AddElementOptions): Node;
+    addElements(elements: Element[], options?: AddElementOptions): Node[];
+    set(source: Document): this;
+    protected _deleteElement(id: string): void;
+    deleteElement(id: string): void;
+    moveElement(id: string, toIndex: number): void;
+    protected _proxyProps(obj: CoreObject, yMap: Y.Map<any>, isMeta?: boolean): void;
+    protected _proxyChildren(node: Node, childrenIds: Y.Array<string>): void;
+    protected _proxyNode(node: Node, yEle: YElement): void;
+    protected _getOrCreateNode(yNode: YElement): Node;
+    toJSON(): Record<string, any>;
+}
+export {};

package/dist/models/Model.d.ts

@@ -0,0 +1,32 @@
+import type { ReactivableEvents } from 'modern-idoc';
+import type { Transaction } from 'yjs';
+import { Reactivable } from 'modern-idoc';
+import * as Y from 'yjs';
+import { IndexeddbProvider } from '../indexeddb';
+export interface ModelEvents extends ReactivableEvents {
+    update: [arg0: Uint8Array, arg1: any, arg2: Y.Doc, arg3: Transaction];
+}
+export interface Model {
+    on: <K extends keyof ModelEvents & string>(event: K, listener: (...args: ModelEvents[K]) => void) => this;
+    once: <K extends keyof ModelEvents & string>(event: K, listener: (...args: ModelEvents[K]) => void) => this;
+    off: <K extends keyof ModelEvents & string>(event: K, listener: (...args: ModelEvents[K]) => void) => this;
+    emit: <K extends keyof ModelEvents & string>(event: K, ...args: ModelEvents[K]) => this;
+}
+export declare class Model extends Reactivable {
+    id: string;
+    _transacting: boolean | undefined;
+    _yDoc: Y.Doc;
+    _yProps: Y.Map<unknown>;
+    indexeddb?: IndexeddbProvider;
+    undoManager: Y.UndoManager;
+    protected _ready: boolean;
+    constructor(id?: string);
+    protected _setupUndoManager(typeScope?: any[]): void;
+    undo(): any;
+    redo(): any;
+    loadIndexeddb(): Promise<void>;
+    transact<T>(fn: () => T, should?: boolean): T;
+    load(initFn?: () => void | Promise<void>): Promise<this>;
+    reset(): this;
+    toJSON(): Record<string, any>;
+}

package/dist/models/Workspace.d.ts

@@ -0,0 +1,17 @@
+import type { Doc } from './Doc';
+import { Model } from './Model';
+export interface WorkspaceProps {
+    name: string;
+    type: 'local' | 'cloud';
+    createdAt: number;
+    updatedAt: number;
+}
+export declare class Workspace extends Model {
+    readonly docs: Map<string, Doc>;
+    name: string;
+    type: 'local' | 'cloud';
+    createdAt: string;
+    updatedAt: string;
+    set(source?: Partial<WorkspaceProps>): this;
+    addDoc(doc: Doc): Doc;
+}

package/dist/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Doc';
+export * from './Model';
+export * from './Workspace';

package/dist/plugins/0.command.d.ts

@@ -0,0 +1,27 @@
+import type { Ref } from 'vue';
+declare global {
+    namespace Mce {
+        interface Commands {
+        }
+        type CommandHandle = (...args: any[]) => any;
+        type CommandEvents = {
+            [K in keyof Commands as `command:${K}`]: [ReturnType<Commands[K]>];
+        };
+        interface Events extends CommandEvents {
+        }
+        interface Editor {
+            commands: Ref<Map<string, Commands[keyof Commands]>>;
+            registerCommand: {
+                <K extends keyof Commands>(key: K, command: Commands[K]): void;
+                <K extends keyof Commands>(commands: {
+                    key: K;
+                    handle: Commands[K];
+                }[]): void;
+            };
+            unregisterCommand: <K extends keyof Commands = keyof Commands>(key: K) => void;
+            exec: <K extends keyof Commands>(key: K, ...args: Parameters<Commands[K]>) => ReturnType<Commands[K]>;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/0.config/base.d.ts

@@ -0,0 +1,30 @@
+declare global {
+    namespace Mce {
+        interface Options extends Partial<Config> {
+        }
+        type Theme = 'system' | 'light' | 'dark';
+        type Language = string;
+        type ViewMode = 'frame' | 'edgeless';
+        type TypographyStrategy = 'autoHeight' | 'autoWidth' | 'fixedWidthHeight' | 'autoFontSize';
+        type HandleShape = 'rect' | 'circle';
+        interface Config {
+            theme: Theme;
+            language: Language;
+            viewMode: ViewMode;
+            checkerboard: boolean;
+            pixelGrid: boolean;
+            camera: boolean;
+            ruler: boolean;
+            scrollbar: boolean;
+            bottombar: boolean;
+            statusbar: boolean;
+            wheelZoom: boolean;
+            frameGap: number;
+            typographyStrategy: TypographyStrategy;
+            handleShape: HandleShape;
+            localDb: boolean;
+        }
+    }
+}
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/0.config.d.ts

@@ -0,0 +1,16 @@
+import type { WritableComputedRef } from 'vue';
+declare global {
+    namespace Mce {
+        interface Editor {
+            getConfigValue: (path: keyof Config | string, defaultValue?: any) => any;
+            setConfigValue: (path: keyof Config | string, value: any) => void;
+            getConfig: <T = any>(path: string) => WritableComputedRef<T>;
+            registerConfig: <T>(path: keyof Config | string, initValue: T) => WritableComputedRef<T>;
+            importConfig: () => Promise<void>;
+            exportConfig: () => Blob;
+            saveAsConfig: (filename?: string) => void;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/0.context.d.ts

@@ -0,0 +1,32 @@
+import type { Cursor, Node, Vector2Data } from 'modern-canvas';
+import type { ComputedRef, Ref } from 'vue';
+import type { Doc, Workspace } from '../models';
+import type { AxisAlignedBoundingBox } from '../types';
+import { Camera2D, DrawboardEffect, Engine } from 'modern-canvas';
+import { Fonts } from 'modern-font';
+declare global {
+    namespace Mce {
+        interface Editor {
+            fonts: Fonts;
+            renderEngine: Ref<Engine>;
+            camera: Ref<Camera2D>;
+            drawboardEffect: Ref<DrawboardEffect>;
+            setCursor: (mode: Cursor | undefined) => void;
+            drawboardDom: Ref<HTMLElement | undefined>;
+            drawboardAabb: Ref<AxisAlignedBoundingBox>;
+            drawboardPointer: Ref<Vector2Data | undefined>;
+            workspace: Ref<Workspace | undefined>;
+            root: ComputedRef<Node | undefined>;
+            doc: Ref<Doc | undefined>;
+            state: Ref<State | undefined>;
+            setState: (state: State, context?: StateContext) => void;
+            stateContext: Ref<StateContext | undefined>;
+            getGlobalPointer: () => Vector2Data;
+        }
+        interface Events {
+            setState: [state: State];
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/0.element.d.ts

@@ -0,0 +1,14 @@
+import type { Ref } from 'vue';
+import { Element2D } from 'modern-canvas';
+declare global {
+    namespace Mce {
+        interface Editor {
+            selection: Ref<Element2D[]>;
+            textSelection: Ref<any[] | undefined>;
+            getAncestor: (element?: Element2D) => Element2D | undefined;
+            hoverElement: Ref<Element2D | undefined>;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/0.font.d.ts

@@ -0,0 +1,18 @@
+import type { FontLoadedResult, FontLoadOptions, FontSource } from 'modern-font';
+declare global {
+    namespace Mce {
+        interface Editor {
+            loadFont: (source: FontSource, options?: FontLoadOptions) => Promise<FontLoadedResult>;
+            setDefaultFont: (source: FontSource, options?: FontLoadOptions) => Promise<void>;
+            waitUntilFontLoad: () => Promise<void>;
+        }
+        interface Options {
+            defaultFont?: FontSource;
+        }
+        interface Events {
+            loadFont: [font: FontLoadedResult];
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/0.i18n.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    namespace Mce {
+        type Translation = (key: string, fallback?: string) => string;
+        interface Editor {
+            t: Translation;
+        }
+        interface Options {
+            t?: Translation;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/1.frame.d.ts

@@ -0,0 +1,24 @@
+import type { Node } from 'modern-canvas';
+import type { ComputedRef, Ref } from 'vue';
+import type { AxisAlignedBoundingBox } from '../types';
+import { Element2D } from 'modern-canvas';
+declare global {
+    namespace Mce {
+        interface FrameThumb {
+            width: number;
+            height: number;
+            url: string;
+        }
+        interface Editor {
+            frameThumbs: Ref<FrameThumb[]>;
+            frames: ComputedRef<Element2D[]>;
+            activeFrameIndex: Ref<number>;
+            activeFrame: ComputedRef<Element2D | undefined>;
+            activeFrameAabb: ComputedRef<AxisAlignedBoundingBox>;
+            isFrame: (node: Node) => node is Element2D;
+            getAncestorFrame: (element?: Element2D) => Element2D | undefined;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/1.hotkey.d.ts

@@ -0,0 +1,39 @@
+import type { Ref, WritableComputedRef } from 'vue';
+declare global {
+    namespace Mce {
+        interface Hotkeys {
+            cancel: [event: KeyboardEvent];
+        }
+        type HotkeyEvents = {
+            [K in keyof Hotkeys as `hotkey:${K}`]: Hotkeys[K];
+        };
+        interface Events extends HotkeyEvents {
+        }
+        interface Config {
+            hotkeys: HotkeyData[];
+        }
+        interface HotkeyData {
+            key: keyof Hotkeys;
+            accelerator: string | string[];
+            editable?: boolean;
+            enabled?: boolean;
+            system?: boolean;
+        }
+        interface Hotkey extends HotkeyData {
+            condition?: (e: KeyboardEvent) => boolean;
+            handle?: (e: KeyboardEvent) => void;
+        }
+        interface Editor {
+            hotkeysData: WritableComputedRef<HotkeyData[]>;
+            hotkeys: Ref<Map<string, Hotkey>>;
+            registerHotkey: {
+                (key: string, hotkey: Hotkey): void;
+                (hotkeys: Hotkey[]): void;
+            };
+            unregisterHotkey: (key: string) => void;
+            getKbd: (key: string | keyof Hotkeys) => string;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/1.upload.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    namespace Mce {
+        type Upload = (file: File | Blob) => Promise<string>;
+        interface Editor {
+            upload: Upload;
+        }
+        interface Options {
+            upload?: Upload;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/2.box.d.ts

@@ -0,0 +1,20 @@
+import type { Node } from 'modern-canvas';
+import type { ComputedRef } from 'vue';
+import type { AxisAlignedBoundingBox, OrientedBoundingBox } from '../types';
+import { Element2D } from 'modern-canvas';
+declare global {
+    namespace Mce {
+        interface Editor {
+            obbToFit: (element: Element2D) => void;
+            getObb: (node: Node | Node[] | undefined, inTarget?: 'drawboard' | 'frame') => OrientedBoundingBox;
+            getObbInDrawboard: (node?: Node | Node[]) => OrientedBoundingBox;
+            getAabb: (node: Node | Node[] | undefined, inTarget?: 'drawboard' | 'frame') => AxisAlignedBoundingBox;
+            getAabbInDrawboard: (node?: Node | Node[]) => AxisAlignedBoundingBox;
+            aabbToDrawboardAabb: (aabb: AxisAlignedBoundingBox) => AxisAlignedBoundingBox;
+            rootAabb: ComputedRef<AxisAlignedBoundingBox>;
+            currentAabb: ComputedRef<AxisAlignedBoundingBox>;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/2.exporter/0.json.d.ts

@@ -0,0 +1,10 @@
+import type { NormalizedDocument } from 'modern-idoc';
+declare global {
+    namespace Mce {
+        interface Exporters {
+            json: NormalizedDocument;
+        }
+    }
+}
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.exporter/image.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    namespace Mce {
+        interface Exporters {
+            png: Blob;
+            jpeg: Blob;
+            webp: Blob;
+        }
+    }
+}
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.exporter/pdf.d.ts

@@ -0,0 +1,9 @@
+declare global {
+    namespace Mce {
+        interface Exporters {
+            pdf: Blob;
+        }
+    }
+}
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.exporter/pptx.d.ts

@@ -0,0 +1,9 @@
+declare global {
+    namespace Mce {
+        interface Exporters {
+            pptx: Blob;
+        }
+    }
+}
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.exporter/video.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    namespace Mce {
+        interface Exporters {
+            gif: Blob;
+            mp4: Blob;
+        }
+    }
+}
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.exporter.d.ts

@@ -0,0 +1,27 @@
+import type { Element2D } from 'modern-canvas';
+import type { Ref } from 'vue';
+declare global {
+    namespace Mce {
+        type ExporterProgress = (current: number, total: number) => void;
+        interface ExporterOptions {
+            scale?: number;
+            selected?: boolean | Element2D[];
+            onProgress?: ExporterProgress;
+        }
+        type Exporter = (options: ExporterOptions) => any | Promise<any>;
+        interface Editor {
+            exporters: Ref<Map<string, Exporter>>;
+            registerExporter: {
+                (key: string, exporter: Exporter): void;
+                (exporters: {
+                    key: string;
+                    handle: Exporter;
+                }[]): void;
+            };
+            unregisterExporter: (key: keyof Exporters) => void;
+            to: <K extends keyof Exporters>(key: K, options?: ExporterOptions) => Exporters[K];
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/2.loader/0.url.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.loader/image.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.loader/json.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.loader/pptx.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.loader/txt.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../..").Plugin;
+export default _default;

package/dist/plugins/2.loader.d.ts

@@ -0,0 +1,23 @@
+import type { NormalizedElement } from 'modern-idoc';
+import type { Ref } from 'vue';
+declare global {
+    namespace Mce {
+        interface Loader {
+            name: string;
+            accept?: string;
+            test: (source: any) => boolean | Promise<boolean>;
+            load: (source: any) => Promise<NormalizedElement | undefined>;
+        }
+        interface Editor {
+            loaders: Ref<Map<string, Loader>>;
+            registerLoader: (loader: Loader | Loader[]) => void;
+            unregisterLoader: (name: string) => void;
+            load: <T = NormalizedElement>(source: any) => Promise<T>;
+            openFileDialog: (options?: {
+                multiple?: boolean;
+            }) => Promise<File[]>;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/3.view.d.ts

@@ -0,0 +1,12 @@
+import type { ComputedRef } from 'vue';
+import type { AxisAlignedBoundingBox } from '../types';
+declare global {
+    namespace Mce {
+        interface Editor {
+            viewAabb: ComputedRef<AxisAlignedBoundingBox>;
+            bindRenderCanvas: (canvas: HTMLCanvasElement, setEventTarget?: HTMLElement) => () => void;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/4.0.text.d.ts

@@ -0,0 +1,11 @@
+import { Element2D } from 'modern-canvas';
+declare global {
+    namespace Mce {
+        interface Editor {
+            textFontSizeToFit: (element: Element2D) => void;
+            textToFit: (element: Element2D, typography?: Mce.TypographyStrategy) => void;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;

package/dist/plugins/4.1.lock.d.ts

@@ -0,0 +1,20 @@
+import type { Element2D } from 'modern-canvas';
+declare global {
+    namespace Mce {
+        interface Commands {
+            'lock': () => void;
+            'unlock': () => void;
+            'lock/unlock': () => void;
+        }
+        interface Hotkeys {
+            'lock/unlock': [event: KeyboardEvent];
+        }
+        interface Editor {
+            isLocked: (element: Element2D) => boolean;
+            lock: (element: Element2D) => void;
+            unlock: (element: Element2D) => void;
+        }
+    }
+}
+declare const _default: import("..").Plugin;
+export default _default;