@idraw/util 0.4.0-beta.3 → 0.4.0-beta.31

package/dist/esm/lib/element.d.ts

@@ -16,6 +16,7 @@ export declare function getElemenetsAssetIds(elements: Elements): string[];
 export declare function findElementFromList(uuid: string, list: Element<ElementType>[]): Element<ElementType> | null;
 export declare function findElementsFromList(uuids: string[], list: Element<ElementType>[]): Element<ElementType>[];
 export declare function getGroupQueueFromList(uuid: string, elements: Element<ElementType>[]): Element<'group'>[];
+export declare function getGroupQueueByElementPosition(elements: Element<ElementType>[], position: ElementPosition): Element<'group'>[] | null;
 export declare function getElementSize(elem: Element): ElementSize;
 export declare function mergeElementAsset<T extends Element<LoadElementType>>(element: T, assets: ElementAssets): T;
 export declare function filterElementAsset<T extends Element<LoadElementType>>(element: T): {

package/dist/esm/lib/element.js

@@ -260,6 +260,25 @@ export function getGroupQueueFromList(uuid, elements) {
     _scan(uuid, elements);
     return groupQueue;
 }
+export function getGroupQueueByElementPosition(elements, position) {
+    var _a;
+    const groupQueue = [];
+    let currentElements = elements;
+    if (position.length > 1) {
+        for (let i = 0; i < position.length - 1; i++) {
+            const index = position[i];
+            const group = currentElements[index];
+            if ((group === null || group === void 0 ? void 0 : group.type) === 'group' && Array.isArray((_a = group === null || group === void 0 ? void 0 : group.detail) === null || _a === void 0 ? void 0 : _a.children)) {
+                groupQueue.push(group);
+                currentElements = group.detail.children;
+            }
+            else {
+                return null;
+            }
+        }
+    }
+    return groupQueue;
+}
 export function getElementSize(elem) {
     const { x, y, w, h, angle } = elem;
     const size = { x, y, w, h, angle };

package/dist/esm/lib/event.d.ts

@@ -1,9 +1,11 @@
 import type { UtilEventEmitter } from '@idraw/types';
 export declare class EventEmitter<T extends Record<string, any>> implements UtilEventEmitter<T> {
-    private _listeners;
+    #private;
     constructor();
     on<K extends keyof T>(eventKey: K, callback: (e: T[K]) => void): void;
     off<K extends keyof T>(eventKey: K, callback: (e: T[K]) => void): void;
-    trigger<K extends keyof T>(eventKey: K, e: T[K]): boolean;
+    trigger<K extends keyof T>(eventKey: K, e?: T[K]): boolean;
     has<K extends keyof T>(name: K | string): boolean;
+    destroy(): void;
+    clear(): void;
 }

package/dist/esm/lib/event.js

@@ -1,20 +1,33 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EventEmitter_listeners;
 export class EventEmitter {
     constructor() {
-        this._listeners = new Map();
+        _EventEmitter_listeners.set(this, void 0);
+        __classPrivateFieldSet(this, _EventEmitter_listeners, new Map(), "f");
     }
     on(eventKey, callback) {
-        if (this._listeners.has(eventKey)) {
-            const callbacks = this._listeners.get(eventKey) || [];
+        if (__classPrivateFieldGet(this, _EventEmitter_listeners, "f").has(eventKey)) {
+            const callbacks = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(eventKey) || [];
             callbacks === null || callbacks === void 0 ? void 0 : callbacks.push(callback);
-            this._listeners.set(eventKey, callbacks);
+            __classPrivateFieldGet(this, _EventEmitter_listeners, "f").set(eventKey, callbacks);
         }
         else {
-            this._listeners.set(eventKey, [callback]);
+            __classPrivateFieldGet(this, _EventEmitter_listeners, "f").set(eventKey, [callback]);
         }
     }
     off(eventKey, callback) {
-        if (this._listeners.has(eventKey)) {
-            const callbacks = this._listeners.get(eventKey);
+        if (__classPrivateFieldGet(this, _EventEmitter_listeners, "f").has(eventKey)) {
+            const callbacks = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(eventKey);
             if (Array.isArray(callbacks)) {
                 for (let i = 0; i < (callbacks === null || callbacks === void 0 ? void 0 : callbacks.length); i++) {
                     if (callbacks[i] === callback) {
@@ -23,11 +36,11 @@ export class EventEmitter {
                     }
                 }
             }
-            this._listeners.set(eventKey, callbacks || []);
+            __classPrivateFieldGet(this, _EventEmitter_listeners, "f").set(eventKey, callbacks || []);
         }
     }
     trigger(eventKey, e) {
-        const callbacks = this._listeners.get(eventKey);
+        const callbacks = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(eventKey);
         if (Array.isArray(callbacks)) {
             callbacks.forEach((cb) => {
                 cb(e);
@@ -39,12 +52,19 @@ export class EventEmitter {
         }
     }
     has(name) {
-        if (this._listeners.has(name)) {
-            const list = this._listeners.get(name);
+        if (__classPrivateFieldGet(this, _EventEmitter_listeners, "f").has(name)) {
+            const list = __classPrivateFieldGet(this, _EventEmitter_listeners, "f").get(name);
             if (Array.isArray(list) && list.length > 0) {
                 return true;
             }
         }
         return false;
     }
+    destroy() {
+        this.clear();
+    }
+    clear() {
+        __classPrivateFieldGet(this, _EventEmitter_listeners, "f").clear();
+    }
 }
+_EventEmitter_listeners = new WeakMap();

package/dist/esm/lib/file.d.ts

@@ -1,14 +1,19 @@
 type ImageType = 'image/jpeg' | 'image/png';
 export declare function downloadImageFromCanvas(canvas: HTMLCanvasElement, opts: {
-    filename: string;
+    fileName: string;
     type: ImageType;
 }): void;
 export declare function pickFile(opts: {
+    accept?: string;
     success: (data: {
         file: File;
     }) => void;
-    error?: (err: ErrorEvent) => void;
+    error?: (err: Error | any) => void;
 }): void;
 export declare function parseFileToBase64(file: File): Promise<string | ArrayBuffer>;
 export declare function parseFileToText(file: File): Promise<string | ArrayBuffer>;
+export declare function parseTextToBlobURL(text: string): string;
+export declare function downloadFileFromText(text: string, opts: {
+    fileName: string;
+}): void;
 export {};

package/dist/esm/lib/file.js

@@ -1,17 +1,19 @@
 export function downloadImageFromCanvas(canvas, opts) {
-    const { filename, type = 'image/jpeg' } = opts;
+    const { fileName, type = 'image/jpeg' } = opts;
     const stream = canvas.toDataURL(type);
-    const downloadLink = document.createElement('a');
+    let downloadLink = document.createElement('a');
     downloadLink.href = stream;
-    downloadLink.download = filename;
-    const downloadClickEvent = document.createEvent('MouseEvents');
-    downloadClickEvent.initEvent('click', true, false);
-    downloadLink.dispatchEvent(downloadClickEvent);
+    downloadLink.download = fileName;
+    downloadLink.click();
+    downloadLink = null;
 }
 export function pickFile(opts) {
-    const { success, error } = opts;
+    const { accept, success, error } = opts;
     let input = document.createElement('input');
     input.type = 'file';
+    if (accept) {
+        input.accept = accept;
+    }
     input.addEventListener('change', function () {
         var _a;
         const file = (_a = input.files) === null || _a === void 0 ? void 0 : _a[0];
@@ -64,3 +66,20 @@ export function parseFileToText(file) {
         reader.readAsText(file);
     });
 }
+export function parseTextToBlobURL(text) {
+    const bytes = new TextEncoder().encode(text);
+    const blob = new Blob([bytes], {
+        type: 'text/plain;charset=utf-8'
+    });
+    const blobURL = window.URL.createObjectURL(blob);
+    return blobURL;
+}
+export function downloadFileFromText(text, opts) {
+    const { fileName } = opts;
+    const blobURL = parseTextToBlobURL(text);
+    let downloadLink = document.createElement('a');
+    downloadLink.href = blobURL;
+    downloadLink.download = fileName;
+    downloadLink.click();
+    downloadLink = null;
+}

package/dist/esm/lib/flat.d.ts

@@ -0,0 +1,2 @@
+import type { Elements } from '@idraw/types';
+export declare function flatElementList(list: Elements): Elements;

package/dist/esm/lib/flat.js

@@ -0,0 +1,132 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { calcElementVertexesInGroup } from './vertex';
+import { limitAngle, parseAngleToRadian, calcElementCenterFromVertexes, rotatePoint } from './rotate';
+function flatElementSize(elemSize, opts) {
+    const { groupQueue } = opts;
+    let { x, y, w, h, angle = 0 } = elemSize;
+    let totalAngle = 0;
+    groupQueue.forEach((group) => {
+        x += group.x;
+        y += group.y;
+        totalAngle += group.angle || 0;
+    });
+    totalAngle = limitAngle(totalAngle);
+    if (totalAngle === 0) {
+        return {
+            x,
+            y,
+            w,
+            h,
+            angle
+        };
+    }
+    totalAngle += elemSize.angle || 0;
+    totalAngle = limitAngle(totalAngle);
+    const vertexes = calcElementVertexesInGroup(elemSize, { groupQueue });
+    const center = calcElementCenterFromVertexes(vertexes);
+    const start = rotatePoint(center, vertexes[0], parseAngleToRadian(0 - totalAngle));
+    x = start.x;
+    y = start.y;
+    return {
+        x,
+        y,
+        w,
+        h,
+        angle: totalAngle
+    };
+}
+function isValidElement(elem) {
+    var _a;
+    if (['rect', 'circle'].includes(elem.type)) {
+        const detail = elem.detail;
+        if (!detail.background && !detail.borderWidth) {
+            return false;
+        }
+        if (detail.background === 'transparent' && !detail.borderWidth) {
+            return false;
+        }
+    }
+    if (['group'].includes(elem.type)) {
+        const detail = elem.detail || {};
+        const { children } = detail;
+        if (!(children.length > 0) && !detail.background && !detail.borderWidth) {
+            return false;
+        }
+        if (!(children.length > 0) && detail.background === 'transparent' && !detail.borderWidth) {
+            return false;
+        }
+    }
+    if (elem.type === 'text') {
+        if (!elem.detail.text) {
+            return false;
+        }
+    }
+    if (elem.type === 'image') {
+        if (!elem.detail.src) {
+            return false;
+        }
+    }
+    if (elem.type === 'html') {
+        if (!elem.detail.html) {
+            return false;
+        }
+    }
+    if (elem.type === 'svg') {
+        if (!elem.detail.svg) {
+            return false;
+        }
+    }
+    if (elem.type === 'path') {
+        const detail = elem.detail;
+        if (!(((_a = detail === null || detail === void 0 ? void 0 : detail.commands) === null || _a === void 0 ? void 0 : _a.length) > 0)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function flatElementList(list) {
+    const elemeList = [];
+    const currentGroupQueue = [];
+    const _resetElemSize = (elem) => {
+        if (!isValidElement(elem)) {
+            return;
+        }
+        const newSize = flatElementSize(elem, { groupQueue: currentGroupQueue });
+        const resizeElem = Object.assign(Object.assign({}, elem), newSize);
+        elemeList.push(resizeElem);
+    };
+    const _walk = (elem) => {
+        var _a;
+        if (((_a = elem === null || elem === void 0 ? void 0 : elem.operations) === null || _a === void 0 ? void 0 : _a.invisible) === true) {
+            return;
+        }
+        if (elem.type === 'group') {
+            const { detail } = elem;
+            const { children } = detail, restDetail = __rest(detail, ["children"]);
+            _resetElemSize(Object.assign(Object.assign({}, elem), { detail: Object.assign(Object.assign({}, restDetail), { children: [] }) }));
+            currentGroupQueue.push(elem);
+            children.forEach((child) => {
+                _walk(child);
+            });
+            currentGroupQueue.pop();
+        }
+        else {
+            _resetElemSize(elem);
+        }
+    };
+    for (let i = 0; i < list.length; i++) {
+        const elem = list[i];
+        _walk(elem);
+    }
+    return elemeList;
+}

package/dist/esm/lib/handle-element.d.ts

@@ -10,5 +10,10 @@ export declare function deleteElementInList(uuid: string, list: Element[]): bool
 export declare function moveElementPosition(elements: Elements, opts: {
     from: ElementPosition;
     to: ElementPosition;
-}): Elements;
+}): {
+    elements: Elements;
+    from: ElementPosition;
+    to: ElementPosition;
+};
 export declare function updateElementInList(uuid: string, updateContent: RecursivePartial<Element<ElementType>>, elements: Element[]): Element | null;
+export declare function updateElementInListByPosition(position: ElementPosition, updateContent: RecursivePartial<Element<ElementType>>, elements: Element[]): Element | null;

package/dist/esm/lib/handle-element.js

@@ -1,10 +1,10 @@
 import { createUUID } from './uuid';
-import { getDefaultElementDetailConfig, getDefaultElementRectDetail, getDefaultElementCircleDetail, getDefaultElementTextDetail, getDefaultElementSVGDetail, getDefaultElementImageDetail, getDefaultElementGroupDetail } from './config';
+import { defaultText, getDefaultElementRectDetail, getDefaultElementCircleDetail, getDefaultElementTextDetail, getDefaultElementSVGDetail, getDefaultElementImageDetail, getDefaultElementGroupDetail } from './config';
 import { istype } from './istype';
 import { findElementFromListByPosition, getElementPositionFromList } from './element';
+import { deepResizeGroupElement } from './resize-element';
 const defaultViewWidth = 200;
 const defaultViewHeight = 200;
-const defaultDetail = getDefaultElementDetailConfig();
 function createElementSize(type, opts) {
     let x = 0;
     let y = 0;
@@ -14,29 +14,26 @@ function createElementSize(type, opts) {
         const { viewScaleInfo, viewSizeInfo } = opts;
         const { scale, offsetLeft, offsetTop } = viewScaleInfo;
         const { width, height } = viewSizeInfo;
-        if (type === 'text') {
-            const textDetail = getDefaultElementTextDetail();
-            w = defaultDetail.fontSize * scale * textDetail.text.length;
-            h = defaultDetail.fontSize * scale * 2;
+        const limitViewWidth = width / 4;
+        const limitViewHeight = height / 4;
+        if (defaultViewWidth >= limitViewWidth) {
+            w = limitViewWidth / scale;
         }
         else {
-            const limitViewWidth = width / 4;
-            const limitViewHeight = height / 4;
-            if (defaultViewWidth >= limitViewWidth) {
-                w = limitViewWidth / scale;
-            }
-            else {
-                w = defaultViewWidth / scale;
-            }
-            if (defaultViewHeight >= limitViewHeight) {
-                h = limitViewHeight / scale;
-            }
-            else {
-                h = defaultViewHeight / scale;
-            }
-            if (['circle', 'svg', 'image'].includes(type)) {
-                w = h = Math.max(w, h);
-            }
+            w = defaultViewWidth / scale;
+        }
+        if (defaultViewHeight >= limitViewHeight) {
+            h = limitViewHeight / scale;
+        }
+        else {
+            h = defaultViewHeight / scale;
+        }
+        if (['circle', 'svg', 'image'].includes(type)) {
+            w = h = Math.max(w, h);
+        }
+        else if (type === 'text') {
+            const fontSize = w / defaultText.length;
+            h = fontSize * 2;
         }
         x = (0 - offsetLeft + width / 2 - (w * scale) / 2) / scale;
         y = (0 - offsetTop + height / 2 - (h * scale) / 2) / scale;
@@ -50,18 +47,16 @@ function createElementSize(type, opts) {
     return elemSize;
 }
 export function createElement(type, baseElem, opts) {
-    const elemSize = createElementSize(type, opts);
+    const elementSize = createElementSize(type, opts);
     let detail = {};
     if (type === 'rect') {
         detail = getDefaultElementRectDetail();
     }
     else if (type === 'circle') {
-        detail = getDefaultElementCircleDetail({
-            radius: elemSize.w
-        });
+        detail = getDefaultElementCircleDetail();
     }
     else if (type === 'text') {
-        detail = getDefaultElementTextDetail(opts);
+        detail = getDefaultElementTextDetail(elementSize);
     }
     else if (type === 'svg') {
         detail = getDefaultElementSVGDetail();
@@ -72,7 +67,7 @@ export function createElement(type, baseElem, opts) {
     else if (type === 'group') {
         detail = getDefaultElementGroupDetail();
     }
-    const elem = Object.assign(Object.assign(Object.assign({}, elemSize), baseElem), { uuid: createUUID(), type, detail: Object.assign(Object.assign({}, detail), (baseElem.detail || {})) });
+    const elem = Object.assign(Object.assign(Object.assign({}, elementSize), baseElem), { uuid: createUUID(), type, detail: Object.assign(Object.assign({}, detail), (baseElem.detail || {})) });
     return elem;
 }
 export function insertElementToListByPosition(element, position, list) {
@@ -134,15 +129,16 @@ export function deleteElementInList(uuid, list) {
     return deleteElementInListByPosition(position, list);
 }
 export function moveElementPosition(elements, opts) {
-    const { from, to } = opts;
+    const from = [...opts.from];
+    const to = [...opts.to];
     if (from.length === 0 || to.length === 0) {
-        return elements;
+        return { elements, from, to };
     }
     if (from.length <= to.length) {
         for (let i = 0; i < from.length; i++) {
             if (to[i] === from[i]) {
                 if (i === from.length - 1) {
-                    return elements;
+                    return { elements, from, to };
                 }
                 continue;
             }
@@ -152,19 +148,64 @@ export function moveElementPosition(elements, opts) {
     if (target) {
         const insterResult = insertElementToListByPosition(target, to, elements);
         if (!insterResult) {
-            return elements;
+            return { elements, from, to };
         }
         let trimDeletePosIndex = -1;
         const trimDeletePosAction = 'down';
-        for (let i = 0; i < from.length; i++) {
-            if (!(to[i] >= 0)) {
-                break;
+        let isEffectToIndex = false;
+        if (from.length >= 1 && to.length >= 1) {
+            if (from.length <= to.length) {
+                if (from.length === 1) {
+                    if (from[0] < to[0]) {
+                        isEffectToIndex = true;
+                    }
+                }
+                else {
+                    for (let i = 0; i < from.length; i++) {
+                        if (from[i] === to[i]) {
+                            if (from.length === from.length - 1) {
+                                isEffectToIndex = true;
+                                break;
+                            }
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
             }
-            if (to[i] === from[i]) {
-                continue;
+            if (from.length >= to.length) {
+                if (to.length === 1) {
+                    if (to[0] < from[0]) {
+                        isEffectToIndex = true;
+                    }
+                }
+                else {
+                    for (let i = 0; i < to.length; i++) {
+                        if (i === to.length - 1 && to[i] < from[i]) {
+                            isEffectToIndex = true;
+                        }
+                        if (from[i] === to[i]) {
+                            continue;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
             }
-            if (to[i] < from[i] && i == to.length - 1) {
-                trimDeletePosIndex = i;
+        }
+        if (isEffectToIndex === true) {
+            for (let i = 0; i < from.length; i++) {
+                if (!(to[i] >= 0)) {
+                    break;
+                }
+                if (to[i] === from[i]) {
+                    continue;
+                }
+                if (to[i] < from[i] && i == to.length - 1) {
+                    trimDeletePosIndex = i;
+                }
             }
         }
         if (trimDeletePosIndex >= 0) {
@@ -174,7 +215,7 @@ export function moveElementPosition(elements, opts) {
         }
         deleteElementInListByPosition(from, elements);
     }
-    return elements;
+    return { elements, from, to };
 }
 function mergeElement(originElem, updateContent) {
     var _a;
@@ -209,18 +250,42 @@ function mergeElement(originElem, updateContent) {
     return originElem;
 }
 export function updateElementInList(uuid, updateContent, elements) {
-    var _a;
+    var _a, _b;
     let targetElement = null;
     for (let i = 0; i < elements.length; i++) {
         const elem = elements[i];
         if (elem.uuid === uuid) {
+            if (elem.type === 'group' && ((_a = elem.operations) === null || _a === void 0 ? void 0 : _a.deepResize) === true) {
+                if ((updateContent.w && updateContent.w > 0) || (updateContent.h && updateContent.h > 0)) {
+                    deepResizeGroupElement(elem, {
+                        w: updateContent.w,
+                        h: updateContent.h
+                    });
+                }
+            }
             mergeElement(elem, updateContent);
             targetElement = elem;
             break;
         }
         else if (elem.type === 'group') {
-            targetElement = updateElementInList(uuid, updateContent, ((_a = elem === null || elem === void 0 ? void 0 : elem.detail) === null || _a === void 0 ? void 0 : _a.children) || []);
+            targetElement = updateElementInList(uuid, updateContent, ((_b = elem === null || elem === void 0 ? void 0 : elem.detail) === null || _b === void 0 ? void 0 : _b.children) || []);
         }
     }
     return targetElement;
 }
+export function updateElementInListByPosition(position, updateContent, elements) {
+    var _a;
+    const elem = findElementFromListByPosition(position, elements);
+    if (elem) {
+        if (elem.type === 'group' && ((_a = elem.operations) === null || _a === void 0 ? void 0 : _a.deepResize) === true) {
+            if ((updateContent.w && updateContent.w > 0) || (updateContent.h && updateContent.h > 0)) {
+                deepResizeGroupElement(elem, {
+                    w: updateContent.w,
+                    h: updateContent.h
+                });
+            }
+        }
+        mergeElement(elem, updateContent);
+    }
+    return elem;
+}

package/dist/esm/lib/html.d.ts

@@ -1,3 +1,3 @@
 import { HTMLNode } from '@idraw/types';
 export declare function parseHTML(html: string): HTMLNode[];
-export declare function generateHTML(htmlNodes: HTMLNode[]): HTMLNode;
+export declare function generateHTML(htmlNodes: HTMLNode[]): string;

package/dist/esm/lib/istype.d.ts

@@ -4,6 +4,7 @@ export declare const istype: {
     json(data: any): boolean;
     function(data: any): boolean;
     asyncFunction(data: any): boolean;
+    boolean(data: any): boolean;
     string(data: any): boolean;
     number(data: any): boolean;
     undefined(data: any): boolean;

package/dist/esm/lib/istype.js

@@ -20,6 +20,9 @@ export const istype = {
     asyncFunction(data) {
         return parsePrototype(data) === 'AsyncFunction';
     },
+    boolean(data) {
+        return parsePrototype(data) === 'Boolean';
+    },
     string(data) {
         return parsePrototype(data) === 'String';
     },

package/dist/esm/lib/modify-recorder.d.ts

@@ -0,0 +1,15 @@
+import type { Data, ModifyType, ModifyOptions, ModifyRecord } from '@idraw/types';
+export interface ModifyRecorderOptions {
+    recordable: boolean;
+}
+export declare class ModifyRecorder {
+    #private;
+    constructor(opts: ModifyRecorderOptions);
+    $getDoStack(): ModifyRecord[];
+    $getUndoStack(): ModifyRecord[];
+    clear(): void;
+    destroy(): void;
+    do<T extends ModifyType>(data: Data, opts: ModifyOptions<T>): Data;
+    undo(data: Data): Data | null;
+    redo(data: Data): Data | null;
+}