@nocturnium/svelte-ide 1.0.2 → 1.0.3

package/dist/components/editor/index.js

@@ -4,13 +4,27 @@
 // Components
 export { default as Editor } from './Editor.svelte';
 export { default as CustomEditor } from './CustomEditor.svelte';
-export { default as CollaborativeEditor } from './CollaborativeEditor.svelte';
 export { default as EditorTabs } from './EditorTabs.svelte';
 export { default as EditorPane } from './EditorPane.svelte';
 export { default as FileIcon } from './FileIcon.svelte';
 export { default as FileExplorer } from './FileExplorer.svelte';
-// Core utilities
-export * from './core';
+// Core utilities (explicitly excluding CRDT binding; use @nocturnium/svelte-ide/crdt)
+export * from './core/state';
+export * from './core/navigation';
+export * from './core/keybindings';
+export * from './core/search';
+export * from './core/folding';
+export * from './core/multi-cursor';
+export * from './core/complexity-analyzer';
+export * from './core/ai-awareness';
+export * from './core/semantic-analyzer';
+export * from './core/commands';
+export * from './core/bracket-healer';
+export * from './core/git-blame';
+export * from './core/snippet-manager';
+export * from './core/quick-actions';
+export * from './core/diagnostics';
+export * from './core/breakpoints';
 // Theme
 export * from './theme';
 // Languages (explicit exports to avoid conflicts with tokenizer)
@@ -18,4 +32,4 @@ export { getLanguageExtension, getLanguageConfig, getLanguageFromExtension, getL
 // Re-export from languages (these exist in both but we prefer languages versions)
 export { getSupportedLanguages, isLanguageSupported } from './languages';
 // Tokenizer (explicit exports to avoid conflicts)
-export { getTokenizer, tokenize, getTokenClass, tokensToHTML, PlaintextTokenizer, SimpleTokenizer, GrammarTokenizer, createToken } from './tokenizer';
+export { getTokenizer, tokenize, getTokenClass, tokensToHTML, PlaintextTokenizer, createToken } from './tokenizer';

package/dist/components/editor/tokenizer/base.d.ts

@@ -1,35 +1,11 @@
 /**
  * Base tokenizer with common functionality
  */
-import type { Token, TokenizedLine, TokenizerState, TokenType, LanguageGrammar, LanguageTokenizer } from './types';
+import type { Token, TokenizedLine, TokenizerState, TokenType, LanguageTokenizer } from './types';
 /**
  * Create a token
  */
 export declare function createToken(type: TokenType, text: string, start: number): Token;
-/**
- * Base tokenizer class using grammar rules
- */
-export declare class GrammarTokenizer implements LanguageTokenizer {
-    language: string;
-    private grammar;
-    constructor(grammar: LanguageGrammar);
-    getInitialState(): TokenizerState;
-    tokenizeLine(line: string, lineNumber: number, prevState?: TokenizerState): TokenizedLine;
-    private updateState;
-}
-/**
- * Simple regex-based tokenizer for basic languages
- */
-export declare class SimpleTokenizer implements LanguageTokenizer {
-    language: string;
-    private patterns;
-    constructor(language: string, patterns: Array<{
-        type: TokenType;
-        regex: RegExp;
-    }>);
-    getInitialState(): TokenizerState;
-    tokenizeLine(line: string, lineNumber: number, prevState?: TokenizerState): TokenizedLine;
-}
 /**
  * Plaintext tokenizer - no highlighting
  */

package/dist/components/editor/tokenizer/base.js

@@ -12,178 +12,6 @@ export function createToken(type, text, start) {
         end: start + text.length
     };
 }
-/**
- * Base tokenizer class using grammar rules
- */
-export class GrammarTokenizer {
-    language;
-    grammar;
-    constructor(grammar) {
-        this.language = grammar.language;
-        this.grammar = grammar;
-    }
-    getInitialState() {
-        return {};
-    }
-    tokenizeLine(line, lineNumber, prevState) {
-        const tokens = [];
-        let pos = 0;
-        const state = { ...prevState };
-        let currentRuleSet = 'root';
-        // Determine starting rule set based on state
-        if (state.inBlockComment) {
-            currentRuleSet = 'blockComment';
-        }
-        else if (state.inTemplateLiteral) {
-            currentRuleSet = 'templateLiteral';
-        }
-        else if (state.inMultilineString) {
-            currentRuleSet = 'multilineString';
-        }
-        while (pos < line.length) {
-            const remaining = line.slice(pos);
-            let matched = false;
-            // Try to match rules in current rule set
-            const rules = this.grammar.rules[currentRuleSet] || this.grammar.rules['root'] || [];
-            for (const rule of rules) {
-                const match = remaining.match(rule.pattern);
-                if (match && match.index === 0) {
-                    const text = match[0];
-                    tokens.push(createToken(rule.type, text, pos));
-                    pos += text.length;
-                    matched = true;
-                    // Handle state transitions
-                    if (rule.nextState) {
-                        currentRuleSet = rule.nextState;
-                        this.updateState(state, rule.nextState, true);
-                    }
-                    if (rule.popState) {
-                        currentRuleSet = 'root';
-                        this.updateState(state, currentRuleSet, false);
-                    }
-                    break;
-                }
-            }
-            // No match - consume single character as text
-            if (!matched) {
-                const char = line[pos];
-                // Try to merge with previous text token
-                const lastToken = tokens[tokens.length - 1];
-                if (lastToken && lastToken.type === 'text' && lastToken.end === pos) {
-                    lastToken.text += char;
-                    lastToken.end += 1;
-                }
-                else {
-                    tokens.push(createToken('text', char, pos));
-                }
-                pos += 1;
-            }
-        }
-        // Handle empty lines
-        if (tokens.length === 0) {
-            tokens.push(createToken('text', '', 0));
-        }
-        return {
-            lineNumber,
-            tokens,
-            text: line,
-            state: { ...state }
-        };
-    }
-    updateState(state, ruleSet, entering) {
-        switch (ruleSet) {
-            case 'blockComment':
-                state.inBlockComment = entering;
-                break;
-            case 'templateLiteral':
-                state.inTemplateLiteral = entering;
-                break;
-            case 'multilineString':
-                state.inMultilineString = entering;
-                break;
-        }
-    }
-}
-/**
- * Simple regex-based tokenizer for basic languages
- */
-export class SimpleTokenizer {
-    language;
-    patterns;
-    constructor(language, patterns) {
-        this.language = language;
-        this.patterns = patterns;
-    }
-    getInitialState() {
-        return {};
-    }
-    tokenizeLine(line, lineNumber, prevState) {
-        const tokens = [];
-        let pos = 0;
-        const state = { ...prevState };
-        // Handle block comment continuation
-        if (state.inBlockComment) {
-            const endMatch = line.indexOf('*/');
-            if (endMatch !== -1) {
-                tokens.push(createToken('comment.block', line.slice(0, endMatch + 2), 0));
-                pos = endMatch + 2;
-                state.inBlockComment = false;
-            }
-            else {
-                tokens.push(createToken('comment.block', line, 0));
-                return { lineNumber, tokens, text: line, state };
-            }
-        }
-        while (pos < line.length) {
-            const remaining = line.slice(pos);
-            let matched = false;
-            // Check for block comment start
-            if (remaining.startsWith('/*')) {
-                const endMatch = remaining.indexOf('*/', 2);
-                if (endMatch !== -1) {
-                    const text = remaining.slice(0, endMatch + 2);
-                    tokens.push(createToken('comment.block', text, pos));
-                    pos += text.length;
-                }
-                else {
-                    tokens.push(createToken('comment.block', remaining, pos));
-                    state.inBlockComment = true;
-                    pos = line.length;
-                }
-                matched = true;
-                continue;
-            }
-            // Try each pattern
-            for (const { type, regex } of this.patterns) {
-                const match = remaining.match(regex);
-                if (match && match.index === 0) {
-                    const text = match[0];
-                    tokens.push(createToken(type, text, pos));
-                    pos += text.length;
-                    matched = true;
-                    break;
-                }
-            }
-            // No match - consume character
-            if (!matched) {
-                const char = remaining[0];
-                const lastToken = tokens[tokens.length - 1];
-                if (lastToken && lastToken.type === 'text' && lastToken.end === pos) {
-                    lastToken.text += char;
-                    lastToken.end += 1;
-                }
-                else {
-                    tokens.push(createToken('text', char, pos));
-                }
-                pos += 1;
-            }
-        }
-        if (tokens.length === 0) {
-            tokens.push(createToken('text', '', 0));
-        }
-        return { lineNumber, tokens, text: line, state };
-    }
-}
 /**
  * Plaintext tokenizer - no highlighting
  */

package/dist/components/editor/tokenizer/index.d.ts

@@ -15,6 +15,10 @@ export { GoTokenizer, createGoTokenizer } from './languages/go';
 export { MarkdownTokenizer, createMarkdownTokenizer } from './languages/markdown';
 export { SvelteTokenizer, createSvelteTokenizer } from './languages/svelte';
 import type { LanguageTokenizer, Token, TokenizedLine, TokenizerState, TokenType } from './types';
+/**
+ * Tokenizer factory functions by language
+ */
+export declare const tokenizerFactories: Record<string, () => LanguageTokenizer>;
 /**
  * Get the canonical language name from an alias or extension
  */

package/dist/components/editor/tokenizer/index.js

@@ -78,7 +78,7 @@ const languageAliases = {
 /**
  * Tokenizer factory functions by language
  */
-const tokenizerFactories = {
+export const tokenizerFactories = {
     javascript: createJavaScriptTokenizer,
     typescript: createTypeScriptTokenizer,
     jsx: createJSXTokenizer,

package/dist/components/editor/tokenizer/languages/html.d.ts

@@ -3,14 +3,15 @@
  */
 import type { TokenizedLine, TokenizerState } from '../types';
 interface HTMLTokenizerState extends TokenizerState {
-    inTag?: boolean;
     inScript?: boolean;
     inStyle?: boolean;
-    tagName?: string;
+    innerState?: TokenizerState;
 }
 export declare class HTMLTokenizer {
     language: string;
     private isXML;
+    private jsTokenizer;
+    private cssTokenizer;
     constructor(options?: {
         xml?: boolean;
     });

package/dist/components/editor/tokenizer/languages/html.js

@@ -2,9 +2,13 @@
  * HTML/XML tokenizer
  */
 import { createToken } from '../base';
+import { createCSSTokenizer } from './css';
+import { createJavaScriptTokenizer } from './javascript';
 export class HTMLTokenizer {
     language;
     isXML;
+    jsTokenizer = createJavaScriptTokenizer();
+    cssTokenizer = createCSSTokenizer();
     constructor(options = {}) {
         this.isXML = options.xml ?? false;
         this.language = this.isXML ? 'xml' : 'html';
@@ -29,6 +33,54 @@ export class HTMLTokenizer {
                 return { lineNumber, tokens, text: line, state };
             }
         }
+        if (!this.isXML && state.inScript) {
+            const closeScriptMatch = line.match(/<\/script>/i);
+            if (closeScriptMatch) {
+                const scriptPart = line.slice(0, closeScriptMatch.index);
+                if (scriptPart) {
+                    const result = this.jsTokenizer.tokenizeLine(scriptPart, lineNumber, state.innerState ?? this.jsTokenizer.getInitialState());
+                    tokens.push(...result.tokens);
+                    state.innerState = result.state;
+                }
+                state.inScript = false;
+                state.innerState = undefined;
+                pos = closeScriptMatch.index;
+            }
+            else {
+                const result = this.jsTokenizer.tokenizeLine(line, lineNumber, state.innerState ?? this.jsTokenizer.getInitialState());
+                state.innerState = result.state;
+                return {
+                    lineNumber,
+                    tokens: result.tokens,
+                    text: line,
+                    state
+                };
+            }
+        }
+        if (!this.isXML && state.inStyle) {
+            const closeStyleMatch = line.match(/<\/style>/i);
+            if (closeStyleMatch) {
+                const stylePart = line.slice(0, closeStyleMatch.index);
+                if (stylePart) {
+                    const result = this.cssTokenizer.tokenizeLine(stylePart, lineNumber, state.innerState ?? this.cssTokenizer.getInitialState());
+                    tokens.push(...result.tokens);
+                    state.innerState = result.state;
+                }
+                state.inStyle = false;
+                state.innerState = undefined;
+                pos = closeStyleMatch.index;
+            }
+            else {
+                const result = this.cssTokenizer.tokenizeLine(line, lineNumber, state.innerState ?? this.cssTokenizer.getInitialState());
+                state.innerState = result.state;
+                return {
+                    lineNumber,
+                    tokens: result.tokens,
+                    text: line,
+                    state
+                };
+            }
+        }
         while (pos < line.length) {
             const remaining = line.slice(pos);
             const token = this.getNextToken(remaining, pos, state, line);
@@ -89,10 +141,14 @@ export class HTMLTokenizer {
         const closingTagMatch = text.match(/^<\/([a-zA-Z][a-zA-Z0-9:-]*)>/);
         if (closingTagMatch) {
             const tagName = closingTagMatch[1].toLowerCase();
-            if (tagName === 'script')
+            if (tagName === 'script') {
                 state.inScript = false;
-            if (tagName === 'style')
+                state.innerState = undefined;
+            }
+            if (tagName === 'style') {
                 state.inStyle = false;
+                state.innerState = undefined;
+            }
             return createToken('tag', closingTagMatch[0], pos);
         }
         // Opening tag
@@ -121,17 +177,19 @@ export class HTMLTokenizer {
         }
         if (openingMatch) {
             const tagName = openingMatch[1].toLowerCase();
-            if (tagName === 'script')
+            if (!this.isXML && tagName === 'script') {
                 state.inScript = true;
-            if (tagName === 'style')
+                state.innerState = this.jsTokenizer.getInitialState();
+            }
+            if (!this.isXML && tagName === 'style') {
                 state.inStyle = true;
+                state.innerState = this.cssTokenizer.getInitialState();
+            }
             return createToken('tag', openingMatch[0], pos);
         }
         // Partial tag - just match the tag name part
         const partialMatch = text.match(/^<([a-zA-Z][a-zA-Z0-9:-]*)/);
         if (partialMatch) {
-            state.inTag = true;
-            state.tagName = partialMatch[1];
             return createToken('tag.name', partialMatch[0], pos);
         }
         return createToken('tag.punctuation', '<', pos);

package/dist/components/editor/tokenizer/languages/javascript.d.ts

@@ -4,9 +4,6 @@
 import type { TokenizedLine, TokenizerState } from '../types';
 interface JSTokenizerState extends TokenizerState {
     templateDepth?: number;
-    jsxDepth?: number;
-    /** Track if regex is valid in current context (for division vs regex ambiguity) */
-    expectExpression?: boolean;
     /**
      * Last significant token text, used for regex/division disambiguation.
      * Stored per-line in the threaded state (not on the tokenizer instance) so a

package/dist/components/editor/tokenizer/languages/javascript.js

@@ -234,8 +234,7 @@ export class JavaScriptTokenizer {
     }
     getInitialState() {
         return {
-            templateDepth: 0,
-            jsxDepth: 0
+            templateDepth: 0
         };
     }
     tokenizeLine(line, lineNumber, prevState) {

package/dist/components/editor/tokenizer/languages/svelte.d.ts

@@ -29,7 +29,7 @@ export declare class SvelteTokenizer implements LanguageTokenizer {
     private cssTokenizer;
     constructor();
     getInitialState(): SvelteTokenizerState;
-    tokenizeLine(line: string, lineNumber: number, state: SvelteTokenizerState): TokenizedLine;
+    tokenizeLine(line: string, lineNumber: number, prevState?: SvelteTokenizerState): TokenizedLine;
     private tokenizeTemplate;
     private tokenizeTag;
     private tokenizeJSExpression;

package/dist/components/editor/tokenizer/languages/svelte.js

@@ -65,9 +65,14 @@ export class SvelteTokenizer {
             tagDepth: 0
         };
     }
-    tokenizeLine(line, lineNumber, state) {
+    tokenizeLine(line, lineNumber, prevState) {
         const tokens = [];
         let pos = 0;
+        const state = {
+            ...this.getInitialState(),
+            ...prevState,
+            innerState: prevState?.innerState ? { ...prevState.innerState } : undefined
+        };
         // Handle script context
         if (state.context === 'script') {
             const closeScriptMatch = line.match(/<\/script>/i);

package/dist/components/editor/tokenizer/types.d.ts

@@ -56,31 +56,3 @@ export interface LanguageTokenizer {
     /** Get initial state */
     getInitialState(): TokenizerState;
 }
-/**
- * Token rule for regex-based tokenization
- */
-export interface TokenRule {
-    /** Token type to assign */
-    type: TokenType;
-    /** Regex pattern to match */
-    pattern: RegExp;
-    /** Optional: next state after matching */
-    nextState?: string;
-    /** Optional: pop state after matching */
-    popState?: boolean;
-}
-/**
- * Grammar definition for a language
- */
-export interface LanguageGrammar {
-    /** Language identifier */
-    language: string;
-    /** File extensions */
-    extensions: string[];
-    /** Line comment prefix */
-    lineComment?: string;
-    /** Block comment start/end */
-    blockComment?: [string, string];
-    /** Token rules by state */
-    rules: Record<string, TokenRule[]>;
-}

package/dist/crdt/awareness.d.ts

@@ -28,10 +28,16 @@ export interface AwarenessProtocol {
     onUsersChange(callback: (users: AwarenessUser[]) => void): () => void;
     destroy(): void;
 }
+export interface CreateAwarenessProtocolOptions {
+    destroyAwareness?: boolean;
+}
 /**
- * Create an awareness protocol instance
+ * Create an awareness protocol instance.
+ *
+ * Pass a provider-owned Awareness instance to broadcast presence through that
+ * provider. Passing a Y.Doc creates a standalone Awareness instance.
  */
-export declare function createAwarenessProtocol(doc: YDoc): AwarenessProtocol;
+export declare function createAwarenessProtocol(source: YDoc | Awareness, options?: CreateAwarenessProtocolOptions): AwarenessProtocol;
 /**
  * Generate a random color for a user
  */

package/dist/crdt/awareness.js

@@ -3,10 +3,15 @@
  */
 import { Awareness } from 'y-protocols/awareness';
 /**
- * Create an awareness protocol instance
+ * Create an awareness protocol instance.
+ *
+ * Pass a provider-owned Awareness instance to broadcast presence through that
+ * provider. Passing a Y.Doc creates a standalone Awareness instance.
  */
-export function createAwarenessProtocol(doc) {
-    const awareness = new Awareness(doc);
+export function createAwarenessProtocol(source, options = {}) {
+    const ownsAwareness = source instanceof Awareness;
+    const awareness = ownsAwareness ? source : new Awareness(source);
+    const shouldDestroyAwareness = options.destroyAwareness ?? !ownsAwareness;
     const userChangeCallbacks = new Set();
     // Track awareness changes
     awareness.on('change', () => {
@@ -75,7 +80,9 @@ export function createAwarenessProtocol(doc) {
             return () => userChangeCallbacks.delete(callback);
         },
         destroy() {
-            awareness.destroy();
+            if (shouldDestroyAwareness) {
+                awareness.destroy();
+            }
             userChangeCallbacks.clear();
         }
     };

package/dist/crdt/document.d.ts

@@ -4,6 +4,11 @@
  */
 import * as Y from 'yjs';
 import type { DocumentOptions } from './types';
+export interface CollaborativeUndoManagerOptions {
+    captureTimeout?: number;
+    trackedOrigins?: Set<unknown>;
+    deleteFilter?: (item: Y.Item) => boolean;
+}
 export declare class CollaborativeDocument {
     readonly doc: Y.Doc;
     readonly id: string;
@@ -49,7 +54,11 @@ export declare class CollaborativeDocument {
     /**
      * Setup undo manager
      */
-    private setupUndoManager;
+    getUndoManager(options?: CollaborativeUndoManagerOptions): Y.UndoManager;
+    /**
+     * Check whether this document currently owns an undo manager.
+     */
+    hasUndoManager(): boolean;
     /**
      * Track additional origins for undo
      */

package/dist/crdt/document.js

@@ -18,7 +18,7 @@ export class CollaborativeDocument {
         }
         // Setup undo manager if enabled
         if (options.enableUndo !== false) {
-            this.setupUndoManager(options.undoCaptureTimeout);
+            this.getUndoManager({ captureTimeout: options.undoCaptureTimeout });
         }
     }
     /**
@@ -97,20 +97,28 @@ export class CollaborativeDocument {
     /**
      * Setup undo manager
      */
-    setupUndoManager(captureTimeout = 500) {
-        const trackedOrigins = new Set([null, 'local']);
+    getUndoManager(options = {}) {
+        if (this.undoManager)
+            return this.undoManager;
+        const { captureTimeout = 500, trackedOrigins = new Set([null, 'local']), deleteFilter } = options;
         this.undoManager = new Y.UndoManager(this.getText(), {
             trackedOrigins,
-            captureTimeout
+            captureTimeout,
+            deleteFilter
         });
+        return this.undoManager;
+    }
+    /**
+     * Check whether this document currently owns an undo manager.
+     */
+    hasUndoManager() {
+        return this.undoManager !== null;
     }
     /**
      * Track additional origins for undo
      */
     trackOrigin(origin) {
-        if (this.undoManager) {
-            this.undoManager.trackedOrigins.add(origin);
-        }
+        this.getUndoManager().trackedOrigins.add(origin);
     }
     /**
      * Undo last change

package/dist/crdt/index.d.ts

@@ -4,6 +4,12 @@
  */
 export { CollaborativeDocument } from './document';
 export { CollaborativeProvider } from './provider';
-export { createAwarenessProtocol } from './awareness';
-export { createUndoManager } from './undo';
+export { createProvider } from './provider';
+export { createAwarenessProtocol, generateUserColor, getInitials } from './awareness';
+export { createUndoManager, createUserUndoManager } from './undo';
+export { default as CollaborativeEditor } from '../components/editor/CollaborativeEditor.svelte';
+export { CRDTBinding, createCRDTBinding, createRelativePosition, resolveRelativePosition } from '../components/editor/core/crdt-binding';
 export type * from './types';
+export type { AwarenessProtocol, AwarenessUser, CreateAwarenessProtocolOptions } from './awareness';
+export type { UndoManagerInstance, UndoManagerOptions, UndoManagerState } from './undo';
+export type { CRDTBindingConfig, CRDTPosition, RelativePosition } from '../components/editor/core/crdt-binding';

package/dist/crdt/index.js

@@ -4,5 +4,8 @@
  */
 export { CollaborativeDocument } from './document';
 export { CollaborativeProvider } from './provider';
-export { createAwarenessProtocol } from './awareness';
-export { createUndoManager } from './undo';
+export { createProvider } from './provider';
+export { createAwarenessProtocol, generateUserColor, getInitials } from './awareness';
+export { createUndoManager, createUserUndoManager } from './undo';
+export { default as CollaborativeEditor } from '../components/editor/CollaborativeEditor.svelte';
+export { CRDTBinding, createCRDTBinding, createRelativePosition, resolveRelativePosition } from '../components/editor/core/crdt-binding';

package/dist/crdt/undo.d.ts

@@ -1,13 +1,8 @@
 /**
  * Undo manager for CRDT documents
  */
-import * as Y from 'yjs';
-import type { CollaborativeDocument } from './document';
-export interface UndoManagerOptions {
-    captureTimeout?: number;
-    trackedOrigins?: Set<unknown>;
-    deleteFilter?: (item: Y.Item) => boolean;
-}
+import type { CollaborativeDocument, CollaborativeUndoManagerOptions } from './document';
+export type UndoManagerOptions = CollaborativeUndoManagerOptions;
 export interface UndoManagerState {
     canUndo: boolean;
     canRedo: boolean;

package/dist/crdt/undo.js

@@ -1,18 +1,11 @@
 /**
  * Undo manager for CRDT documents
  */
-import * as Y from 'yjs';
 /**
  * Create an undo manager for a collaborative document
  */
 export function createUndoManager(document, options = {}) {
-    const { captureTimeout = 500, trackedOrigins = new Set([null, 'local']), deleteFilter } = options;
-    const text = document.getText();
-    const manager = new Y.UndoManager(text, {
-        captureTimeout,
-        trackedOrigins,
-        deleteFilter
-    });
+    const manager = document.getUndoManager(options);
     const stateCallbacks = new Set();
     function getState() {
         return {