@plait/core 0.0.13 → 0.0.17

package/fesm2015/plait-core.mjs

@@ -4,9 +4,9 @@ import produce, { createDraft, finishDraft, isDraft } from 'immer';
 import { Subject, fromEvent } from 'rxjs';
 import { takeUntil, filter } from 'rxjs/operators';
 import rough from 'roughjs/bin/rough';
+import { isKeyHotkey, isHotkey } from 'is-hotkey';
 import * as i2 from '@angular/common';
 import { BrowserModule } from '@angular/platform-browser';
-import { isKeyHotkey } from 'is-hotkey';
 
 // record richtext type status
 const FLUSHING = new WeakMap();
@@ -341,7 +341,8 @@ function setNode(board, props, path) {
     board.apply(operation);
 }
 function removeNode(board, path) {
-    const operation = { type: 'remove_node', path };
+    const node = PlaitNode.get(board, path);
+    const operation = { type: 'remove_node', path, node };
     board.apply(operation);
 }
 function moveNode(board, path, newPath) {
@@ -390,9 +391,16 @@ function createBoard(host, children, options) {
         },
         children,
         operations: [],
+        history: {
+            redos: [],
+            undos: []
+        },
         selection: null,
         cursor: BaseCursorStatus.select,
         readonly: options.readonly,
+        allowClearBoard: options.allowClearBoard,
+        undo: () => { },
+        redo: () => { },
         apply: (operation) => {
             board.operations.push(operation);
             Transforms.transform(board, operation);
@@ -533,8 +541,372 @@ function withSelection(board) {
 const isSetViewportOperation = (value) => {
     return value.type === 'set_viewport';
 };
+const inverse = (op) => {
+    switch (op.type) {
+        case 'insert_node': {
+            return Object.assign(Object.assign({}, op), { type: 'remove_node' });
+        }
+        case 'remove_node': {
+            return Object.assign(Object.assign({}, op), { type: 'insert_node' });
+        }
+        case 'move_node': {
+            const { newPath, path } = op;
+            // PERF: in this case the move operation is a no-op anyways.
+            if (Path.equals(newPath, path)) {
+                return op;
+            }
+            // If the move happens completely within a single parent the path and
+            // newPath are stable with respect to each other.
+            if (Path.isSibling(path, newPath)) {
+                return Object.assign(Object.assign({}, op), { path: newPath, newPath: path });
+            }
+            // If the move does not happen within a single parent it is possible
+            // for the move to impact the true path to the location where the node
+            // was removed from and where it was inserted. We have to adjust for this
+            // and find the original path. We can accomplish this (only in non-sibling)
+            // moves by looking at the impact of the move operation on the node
+            // after the original move path.
+            const inversePath = Path.transform(path, op);
+            const inverseNewPath = Path.transform(Path.next(path), op);
+            return Object.assign(Object.assign({}, op), { path: inversePath, newPath: inverseNewPath });
+        }
+        case 'set_node': {
+            const { properties, newProperties } = op;
+            return Object.assign(Object.assign({}, op), { properties: newProperties, newProperties: properties });
+        }
+        case 'set_selection': {
+            const { properties, newProperties } = op;
+            if (properties == null) {
+                return Object.assign(Object.assign({}, op), { properties: newProperties, newProperties: null });
+            }
+            else if (newProperties == null) {
+                return Object.assign(Object.assign({}, op), { properties: null, newProperties: properties });
+            }
+            else {
+                return Object.assign(Object.assign({}, op), { properties: newProperties, newProperties: properties });
+            }
+        }
+        case 'set_viewport': {
+            const { properties, newProperties } = op;
+            if (properties == null) {
+                return Object.assign(Object.assign({}, op), { properties: newProperties, newProperties: newProperties });
+            }
+            else if (newProperties == null) {
+                return Object.assign(Object.assign({}, op), { properties: properties, newProperties: properties });
+            }
+            else {
+                return Object.assign(Object.assign({}, op), { properties: newProperties, newProperties: properties });
+            }
+        }
+    }
+};
 const PlaitOperation = {
-    isSetViewportOperation
+    isSetViewportOperation,
+    inverse
+};
+
+const IS_IOS = typeof navigator !== 'undefined' &&
+    typeof window !== 'undefined' &&
+    /iPad|iPhone|iPod/.test(navigator.userAgent) &&
+    !window.MSStream;
+const IS_APPLE = typeof navigator !== 'undefined' && /Mac OS X/.test(navigator.userAgent);
+const IS_FIREFOX = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
+const IS_SAFARI = typeof navigator !== 'undefined' && /Version\/[\d\.]+.*Safari/.test(navigator.userAgent);
+// "modern" Edge was released at 79.x
+const IS_EDGE_LEGACY = typeof navigator !== 'undefined' && /Edge?\/(?:[0-6][0-9]|[0-7][0-8])/i.test(navigator.userAgent);
+const IS_CHROME = typeof navigator !== 'undefined' && /Chrome/i.test(navigator.userAgent);
+// Native beforeInput events don't work well with react on Chrome 75 and older, Chrome 76+ can use beforeInput
+const IS_CHROME_LEGACY = typeof navigator !== 'undefined' && /Chrome?\/(?:[0-7][0-5]|[0-6][0-9])/i.test(navigator.userAgent);
+
+/**
+ * Hotkey mappings for each platform.
+ */
+const HOTKEYS = {
+    bold: 'mod+b',
+    compose: ['down', 'left', 'right', 'up', 'backspace', 'enter'],
+    moveBackward: 'left',
+    moveForward: 'right',
+    moveUp: 'up',
+    moveDown: 'down',
+    moveWordBackward: 'ctrl+left',
+    moveWordForward: 'ctrl+right',
+    deleteBackward: 'shift?+backspace',
+    deleteForward: 'shift?+delete',
+    extendBackward: 'shift+left',
+    extendForward: 'shift+right',
+    italic: 'mod+i',
+    splitBlock: 'shift?+enter',
+    undo: 'mod+z'
+};
+const APPLE_HOTKEYS = {
+    moveLineBackward: 'opt+up',
+    moveLineForward: 'opt+down',
+    moveWordBackward: 'opt+left',
+    moveWordForward: 'opt+right',
+    deleteBackward: ['ctrl+backspace', 'ctrl+h'],
+    deleteForward: ['ctrl+delete', 'ctrl+d'],
+    deleteLineBackward: 'cmd+shift?+backspace',
+    deleteLineForward: ['cmd+shift?+delete', 'ctrl+k'],
+    deleteWordBackward: 'opt+shift?+backspace',
+    deleteWordForward: 'opt+shift?+delete',
+    extendLineBackward: 'opt+shift+up',
+    extendLineForward: 'opt+shift+down',
+    redo: 'cmd+shift+z',
+    transposeCharacter: 'ctrl+t'
+};
+const WINDOWS_HOTKEYS = {
+    deleteWordBackward: 'ctrl+shift?+backspace',
+    deleteWordForward: 'ctrl+shift?+delete',
+    redo: ['ctrl+y', 'ctrl+shift+z']
+};
+/**
+ * Create a platform-aware hotkey checker.
+ */
+const create = (key) => {
+    const generic = HOTKEYS[key];
+    const apple = APPLE_HOTKEYS[key];
+    const windows = WINDOWS_HOTKEYS[key];
+    const isGeneric = generic && isKeyHotkey(generic);
+    const isApple = apple && isKeyHotkey(apple);
+    const isWindows = windows && isKeyHotkey(windows);
+    return (event) => {
+        if (isGeneric && isGeneric(event)) {
+            return true;
+        }
+        if (IS_APPLE && isApple && isApple(event)) {
+            return true;
+        }
+        if (!IS_APPLE && isWindows && isWindows(event)) {
+            return true;
+        }
+        return false;
+    };
+};
+/**
+ * Hotkeys.
+ */
+const hotkeys = {
+    isBold: create('bold'),
+    isCompose: create('compose'),
+    isMoveBackward: create('moveBackward'),
+    isMoveForward: create('moveForward'),
+    isMoveUp: create('moveUp'),
+    isMoveDown: create('moveDown'),
+    isDeleteBackward: create('deleteBackward'),
+    isDeleteForward: create('deleteForward'),
+    isDeleteLineBackward: create('deleteLineBackward'),
+    isDeleteLineForward: create('deleteLineForward'),
+    isDeleteWordBackward: create('deleteWordBackward'),
+    isDeleteWordForward: create('deleteWordForward'),
+    isExtendBackward: create('extendBackward'),
+    isExtendForward: create('extendForward'),
+    isExtendLineBackward: create('extendLineBackward'),
+    isExtendLineForward: create('extendLineForward'),
+    isItalic: create('italic'),
+    isMoveLineBackward: create('moveLineBackward'),
+    isMoveLineForward: create('moveLineForward'),
+    isMoveWordBackward: create('moveWordBackward'),
+    isMoveWordForward: create('moveWordForward'),
+    isRedo: create('redo'),
+    isSplitBlock: create('splitBlock'),
+    isTransposeCharacter: create('transposeCharacter'),
+    isUndo: create('undo')
+};
+
+function idCreator(length = 5) {
+    // remove numeral
+    const $chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz'; /****默认去掉了容易混淆的字符oOLl,9gq,Vv,Uu,I1****/
+    const maxPosition = $chars.length;
+    let key = '';
+    for (let i = 0; i < length; i++) {
+        key += $chars.charAt(Math.floor(Math.random() * maxPosition));
+    }
+    return key;
+}
+
+// https://stackoverflow.com/a/6853926/232122
+function distanceBetweenPointAndSegment(x, y, x1, y1, x2, y2) {
+    const A = x - x1;
+    const B = y - y1;
+    const C = x2 - x1;
+    const D = y2 - y1;
+    const dot = A * C + B * D;
+    const lenSquare = C * C + D * D;
+    let param = -1;
+    if (lenSquare !== 0) {
+        // in case of 0 length line
+        param = dot / lenSquare;
+    }
+    let xx, yy;
+    if (param < 0) {
+        xx = x1;
+        yy = y1;
+    }
+    else if (param > 1) {
+        xx = x2;
+        yy = y2;
+    }
+    else {
+        xx = x1 + param * C;
+        yy = y1 + param * D;
+    }
+    const dx = x - xx;
+    const dy = y - yy;
+    return Math.hypot(dx, dy);
+}
+function rotate(x1, y1, x2, y2, angle) {
+    // 𝑎′𝑥=(𝑎𝑥−𝑐𝑥)cos𝜃−(𝑎𝑦−𝑐𝑦)sin𝜃+𝑐𝑥
+    // 𝑎′𝑦=(𝑎𝑥−𝑐𝑥)sin𝜃+(𝑎𝑦−𝑐𝑦)cos𝜃+𝑐𝑦.
+    // https://math.stackexchange.com/questions/2204520/how-do-i-rotate-a-line-segment-in-a-specific-point-on-the-line
+    return [(x1 - x2) * Math.cos(angle) - (y1 - y2) * Math.sin(angle) + x2, (x1 - x2) * Math.sin(angle) + (y1 - y2) * Math.cos(angle) + y2];
+}
+
+/**
+ * Check whether to merge an operation into the previous operation.
+ */
+const shouldMerge = (op, prev) => {
+    if (op.type === 'set_viewport') {
+        return true;
+    }
+    return false;
+};
+/**
+ * Check whether an operation needs to be saved to the history.
+ */
+const shouldSave = (op, prev) => {
+    if (op.type === 'set_selection') {
+        return false;
+    }
+    return true;
+};
+/**
+ * Check whether an operation should clear the redos stack.
+ */
+const shouldClear = (op) => {
+    if (op.type === 'set_selection') {
+        return false;
+    }
+    return true;
+};
+
+function withHistroy(board) {
+    const { apply, keydown } = board;
+    board.history = { undos: [], redos: [] };
+    board.redo = () => {
+        const { history } = board;
+        const { redos } = history;
+        if (redos.length > 0) {
+            const batch = redos[redos.length - 1];
+            PlaitHistoryBoard.withoutSaving(board, () => {
+                for (const op of batch) {
+                    board.apply(op);
+                }
+            });
+            history.redos.pop();
+            history.undos.push(batch);
+        }
+    };
+    board.undo = () => {
+        const { history } = board;
+        const { undos } = history;
+        if (undos.length > 0) {
+            const batch = undos[undos.length - 1];
+            PlaitHistoryBoard.withoutSaving(board, () => {
+                const inverseOps = batch.map(PlaitOperation.inverse).reverse();
+                for (const op of inverseOps) {
+                    board.apply(op);
+                }
+            });
+            history.redos.push(batch);
+            history.undos.pop();
+        }
+    };
+    board.apply = (op) => {
+        const { operations, history } = board;
+        const { undos } = history;
+        const lastBatch = undos[undos.length - 1];
+        const lastOp = lastBatch && lastBatch[lastBatch.length - 1];
+        let save = PlaitHistoryBoard.isSaving(board);
+        let merge = PlaitHistoryBoard.isMerging(board);
+        if (save == null) {
+            save = shouldSave(op, lastOp);
+        }
+        if (save) {
+            if (merge == null) {
+                if (lastBatch == null) {
+                    merge = false;
+                }
+                else if (operations.length !== 0) {
+                    merge = true;
+                }
+                else {
+                    merge = shouldMerge(op, lastOp);
+                }
+            }
+            if (lastBatch && merge) {
+                lastBatch.push(op);
+            }
+            else {
+                const batch = [op];
+                undos.push(batch);
+            }
+            while (undos.length > 100) {
+                undos.shift();
+            }
+            if (shouldClear(op)) {
+                history.redos = [];
+            }
+        }
+        apply(op);
+    };
+    board.keydown = (event) => {
+        if (isHotkey('mod+z', event)) {
+            board.undo();
+            return;
+        }
+        if (isHotkey('mod+shift+z', event)) {
+            board.redo();
+            return;
+        }
+        keydown(event);
+    };
+    return board;
+}
+const SAVING = new WeakMap();
+const MERGING = new WeakMap();
+const PlaitHistoryBoard = {
+    /**
+     * Get the saving flag's current value.
+     */
+    isSaving(board) {
+        return SAVING.get(board);
+    },
+    /**
+     * Get the merge flag's current value.
+     */
+    isMerging(board) {
+        return MERGING.get(board);
+    },
+    /**
+     * Apply a series of changes inside a synchronous `fn`, without merging any of
+     * the new operations into previous save point in the history.
+     */
+    withoutMerging(editor, fn) {
+        const prev = PlaitHistoryBoard.isMerging(editor);
+        MERGING.set(editor, false);
+        fn();
+        MERGING.set(editor, prev);
+    },
+    /**
+     * Apply a series of changes inside a synchronous `fn`, without saving any of
+     * their operations into the history.
+     */
+    withoutSaving(editor, fn) {
+        const prev = PlaitHistoryBoard.isSaving(editor);
+        SAVING.set(editor, false);
+        fn();
+        SAVING.set(editor, prev);
+    }
 };
 
 class PlaitElementComponent {
@@ -614,6 +986,7 @@ class PlaitBoardComponent {
         this.plaitValue = [];
         this.plaitPlugins = [];
         this.plaitReadonly = false;
+        this.plaitAllowClearBoard = false;
         this.plaitChange = new EventEmitter();
         this.plaitBoardInitialized = new EventEmitter();
         this.trackBy = (index, element) => {
@@ -652,8 +1025,8 @@ class PlaitBoardComponent {
         this.plaitBoardInitialized.emit(this.board);
     }
     initializePlugins() {
-        const options = { readonly: this.plaitReadonly };
-        let board = withSelection(withBoard(createBoard(this.host, this.plaitValue, options)));
+        const options = { readonly: this.plaitReadonly, allowClearBoard: this.plaitAllowClearBoard };
+        let board = withHistroy(withSelection(withBoard(createBoard(this.host, this.plaitValue, options))));
         this.plaitPlugins.forEach(plugin => {
             board = plugin(board);
         });
@@ -709,12 +1082,15 @@ class PlaitBoardComponent {
             (_a = this.board) === null || _a === void 0 ? void 0 : _a.keyup(event);
         });
         window.onresize = () => {
-            var _a;
-            const viewBoxModel = getViewBox(this.board);
-            const viewBoxValues = (_a = this.host.getAttribute('viewBox')) === null || _a === void 0 ? void 0 : _a.split(',');
-            this.renderer2.setAttribute(this.host, 'viewBox', `${viewBoxValues[0].trim()}, ${viewBoxValues[1].trim()}, ${viewBoxModel.width}, ${viewBoxModel.height}`);
+            this.refreshViewport();
         };
     }
+    refreshViewport() {
+        var _a;
+        const viewBoxModel = getViewBox(this.board);
+        const viewBoxValues = (_a = this.host.getAttribute('viewBox')) === null || _a === void 0 ? void 0 : _a.split(',');
+        this.renderer2.setAttribute(this.host, 'viewBox', `${viewBoxValues[0].trim()}, ${viewBoxValues[1].trim()}, ${viewBoxModel.width}, ${viewBoxModel.height}`);
+    }
     updateViewport() {
         this.zoom = Math.floor(this.board.viewport.zoom * 100);
         const viewBox = getViewBox(this.board);
@@ -744,7 +1120,7 @@ class PlaitBoardComponent {
     }
 }
 PlaitBoardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: PlaitBoardComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
-PlaitBoardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: PlaitBoardComponent, selector: "plait-board", inputs: { plaitValue: "plaitValue", plaitViewport: "plaitViewport", plaitPlugins: "plaitPlugins", plaitReadonly: "plaitReadonly" }, outputs: { plaitChange: "plaitChange", plaitBoardInitialized: "plaitBoardInitialized" }, host: { properties: { "class": "this.hostClass" } }, viewQueries: [{ propertyName: "svg", first: true, predicate: ["svg"], descendants: true, static: true }], ngImport: i0, template: `
+PlaitBoardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.11", type: PlaitBoardComponent, selector: "plait-board", inputs: { plaitValue: "plaitValue", plaitViewport: "plaitViewport", plaitPlugins: "plaitPlugins", plaitReadonly: "plaitReadonly", plaitAllowClearBoard: "plaitAllowClearBoard" }, outputs: { plaitChange: "plaitChange", plaitBoardInitialized: "plaitBoardInitialized" }, host: { properties: { "class": "this.hostClass" } }, viewQueries: [{ propertyName: "svg", first: true, predicate: ["svg"], descendants: true, static: true }], ngImport: i0, template: `
         <svg #svg width="100%" height="100%" style="position: relative"></svg>
         <div *ngIf="isFocused" class="plait-toolbar island zoom-toolbar plait-board-attached">
             <button class="item" (mousedown)="zoomOut($event)">-</button>
@@ -800,6 +1176,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                 type: Input
             }], plaitReadonly: [{
                 type: Input
+            }], plaitAllowClearBoard: [{
+                type: Input
             }], plaitChange: [{
                 type: Output
             }], plaitBoardInitialized: [{
@@ -820,162 +1198,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImpo
                 }]
         }] });
 
-const IS_IOS = typeof navigator !== 'undefined' &&
-    typeof window !== 'undefined' &&
-    /iPad|iPhone|iPod/.test(navigator.userAgent) &&
-    !window.MSStream;
-const IS_APPLE = typeof navigator !== 'undefined' && /Mac OS X/.test(navigator.userAgent);
-const IS_FIREFOX = typeof navigator !== 'undefined' && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
-const IS_SAFARI = typeof navigator !== 'undefined' && /Version\/[\d\.]+.*Safari/.test(navigator.userAgent);
-// "modern" Edge was released at 79.x
-const IS_EDGE_LEGACY = typeof navigator !== 'undefined' && /Edge?\/(?:[0-6][0-9]|[0-7][0-8])/i.test(navigator.userAgent);
-const IS_CHROME = typeof navigator !== 'undefined' && /Chrome/i.test(navigator.userAgent);
-// Native beforeInput events don't work well with react on Chrome 75 and older, Chrome 76+ can use beforeInput
-const IS_CHROME_LEGACY = typeof navigator !== 'undefined' && /Chrome?\/(?:[0-7][0-5]|[0-6][0-9])/i.test(navigator.userAgent);
-
-/**
- * Hotkey mappings for each platform.
- */
-const HOTKEYS = {
-    bold: 'mod+b',
-    compose: ['down', 'left', 'right', 'up', 'backspace', 'enter'],
-    moveBackward: 'left',
-    moveForward: 'right',
-    moveUp: 'up',
-    moveDown: 'down',
-    moveWordBackward: 'ctrl+left',
-    moveWordForward: 'ctrl+right',
-    deleteBackward: 'shift?+backspace',
-    deleteForward: 'shift?+delete',
-    extendBackward: 'shift+left',
-    extendForward: 'shift+right',
-    italic: 'mod+i',
-    splitBlock: 'shift?+enter',
-    undo: 'mod+z'
-};
-const APPLE_HOTKEYS = {
-    moveLineBackward: 'opt+up',
-    moveLineForward: 'opt+down',
-    moveWordBackward: 'opt+left',
-    moveWordForward: 'opt+right',
-    deleteBackward: ['ctrl+backspace', 'ctrl+h'],
-    deleteForward: ['ctrl+delete', 'ctrl+d'],
-    deleteLineBackward: 'cmd+shift?+backspace',
-    deleteLineForward: ['cmd+shift?+delete', 'ctrl+k'],
-    deleteWordBackward: 'opt+shift?+backspace',
-    deleteWordForward: 'opt+shift?+delete',
-    extendLineBackward: 'opt+shift+up',
-    extendLineForward: 'opt+shift+down',
-    redo: 'cmd+shift+z',
-    transposeCharacter: 'ctrl+t'
-};
-const WINDOWS_HOTKEYS = {
-    deleteWordBackward: 'ctrl+shift?+backspace',
-    deleteWordForward: 'ctrl+shift?+delete',
-    redo: ['ctrl+y', 'ctrl+shift+z']
-};
-/**
- * Create a platform-aware hotkey checker.
- */
-const create = (key) => {
-    const generic = HOTKEYS[key];
-    const apple = APPLE_HOTKEYS[key];
-    const windows = WINDOWS_HOTKEYS[key];
-    const isGeneric = generic && isKeyHotkey(generic);
-    const isApple = apple && isKeyHotkey(apple);
-    const isWindows = windows && isKeyHotkey(windows);
-    return (event) => {
-        if (isGeneric && isGeneric(event)) {
-            return true;
-        }
-        if (IS_APPLE && isApple && isApple(event)) {
-            return true;
-        }
-        if (!IS_APPLE && isWindows && isWindows(event)) {
-            return true;
-        }
-        return false;
-    };
-};
-/**
- * Hotkeys.
- */
-const hotkeys = {
-    isBold: create('bold'),
-    isCompose: create('compose'),
-    isMoveBackward: create('moveBackward'),
-    isMoveForward: create('moveForward'),
-    isMoveUp: create('moveUp'),
-    isMoveDown: create('moveDown'),
-    isDeleteBackward: create('deleteBackward'),
-    isDeleteForward: create('deleteForward'),
-    isDeleteLineBackward: create('deleteLineBackward'),
-    isDeleteLineForward: create('deleteLineForward'),
-    isDeleteWordBackward: create('deleteWordBackward'),
-    isDeleteWordForward: create('deleteWordForward'),
-    isExtendBackward: create('extendBackward'),
-    isExtendForward: create('extendForward'),
-    isExtendLineBackward: create('extendLineBackward'),
-    isExtendLineForward: create('extendLineForward'),
-    isItalic: create('italic'),
-    isMoveLineBackward: create('moveLineBackward'),
-    isMoveLineForward: create('moveLineForward'),
-    isMoveWordBackward: create('moveWordBackward'),
-    isMoveWordForward: create('moveWordForward'),
-    isRedo: create('redo'),
-    isSplitBlock: create('splitBlock'),
-    isTransposeCharacter: create('transposeCharacter'),
-    isUndo: create('undo')
-};
-
-function idCreator(length = 5) {
-    // remove numeral
-    const $chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz'; /****默认去掉了容易混淆的字符oOLl,9gq,Vv,Uu,I1****/
-    const maxPosition = $chars.length;
-    let key = '';
-    for (let i = 0; i < length; i++) {
-        key += $chars.charAt(Math.floor(Math.random() * maxPosition));
-    }
-    return key;
-}
-
-// https://stackoverflow.com/a/6853926/232122
-function distanceBetweenPointAndSegment(x, y, x1, y1, x2, y2) {
-    const A = x - x1;
-    const B = y - y1;
-    const C = x2 - x1;
-    const D = y2 - y1;
-    const dot = A * C + B * D;
-    const lenSquare = C * C + D * D;
-    let param = -1;
-    if (lenSquare !== 0) {
-        // in case of 0 length line
-        param = dot / lenSquare;
-    }
-    let xx, yy;
-    if (param < 0) {
-        xx = x1;
-        yy = y1;
-    }
-    else if (param > 1) {
-        xx = x2;
-        yy = y2;
-    }
-    else {
-        xx = x1 + param * C;
-        yy = y1 + param * D;
-    }
-    const dx = x - xx;
-    const dy = y - yy;
-    return Math.hypot(dx, dy);
-}
-function rotate(x1, y1, x2, y2, angle) {
-    // 𝑎′𝑥=(𝑎𝑥−𝑐𝑥)cos𝜃−(𝑎𝑦−𝑐𝑦)sin𝜃+𝑐𝑥
-    // 𝑎′𝑦=(𝑎𝑥−𝑐𝑥)sin𝜃+(𝑎𝑦−𝑐𝑦)cos𝜃+𝑐𝑦.
-    // https://math.stackexchange.com/questions/2204520/how-do-i-rotate-a-line-segment-in-a-specific-point-on-the-line
-    return [(x1 - x2) * Math.cos(angle) - (y1 - y2) * Math.sin(angle) + x2, (x1 - x2) * Math.sin(angle) + (y1 - y2) * Math.cos(angle) + y2];
-}
-
 /*
  * Public API Surface of plait
  */
@@ -984,5 +1206,5 @@ function rotate(x1, y1, x2, y2, angle) {
  * Generated bundle index. Do not edit.
  */
 
-export { BOARD_TO_ON_CHANGE, BaseCursorStatus, FLUSHING, HOST_TO_ROUGH_SVG, IS_APPLE, IS_CHROME, IS_CHROME_LEGACY, IS_EDGE_LEGACY, IS_FIREFOX, IS_IOS, IS_SAFARI, IS_TEXT_EDITABLE, NS, Path, PlaitBoardComponent, PlaitElementComponent, PlaitModule, PlaitNode, PlaitOperation, Transforms, Viewport, createG, createSVG, createText, distanceBetweenPointAndSegment, getViewBox, hotkeys, idCreator, isNoSelectionElement, isNullOrUndefined, isSetViewportOperation, rotate, toPoint, toRectangleClient, transformPoint, transformPoints };
+export { BOARD_TO_ON_CHANGE, BaseCursorStatus, FLUSHING, HOST_TO_ROUGH_SVG, IS_APPLE, IS_CHROME, IS_CHROME_LEGACY, IS_EDGE_LEGACY, IS_FIREFOX, IS_IOS, IS_SAFARI, IS_TEXT_EDITABLE, NS, Path, PlaitBoardComponent, PlaitElementComponent, PlaitModule, PlaitNode, PlaitOperation, Transforms, Viewport, createG, createSVG, createText, distanceBetweenPointAndSegment, getViewBox, hotkeys, idCreator, inverse, isNoSelectionElement, isNullOrUndefined, isSetViewportOperation, rotate, shouldClear, shouldMerge, shouldSave, toPoint, toRectangleClient, transformPoint, transformPoints };
 //# sourceMappingURL=plait-core.mjs.map