edytor 0.0.6 → 0.0.8

package/dist/hotkeys.js

@@ -0,0 +1,282 @@
+import { Text } from './text/text.svelte.js';
+import { prevent, PreventionError } from './utils.js';
+import { Block } from './block/block.svelte.js';
+import { tick } from 'svelte';
+const letter = new Set([
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z'
+]);
+const escapedKeys = new Set(['shift']);
+const defaultHotKeys = {
+    'mod+z': ({ edytor }) => {
+        prevent(() => {
+            edytor.undoManager.undo();
+        });
+    },
+    'mod+shift+z': ({ edytor, prevent }) => {
+        prevent(() => {
+            edytor.undoManager.redo();
+        });
+    },
+    'mod+enter': ({ edytor, prevent }) => {
+        prevent(() => {
+            const newBlock = edytor.selection.state.startText?.parent.splitBlock({
+                index: edytor.selection.state.startText?.yText.length,
+                text: edytor.selection.state.startText
+            });
+            if (newBlock && newBlock.content[0] instanceof Text) {
+                newBlock && edytor.selection.setAtTextOffset(newBlock.content[0], newBlock.content.length);
+            }
+        });
+    },
+    'mod+a': ({ edytor, prevent }) => {
+        prevent(() => {
+            const { startText, startBlock, islandRoot, isVoid, isIsland, voidRoot } = edytor.selection.state;
+            if (startText) {
+                if (edytor.selection.selectedBlocks.size) {
+                    edytor.selection.selectBlocks(...edytor.root.children);
+                }
+                else if (edytor.selection.state.isAtStartOfBlock &&
+                    edytor.selection.state.isAtEndOfBlock) {
+                    window.getSelection()?.removeAllRanges();
+                    edytor.selection.selectBlocks(edytor.selection.state.isIsland ? islandRoot : startText.parent);
+                }
+                else {
+                    edytor.selection.setAtBlockRange(startBlock);
+                }
+            }
+        });
+    },
+    arrowup: ({ edytor, prevent }) => {
+        const selectedBlocks = edytor.selection.selectedBlocks;
+        if (selectedBlocks.size === 1) {
+            prevent(() => {
+                const selectedBlock = selectedBlocks.values().next().value;
+                let prevBlock = selectedBlock.closestPreviousBlock;
+                // If the block is inside an island, we will select the island root
+                while (prevBlock?.insideIsland) {
+                    if (prevBlock.parent instanceof Block) {
+                        prevBlock = prevBlock.parent;
+                    }
+                }
+                if (prevBlock && prevBlock instanceof Block) {
+                    edytor.selection.selectBlocks(prevBlock);
+                    edytor.selection.focusBlocks();
+                }
+            });
+        }
+    },
+    arrowdown: ({ edytor, prevent }) => {
+        const selectedBlocks = edytor.selection.selectedBlocks;
+        if (selectedBlocks.size === 1) {
+            prevent(() => {
+                const selectedBlock = selectedBlocks.values().next().value;
+                let nextBlock = selectedBlock.definition.island
+                    ? selectedBlock.nextBlock
+                    : selectedBlock.closestNextBlock;
+                if (nextBlock && nextBlock instanceof Block) {
+                    edytor.selection.selectBlocks(nextBlock);
+                    edytor.selection.focusBlocks();
+                }
+            });
+        }
+    },
+    tab: ({ edytor, prevent }) => {
+        prevent(() => {
+            const selectedBlocks = edytor.selection.selectedBlocks;
+            if (selectedBlocks.size <= 1) {
+                const selectedBlock = selectedBlocks.values().next().value;
+                const { yStart, startText, startBlock } = edytor.selection.state;
+                const blockToNest = selectedBlock || startBlock;
+                const newBlock = blockToNest?.nestBlock();
+                const index = startText?.index;
+                if (selectedBlock) {
+                    tick().then(() => {
+                        newBlock && edytor.selection.selectBlocks(newBlock);
+                    });
+                }
+                else {
+                    if (newBlock && index !== undefined) {
+                        const textToFocus = newBlock.content[index];
+                        edytor.selection.setAtTextOffset(textToFocus, yStart);
+                    }
+                }
+            }
+        });
+    },
+    escape: ({ edytor, prevent }) => {
+        if (edytor.selection.selectedBlocks.size > 0) {
+            prevent(() => {
+                const firstSelectedBlock = edytor.selection.selectedBlocks.values().next().value;
+                edytor.selection.selectBlocks();
+                if (firstSelectedBlock.firstEditableText) {
+                    edytor.selection.setAtTextOffset(firstSelectedBlock.firstEditableText, firstSelectedBlock.firstEditableText.yText.length);
+                }
+            });
+        }
+    },
+    backspace: ({ edytor, prevent }) => {
+        if (edytor.selection.selectedBlocks.size) {
+            const selectedBlock = edytor.selection.selectedBlocks.values().next().value;
+            const isNested = selectedBlock.parent !== edytor.root;
+            const isLastChild = selectedBlock.parent?.children.at(-1) === selectedBlock;
+            if (isNested && isLastChild) {
+                const newBlock = selectedBlock.unNestBlock();
+                if (newBlock) {
+                    setTimeout(() => {
+                        edytor.selection.selectBlocks(newBlock);
+                    });
+                    return;
+                }
+            }
+            const selectedBlocks = Array.from(edytor.selection.selectedBlocks.values());
+            edytor.edytor.plugins.forEach((plugin) => {
+                plugin.onDeleteSelectedBlocks?.({ prevent, selectedBlocks });
+            });
+            const firstSelectedBlock = selectedBlocks.at(0);
+            const lastSelectedBlock = selectedBlocks.at(-1);
+            const blockToFocus = firstSelectedBlock.closestPreviousBlock || lastSelectedBlock.closestNextBlock;
+            edytor.edytor.transact(() => {
+                edytor.selection.selectedBlocks.forEach((block) => {
+                    block.removeBlock();
+                });
+            });
+            if (blockToFocus) {
+                setTimeout(() => {
+                    edytor.edytor.node?.focus();
+                    edytor.selection.setAtTextOffset(blockToFocus.firstEditableText, blockToFocus.firstEditableText?.yText.length);
+                });
+            }
+        }
+    }
+};
+// Features:
+// Case insensitive hotkeys
+// Modifier keys in any order
+// Hotkeys can prevent execution of subsequent hotkeys and therefore allow for overriding default hotkeys
+// Mod to match modifier cmd on mac or ctrl on windows
+export class HotKeys {
+    edytor;
+    userHotKeys;
+    plugins;
+    hotkeys = new Map();
+    get isMac() {
+        return typeof window != 'undefined' && /Mac|iPod|iPhone|iPad/.test(window.navigator.platform);
+    }
+    constructor(edytor, userHotKeys = {}, plugins = []) {
+        this.edytor = edytor;
+        this.userHotKeys = userHotKeys;
+        this.plugins = plugins;
+    }
+    init = () => {
+        if (typeof window === 'undefined')
+            return;
+        // User hotkeys > plugins hotkeys > default hotkeys
+        const entries = [
+            this.userHotKeys || {},
+            ...this.plugins.map((plugin) => plugin.hotkeys || {}),
+            defaultHotKeys
+        ];
+        entries.forEach((hotKeys) => {
+            Object.entries(hotKeys).forEach(([key, func]) => {
+                const normalizedKey = this.normalizeKey(key);
+                if (this.hotkeys.has(normalizedKey)) {
+                    this.hotkeys.get(normalizedKey).push(func);
+                }
+                else {
+                    this.hotkeys.set(this.normalizeKey(key), [func]);
+                }
+            });
+        });
+    };
+    normalizeKey = (key) => {
+        const parts = key.toLowerCase().split('+');
+        const orderedParts = [];
+        // Add modifiers in the correct order
+        if (parts.includes('mod'))
+            orderedParts.push('mod');
+        if (parts.includes('alt'))
+            orderedParts.push('alt');
+        if (parts.includes('ctrl'))
+            orderedParts.push('ctrl');
+        if (parts.includes('shift'))
+            orderedParts.push('shift');
+        // Add remaining keys that aren't modifiers
+        parts.forEach((part) => {
+            if (!['mod', 'alt', 'ctrl', 'shift'].includes(part)) {
+                orderedParts.push(part);
+            }
+        });
+        return orderedParts.join('+');
+    };
+    combination = (e) => {
+        const key = e.key.toLowerCase();
+        let combination = '';
+        // Is modifier
+        if (e.ctrlKey || e.metaKey) {
+            combination += 'mod+';
+        }
+        // Is alt
+        if (e.altKey) {
+            combination += 'alt+';
+        }
+        // Is ctrl
+        if (e.ctrlKey && !e.metaKey) {
+            combination += 'ctrl+';
+        }
+        // Is shift
+        if (e.shiftKey) {
+            combination += 'shift+';
+        }
+        if (!escapedKeys.has(key)) {
+            combination += key;
+        }
+        // Remove trailing plus if it exists
+        combination = combination.replace(/\+$/, '');
+        return combination;
+    };
+    isHotkey = (e) => {
+        const combination = this.combination(e);
+        const hotKeys = this.hotkeys.get(combination);
+        if (!hotKeys?.length)
+            return false;
+        try {
+            hotKeys.forEach((hotKey) => {
+                hotKey({ event: e, edytor: this.edytor, prevent });
+            });
+            return false;
+        }
+        catch (error) {
+            if (error instanceof PreventionError) {
+                e.preventDefault();
+                e.stopPropagation();
+                error.cb?.();
+            }
+            return true;
+        }
+    };
+}

package/dist/index.d.ts

@@ -1,5 +1 @@
-export * from "./events";
-export * from "./operations";
-export * from "./utils";
-export * from "./types";
-export * from "./yjs";
+export {};

package/dist/index.js

@@ -1,8 +1,2 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./edytor.cjs.production.min.js')
-} else {
-  module.exports = require('./edytor.cjs.development.js')
-}
+"use strict";
+// Reexport your entry components here

package/dist/localProvider.d.ts

@@ -0,0 +1,82 @@
+import * as Y from 'yjs';
+import { ObservableV2 } from 'lib0/observable';
+import * as awarenessProtocol from 'y-protocols/awareness';
+export declare const PREFERRED_TRIM_SIZE = 500;
+type IdbPersistence = {
+    db: IDBDatabase | null;
+    doc: Y.Doc;
+    _dbref: number;
+    _dbsize: number;
+    _destroyed: boolean;
+};
+/**
+ * @param {IndexeddbPersistence} idbPersistence
+ * @param {function(IDBObjectStore):void} [beforeApplyUpdatesCallback]
+ * @param {function(IDBObjectStore):void} [afterApplyUpdatesCallback]
+ */
+export declare const fetchUpdates: (idbPersistence: IdbPersistence, beforeApplyUpdatesCallback?: (store: IDBObjectStore) => void, afterApplyUpdatesCallback?: (store: IDBObjectStore) => void) => Promise<IDBObjectStore>;
+/**
+ * @param {IndexeddbPersistence} idbPersistence
+ * @param {boolean} forceStore
+ */
+export declare const storeState: (idbPersistence: IdbPersistence, forceStore?: boolean) => Promise<void>;
+/**
+ * @param {string} name
+ */
+export declare const clearDocument: (name: string) => Promise<any>;
+/**
+ * @extends Observable<string>
+ */
+export declare class IndexeddbPersistence extends ObservableV2<{
+    synced: (provider: IndexeddbPersistence) => void;
+}> {
+    doc: Y.Doc;
+    name: string;
+    _dbref: number;
+    _dbsize: number;
+    _destroyed: boolean;
+    db: IDBDatabase | null;
+    synced: boolean;
+    _db: Promise<IDBDatabase>;
+    whenSynced: Promise<IndexeddbPersistence>;
+    _storeTimeout: number;
+    _storeTimeoutId: number | null;
+    _storeUpdate: (update: Uint8Array, origin: any) => void;
+    awareness: awarenessProtocol.Awareness;
+    bcconnected: boolean;
+    private _bcSubscriber;
+    private _awarenessUpdateHandler;
+    /**
+     * @param {string} name
+     * @param {Y.Doc} doc
+     */
+    constructor(name: string, doc: Y.Doc);
+    private messageHandlers;
+    private readMessage;
+    private broadcastMessage;
+    private connectBc;
+    private disconnectBc;
+    /**
+     * Destroys this instance and removes all data from indexeddb.
+     *
+     * @return {Promise<void>}
+     */
+    destroy(): Promise<void>;
+    /**
+     * @param {String | number | ArrayBuffer | Date} key
+     * @return {Promise<String | number | ArrayBuffer | Date | any>}
+     */
+    get(key: string | number | ArrayBuffer | Date): Promise<string | number | any[] | ArrayBuffer | Date>;
+    /**
+     * @param {String | number | ArrayBuffer | Date} key
+     * @param {String | number | ArrayBuffer | Date} value
+     * @return {Promise<String | number | ArrayBuffer | Date>}
+     */
+    set(key: string | number | ArrayBuffer | Date, value: string | number | ArrayBuffer | Date): Promise<any>;
+    /**
+     * @param {String | number | ArrayBuffer | Date} key
+     * @return {Promise<undefined>}
+     */
+    del(key: string | number | ArrayBuffer | Date): Promise<any>;
+}
+export {};

package/dist/localProvider.js

@@ -0,0 +1,267 @@
+import * as Y from 'yjs';
+import * as idb from 'lib0/indexeddb';
+import * as promise from 'lib0/promise';
+import { ObservableV2 } from 'lib0/observable';
+import * as bc from 'lib0/broadcastchannel';
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+import * as syncProtocol from 'y-protocols/sync';
+import * as awarenessProtocol from 'y-protocols/awareness';
+const customStoreName = 'custom';
+const updatesStoreName = 'updates';
+const messageSync = 0;
+const messageQueryAwareness = 3;
+const messageAwareness = 1;
+export const PREFERRED_TRIM_SIZE = 500;
+/**
+ * @param {IndexeddbPersistence} idbPersistence
+ * @param {function(IDBObjectStore):void} [beforeApplyUpdatesCallback]
+ * @param {function(IDBObjectStore):void} [afterApplyUpdatesCallback]
+ */
+export const fetchUpdates = (idbPersistence, beforeApplyUpdatesCallback = () => { }, afterApplyUpdatesCallback = () => { }) => {
+    const [updatesStore] = idb.transact(idbPersistence.db, [updatesStoreName]);
+    return idb
+        .getAll(updatesStore, idb.createIDBKeyRangeLowerBound(idbPersistence._dbref, false))
+        .then((updates) => {
+        if (!idbPersistence._destroyed) {
+            beforeApplyUpdatesCallback(updatesStore);
+            Y.transact(idbPersistence.doc, () => {
+                updates.forEach((val) => Y.applyUpdate(idbPersistence.doc, val));
+            }, idbPersistence, false);
+            afterApplyUpdatesCallback(updatesStore);
+        }
+    })
+        .then(() => idb.getLastKey(updatesStore).then((lastKey) => {
+        idbPersistence._dbref = lastKey + 1;
+    }))
+        .then(() => idb.count(updatesStore).then((cnt) => {
+        idbPersistence._dbsize = cnt;
+    }))
+        .then(() => updatesStore);
+};
+/**
+ * @param {IndexeddbPersistence} idbPersistence
+ * @param {boolean} forceStore
+ */
+export const storeState = (idbPersistence, forceStore = true) => fetchUpdates(idbPersistence).then((updatesStore) => {
+    if (forceStore || idbPersistence._dbsize >= PREFERRED_TRIM_SIZE) {
+        idb
+            .addAutoKey(updatesStore, Y.encodeStateAsUpdate(idbPersistence.doc))
+            .then(() => idb.del(updatesStore, idb.createIDBKeyRangeUpperBound(idbPersistence._dbref, true)))
+            .then(() => idb.count(updatesStore).then((cnt) => {
+            idbPersistence._dbsize = cnt;
+        }));
+    }
+});
+/**
+ * @param {string} name
+ */
+export const clearDocument = (name) => idb.deleteDB(name);
+/**
+ * @extends Observable<string>
+ */
+export class IndexeddbPersistence extends ObservableV2 {
+    doc;
+    name;
+    _dbref;
+    _dbsize;
+    _destroyed;
+    db;
+    synced;
+    _db;
+    whenSynced;
+    _storeTimeout;
+    _storeTimeoutId;
+    _storeUpdate;
+    awareness;
+    bcconnected = false;
+    _bcSubscriber;
+    _awarenessUpdateHandler;
+    /**
+     * @param {string} name
+     * @param {Y.Doc} doc
+     */
+    constructor(name, doc) {
+        super();
+        this.doc = doc;
+        this.name = name;
+        this._dbref = 0;
+        this._dbsize = 0;
+        this._destroyed = false;
+        this.db = null;
+        this.synced = false;
+        this.awareness = new awarenessProtocol.Awareness(doc);
+        this._db = idb.openDB(name, (db) => idb.createStores(db, [['updates', { autoIncrement: true }], ['custom']]));
+        this.whenSynced = promise.create((resolve) => this.on('synced', () => resolve(this)));
+        this._bcSubscriber = (data, origin) => {
+            if (origin !== this) {
+                const encoder = this.readMessage(new Uint8Array(data), false);
+                if (encoding.length(encoder) > 1) {
+                    bc.publish(this.name, encoding.toUint8Array(encoder), this);
+                }
+            }
+        };
+        this._awarenessUpdateHandler = ({ added, updated, removed }, _origin) => {
+            const changedClients = added.concat(updated).concat(removed);
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageAwareness);
+            encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, changedClients));
+            this.broadcastMessage(encoding.toUint8Array(encoder));
+        };
+        this._db.then((db) => {
+            this.db = db;
+            const beforeApplyUpdatesCallback = (updatesStore) => idb.addAutoKey(updatesStore, Y.encodeStateAsUpdate(doc));
+            const afterApplyUpdatesCallback = () => {
+                if (this._destroyed)
+                    return this;
+                this.connectBc();
+            };
+            fetchUpdates(this, beforeApplyUpdatesCallback, afterApplyUpdatesCallback);
+        });
+        this._storeTimeout = 1000;
+        this._storeTimeoutId = null;
+        this._storeUpdate = (update, origin) => {
+            if (this.db && origin !== this) {
+                const [updatesStore] = idb.transact(this.db, [updatesStoreName]);
+                idb.addAutoKey(updatesStore, update);
+                if (++this._dbsize >= PREFERRED_TRIM_SIZE) {
+                    if (this._storeTimeoutId !== null) {
+                        clearTimeout(this._storeTimeoutId);
+                    }
+                    this._storeTimeoutId = setTimeout(() => {
+                        storeState(this, false);
+                        this._storeTimeoutId = null;
+                    }, this._storeTimeout);
+                }
+            }
+            // Broadcast the update to other tabs
+            if (origin !== this) {
+                const encoder = encoding.createEncoder();
+                encoding.writeVarUint(encoder, messageSync);
+                syncProtocol.writeUpdate(encoder, update);
+                this.broadcastMessage(encoding.toUint8Array(encoder));
+            }
+        };
+        doc.on('update', this._storeUpdate);
+        this.awareness.on('update', this._awarenessUpdateHandler);
+        this.destroy = this.destroy.bind(this);
+        doc.on('destroy', this.destroy);
+        globalThis.addEventListener('beforeunload', () => this.destroy());
+    }
+    messageHandlers = {
+        [messageSync]: (encoder, decoder, provider, _emitSynced) => {
+            encoding.writeVarUint(encoder, messageSync);
+            const syncMessageType = syncProtocol.readSyncMessage(decoder, encoder, provider.doc, provider);
+            if (syncMessageType === syncProtocol.messageYjsSyncStep2 && !provider.synced) {
+                //
+            }
+        },
+        [messageQueryAwareness]: (encoder, _decoder, provider) => {
+            encoding.writeVarUint(encoder, messageAwareness);
+            encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(provider.awareness, Array.from(provider.awareness.getStates().keys())));
+        },
+        [messageAwareness]: (_encoder, decoder, provider) => {
+            awarenessProtocol.applyAwarenessUpdate(provider.awareness, decoding.readVarUint8Array(decoder), provider);
+        }
+    };
+    readMessage = (buf, emitSynced) => {
+        const decoder = decoding.createDecoder(buf);
+        const encoder = encoding.createEncoder();
+        const messageType = decoding.readVarUint(decoder);
+        const messageHandler = this.messageHandlers[messageType];
+        if (messageHandler) {
+            messageHandler(encoder, decoder, this, emitSynced);
+        }
+        return encoder;
+    };
+    broadcastMessage(buf) {
+        if (this.bcconnected) {
+            bc.publish(this.name, buf, this);
+        }
+    }
+    connectBc() {
+        if (!this.bcconnected) {
+            bc.subscribe(this.name, this._bcSubscriber);
+            this.bcconnected = true;
+        }
+        // Sync initial state
+        const encoderSync = encoding.createEncoder();
+        encoding.writeVarUint(encoderSync, messageSync);
+        syncProtocol.writeSyncStep1(encoderSync, this.doc);
+        bc.publish(this.name, encoding.toUint8Array(encoderSync), this);
+        const encoderState = encoding.createEncoder();
+        encoding.writeVarUint(encoderState, messageSync);
+        syncProtocol.writeSyncStep2(encoderState, this.doc);
+        bc.publish(this.name, encoding.toUint8Array(encoderState), this);
+        // Sync awareness state
+        const encoderAwarenessQuery = encoding.createEncoder();
+        encoding.writeVarUint(encoderAwarenessQuery, messageQueryAwareness);
+        bc.publish(this.name, encoding.toUint8Array(encoderAwarenessQuery), this);
+        const encoderAwarenessState = encoding.createEncoder();
+        encoding.writeVarUint(encoderAwarenessState, messageAwareness);
+        encoding.writeVarUint8Array(encoderAwarenessState, awarenessProtocol.encodeAwarenessUpdate(this.awareness, [this.doc.clientID]));
+        bc.publish(this.name, encoding.toUint8Array(encoderAwarenessState), this);
+        this.synced = true;
+        this.emit('synced', [this]);
+    }
+    disconnectBc() {
+        // Notify other clients about disconnection
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, messageAwareness);
+        encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.awareness, [this.doc.clientID], new Map()));
+        this.broadcastMessage(encoding.toUint8Array(encoder));
+        if (this.bcconnected) {
+            bc.unsubscribe(this.name, this._bcSubscriber);
+            this.bcconnected = false;
+        }
+    }
+    /**
+     * Destroys this instance and removes all data from indexeddb.
+     *
+     * @return {Promise<void>}
+     */
+    destroy() {
+        if (this._storeTimeoutId) {
+            clearTimeout(this._storeTimeoutId);
+        }
+        this.doc.off('update', this._storeUpdate);
+        this.doc.off('destroy', this.destroy);
+        this.awareness.off('update', this._awarenessUpdateHandler);
+        this._destroyed = true;
+        this.disconnectBc();
+        return this._db.then((db) => {
+            db.close();
+        });
+    }
+    /**
+     * @param {String | number | ArrayBuffer | Date} key
+     * @return {Promise<String | number | ArrayBuffer | Date | any>}
+     */
+    get(key) {
+        return this._db.then((db) => {
+            const [custom] = idb.transact(db, [customStoreName], 'readonly');
+            return idb.get(custom, key);
+        });
+    }
+    /**
+     * @param {String | number | ArrayBuffer | Date} key
+     * @param {String | number | ArrayBuffer | Date} value
+     * @return {Promise<String | number | ArrayBuffer | Date>}
+     */
+    set(key, value) {
+        return this._db.then((db) => {
+            const [custom] = idb.transact(db, [customStoreName]);
+            return idb.put(custom, value, key);
+        });
+    }
+    /**
+     * @param {String | number | ArrayBuffer | Date} key
+     * @return {Promise<undefined>}
+     */
+    del(key) {
+        return this._db.then((db) => {
+            const [custom] = idb.transact(db, [customStoreName]);
+            return idb.del(custom, key);
+        });
+    }
+}

package/dist/plugins/arrowMove/arrowMove.d.ts

@@ -0,0 +1,2 @@
+import { type Plugin } from '../../plugins.js';
+export declare const arrowMovePlugin: Plugin;