superdoc-macros 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 palmoni5
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,154 @@
+# superdoc-macros
+
+ערכת מאקרו לעורכים מבוססי **SuperDoc v2**. נכתבה במקור עבור [otzaria-word-editor](https://github.com/Y-PLONI/otzaria-word-editor), אך כללית לחלוטין: אין תלות בו ואף לא בחבילת superdoc עצמה (החיבור למנוע מבני, דרך המשטחים הציבוריים שלו), והליבה עובדת מול כל עורך שמממש ממשק `MacroHost` קטן.
+
+שלוש יכולות, בדומה למאקרו של Word:
+
+| יכולת | מה זה נותן |
+| --- | --- |
+| **סקריפטים** | מאקרו כתובים ב-JavaScript שרצים בארגז חול (iframe מבודד) מול API מצומצם ובטוח של המסמך |
+| **מקליט מאקרו** | "הקלט → עשה פעולות → עצור → נגן" — מקליט פקודות והקלדה, כמו המקליט של Word |
+| **קטעי טקסט (Snippets)** | תבניות עם משתנים (`{{date}}`, `{{selection}}`…), קיצורי מקלדת, והשלמה אוטומטית בהקלדה (הקלדת `בסד` + רווח ← `בס"ד`) |
+
+בנוסף: שמירה מתמשכת (localStorage או אחסון מותאם), ייבוא/ייצוא JSON, וקישור קיצורי מקלדת.
+
+> **הערה על VBA:** החבילה אינה מריצה מאקרו VBA מתוך קובצי `.docm` — אין מנוע VBA בדפדפן. היא נותנת מערכת מאקרו מקבילה, מבוססת JavaScript, שמתאימה לעורך רץ-בדפדפן.
+
+## התקנה
+
+```bash
+npm install superdoc-macros
+```
+
+או ישירות מגיטהאב (עד הפרסום ב-npm):
+
+```bash
+npm install github:palmoni5/superdoc-macros
+```
+
+## התחלה מהירה (עם SuperDoc)
+
+```ts
+import { MacroKit, createSuperdocHost } from 'superdoc-macros';
+
+// superdoc — מופע SuperDoc מוכן (אחרי onReady); container — האלמנט שהמסמך מרונדר בו.
+const host = createSuperdocHost({ superdoc, container });
+const kit = new MacroKit({ host });
+
+// קיצורי מקלדת לכל מה ששמור, והשלמה אוטומטית:
+const unbindKeys = kit.attachShortcuts(container);
+const disableAutoText = kit.enableAutoText();
+
+// בהחלפת מסמך / פירוק:
+unbindKeys();
+disableAutoText();
+host.dispose();
+```
+
+## 1. מאקרו כתובים (סקריפטים)
+
+סקריפט מקבל אובייקט `api` וכל המתודות שלו א-סינכרוניות:
+
+```ts
+kit.saveScript({
+  name: 'כותרת דבר תורה',
+  shortcut: 'Ctrl+Alt+D',
+  source: `
+    await api.bold();
+    await api.insertText('בעניין ');
+    const selected = await api.getSelectionText();
+    if (selected) await api.insertText(selected);
+    await api.bold();
+    await api.insertParagraph();
+  `,
+});
+
+const result = await kit.runScript(kit.listScripts()[0].id);
+if (!result.ok) console.warn(result.message);
+```
+
+### ה-API שסקריפט מקבל
+
+| מתודה | תיאור |
+| --- | --- |
+| `api.command(id, payload?)` | כל פקודה מקטלוג SuperDoc (`'text-align'`, `'font-size'`…). מחזירה `{ok}` ואינה זורקת |
+| `api.hasCommand(id)` / `api.commandIds()` | בירור יכולות |
+| `api.insertText(text)` / `api.insertParagraph()` | הכנסה במיקום הסמן |
+| `api.deleteBackward(count?)` | מחיקה לאחור |
+| `api.getSelection()` / `api.getSelectionText()` | הבחירה הנוכחית |
+| `api.getDocumentText()` | הטקסט המלא |
+| `api.replaceAll(find, replace)` | החלפה גורפת; מחזירה כמה הוחלפו |
+| `api.bold()` / `italic()` / `underline()` / `bulletList()` / `directionRtl()` … | סוכר לפקודות נפוצות — זורקות בכשל, כדי שהסקריפט ייעצר |
+| `api.log(...)` | יומן ריצה (מגיע ל-`onLog` של ה-Kit) |
+
+### אבטחה
+
+ברירת המחדל היא **ארגז חול אמיתי**: הסקריפט רץ ב-iframe עם `sandbox="allow-scripts"` בלבד — origin אטום, בלי גישה ל-DOM של האפליקציה, ל-localStorage, ל-cookies או לרשת עם אישורי המשתמש. הדרך היחידה שלו לגעת במסמך היא ה-API שלמעלה, עם תקרת זמן (ברירת מחדל 30 שניות — נאכפת גם על לולאה אינסופית, ע"י הסרת ה-iframe) ותקרת קריאות (10,000).
+
+מי שחייב לוותר על הבידוד (למשל CSP שחוסם `srcdoc`) יכול לעבור למריץ ישיר: `new MacroKit({ host, runner: 'eval' })` — ראו האזהרות בקוד.
+
+## 2. מקליט מאקרו
+
+```ts
+kit.startRecording();
+// המשתמש עובד רגיל: מקליד, מדגיש, ממספר...
+const recording = kit.stopRecording('פתיח סטנדרטי', 'Ctrl+Alt+1');
+
+// מאוחר יותר, מכל מקום במסמך:
+await kit.replayRecording(recording.id);
+```
+
+המקליט מתעד **פקודות והקלדה**, לא מיקומי סמן — בדיוק כמו המקליט של Word: הניגון חל במקום שבו הסמן עומד. הקשות רצופות מתלכדות לצעד אחד, `undo`/`redo` אינם מוקלטים (ניתן לשינוי ב-`RecorderOptions`), וההקלטה נשמרת כ-JSON נקי שאפשר לייצא ולשתף.
+
+## 3. קטעי טקסט והשלמה אוטומטית
+
+```ts
+kit.saveSnippet({ name: 'בס"ד', text: 'בס"ד', trigger: 'בסד' });
+kit.saveSnippet({
+  name: 'חתימה',
+  text: 'ונשלם בעז"ה, {{date}}',
+  shortcut: 'Ctrl+Alt+S',
+});
+kit.saveSnippet({ name: 'ציטוט', text: '(עיין {{selection}})' });
+
+kit.enableAutoText();          // מעכשיו: הקלדת "בסד" + רווח ⟵ בס"ד
+await kit.expandSnippet(id);   // או הרחבה יזומה / דרך הקיצור
+```
+
+משתנים מובנים: `{{date}}`, `{{time}}`, `{{datetime}}` (עברית), `{{selection}}`. כל שם אחר נפתר מ-`variables` שנמסרו ל-`expandSnippet`; משתנה ללא ערך נשאר גלוי בטקסט.
+
+## שמירה, ייבוא וייצוא
+
+```ts
+import { createLocalStorage } from 'superdoc-macros';
+
+const kit = new MacroKit({ host, storage: createLocalStorage('my-key') });
+
+const json = kit.exportState();       // גיבוי / שיתוף
+kit.importState(json, { merge: true });
+```
+
+`MacroStorage` הוא ממשק בן שתי מתודות — אפשר לממש שמירה לקובץ (למשל ב-workspace של תוסף אוצריא).
+
+## חיבור למארח אחר
+
+כל הערכה עובדת מול ממשק `MacroHost` אחד (פקודות, הכנסת טקסט, בחירה, החלפה, אירועי הקלדה). `createSuperdocHost` הוא המימוש ל-SuperDoc v2 במצב `ui: false`; עורך אחר מתחבר במימוש משלו של הממשק — ראו `src/types.ts` ואת הכפיל ב-`tests/fake-host.ts`.
+
+## מגבלות ידועות
+
+- אין הרצת VBA. קובצי `.docm` נפתחים כרגיל אבל המאקרו שבהם אינו מורץ.
+- המקליט אינו מתעד תנועת סמן ובחירה בעכבר (כמו ב-Word — הניגון פועל מהסמן הנוכחי).
+- `deleteBackward` וטקסט-מלא-של-המסמך משתמשים ב-view הפנימי של המנוע (ProseMirror) — זמינים בדפדפן, לא ב-headless.
+- תקרת הזמן במריץ `eval` אינה עוצרת לולאה סינכרונית אינסופית (במריץ ה-iframe — כן).
+
+## פיתוח
+
+```bash
+npm install
+npm test        # vitest — 43 בדיקות
+npm run build   # tsc ⟵ dist/
+```
+
+## רישיון
+
+MIT

package/dist/host/superdoc-host.d.ts

@@ -0,0 +1,130 @@
+/**
+ * מימוש `MacroHost` מעל SuperDoc v2 במצב מנוע-בלבד (`ui: false`) — הקונפיגורציה
+ * של otzaria-word-editor.
+ *
+ * המשטחים שבשימוש, לפי סדר עדיפות:
+ *   1. `superdoc.ui.commands` — קטלוג הפקודות של ה-controller (הרצה + תצפית).
+ *   2. `superdoc.activeEditor.doc` — ה-Document API הציבורי (בחירה, הכנסה, בלוקים).
+ *   3. `superdoc.ui.search` — חיפוש/החלפה.
+ *   4. `superdoc.activeEditor.view` — מופע ProseMirror הפנימי, **רק** לפערים
+ *      שאין להם משטח ציבורי: מחיקה לאחור וטקסט מלא של המסמך. קיים בדפדפן
+ *      ו-null ב-headless.
+ *
+ * הטיפוסים כאן מבניים (structural) ואינם מייבאים מ-superdoc: הערכה לא תלויה
+ * בחבילה, וגרסת מנוע שמשנה שדה תיכשל סגור (הפונקציה תחזיר כשל) ולא תקרוס.
+ *
+ * תצפית הפקודות למקליט נעשית בעטיפת `executeAsync` על אובייקט ה-commands.
+ * זה מכסה כל מסלול שקורא לו — כולל ה-CommandAdapter של otzaria — בלי לשנות
+ * את הקוד הקורא. `dispose()` מחזיר את המתודה המקורית.
+ */
+import type { MacroHost } from '../types.js';
+interface CommandStateLike {
+    reason?: string;
+}
+interface CommandsLike {
+    has(id: string): boolean;
+    ids?: readonly string[] | (() => readonly string[]);
+    get(id: string): {
+        getState(): CommandStateLike;
+    };
+    executeAsync(id: string, payload?: unknown): Promise<unknown>;
+}
+interface SearchSliceLike {
+    available?: boolean;
+    total?: number;
+    query?: string;
+}
+interface SearchHandleLike {
+    getSnapshot(): SearchSliceLike;
+    search(query: string): SearchSliceLike;
+    clear?(): void;
+    open?(): unknown;
+    close?(): unknown;
+    replaceAll(replacement: string): Promise<{
+        ok?: boolean;
+        reason?: string;
+    } | undefined> | {
+        ok?: boolean;
+        reason?: string;
+    } | undefined;
+}
+interface DocReceiptLike {
+    success?: boolean;
+    failure?: {
+        code?: string;
+        message?: string;
+    };
+}
+interface SelectionInfoLike {
+    empty?: boolean;
+    text?: string;
+    target?: {
+        segments?: readonly {
+            blockId?: string;
+            range?: {
+                start?: number;
+                end?: number;
+            };
+        }[];
+    } | null;
+    selectionTarget?: unknown;
+}
+interface DocLike {
+    insert?(input: {
+        value: string;
+        type: 'text';
+        target?: unknown;
+    }): Promise<DocReceiptLike | undefined> | DocReceiptLike | undefined;
+    selection?: {
+        current?(input?: {
+            includeText?: boolean;
+        }): Promise<SelectionInfoLike | undefined> | SelectionInfoLike | undefined;
+    };
+    blocks?: {
+        list?(input?: {
+            offset?: number;
+            limit?: number;
+        }): Promise<unknown> | unknown;
+    } | null;
+}
+interface ProseMirrorViewLike {
+    state: {
+        doc: {
+            content: {
+                size: number;
+            };
+            textBetween(from: number, to: number, blockSeparator?: string): string;
+        };
+        selection: {
+            from: number;
+            empty: boolean;
+        };
+        tr: {
+            delete(from: number, to: number): unknown;
+            insertText(text: string, from?: number, to?: number): unknown;
+            scrollIntoView(): unknown;
+        };
+    };
+    dispatch(tr: unknown): void;
+}
+export interface SuperdocLike {
+    ui?: {
+        commands?: CommandsLike;
+        search?: SearchHandleLike;
+    } | null;
+    activeEditor?: {
+        doc?: DocLike | null;
+        view?: ProseMirrorViewLike | null;
+    } | null;
+}
+export interface SuperdocHostOptions {
+    superdoc: SuperdocLike;
+    /** האלמנט שהמסמך מרונדר בתוכו — עליו נקלטים אירועי ההקלדה. */
+    container?: HTMLElement | null;
+}
+export interface SuperdocMacroHost extends MacroHost {
+    /** מסירה את עטיפת התצפית ואת מאזיני ה-DOM. לקרוא לפני החלפת מסמך. */
+    dispose(): void;
+}
+export declare function createSuperdocHost(options: SuperdocHostOptions): SuperdocMacroHost;
+export {};

package/dist/host/superdoc-host.js

@@ -0,0 +1,257 @@
+/* ---------- עזרים ---------- */
+const NOT_READY = { ok: false, message: 'אין מסמך פתוח', reason: 'not-ready' };
+function failed(message, reason) {
+    return { ok: false, message, reason };
+}
+function receiptOutcome(receipt, failedAction) {
+    if (receipt && receipt.success === false) {
+        const code = receipt.failure?.code;
+        if (code === 'NO_OP')
+            return { ok: true };
+        const detail = receipt.failure?.message;
+        return failed(detail ? `${failedAction}: ${detail}` : `${failedAction}${code ? ` (${code})` : ''}`, code);
+    }
+    return { ok: true };
+}
+function emptySelection() {
+    return { text: '', hasRange: false, blockId: null, selectionTarget: null, empty: true };
+}
+/* ---------- המימוש ---------- */
+export function createSuperdocHost(options) {
+    const { superdoc, container } = options;
+    // נקראים ברגע השימוש ולא נשמרים: activeEditor מוחלף בכל פתיחת מסמך.
+    const commands = () => superdoc.ui?.commands ?? null;
+    const doc = () => superdoc.activeEditor?.doc ?? null;
+    const view = () => superdoc.activeEditor?.view ?? null;
+    const search = () => superdoc.ui?.search ?? null;
+    const commandListeners = new Set();
+    const inputListeners = new Set();
+    /* תצפית פקודות: עטיפת executeAsync, פעם אחת, עם שחזור ב-dispose. */
+    const wrapped = commands();
+    const originalExecuteAsync = wrapped?.executeAsync;
+    if (wrapped && originalExecuteAsync) {
+        wrapped.executeAsync = function (id, payload) {
+            for (const listener of commandListeners) {
+                try {
+                    listener(id, payload);
+                }
+                catch (error) {
+                    console.warn('[superdoc-macros] מאזין פקודות זרק', error);
+                }
+            }
+            return originalExecuteAsync.call(wrapped, id, payload);
+        };
+    }
+    /* הקלדה: beforeinput על ה-container, בשלב הלכידה. */
+    const onBeforeInput = (event) => {
+        const input = event;
+        let mapped = null;
+        switch (input.inputType) {
+            case 'insertText':
+            case 'insertCompositionText':
+                if (typeof input.data === 'string' && input.data.length > 0) {
+                    mapped = { kind: 'insert-text', text: input.data };
+                }
+                break;
+            case 'insertParagraph':
+                mapped = { kind: 'insert-paragraph' };
+                break;
+            case 'deleteContentBackward':
+                mapped = { kind: 'delete-backward' };
+                break;
+            case 'deleteContentForward':
+                mapped = { kind: 'delete-forward' };
+                break;
+            default:
+                break;
+        }
+        if (!mapped)
+            return;
+        for (const listener of inputListeners) {
+            try {
+                listener(mapped);
+            }
+            catch (error) {
+                console.warn('[superdoc-macros] מאזין הקלדה זרק', error);
+            }
+        }
+    };
+    container?.addEventListener('beforeinput', onBeforeInput, true);
+    async function readSelection(includeText) {
+        const current = doc()?.selection?.current;
+        if (typeof current !== 'function')
+            return emptySelection();
+        let info;
+        try {
+            info = await current(includeText ? { includeText: true } : undefined);
+        }
+        catch {
+            return emptySelection();
+        }
+        if (!info || typeof info !== 'object')
+            return emptySelection();
+        const segments = Array.isArray(info.target?.segments) ? info.target.segments : [];
+        const first = segments.find((segment) => typeof segment?.blockId === 'string');
+        const hasRange = segments.some((segment) => typeof segment?.blockId === 'string' &&
+            typeof segment.range?.start === 'number' &&
+            typeof segment.range?.end === 'number' &&
+            segment.range.start !== segment.range.end);
+        const text = typeof info.text === 'string' ? info.text : '';
+        return {
+            text,
+            hasRange,
+            blockId: first?.blockId ?? null,
+            selectionTarget: info.selectionTarget !== null && typeof info.selectionTarget === 'object' ? info.selectionTarget : null,
+            empty: typeof info.empty === 'boolean' ? info.empty : !(hasRange || text.length > 0),
+        };
+    }
+    return {
+        commands: {
+            has(id) {
+                return commands()?.has(id) ?? false;
+            },
+            ids() {
+                const raw = commands()?.ids;
+                if (typeof raw === 'function')
+                    return raw();
+                return Array.isArray(raw) ? raw : [];
+            },
+            async execute(id, payload) {
+                const bus = commands();
+                if (!bus)
+                    return NOT_READY;
+                if (!bus.has(id))
+                    return failed(`הפקודה ${id} אינה מוכרת למנוע`, 'unknown-command');
+                let result;
+                try {
+                    result = await bus.executeAsync(id, payload);
+                }
+                catch (error) {
+                    return failed(error instanceof Error ? error.message : 'הפעולה נכשלה', 'threw');
+                }
+                // false = ה-controller לא ניתב את הפקודה; מצב הפקד מסביר למה.
+                if (result === false) {
+                    const reason = bus.get(id).getState().reason;
+                    return failed(reason ? `הפעולה נכשלה (${reason})` : 'הפעולה נכשלה', reason);
+                }
+                if (typeof result === 'object' && result !== null) {
+                    return receiptOutcome(result, `הפקודה ${id} נכשלה`);
+                }
+                return { ok: true };
+            },
+        },
+        async insertText(text) {
+            const insert = doc()?.insert;
+            if (typeof insert === 'function') {
+                // בלי target ההכנסה נופלת לסוף המסמך — לכן היעד נלקח מהבחירה החיה.
+                const snapshot = await readSelection(false);
+                try {
+                    const receipt = await insert({
+                        value: text,
+                        type: 'text',
+                        ...(snapshot.selectionTarget ? { target: snapshot.selectionTarget } : {}),
+                    });
+                    return receiptOutcome(receipt, 'הכנסת הטקסט נכשלה');
+                }
+                catch (error) {
+                    return failed(error instanceof Error ? error.message : 'הכנסת הטקסט נכשלה', 'threw');
+                }
+            }
+            // נפילה לאחור: ProseMirror ישיר, כשה-Document API אינו זמין.
+            const pm = view();
+            if (pm) {
+                try {
+                    const tr = pm.state.tr;
+                    tr.insertText(text);
+                    tr.scrollIntoView();
+                    pm.dispatch(tr);
+                    return { ok: true };
+                }
+                catch (error) {
+                    return failed(error instanceof Error ? error.message : 'הכנסת הטקסט נכשלה', 'threw');
+                }
+            }
+            return NOT_READY;
+        },
+        async deleteBackward(count) {
+            // אין משטח ציבורי למחיקה — זה השימוש המרכזי ב-escape hatch של ProseMirror.
+            const pm = view();
+            if (!pm)
+                return failed('מחיקה אינה זמינה במסמך הזה', 'view-unavailable');
+            try {
+                const { from } = pm.state.selection;
+                const start = Math.max(0, from - Math.max(0, Math.trunc(count)));
+                if (start === from)
+                    return { ok: true };
+                const tr = pm.state.tr;
+                tr.delete(start, from);
+                pm.dispatch(tr);
+                return { ok: true };
+            }
+            catch (error) {
+                return failed(error instanceof Error ? error.message : 'המחיקה נכשלה', 'threw');
+            }
+        },
+        getSelection(options) {
+            return readSelection(options?.includeText ?? false);
+        },
+        async replaceAll(query, replacement) {
+            const handle = search();
+            if (!handle)
+                return { ok: false, replaced: 0, message: 'החיפוש אינו זמין' };
+            try {
+                handle.open?.();
+                const slice = handle.search(query);
+                if (slice?.available === false) {
+                    return { ok: false, replaced: 0, message: 'החיפוש אינו זמין במסמך הזה' };
+                }
+                const total = typeof slice?.total === 'number' ? slice.total : 0;
+                if (total === 0)
+                    return { ok: true, replaced: 0 };
+                const result = await handle.replaceAll(replacement);
+                if (result && result.ok === false) {
+                    return { ok: false, replaced: 0, message: `ההחלפה נכשלה${result.reason ? ` (${result.reason})` : ''}` };
+                }
+                return { ok: true, replaced: total };
+            }
+            catch (error) {
+                return { ok: false, replaced: 0, message: error instanceof Error ? error.message : 'ההחלפה נכשלה' };
+            }
+            finally {
+                try {
+                    handle.clear?.();
+                    handle.close?.();
+                }
+                catch {
+                    /* ניקוי בלבד */
+                }
+            }
+        },
+        async getDocumentText() {
+            const pm = view();
+            if (!pm)
+                return '';
+            try {
+                return pm.state.doc.textBetween(0, pm.state.doc.content.size, '\n');
+            }
+            catch {
+                return '';
+            }
+        },
+        onCommand(listener) {
+            commandListeners.add(listener);
+            return () => commandListeners.delete(listener);
+        },
+        onTextInput(listener) {
+            inputListeners.add(listener);
+            return () => inputListeners.delete(listener);
+        },
+        dispose() {
+            if (wrapped && originalExecuteAsync)
+                wrapped.executeAsync = originalExecuteAsync;
+            container?.removeEventListener('beforeinput', onBeforeInput, true);
+            commandListeners.clear();
+            inputListeners.clear();
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export type { MacroHost, MacroOutcome, MacroStep, RecordedMacro, SavedScript, SelectionSnapshot, Snippet, TextInputEvent, } from './types.js';
+export { MacroKit, type MacroKitOptions } from './manager.js';
+export { createSuperdocHost, type SuperdocHostOptions, type SuperdocLike, type SuperdocMacroHost } from './host/superdoc-host.js';
+export { createMacroApi, MacroError, type MacroApi, type MacroBridge, type ScriptSelection } from './scripting/macro-api.js';
+export { createEvalRunner } from './scripting/eval-runner.js';
+export { createIframeRunner, SANDBOX_BOOTSTRAP, isProtocolMessage } from './scripting/iframe-runner.js';
+export type { MacroRunner, MacroRunOptions, MacroRunResult } from './scripting/runner.js';
+export { MacroRecorder, replayMacro, type RecorderOptions, type ReplayOptions, type ReplayResult } from './recorder/recorder.js';
+export { renderSnippet, expandSnippet, usesSelection, type ExpandOptions, type RenderContext } from './snippets/snippets.js';
+export { AutoText, type AutoTextOptions } from './snippets/autotext.js';
+export { parseShortcut, eventMatches, bindShortcuts, type ParsedShortcut, type ShortcutBinding, type ShortcutTarget } from './shortcuts.js';
+export { createLocalStorage, createMemoryStorage, emptyState, parsePersistedState, DEFAULT_STORAGE_KEY, type MacroStorage, type PersistedMacroState, } from './storage.js';

package/dist/index.js

@@ -0,0 +1,10 @@
+export { MacroKit } from './manager.js';
+export { createSuperdocHost } from './host/superdoc-host.js';
+export { createMacroApi, MacroError } from './scripting/macro-api.js';
+export { createEvalRunner } from './scripting/eval-runner.js';
+export { createIframeRunner, SANDBOX_BOOTSTRAP, isProtocolMessage } from './scripting/iframe-runner.js';
+export { MacroRecorder, replayMacro } from './recorder/recorder.js';
+export { renderSnippet, expandSnippet, usesSelection } from './snippets/snippets.js';
+export { AutoText } from './snippets/autotext.js';
+export { parseShortcut, eventMatches, bindShortcuts } from './shortcuts.js';
+export { createLocalStorage, createMemoryStorage, emptyState, parsePersistedState, DEFAULT_STORAGE_KEY, } from './storage.js';