@sciflow/editor-start 0.0.3 → 0.1.1

package/dist/lib/read-only.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @module read-only
+ *
+ * A generic, toggleable read-only `Feature`: vetoes every doc-changing
+ * transaction while leaving selection/scroll transactions free to pass (so
+ * browsing — clicking around, selecting text to read it — still works),
+ * disables the DOM's own `contenteditable`/caret/IME behavior, and marks the
+ * editable surface with a styling hook so consumers can render a muted look.
+ *
+ * # Mechanism
+ *
+ * - `filterTransaction: (tr, state) => !tr.docChanged || isExternalSyncTransaction(tr) || key.getState(state) !== true`
+ *   — `EditorState.applyTransaction` checks this BEFORE running any plugin's
+ *   `state.apply`, so a vetoed transaction never reaches the doc, the
+ *   undo-history plugin, or anything else — the state comes back byte-for-
+ *   byte unchanged (`newState === oldState`). Selection-only and meta-only
+ *   transactions (`tr.docChanged === false` — e.g. a click, or another
+ *   feature's own `dispatchMeta` update) are explicitly let through, and so
+ *   is `Editor`'s own external-doc reconciliation transaction (see the
+ *   "Programmatic doc replacement" section below) — only an actual user/
+ *   command edit is vetoed.
+ * - `props.editable: (state) => key.getState(state) !== true` — the DOM-level
+ *   backstop: disables `contenteditable`, so the browser's own caret/IME
+ *   never engages in the first place. `filterTransaction` alone would still
+ *   technically block an edit, but a live caret sitting in "dead" text reads
+ *   as broken, not read-only.
+ * - `props.attributes: (state) => (key.getState(state) ? { 'data-readonly': 'true' } : {})`
+ *   — the styling hook. No baked-in colors here (only a `data-readonly`
+ *   attribute) — style the muted look with your own token-based CSS, e.g.
+ *   `.sf-editable-surface .ProseMirror[data-readonly] { opacity: var(--sf-opacity-muted); }`.
+ *
+ * # Programmatic doc replacement still works while read-only
+ *
+ * "Read-only" means "the user cannot edit this document" — not "this
+ * document can never change from any source." A host that reassigns
+ * `editor.doc` (e.g. a revision viewer paging through history) drives
+ * `Editor.updateFromSync()`, which reconciles the mounted view via its own
+ * transaction (`Editor`'s internal `syncViewWithState()`), tagged with
+ * `EXTERNAL_SYNC_TRANSACTION_META`. `filterTransaction` lets THAT transaction
+ * through even while read-only, so the view keeps rendering every
+ * subsequent doc the host assigns; only a transaction WITHOUT that meta
+ * (a real edit) is vetoed. See `@sciflow/editor-core`'s
+ * `EXTERNAL_SYNC_TRANSACTION_META`/`isExternalSyncTransaction` doc for the
+ * full contract — any custom read-only-style `filterTransaction` should
+ * follow the same check, or it will "freeze" the editor's own
+ * `updateFromSync()` calls after the first doc assignment, not just block
+ * user typing.
+ *
+ * # Toggling without re-initializing the editor
+ *
+ * The read-only flag lives in PLUGIN STATE (keyed, like `range-decorations.ts`,
+ * so it survives every transaction via a plain `state.apply`), not a value
+ * captured once at feature-construction time — `filterTransaction`/`editable`/
+ * `attributes` all read the CURRENT state on every check. This means the
+ * flag genuinely toggles live, no `configureFeatures()`/re-mount needed:
+ *
+ * ```typescript
+ * import { createReadOnlyFeature } from '@sciflow/editor-start/bundle';
+ *
+ * const { feature, key } = createReadOnlyFeature('my-read-only');
+ * await editor.configureFeatures([...otherFeatures, feature]);
+ *
+ * editor.plugins.dispatchMeta(key, true);   // now read-only
+ * editor.plugins.dispatchMeta(key, false);  // editable again, same editor instance
+ * ```
+ *
+ * # A caveat worth stating plainly, not silently
+ *
+ * `filterTransaction` guarantees the DOC never actually changes for a
+ * vetoed transaction, but a host's own `dispatchTransaction` handler that
+ * inspects the REJECTED transaction object directly (rather than comparing
+ * before/after state) can still be misled: `tr.docChanged` reflects what the
+ * transaction WOULD have done, not whether it was applied. A consumer
+ * wiring up its own change-tracking on a read-only editor should compare
+ * `newState !== oldState` (or `newState.doc.eq(oldState.doc)`) rather than
+ * trusting `tr.docChanged` alone. `@sciflow/editor-core`'s own
+ * `handleTransaction` does inspect `tr.docChanged` directly — this is a
+ * known, narrow gap for the (unusual) case of listening to `editor-change`
+ * on a read-only instance, not something this feature can close from a
+ * plugin alone. Not a concern for the ordinary "browse a read-view editor,
+ * nobody listens to its `editor-change`" case.
+ */
+import { PluginKey } from 'prosemirror-state';
+import { type Feature } from '@sciflow/editor-core';
+/**
+ * Build a fresh, independently-keyed read-only `Feature`. `initialReadOnly`
+ * sets the STARTING value (default `false` — editable, matching an ordinary
+ * editor's least-surprising default); flip it live afterward via
+ * `editor.plugins.dispatchMeta(key, true | false)`.
+ */
+export declare function createReadOnlyFeature(name: string, initialReadOnly?: boolean): {
+    feature: Feature;
+    key: PluginKey<boolean>;
+};
+//# sourceMappingURL=read-only.d.ts.map

package/dist/lib/read-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-only.d.ts","sourceRoot":"","sources":["../../src/lib/read-only.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiFG;AAEH,OAAO,EAAU,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAA6B,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/E;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,eAAe,UAAQ,GACtB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;CAAE,CAiC/C"}

package/dist/lib/read-only.js

@@ -0,0 +1,123 @@
+/**
+ * @module read-only
+ *
+ * A generic, toggleable read-only `Feature`: vetoes every doc-changing
+ * transaction while leaving selection/scroll transactions free to pass (so
+ * browsing — clicking around, selecting text to read it — still works),
+ * disables the DOM's own `contenteditable`/caret/IME behavior, and marks the
+ * editable surface with a styling hook so consumers can render a muted look.
+ *
+ * # Mechanism
+ *
+ * - `filterTransaction: (tr, state) => !tr.docChanged || isExternalSyncTransaction(tr) || key.getState(state) !== true`
+ *   — `EditorState.applyTransaction` checks this BEFORE running any plugin's
+ *   `state.apply`, so a vetoed transaction never reaches the doc, the
+ *   undo-history plugin, or anything else — the state comes back byte-for-
+ *   byte unchanged (`newState === oldState`). Selection-only and meta-only
+ *   transactions (`tr.docChanged === false` — e.g. a click, or another
+ *   feature's own `dispatchMeta` update) are explicitly let through, and so
+ *   is `Editor`'s own external-doc reconciliation transaction (see the
+ *   "Programmatic doc replacement" section below) — only an actual user/
+ *   command edit is vetoed.
+ * - `props.editable: (state) => key.getState(state) !== true` — the DOM-level
+ *   backstop: disables `contenteditable`, so the browser's own caret/IME
+ *   never engages in the first place. `filterTransaction` alone would still
+ *   technically block an edit, but a live caret sitting in "dead" text reads
+ *   as broken, not read-only.
+ * - `props.attributes: (state) => (key.getState(state) ? { 'data-readonly': 'true' } : {})`
+ *   — the styling hook. No baked-in colors here (only a `data-readonly`
+ *   attribute) — style the muted look with your own token-based CSS, e.g.
+ *   `.sf-editable-surface .ProseMirror[data-readonly] { opacity: var(--sf-opacity-muted); }`.
+ *
+ * # Programmatic doc replacement still works while read-only
+ *
+ * "Read-only" means "the user cannot edit this document" — not "this
+ * document can never change from any source." A host that reassigns
+ * `editor.doc` (e.g. a revision viewer paging through history) drives
+ * `Editor.updateFromSync()`, which reconciles the mounted view via its own
+ * transaction (`Editor`'s internal `syncViewWithState()`), tagged with
+ * `EXTERNAL_SYNC_TRANSACTION_META`. `filterTransaction` lets THAT transaction
+ * through even while read-only, so the view keeps rendering every
+ * subsequent doc the host assigns; only a transaction WITHOUT that meta
+ * (a real edit) is vetoed. See `@sciflow/editor-core`'s
+ * `EXTERNAL_SYNC_TRANSACTION_META`/`isExternalSyncTransaction` doc for the
+ * full contract — any custom read-only-style `filterTransaction` should
+ * follow the same check, or it will "freeze" the editor's own
+ * `updateFromSync()` calls after the first doc assignment, not just block
+ * user typing.
+ *
+ * # Toggling without re-initializing the editor
+ *
+ * The read-only flag lives in PLUGIN STATE (keyed, like `range-decorations.ts`,
+ * so it survives every transaction via a plain `state.apply`), not a value
+ * captured once at feature-construction time — `filterTransaction`/`editable`/
+ * `attributes` all read the CURRENT state on every check. This means the
+ * flag genuinely toggles live, no `configureFeatures()`/re-mount needed:
+ *
+ * ```typescript
+ * import { createReadOnlyFeature } from '@sciflow/editor-start/bundle';
+ *
+ * const { feature, key } = createReadOnlyFeature('my-read-only');
+ * await editor.configureFeatures([...otherFeatures, feature]);
+ *
+ * editor.plugins.dispatchMeta(key, true);   // now read-only
+ * editor.plugins.dispatchMeta(key, false);  // editable again, same editor instance
+ * ```
+ *
+ * # A caveat worth stating plainly, not silently
+ *
+ * `filterTransaction` guarantees the DOC never actually changes for a
+ * vetoed transaction, but a host's own `dispatchTransaction` handler that
+ * inspects the REJECTED transaction object directly (rather than comparing
+ * before/after state) can still be misled: `tr.docChanged` reflects what the
+ * transaction WOULD have done, not whether it was applied. A consumer
+ * wiring up its own change-tracking on a read-only editor should compare
+ * `newState !== oldState` (or `newState.doc.eq(oldState.doc)`) rather than
+ * trusting `tr.docChanged` alone. `@sciflow/editor-core`'s own
+ * `handleTransaction` does inspect `tr.docChanged` directly — this is a
+ * known, narrow gap for the (unusual) case of listening to `editor-change`
+ * on a read-only instance, not something this feature can close from a
+ * plugin alone. Not a concern for the ordinary "browse a read-view editor,
+ * nobody listens to its `editor-change`" case.
+ */
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { isExternalSyncTransaction } from '@sciflow/editor-core';
+/**
+ * Build a fresh, independently-keyed read-only `Feature`. `initialReadOnly`
+ * sets the STARTING value (default `false` — editable, matching an ordinary
+ * editor's least-surprising default); flip it live afterward via
+ * `editor.plugins.dispatchMeta(key, true | false)`.
+ */
+export function createReadOnlyFeature(name, initialReadOnly = false) {
+    const key = new PluginKey(name);
+    const plugin = new Plugin({
+        key,
+        state: {
+            init: () => initialReadOnly,
+            apply(tr, readOnly) {
+                const meta = tr.getMeta(key);
+                return typeof meta === 'boolean' ? meta : readOnly;
+            },
+        },
+        filterTransaction(tr, state) {
+            if (!tr.docChanged)
+                return true;
+            // The editor's OWN external-doc reconciliation (Editor.updateFromSync /
+            // .applyOps, via syncViewWithState) — not a user edit. Letting it
+            // through is what makes `editor.doc = nextSnapshot` keep rendering on a
+            // read-only instance after the first assignment; see the module doc.
+            if (isExternalSyncTransaction(tr))
+                return true;
+            return key.getState(state) !== true;
+        },
+        props: {
+            editable: (state) => key.getState(state) !== true,
+            attributes: (state) => (key.getState(state) ? { 'data-readonly': 'true' } : {}),
+        },
+    });
+    const feature = {
+        name,
+        addPlugins: () => [plugin],
+    };
+    return { feature, key };
+}

package/dist/lib/selection-editor.d.ts

@@ -96,9 +96,39 @@ export declare class SciFlowSelectionEditorElement extends LitElement {
     /** Convenience getter mirroring `editor.getCommands()`. */
     private getCommandRunner;
     /**
-     * Render a single attribute field, decoding known encoded values for readability.
+     * Whether the bound editor currently accepts edits. Every path in this panel
+     * that writes to the document asks first, and fails closed when there is no
+     * view to ask.
+     *
+     * A host can turn editing off at any time
+     * (`view.setProps({ editable: () => false })`) and expects the whole surface
+     * to go quiet — a side panel that still writes would make a read-only
+     * document change under the reader. `view.editable` is the same signal the
+     * editor's own key and click handling reads, so the panel cannot drift from
+     * the editing surface. The guards sit on the write itself rather than only on
+     * the controls: the panel re-renders on selection changes, so editability can
+     * flip while a button from the editable render is still on screen.
      */
+    private isEditorEditable;
+    /**
+     * The panel's own name for a node type in the active locale, or `null` when it
+     * has none. Cased for use inside a sentence, so callers that need a heading
+     * capitalise it themselves — English writes these names lower case, German
+     * capitalises every noun, and only the dictionary knows which.
+     */
+    private getNodeTypeName;
     private getNodeTypeLabel;
+    /**
+     * The node this panel is currently describing, read back from the live
+     * document, or `null` when the panel is describing a mark or nothing at all.
+     */
+    private getSelectedNode;
+    /**
+     * A table is a `figure` whose first child is a `table` rather than an image,
+     * so the content is what tells a reader which one is selected — the node type
+     * is `figure` either way.
+     */
+    private isTableFigure;
     private renderAttributeField;
     /**
      * Convert a raw attribute name like 'text-align' to a human-readable label.
@@ -119,7 +149,18 @@ export declare class SciFlowSelectionEditorElement extends LitElement {
     private unmountCitationSourceAdapter;
     private handleDraftAttrChange;
     /**
-     * Render the figure sidebar: type, id, alt text.
+     * Render the figure sidebar: type, image address, alt text.
+     *
+     * The image address is editable here because this panel is the only place a
+     * reader can change it: clicking an image selects the figure rather than
+     * opening a picker, so the address has to be reachable as an ordinary field.
+     * It is a plain text input, so a URL, a relative path or a data URI are all
+     * accepted; the value is written on `change` like every other draft attribute
+     * and committed with Apply.
+     *
+     * A table is a `figure` too, so the heading and the form's accessible name
+     * both come from the selected node rather than from the node type alone —
+     * otherwise a selected table would be titled "Figure".
      */
     private renderFigureSidebar;
     /**
@@ -155,8 +196,68 @@ export declare class SciFlowSelectionEditorElement extends LitElement {
     private setDraftAttr;
     private applyDraftAttrs;
     private revertDraftAttrs;
+    /**
+     * Apply/Revert for pending attribute edits.
+     *
+     * Withheld when the editor is not editable: `applyDraftAttrs` refuses to write
+     * either way — that guard is the barrier — but offering an Apply that cannot
+     * act reads as a broken control rather than a read-only document.
+     */
     private renderDraftActions;
+    /**
+     * Controls that act on the selection itself rather than on its attributes.
+     *
+     * The delete action sits here, at the top of the panel, deliberately far from
+     * the Apply/Update primary at the bottom: a destructive verb never shares a
+     * region with the action a user is aiming for. It is a plain `<button>` with
+     * visible text, so it is keyboard reachable and its accessible name is the
+     * label itself. Removal is undoable through editor history, so it commits
+     * straight away rather than opening a confirmation step.
+     */
     private renderSelectionControls;
+    /**
+     * The node the delete action would remove, or `null` when there is none the
+     * panel may act on.
+     *
+     * Only a `NodeSelection` qualifies: a text range inside a caption or paragraph
+     * belongs to the editing surface, not to a panel-level "delete this element"
+     * verb. `deleteSelection` is probed with `dispatch` omitted, so the check
+     * cannot edit the document.
+     *
+     * A view that is not editable never yields a target. A host can turn editing
+     * off at any time (`view.setProps({ editable: () => false })`) and expects the
+     * whole surface to go quiet — a side panel that still removes content would
+     * make a read-only document lose it. `view.editable` is the same signal the
+     * editor's own key and click handling reads, so the panel cannot drift from
+     * the editing surface.
+     *
+     * Withheld while the panel is pinned, and that is a limitation rather than a
+     * design goal. A pinned panel stops following the editor selection and
+     * therefore stops re-rendering, while `elementInfo.position` is never remapped
+     * through the transaction mapping — so every pinned control already acts on a
+     * position that may have drifted, and the attribute fields cope only because
+     * they re-check the node type at that position before writing. Removal has no
+     * such recheck available: after one deletion the frozen panel would still show
+     * the control, now aimed at whatever moved into that position. Making the pin
+     * remap its stored position on every document change would fix this for all
+     * pinned controls at once; until then the destructive one stays out.
+     */
+    private getDeletableNode;
+    /**
+     * Label for the delete action, naming what is about to be removed. The visible
+     * text is the button's accessible name, so naming the node here keeps the two
+     * identical — no `aria-label` to drift from what is on screen. Anything the
+     * panel has no name for falls back to the generic wording.
+     */
+    private getDeleteLabel;
+    /**
+     * Remove the selected node through ProseMirror's own deletion command, so the
+     * change is a normal transaction and stays undoable and collab-safe. The state
+     * is read from the view at call time rather than reused from render, and the
+     * editability guard is repeated here: a host can switch the view to read-only
+     * after the button was rendered, and the rendered panel would not know.
+     */
+    private deleteSelectedNode;
     private togglePinSelection;
     private handleGenericKeydown;
     /**

package/dist/lib/selection-editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection-editor.d.ts","sourceRoot":"","sources":["../../src/lib/selection-editor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAa,UAAU,EAAa,MAAM,KAAK,CAAC;AAcvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,8BAA8B,CAAC;AAGtC,OAAO,4BAA4B,CAAC;AAWpC;;;;;;;;GAQG;AACH,qBACa,6BAA8B,SAAQ,UAAU;IAC3D,oFAAoF;IAEpF,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IAE3C,gEAAgE;IAEhE,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,uFAAuF;IAEvF,qBAAqB,EAAE,2BAA2B,GAAG,IAAI,CAAQ;IAGjE,OAAO,CAAC,WAAW,CAAqB;IAExC,uGAAuG;IAEvG,OAAO,CAAC,SAAS,CAA4E;IAE7F,gGAAgG;IAEhG,OAAO,CAAC,iBAAiB,CAAwD;IAEjF,oFAAoF;IAEpF,OAAO,CAAC,aAAa,CAAkE;IAEvF,6EAA6E;IAE7E,OAAO,CAAC,mBAAmB,CAAkD;IAE7E,wDAAwD;IAExD,OAAO,CAAC,cAAc,CAAiC;IAGvD,OAAO,CAAC,UAAU,CAAuD;IAGzE,OAAO,CAAC,UAAU,CAAS;IAG3B,OAAO,CAAC,YAAY,CAAS;IAG7B,OAAO,CAAC,YAAY,CAAS;IAE7B,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,iBAAiB,CAAC,CAAgB;IAC1C,OAAO,CAAC,aAAa,CAAC,CAAgB;IACtC,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,kBAAkB,CAA0B;IACpD,OAAO,CAAC,uBAAuB,CAA4B;IAC3D,OAAO,CAAC,oBAAoB,CAA4B;IACxD,OAAO,CAAC,mBAAmB,CAA8C;IACzE,OAAO,CAAC,8BAA8B,CAA4B;IAClE,OAAO,CAAC,mBAAmB,CAA2B;IACtD,OAAO,CAAC,6BAA6B,CAAuB;IAC5D,OAAO,CAAC,iBAAiB,CAA8C;IACvE,OAAO,CAAC,cAAc,CAAC,CAAgB;IACvC,OAAO,CAAC,4BAA4B,CAAgC;IACpE,OAAO,CAAC,yBAAyB,CAA6C;IAE9E,OAAgB,MAAM,0BAAyC;IAEtD,iBAAiB,IAAI,IAAI;IAczB,oBAAoB,IAAI,IAAI;IAgB5B,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;cA8G9D,MAAM;IAkIzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA2C9B,OAAO,CAAC,aAAa;IAmBrB,+DAA+D;IAC/D,OAAO,CAAC,qBAAqB;IAc7B,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA2LzB,6FAA6F;IAC7F,OAAO,CAAC,0BAA0B;IAKlC,+FAA+F;IAC/F,OAAO,CAAC,8BAA8B;IAKtC,+DAA+D;IAC/D,OAAO,CAAC,eAAe;IAsBvB,wFAAwF;IACxF,OAAO,CAAC,sBAAsB;IAK9B,gFAAgF;IAChF,OAAO,CAAC,WAAW;IAsBnB,0FAA0F;IAC1F,OAAO,CAAC,uBAAuB;IA+B/B,OAAO,CAAC,0BAA0B;IASlC,OAAO,CAAC,0BAA0B;IAmClC,2DAA2D;IAC3D,OAAO,CAAC,gBAAgB;IAIxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,oBAAoB;IAiD5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAiB9B;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IA+BlC;;OAEG;IACH,OAAO,CAAC,4BAA4B;IASpC,OAAO,CAAC,qBAAqB;IAyB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAuB3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAuGzB,OAAO,CAAC,mBAAmB;IAU3B,OAAO,CAAC,cAAc;IA+BtB,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,iBAAiB;IAUzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAuD7B,OAAO,CAAC,kBAAkB;IA6B1B,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;IACH,OAAO,CAAC,2BAA2B;IA8DnC,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,2BAA2B;IAOnC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA6C9B,OAAO,CAAC,mBAAmB;IAwC3B,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,eAAe;IAKvB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,eAAe;IAsBvB,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,kBAAkB;IAyB1B,OAAO,CAAC,uBAAuB;IAe/B,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,oBAAoB;IAU5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAmB1B;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,0BAA0B,EAAE,6BAA6B,CAAC;KAC3D;CACF"}
+{"version":3,"file":"selection-editor.d.ts","sourceRoot":"","sources":["../../src/lib/selection-editor.ts"],"names":[],"mappings":"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"}