@vizel/svelte 0.0.1-alpha.1

package/dist/runes/createVizelEditorState.svelte.d.ts

@@ -0,0 +1,27 @@
+import { type Editor, type VizelEditorState } from "@vizel/core";
+/**
+ * Rune that returns the current editor state and updates on state changes.
+ * This is a convenience rune that combines `createVizelState` (for reactivity)
+ * and `getVizelEditorState` (for state extraction).
+ *
+ * @param getEditor - A function that returns the editor instance
+ * @returns An object with a `current` getter for the editor state
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * const editorState = createVizelEditorState(() => editor);
+ * </script>
+ *
+ * <div class="status-bar">
+ *   <span>{editorState.current.characterCount} characters</span>
+ *   <span>{editorState.current.wordCount} words</span>
+ *   <button disabled={!editorState.current.canUndo}>Undo</button>
+ *   <button disabled={!editorState.current.canRedo}>Redo</button>
+ * </div>
+ * ```
+ */
+export declare function createVizelEditorState(getEditor: () => Editor | null | undefined): {
+    readonly current: VizelEditorState;
+};
+//# sourceMappingURL=createVizelEditorState.svelte.d.ts.map

package/dist/runes/createVizelEditorState.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVizelEditorState.svelte.d.ts","sourceRoot":"","sources":["../../src/runes/createVizelEditorState.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAuB,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGtF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG;IAClF,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;CACpC,CAWA"}

package/dist/runes/createVizelEditorState.svelte.js

@@ -0,0 +1,35 @@
+import { getVizelEditorState } from "@vizel/core";
+import { createVizelState } from "./createVizelState.svelte.ts";
+/**
+ * Rune that returns the current editor state and updates on state changes.
+ * This is a convenience rune that combines `createVizelState` (for reactivity)
+ * and `getVizelEditorState` (for state extraction).
+ *
+ * @param getEditor - A function that returns the editor instance
+ * @returns An object with a `current` getter for the editor state
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * const editorState = createVizelEditorState(() => editor);
+ * </script>
+ *
+ * <div class="status-bar">
+ *   <span>{editorState.current.characterCount} characters</span>
+ *   <span>{editorState.current.wordCount} words</span>
+ *   <button disabled={!editorState.current.canUndo}>Undo</button>
+ *   <button disabled={!editorState.current.canRedo}>Redo</button>
+ * </div>
+ * ```
+ */
+export function createVizelEditorState(getEditor) {
+    // Subscribe to editor state changes for reactivity
+    const state = createVizelState(getEditor);
+    return {
+        get current() {
+            // Access state.current to establish reactivity dependency
+            void state.current;
+            return getVizelEditorState(getEditor());
+        },
+    };
+}

package/dist/runes/createVizelMarkdown.svelte.d.ts

@@ -0,0 +1,68 @@
+import { type Editor, type VizelMarkdownSyncOptions } from "@vizel/core";
+export interface CreateVizelMarkdownOptions extends VizelMarkdownSyncOptions {
+    /**
+     * Initial markdown value. If provided, this will be set to the editor on mount.
+     */
+    initialValue?: string;
+}
+export interface CreateVizelMarkdownResult {
+    /**
+     * Current markdown content (reactive getter).
+     * Updates with debounce when editor content changes.
+     */
+    readonly markdown: string;
+    /**
+     * Set markdown content to the editor.
+     * Automatically transforms diagram code blocks if transformDiagrams is enabled.
+     */
+    setMarkdown: (markdown: string) => void;
+    /**
+     * Whether markdown export is currently pending (debounced).
+     */
+    readonly isPending: boolean;
+    /**
+     * Force immediate export (flush pending debounced export).
+     */
+    flush: () => void;
+}
+/**
+ * Svelte 5 rune for bidirectional Markdown synchronization with the editor.
+ *
+ * @param getEditor - Function to get the editor instance
+ * @param options - Sync options
+ * @returns Markdown state and control functions
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * import { createVizelEditor, createVizelMarkdown, VizelEditor } from '@vizel/svelte';
+ *
+ * const editorState = createVizelEditor();
+ * const markdownState = createVizelMarkdown(() => editorState.current, {
+ *   debounceMs: 300,
+ * });
+ * </script>
+ *
+ * <VizelEditor editor={editorState.current} />
+ * <textarea
+ *   value={markdownState.markdown}
+ *   oninput={(e) => markdownState.setMarkdown(e.currentTarget.value)}
+ * />
+ * {#if markdownState.isPending}
+ *   <span>Syncing...</span>
+ * {/if}
+ * ```
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * // With initial markdown value
+ * const markdownState = createVizelMarkdown(() => editorState.current, {
+ *   initialValue: "# Hello World",
+ *   transformDiagrams: true,
+ * });
+ * </script>
+ * ```
+ */
+export declare function createVizelMarkdown(getEditor: () => Editor | null | undefined, options?: CreateVizelMarkdownOptions): CreateVizelMarkdownResult;
+//# sourceMappingURL=createVizelMarkdown.svelte.d.ts.map

package/dist/runes/createVizelMarkdown.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVizelMarkdown.svelte.d.ts","sourceRoot":"","sources":["../../src/runes/createVizelMarkdown.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAGX,KAAK,wBAAwB,EAC9B,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,0BAA2B,SAAQ,wBAAwB;IAC1E;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,SAAS,EAC1C,OAAO,GAAE,0BAA+B,GACvC,yBAAyB,CA6F3B"}

package/dist/runes/createVizelMarkdown.svelte.js

@@ -0,0 +1,123 @@
+import { createVizelMarkdownSyncHandlers, getVizelMarkdown, } from "@vizel/core";
+/**
+ * Svelte 5 rune for bidirectional Markdown synchronization with the editor.
+ *
+ * @param getEditor - Function to get the editor instance
+ * @param options - Sync options
+ * @returns Markdown state and control functions
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * import { createVizelEditor, createVizelMarkdown, VizelEditor } from '@vizel/svelte';
+ *
+ * const editorState = createVizelEditor();
+ * const markdownState = createVizelMarkdown(() => editorState.current, {
+ *   debounceMs: 300,
+ * });
+ * </script>
+ *
+ * <VizelEditor editor={editorState.current} />
+ * <textarea
+ *   value={markdownState.markdown}
+ *   oninput={(e) => markdownState.setMarkdown(e.currentTarget.value)}
+ * />
+ * {#if markdownState.isPending}
+ *   <span>Syncing...</span>
+ * {/if}
+ * ```
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * // With initial markdown value
+ * const markdownState = createVizelMarkdown(() => editorState.current, {
+ *   initialValue: "# Hello World",
+ *   transformDiagrams: true,
+ * });
+ * </script>
+ * ```
+ */
+export function createVizelMarkdown(getEditor, options = {}) {
+    const { initialValue, ...syncOptions } = options;
+    let markdown = $state(initialValue ?? "");
+    let isPending = $state(false);
+    // Create sync handlers
+    let handlers = null;
+    const initHandlers = () => {
+        if (!handlers) {
+            handlers = createVizelMarkdownSyncHandlers(syncOptions);
+        }
+        return handlers;
+    };
+    // Track if initial value has been set
+    let initialSet = false;
+    // Watch for editor availability and subscribe to updates
+    $effect(() => {
+        const editor = getEditor();
+        if (!editor)
+            return;
+        const h = initHandlers();
+        // Initialize markdown on first editor availability
+        if (!initialSet) {
+            if (initialValue !== undefined) {
+                h.setMarkdown(editor, initialValue);
+                markdown = initialValue;
+            }
+            else {
+                // Get initial markdown from editor
+                markdown = getVizelMarkdown(editor);
+            }
+            initialSet = true;
+        }
+        // Subscribe to editor updates
+        const handleUpdate = () => {
+            h.handleUpdate(editor);
+            isPending = h.isPending();
+            // Schedule state update after debounce
+            const checkPending = () => {
+                if (h.isPending()) {
+                    requestAnimationFrame(checkPending);
+                }
+                else {
+                    markdown = h.getMarkdown();
+                    isPending = false;
+                }
+            };
+            requestAnimationFrame(checkPending);
+        };
+        editor.on("update", handleUpdate);
+        return () => {
+            editor.off("update", handleUpdate);
+            handlers?.destroy();
+        };
+    });
+    const setMarkdown = (newMarkdown) => {
+        const editor = getEditor();
+        if (!editor)
+            return;
+        const h = initHandlers();
+        h.setMarkdown(editor, newMarkdown);
+        markdown = newMarkdown;
+        isPending = false;
+    };
+    const flush = () => {
+        const editor = getEditor();
+        if (!editor)
+            return;
+        const h = initHandlers();
+        h.flush(editor);
+        markdown = h.getMarkdown();
+        isPending = false;
+    };
+    return {
+        get markdown() {
+            return markdown;
+        },
+        setMarkdown,
+        get isPending() {
+            return isPending;
+        },
+        flush,
+    };
+}

package/dist/runes/createVizelSlashMenuRenderer.d.ts

@@ -0,0 +1,22 @@
+import { type SuggestionOptions, type VizelSlashCommandItem, type VizelSlashMenuRendererOptions } from "@vizel/core";
+export type { VizelSlashMenuRendererOptions };
+/**
+ * Creates a suggestion render configuration for the SlashCommand extension.
+ * This handles the popup positioning and Svelte component lifecycle.
+ *
+ * @example
+ * ```ts
+ * import { createVizelSlashMenuRenderer } from '@vizel/svelte';
+ * import { VizelSlashCommand } from '@vizel/core';
+ *
+ * const editor = new Editor({
+ *   extensions: [
+ *     VizelSlashCommand.configure({
+ *       suggestion: createVizelSlashMenuRenderer(),
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare function createVizelSlashMenuRenderer(options?: VizelSlashMenuRendererOptions): Partial<SuggestionOptions<VizelSlashCommandItem>>;
+//# sourceMappingURL=createVizelSlashMenuRenderer.d.ts.map

package/dist/runes/createVizelSlashMenuRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVizelSlashMenuRenderer.d.ts","sourceRoot":"","sources":["../../src/runes/createVizelSlashMenuRenderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EACnC,MAAM,aAAa,CAAC;AAIrB,YAAY,EAAE,6BAA6B,EAAE,CAAC;AAU9C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,CAAC,CAmEnD"}

package/dist/runes/createVizelSlashMenuRenderer.js

@@ -0,0 +1,84 @@
+import { createVizelSuggestionContainer, handleVizelSuggestionEscape, } from "@vizel/core";
+import { mount, unmount } from "svelte";
+import VizelSlashMenu from "../components/VizelSlashMenu.svelte";
+/** Type guard for SlashMenuRef */
+const isSlashMenuRef = (value) => typeof value === "object" && value !== null && "onKeyDown" in value;
+/**
+ * Creates a suggestion render configuration for the SlashCommand extension.
+ * This handles the popup positioning and Svelte component lifecycle.
+ *
+ * @example
+ * ```ts
+ * import { createVizelSlashMenuRenderer } from '@vizel/svelte';
+ * import { VizelSlashCommand } from '@vizel/core';
+ *
+ * const editor = new Editor({
+ *   extensions: [
+ *     VizelSlashCommand.configure({
+ *       suggestion: createVizelSlashMenuRenderer(),
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export function createVizelSlashMenuRenderer(options = {}) {
+    return {
+        render: () => {
+            let component = null;
+            let suggestionContainer = null;
+            let items = [];
+            let commandFn = null;
+            const mountComponent = () => {
+                if (!suggestionContainer)
+                    return;
+                component = mount(VizelSlashMenu, {
+                    target: suggestionContainer.menuContainer,
+                    props: {
+                        items,
+                        ...(options.className !== undefined && { class: options.className }),
+                        oncommand: (item) => {
+                            commandFn?.(item);
+                        },
+                    },
+                });
+            };
+            return {
+                onStart: (props) => {
+                    items = props.items;
+                    commandFn = props.command;
+                    suggestionContainer = createVizelSuggestionContainer();
+                    mountComponent();
+                    suggestionContainer.updatePosition(props.clientRect);
+                },
+                onUpdate: (props) => {
+                    items = props.items;
+                    commandFn = props.command;
+                    // Svelte 5 mount doesn't support updating props after mount
+                    // We need to remount the component with new props
+                    if (component && suggestionContainer) {
+                        unmount(component);
+                        mountComponent();
+                    }
+                    suggestionContainer?.updatePosition(props.clientRect);
+                },
+                onKeyDown: (props) => {
+                    if (handleVizelSuggestionEscape(props.event)) {
+                        return true;
+                    }
+                    if (component && isSlashMenuRef(component)) {
+                        return component.onKeyDown(props.event);
+                    }
+                    return false;
+                },
+                onExit: () => {
+                    if (component) {
+                        unmount(component);
+                    }
+                    suggestionContainer?.destroy();
+                    component = null;
+                    suggestionContainer = null;
+                },
+            };
+        },
+    };
+}

package/dist/runes/createVizelState.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { Editor } from "@vizel/core";
+/**
+ * Rune that forces a re-render whenever the editor's state changes.
+ * This is useful for components that need to reflect the current editor state
+ * (e.g., formatting buttons that show active state).
+ *
+ * @param getEditor - A function that returns the editor instance
+ * @returns An object with a `current` getter for the update count
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * const state = createVizelState(() => editor);
+ * // Access state.current to trigger reactivity
+ * </script>
+ * <button class:active={state.current >= 0 && editor.isActive('bold')}>Bold</button>
+ * ```
+ */
+export declare function createVizelState(getEditor: () => Editor | null | undefined): {
+    readonly current: number;
+};
+//# sourceMappingURL=createVizelState.svelte.d.ts.map

package/dist/runes/createVizelState.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createVizelState.svelte.d.ts","sourceRoot":"","sources":["../../src/runes/createVizelState.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG;IAC5E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAuCA"}

package/dist/runes/createVizelState.svelte.js

@@ -0,0 +1,50 @@
+/**
+ * Rune that forces a re-render whenever the editor's state changes.
+ * This is useful for components that need to reflect the current editor state
+ * (e.g., formatting buttons that show active state).
+ *
+ * @param getEditor - A function that returns the editor instance
+ * @returns An object with a `current` getter for the update count
+ *
+ * @example
+ * ```svelte
+ * <script lang="ts">
+ * const state = createVizelState(() => editor);
+ * // Access state.current to trigger reactivity
+ * </script>
+ * <button class:active={state.current >= 0 && editor.isActive('bold')}>Bold</button>
+ * ```
+ */
+export function createVizelState(getEditor) {
+    let updateCount = $state(0);
+    let currentEditor = null;
+    function handleTransaction() {
+        updateCount++;
+    }
+    function subscribe(editor) {
+        // Unsubscribe from previous editor
+        if (currentEditor) {
+            currentEditor.off("transaction", handleTransaction);
+        }
+        currentEditor = editor ?? null;
+        // Subscribe to new editor
+        if (currentEditor) {
+            currentEditor.on("transaction", handleTransaction);
+        }
+    }
+    // Use $effect to watch for editor changes - $effect cleanup handles unmount
+    $effect(() => {
+        const editor = getEditor();
+        subscribe(editor);
+        return () => {
+            if (currentEditor) {
+                currentEditor.off("transaction", handleTransaction);
+            }
+        };
+    });
+    return {
+        get current() {
+            return updateCount;
+        },
+    };
+}

package/dist/runes/getVizelTheme.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { VizelThemeState } from "@vizel/core";
+/**
+ * Get theme state and controls from context
+ *
+ * Must be used within a VizelThemeProvider
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * const theme = getVizelTheme();
+ * </script>
+ *
+ * <button onclick={() => theme.setTheme(theme.resolvedTheme === 'dark' ? 'light' : 'dark')}>
+ *   Toggle theme
+ * </button>
+ * ```
+ */
+export declare function getVizelTheme(): VizelThemeState;
+/**
+ * Get theme state safely (returns null if not in provider)
+ */
+export declare function getVizelThemeSafe(): VizelThemeState | null;
+//# sourceMappingURL=getVizelTheme.svelte.d.ts.map

package/dist/runes/getVizelTheme.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getVizelTheme.svelte.d.ts","sourceRoot":"","sources":["../../src/runes/getVizelTheme.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAInD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,IAAI,eAAe,CAQ/C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,eAAe,GAAG,IAAI,CAE1D"}

package/dist/runes/getVizelTheme.svelte.js

@@ -0,0 +1,31 @@
+import { getContext } from "svelte";
+import { VIZEL_THEME_CONTEXT_KEY } from "../components/VizelThemeProvider.svelte";
+/**
+ * Get theme state and controls from context
+ *
+ * Must be used within a VizelThemeProvider
+ *
+ * @example
+ * ```svelte
+ * <script>
+ * const theme = getVizelTheme();
+ * </script>
+ *
+ * <button onclick={() => theme.setTheme(theme.resolvedTheme === 'dark' ? 'light' : 'dark')}>
+ *   Toggle theme
+ * </button>
+ * ```
+ */
+export function getVizelTheme() {
+    const context = getContext(VIZEL_THEME_CONTEXT_KEY);
+    if (!context) {
+        throw new Error("getVizelTheme must be used within a VizelThemeProvider");
+    }
+    return context;
+}
+/**
+ * Get theme state safely (returns null if not in provider)
+ */
+export function getVizelThemeSafe() {
+    return getContext(VIZEL_THEME_CONTEXT_KEY) ?? null;
+}

package/dist/runes/index.d.ts

@@ -0,0 +1,8 @@
+export { type CreateVizelAutoSaveResult, createVizelAutoSave, } from "./createVizelAutoSave.svelte.ts";
+export { type CreateVizelEditorOptions, createVizelEditor, } from "./createVizelEditor.svelte.ts";
+export { createVizelEditorState } from "./createVizelEditorState.svelte.ts";
+export { type CreateVizelMarkdownOptions, type CreateVizelMarkdownResult, createVizelMarkdown, } from "./createVizelMarkdown.svelte.ts";
+export { createVizelSlashMenuRenderer, type VizelSlashMenuRendererOptions, } from "./createVizelSlashMenuRenderer.ts";
+export { createVizelState } from "./createVizelState.svelte.ts";
+export { getVizelTheme, getVizelThemeSafe } from "./getVizelTheme.svelte.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/runes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,yBAAyB,EAC9B,mBAAmB,GACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,KAAK,wBAAwB,EAC7B,iBAAiB,GAClB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,yBAAyB,EAC9B,mBAAmB,GACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,4BAA4B,EAC5B,KAAK,6BAA6B,GACnC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/runes/index.js

@@ -0,0 +1,7 @@
+export { createVizelAutoSave, } from "./createVizelAutoSave.svelte.ts";
+export { createVizelEditor, } from "./createVizelEditor.svelte.ts";
+export { createVizelEditorState } from "./createVizelEditorState.svelte.ts";
+export { createVizelMarkdown, } from "./createVizelMarkdown.svelte.ts";
+export { createVizelSlashMenuRenderer, } from "./createVizelSlashMenuRenderer.ts";
+export { createVizelState } from "./createVizelState.svelte.ts";
+export { getVizelTheme, getVizelThemeSafe } from "./getVizelTheme.svelte.ts";

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@vizel/svelte",
+  "version": "0.0.1-alpha.1",
+  "description": "Svelte 5 components for Vizel block-based Markdown editor",
+  "keywords": [
+    "svelte",
+    "svelte5",
+    "tiptap",
+    "editor",
+    "markdown",
+    "wysiwyg",
+    "rich-text",
+    "block-editor"
+  ],
+  "license": "MIT",
+  "author": "Seiji Kohara",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seijikohara/vizel.git",
+    "directory": "packages/svelte"
+  },
+  "homepage": "https://github.com/seijikohara/vizel",
+  "bugs": "https://github.com/seijikohara/vizel/issues",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "svelte": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "svelte-package -i src -o dist",
+    "typecheck": "svelte-check --tsconfig ./tsconfig.json"
+  },
+  "dependencies": {
+    "@iconify/svelte": "^5",
+    "@vizel/core": "^0.0.1-alpha.1"
+  },
+  "peerDependencies": {
+    "svelte": "^5"
+  },
+  "devDependencies": {
+    "@sveltejs/package": "^2",
+    "@sveltejs/vite-plugin-svelte": "^6",
+    "svelte-check": "^4"
+  }
+}