@sciflow/editor-start 0.0.1-beta

package/dist/lib/format-bar.d.ts

@@ -0,0 +1,98 @@
+/**
+ * @module format-bar
+ *
+ * Developer overview:
+ * --------------------
+ * `SciFlowFormatBarElement` is the companion toolbar for `sciflow-editor`.
+ * It demonstrates how to consume the command runner exposed by the editor
+ * host and how to keep UI state in sync with selection changes.
+ *
+ * Re-implementing the toolbar in another framework largely boils down to:
+ *
+ *   1. Call `editor.getCommands()` to obtain the command runner.
+ *   2. Query `runner.available()` to enable/disable buttons.
+ *   3. Use `runner.flow()` to compose multi-step command sequences.
+ *   4. Listen to editor events (selection, ready) to refresh the toolbar UI.
+ *
+ * The component code below is annotated to map those steps to specific hooks.
+ */
+import { LitElement } from 'lit';
+import type { SciFlowEditorElement } from './editor-element.js';
+/**
+ * Custom element that renders the demo formatting toolbar.
+ *
+ * Responsibilities:
+ * - resolve the nearest `sciflow-editor` instance (or accept one via property)
+ * - enable/disable controls according to `runner.available()` responses
+ * - execute commands using either the immediate API or flow pipelines
+ * - surface an image insertion shortcut that exercises the feature command
+ *
+ * The Lit code mirrors the logic you would implement with other component
+ * frameworks—bind to editor events, keep local state, call commands on click.
+ */
+export declare class SciFlowFormatBarElement extends LitElement {
+    /** Reference to the editor element. May be passed directly via property binding. */
+    editor: SciFlowEditorElement | null;
+    /** ID reference to resolve an editor instance declaratively. */
+    for?: string;
+    private selectionVersion;
+    private resolvedEditor;
+    private selectionListener?;
+    private readyListener?;
+    private themeUnsub?;
+    private themeStyleElements;
+    static styles: import("lit").CSSResult;
+    /** Subscribe to editor events once the toolbar attaches to the DOM. */
+    connectedCallback(): void;
+    /** Remove listeners when the toolbar is detached. */
+    disconnectedCallback(): void;
+    /**
+     * Watch for changes to the `editor`/`for` bindings and reconnect accordingly.
+     * Other frameworks can perform the same logic in an effect hook.
+     */
+    protected updated(changed: Map<string | number | symbol, unknown>): void;
+    /**
+     * Render the toolbar. Commands are discovered dynamically through the
+     * command runner so the UI stays in sync with the currently loaded features.
+     */
+    protected render(): import("lit-html").TemplateResult<1>;
+    /**
+     * Find the target editor element and attach listeners for selection changes.
+     * This mirrors the wiring a framework component would perform in `useEffect`.
+     */
+    private resolveEditorReference;
+    private resolveEditor;
+    /** Clean up listeners attached to the last editor instance. */
+    private detachEditorListeners;
+    /** Convenience getter mirroring `editor.getCommands()`. */
+    private getCommandRunner;
+    /** Interpret the block-style dropdown and trigger the relevant commands. */
+    private handleStyleChange;
+    /** Apply a specific heading level after ensuring the editor can handle it. */
+    private handleSetHeading;
+    /** Reset the current block back to a paragraph. */
+    private handleSetParagraph;
+    /** Determine which block style is currently active for the selection. */
+    private getActiveBlockStyle;
+    /** Check if a style option can be executed against the current editor state. */
+    private canUseStyleOption;
+    /**
+     * Render a set of command buttons that share the same metadata group.
+     * Groups are sorted by each command's declared order so feature authors control layout.
+     */
+    private renderCommandGroup;
+    /**
+     * Render a single command button, wiring up availability checks and active state handling.
+     */
+    private renderCommandButton;
+    /**
+     * Determine which groups should be displayed and in which order based on command metadata.
+     */
+    private getCommandGroups;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sciflow-formatbar': SciFlowFormatBarElement;
+    }
+}
+//# sourceMappingURL=format-bar.d.ts.map

package/dist/lib/format-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-bar.d.ts","sourceRoot":"","sources":["../../src/lib/format-bar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAa,UAAU,EAAa,MAAM,KAAK,CAAC;AAKvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAoBhE;;;;;;;;;;;GAWG;AACH,qBACa,uBAAwB,SAAQ,UAAU;IACrD,oFAAoF;IAEpF,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IAE3C,gEAAgE;IAEhE,GAAG,CAAC,EAAE,MAAM,CAAC;IAGb,OAAO,CAAC,gBAAgB,CAAK;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;IAEpD,OAAgB,MAAM,0BAAmC;IAEzD,uEAAuE;IAC9D,iBAAiB,IAAI,IAAI;IAYlC,qDAAqD;IAC5C,oBAAoB,IAAI,IAAI;IAOrC;;;OAGG;cACgB,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAMjF;;;OAGG;cACgB,MAAM;IAiDzB;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA+B9B,OAAO,CAAC,aAAa;IAkBrB,+DAA+D;IAC/D,OAAO,CAAC,qBAAqB;IAc7B,2DAA2D;IAC3D,OAAO,CAAC,gBAAgB;IAIxB,4EAA4E;IAC5E,OAAO,CAAC,iBAAiB;IAiBzB,8EAA8E;IAC9E,OAAO,CAAC,gBAAgB;IA6BxB,mDAAmD;IACnD,OAAO,CAAC,kBAAkB;IA6B1B,yEAAyE;IACzE,OAAO,CAAC,mBAAmB;IA6C3B,gFAAgF;IAChF,OAAO,CAAC,iBAAiB;IAmBzB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAuC3B;;OAEG;IACH,OAAO,CAAC,gBAAgB;CA2BzB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,mBAAmB,EAAE,uBAAuB,CAAC;KAC9C;CACF"}

package/dist/lib/format-bar.js

@@ -0,0 +1,401 @@
+import { __decorate } from "tslib";
+/**
+ * @module format-bar
+ *
+ * Developer overview:
+ * --------------------
+ * `SciFlowFormatBarElement` is the companion toolbar for `sciflow-editor`.
+ * It demonstrates how to consume the command runner exposed by the editor
+ * host and how to keep UI state in sync with selection changes.
+ *
+ * Re-implementing the toolbar in another framework largely boils down to:
+ *
+ *   1. Call `editor.getCommands()` to obtain the command runner.
+ *   2. Query `runner.available()` to enable/disable buttons.
+ *   3. Use `runner.flow()` to compose multi-step command sequences.
+ *   4. Listen to editor events (selection, ready) to refresh the toolbar UI.
+ *
+ * The component code below is annotated to map those steps to specific hooks.
+ */
+import { css, html, LitElement, unsafeCSS } from 'lit';
+import { customElement, property, state } from 'lit/decorators.js';
+import { classMap } from 'lit/directives/class-map.js';
+import formatBarCss from './format-bar.css?inline';
+import { applyThemeStylesToRoot, subscribeToSciFlowTheme } from './theme.js';
+const STYLE_OPTIONS = [
+    { label: 'Paragraph', value: 'paragraph' },
+    { label: 'Heading 1', value: 'heading-1', level: 1 },
+    { label: 'Heading 2', value: 'heading-2', level: 2 },
+    { label: 'Heading 3', value: 'heading-3', level: 3 },
+];
+/**
+ * Custom element that renders the demo formatting toolbar.
+ *
+ * Responsibilities:
+ * - resolve the nearest `sciflow-editor` instance (or accept one via property)
+ * - enable/disable controls according to `runner.available()` responses
+ * - execute commands using either the immediate API or flow pipelines
+ * - surface an image insertion shortcut that exercises the feature command
+ *
+ * The Lit code mirrors the logic you would implement with other component
+ * frameworks—bind to editor events, keep local state, call commands on click.
+ */
+let SciFlowFormatBarElement = class SciFlowFormatBarElement extends LitElement {
+    constructor() {
+        super(...arguments);
+        /** Reference to the editor element. May be passed directly via property binding. */
+        this.editor = null;
+        this.selectionVersion = 0;
+        this.resolvedEditor = null;
+        this.themeStyleElements = [];
+    }
+    static { this.styles = css `${unsafeCSS(formatBarCss)}`; }
+    /** Subscribe to editor events once the toolbar attaches to the DOM. */
+    connectedCallback() {
+        super.connectedCallback();
+        this.themeUnsub = subscribeToSciFlowTheme((cssTexts) => {
+            this.themeStyleElements = applyThemeStylesToRoot(this.renderRoot, this.themeStyleElements, cssTexts);
+        });
+        this.resolveEditorReference();
+    }
+    /** Remove listeners when the toolbar is detached. */
+    disconnectedCallback() {
+        this.detachEditorListeners();
+        this.themeUnsub?.();
+        this.themeUnsub = undefined;
+        super.disconnectedCallback();
+    }
+    /**
+     * Watch for changes to the `editor`/`for` bindings and reconnect accordingly.
+     * Other frameworks can perform the same logic in an effect hook.
+     */
+    updated(changed) {
+        if (changed.has('for') || changed.has('editor')) {
+            this.resolveEditorReference();
+        }
+    }
+    /**
+     * Render the toolbar. Commands are discovered dynamically through the
+     * command runner so the UI stays in sync with the currently loaded features.
+     */
+    render() {
+        const runner = this.getCommandRunner();
+        const availableCommands = runner?.available?.() ?? null;
+        const headingCommandsAvailable = typeof availableCommands?.setHeading === 'function' || typeof availableCommands?.setParagraph === 'function';
+        const activeStyle = this.getActiveBlockStyle();
+        const selectDisabled = !runner || !headingCommandsAvailable;
+        const commandMetadata = runner?.commandsMeta?.() ?? {};
+        const commandGroups = this.getCommandGroups(commandMetadata);
+        const tableGroup = 'table';
+        const primaryGroups = commandGroups.filter((group) => group !== tableGroup);
+        const tableGroups = commandGroups.filter((group) => group === tableGroup);
+        return html `
+      <select
+        class="style-select"
+        aria-label="Text style"
+        .value=${activeStyle}
+        ?disabled=${selectDisabled}
+        @change=${this.handleStyleChange}
+      >
+        ${STYLE_OPTIONS.map((option) => html `
+            <option
+              value=${option.value}
+              ?selected=${option.value === activeStyle}
+              ?disabled=${!this.canUseStyleOption(option, availableCommands)}
+            >
+              ${option.label}
+            </option>
+          `)}
+      </select>
+      <div class="command-rows">
+        ${primaryGroups.length
+            ? html `<div class="command-row">
+              ${primaryGroups.map((group) => this.renderCommandGroup(runner, commandMetadata, group))}
+            </div>`
+            : null}
+        ${tableGroups.length
+            ? html `<div class="command-row table-row">
+              ${tableGroups.map((group) => this.renderCommandGroup(runner, commandMetadata, group))}
+            </div>`
+            : null}
+      </div>
+    `;
+    }
+    /**
+     * Find the target editor element and attach listeners for selection changes.
+     * This mirrors the wiring a framework component would perform in `useEffect`.
+     */
+    resolveEditorReference() {
+        const previous = this.resolvedEditor;
+        const next = this.resolveEditor();
+        if (previous === next && this.selectionListener) {
+            return;
+        }
+        this.detachEditorListeners();
+        this.resolvedEditor = next;
+        if (!next) {
+            return;
+        }
+        this.selectionListener = () => {
+            this.selectionVersion++;
+            this.requestUpdate();
+        };
+        this.readyListener = () => {
+            this.selectionVersion++;
+            this.requestUpdate();
+        };
+        next.addEventListener('editor-selection-change', this.selectionListener);
+        next.addEventListener('editor-ready', this.readyListener);
+        // Prompt initial render state.
+        this.selectionVersion++;
+        this.requestUpdate();
+    }
+    resolveEditor() {
+        if (this.editor) {
+            return this.editor;
+        }
+        // When using declarative binding, walk the DOM to locate the target editor.
+        if (this.for) {
+            const root = this.getRootNode();
+            const candidate = root.getElementById(this.for);
+            if (candidate) {
+                return candidate;
+            }
+        }
+        const nearest = this.closest('sciflow-editor');
+        if (nearest) {
+            return nearest;
+        }
+        return null;
+    }
+    /** Clean up listeners attached to the last editor instance. */
+    detachEditorListeners() {
+        if (this.resolvedEditor) {
+            if (this.selectionListener) {
+                this.resolvedEditor.removeEventListener('editor-selection-change', this.selectionListener);
+            }
+            if (this.readyListener) {
+                this.resolvedEditor.removeEventListener('editor-ready', this.readyListener);
+            }
+        }
+        this.selectionListener = undefined;
+        this.readyListener = undefined;
+        this.resolvedEditor = null;
+    }
+    /** Convenience getter mirroring `editor.getCommands()`. */
+    getCommandRunner() {
+        return this.resolvedEditor?.commands ?? null;
+    }
+    /** Interpret the block-style dropdown and trigger the relevant commands. */
+    handleStyleChange(event) {
+        const select = event.target;
+        const value = select.value;
+        if (value === 'paragraph') {
+            this.handleSetParagraph();
+            return;
+        }
+        const parsed = Number.parseInt(value.split('-')[1] ?? '', 10);
+        if (!Number.isInteger(parsed)) {
+            return;
+        }
+        this.handleSetHeading(parsed);
+    }
+    /** Apply a specific heading level after ensuring the editor can handle it. */
+    handleSetHeading(level) {
+        const runner = this.getCommandRunner();
+        if (!runner) {
+            return;
+        }
+        const available = runner.available?.();
+        if (available?.setHeading && !available.setHeading(level)) {
+            return;
+        }
+        const flow = runner.flow?.();
+        if (flow) {
+            const chain = typeof flow.focus === 'function' ? flow.focus() : flow;
+            const next = chain.setHeading?.(level) ?? null;
+            if (next && typeof next.run === 'function' && next.run()) {
+                this.selectionVersion++;
+                this.requestUpdate();
+                return;
+            }
+        }
+        const immediate = runner.commands?.setHeading;
+        if (typeof immediate === 'function' && immediate(level)) {
+            this.selectionVersion++;
+            this.requestUpdate();
+        }
+    }
+    /** Reset the current block back to a paragraph. */
+    handleSetParagraph() {
+        const runner = this.getCommandRunner();
+        if (!runner) {
+            return;
+        }
+        const available = runner.available?.();
+        if (available?.setParagraph && !available.setParagraph()) {
+            return;
+        }
+        const flow = runner.flow?.();
+        if (flow) {
+            const chain = typeof flow.focus === 'function' ? flow.focus() : flow;
+            const next = chain.setParagraph?.() ?? null;
+            if (next && typeof next.run === 'function' && next.run()) {
+                this.selectionVersion++;
+                this.requestUpdate();
+                return;
+            }
+        }
+        const immediate = runner.commands?.setParagraph;
+        if (typeof immediate === 'function' && immediate()) {
+            this.selectionVersion++;
+            this.requestUpdate();
+        }
+    }
+    /** Determine which block style is currently active for the selection. */
+    getActiveBlockStyle() {
+        const view = this.resolvedEditor?.editorView;
+        if (!view) {
+            return 'paragraph';
+        }
+        const { state } = view;
+        const headingType = state.schema.nodes.heading;
+        if (!headingType) {
+            return 'paragraph';
+        }
+        const { from, to, empty, $from } = state.selection;
+        let detectedLevel = null;
+        state.doc.nodesBetween(from, to, (node) => {
+            if (node.type === headingType) {
+                const level = Number(node.attrs?.level);
+                if (Number.isInteger(level) && level >= 1 && level <= 6) {
+                    detectedLevel = level;
+                    return false;
+                }
+            }
+            return true;
+        });
+        if (!detectedLevel && empty && $from.parent.type === headingType) {
+            const level = Number($from.parent.attrs?.level);
+            if (Number.isInteger(level) && level >= 1 && level <= 6) {
+                detectedLevel = level;
+            }
+        }
+        switch (detectedLevel) {
+            case 1:
+                return 'heading-1';
+            case 2:
+                return 'heading-2';
+            case 3:
+                return 'heading-3';
+            default:
+                return 'paragraph';
+        }
+    }
+    /** Check if a style option can be executed against the current editor state. */
+    canUseStyleOption(option, commands) {
+        if (!commands) {
+            return false;
+        }
+        if (option.value === 'paragraph') {
+            return commands.setParagraph?.() ?? false;
+        }
+        const level = option.level;
+        if (!level) {
+            return false;
+        }
+        return commands.setHeading?.(level) ?? false;
+    }
+    /**
+     * Render a set of command buttons that share the same metadata group.
+     * Groups are sorted by each command's declared order so feature authors control layout.
+     */
+    renderCommandGroup(runner, metadata, group) {
+        return Object.entries(metadata)
+            .filter(([, meta]) => meta?.group === group && (meta.icon || meta.label))
+            .sort(([, a], [, b]) => (a?.order ?? 0) - (b?.order ?? 0))
+            .map(([name, meta]) => this.renderCommandButton(name, meta, runner));
+    }
+    /**
+     * Render a single command button, wiring up availability checks and active state handling.
+     */
+    renderCommandButton(name, meta, runner) {
+        const command = runner?.commands?.[name];
+        if (typeof command !== 'function') {
+            return null;
+        }
+        const availability = runner?.available?.();
+        const canExecute = availability?.[name] ? availability[name]() : true;
+        const view = this.resolvedEditor?.editorView ?? null;
+        const state = view?.state ?? null;
+        const isActive = state && meta.isActive ? meta.isActive(state, view) : false;
+        const handleClick = () => {
+            if (!canExecute) {
+                return;
+            }
+            const result = command();
+            if (result) {
+                this.selectionVersion++;
+                this.requestUpdate();
+            }
+        };
+        return html `
+      <button
+        type="button"
+        class=${classMap({ active: isActive })}
+        aria-label=${meta.label ?? name}
+        title=${meta.description ?? meta.label ?? name}
+        ?aria-pressed=${meta.isActive ? (isActive ? 'true' : 'false') : undefined}
+        ?disabled=${!canExecute}
+        data-tooltip=${meta.description ?? meta.label ?? name}
+        @click=${handleClick}
+      >
+        ${meta.icon
+            ? html `<span class="material-symbols-rounded" aria-hidden="true">${meta.icon}</span>`
+            : meta.label ?? name}
+      </button>
+    `;
+    }
+    /**
+     * Determine which groups should be displayed and in which order based on command metadata.
+     */
+    getCommandGroups(metadata) {
+        const groupOrder = new Map();
+        Object.values(metadata).forEach((meta) => {
+            if (!meta?.group) {
+                return;
+            }
+            const currentOrder = groupOrder.get(meta.group);
+            const candidateOrder = meta.order ?? Number.MAX_SAFE_INTEGER;
+            if (typeof currentOrder === 'number') {
+                if (candidateOrder < currentOrder) {
+                    groupOrder.set(meta.group, candidateOrder);
+                }
+            }
+            else {
+                groupOrder.set(meta.group, candidateOrder);
+            }
+        });
+        return Array.from(groupOrder.entries())
+            .sort((a, b) => {
+            if (a[1] === b[1]) {
+                return a[0].localeCompare(b[0]);
+            }
+            return a[1] - b[1];
+        })
+            .map(([group]) => group);
+    }
+};
+__decorate([
+    property({ attribute: false })
+], SciFlowFormatBarElement.prototype, "editor", void 0);
+__decorate([
+    property({ type: String, attribute: 'for' })
+], SciFlowFormatBarElement.prototype, "for", void 0);
+__decorate([
+    state()
+], SciFlowFormatBarElement.prototype, "selectionVersion", void 0);
+SciFlowFormatBarElement = __decorate([
+    customElement('sciflow-formatbar')
+], SciFlowFormatBarElement);
+export { SciFlowFormatBarElement };

package/dist/lib/outline.d.ts

@@ -0,0 +1,94 @@
+import { LitElement } from 'lit';
+import type { Node as ProsemirrorNode } from 'prosemirror-model';
+import { type SciFlowDocJSON } from '@sciflow/editor-core';
+import type { SciFlowEditorElement } from './editor-element.js';
+export type OutlineHeading = {
+    text: string;
+    level: number | null;
+    id: string | null;
+    position: number | null;
+    end: number | null;
+};
+export type OutlineCitation = {
+    id: string | null;
+    source: Array<Record<string, unknown>>;
+};
+export type DocumentOutline = {
+    headings: OutlineHeading[];
+    citations: OutlineCitation[];
+};
+export type OutlineClickBehavior = 'none' | 'select' | 'scroll';
+/**
+ * Collect heading and citation metadata from a SciFlow document snapshot.
+ * When a ProseMirror document is available, positions and node boundaries are
+ * included so navigation and selection syncing can be precise.
+ */
+export declare function collectDocumentOutline(doc: SciFlowDocJSON | null | undefined, pmDoc?: ProsemirrorNode | null): DocumentOutline;
+/**
+ * Helper used by the demo to expose outline data for debugging.
+ */
+export declare function logDocumentOutline(doc: SciFlowDocJSON | null | undefined, pmDoc?: ProsemirrorNode | null): DocumentOutline;
+/**
+ * Web component that renders a document outline and stays in sync with a
+ * <sciflow-editor> instance. Hosts can either set the `for` attribute to point
+ * to an editor ID or pass the editor reference directly via the `editor`
+ * property.
+ *
+ * Configurable behaviors:
+ * - `levels` attribute filters which heading levels appear (e.g. "1-3" or "1,2")
+ * - `click-behavior` toggles navigation (`none` | `select` | `scroll`)
+ * - `renderHeadingLabel` property accepts a custom label renderer
+ */
+export declare class SciFlowOutlineElement extends LitElement {
+    /** Reference to the editor element. May be passed directly via property binding. */
+    editor: SciFlowEditorElement | null;
+    /** ID reference to resolve an editor instance declaratively. */
+    for?: string;
+    /** Optional document JSON source when not listening to an editor element. */
+    doc: SciFlowDocJSON | null;
+    /** Placeholder text displayed when no headings are present. */
+    emptyText: string;
+    /** Controls click behavior: disabled, set selection, or set selection + scroll. */
+    clickBehavior: OutlineClickBehavior;
+    /** Filter the outline to specific heading levels (e.g., "1-3" or "1,2,3"). */
+    levels: number[] | null;
+    /** Custom label renderer for headings. Receives the heading and its index. */
+    renderHeadingLabel?: (heading: OutlineHeading, index: number) => unknown;
+    private headings;
+    private activeHeadingKey;
+    private resolvedEditor;
+    private selectionListener?;
+    private changeListener?;
+    private readyListener?;
+    private lastSelection;
+    private themeUnsub?;
+    private themeStyleElements;
+    static styles: import("lit").CSSResult;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changedProperties: Map<string | number | symbol, unknown>): void;
+    protected render(): import("lit-html").TemplateResult<1>;
+    private renderHeadingItem;
+    private handleHeadingKeydown;
+    private handleHeadingClick;
+    private resolveEditorReference;
+    private resolveEditor;
+    private attachEditorListeners;
+    private detachEditorListeners;
+    private updateHeadingsFromDoc;
+    private applyLevelFilter;
+    private getLevelFilterSet;
+    private updateActiveHeading;
+    private findHeadingForSelection;
+    private headingKey;
+    private getHeadingSelectionPosition;
+    private extractDocFromEditor;
+    private normalizeClickBehavior;
+    private dispatchOutlineChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sciflow-outline': SciFlowOutlineElement;
+    }
+}
+//# sourceMappingURL=outline.d.ts.map

package/dist/lib/outline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../src/lib/outline.ts"],"names":[],"mappings":"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"}