@thyn/core 0.0.351 → 0.0.353

package/dist/plugin/utils.js

@@ -1,12 +1,13 @@
 export function extractParts(code) {
     // Helper to check if a position is inside a string literal or comment
-    function isInsideStringOrComment(code, pos) {
+    // within a specific range (used for checking script content only)
+    function isInsideStringOrComment(code, startPos, endPos) {
         let inString = false;
         let stringChar = '';
         let escaped = false;
         let inLineComment = false;
         let inBlockComment = false;
-        for (let i = 0; i < pos; i++) {
+        for (let i = startPos; i < endPos; i++) {
             const char = code[i];
             const nextChar = code[i + 1];
             if (inLineComment) {
@@ -52,45 +53,114 @@ export function extractParts(code) {
         }
         return inString || inLineComment || inBlockComment;
     }
-    // Find first real <script> tag (not inside a string)
-    function findScriptSection(code) {
+    // Find all script tag positions with their boundaries
+    function findScriptBoundaries(code) {
+        const boundaries = [];
         const openRegex = /<script([^>]*)>/gi;
+        const closeRegex = /<\/script>/gi;
         let openMatch;
         while ((openMatch = openRegex.exec(code)) !== null) {
-            if (!isInsideStringOrComment(code, openMatch.index)) {
-                const contentStart = openMatch.index + openMatch[0].length;
-                // Find the first </script> that is not inside a string
-                const closeRegex = /<\/script>/gi;
-                let closeMatch;
-                while ((closeMatch = closeRegex.exec(code)) !== null) {
-                    if (closeMatch.index >= contentStart && !isInsideStringOrComment(code, closeMatch.index)) {
-                        return {
-                            start: openMatch.index,
-                            contentStart: contentStart,
-                            contentEnd: closeMatch.index,
-                            end: closeMatch.index + closeMatch[0].length,
-                            attrs: openMatch[1] || ''
-                        };
+            const openIndex = openMatch.index;
+            const openLength = openMatch[0].length;
+            const attrs = openMatch[1] || '';
+            // Find matching close tag
+            closeRegex.lastIndex = openIndex + openLength;
+            let closeMatch;
+            while ((closeMatch = closeRegex.exec(code)) !== null) {
+                // Check if this close tag is inside a JS string within this script
+                const contentStart = openIndex + openLength;
+                if (!isInsideStringOrComment(code, contentStart, closeMatch.index)) {
+                    boundaries.push({
+                        start: openIndex,
+                        end: closeMatch.index + closeMatch[0].length,
+                        attrs
+                    });
+                    break;
+                }
+            }
+        }
+        return boundaries;
+    }
+    // Find the real script section (not inside a string of another script)
+    function findScriptSection(code) {
+        const allBoundaries = findScriptBoundaries(code);
+        if (allBoundaries.length === 0)
+            return null;
+        // The first script tag is the real one if it's not inside any other script's string
+        // Check each boundary to see if it's inside another script's content
+        for (const boundary of allBoundaries) {
+            let isInsideAnotherScript = false;
+            for (const other of allBoundaries) {
+                if (other === boundary)
+                    continue;
+                // Check if this boundary is inside another script's content
+                const otherContentStart = other.start + code.slice(other.start, other.end).indexOf('>') + 1;
+                const otherContentEnd = other.end - code.slice(other.end - 10, other.end).indexOf('<') - 10 + code.slice(other.end - 10, other.end).indexOf('<');
+                if (boundary.start > otherContentStart && boundary.start < other.end) {
+                    // This boundary is inside another script's content area
+                    // Check if it's inside a JS string
+                    if (isInsideStringOrComment(code, otherContentStart, boundary.start)) {
+                        isInsideAnotherScript = true;
+                        break;
                     }
                 }
             }
+            if (!isInsideAnotherScript) {
+                // This is the real script section
+                const openTagEnd = code.indexOf('>', boundary.start) + 1;
+                const closeTagStart = code.lastIndexOf('<', boundary.end - 1);
+                return {
+                    start: boundary.start,
+                    contentStart: openTagEnd,
+                    contentEnd: closeTagStart,
+                    end: boundary.end,
+                    attrs: boundary.attrs
+                };
+            }
         }
         return null;
     }
-    // Find first real <style> tag (not inside a string)
+    // Find the real style section (outside of script sections)
     function findStyleSection(code) {
+        const scriptBoundaries = findScriptBoundaries(code);
         const openRegex = /<style[^>]*>/gi;
+        const closeRegex = /<\/style>/gi;
         let openMatch;
         while ((openMatch = openRegex.exec(code)) !== null) {
-            if (!isInsideStringOrComment(code, openMatch.index)) {
-                const contentStart = openMatch.index + openMatch[0].length;
-                // Find the first </style> that is not inside a string
-                const closeRegex = /<\/style>/gi;
+            const openIndex = openMatch.index;
+            // Check if this style tag is inside any script section
+            let isInsideScript = false;
+            for (const script of scriptBoundaries) {
+                const contentStart = script.start + code.slice(script.start, script.end).indexOf('>') + 1;
+                const contentEnd = script.end - code.slice(script.end - 10, script.end).indexOf('<') - 10 + code.slice(script.end - 10, script.end).indexOf('<');
+                if (openIndex >= contentStart && openIndex < script.end) {
+                    // It's in the script section, check if inside a JS string
+                    if (isInsideStringOrComment(code, contentStart, openIndex)) {
+                        isInsideScript = true;
+                        break;
+                    }
+                }
+            }
+            if (!isInsideScript) {
+                // Found a real style tag, now find its close tag
+                const contentStart = openIndex + openMatch[0].length;
+                closeRegex.lastIndex = contentStart;
                 let closeMatch;
                 while ((closeMatch = closeRegex.exec(code)) !== null) {
-                    if (closeMatch.index >= contentStart && !isInsideStringOrComment(code, closeMatch.index)) {
+                    // Make sure close tag is also outside scripts
+                    let closeIsInsideScript = false;
+                    for (const script of scriptBoundaries) {
+                        const scriptContentStart = script.start + code.slice(script.start, script.end).indexOf('>') + 1;
+                        if (closeMatch.index >= scriptContentStart && closeMatch.index < script.end) {
+                            if (isInsideStringOrComment(code, scriptContentStart, closeMatch.index)) {
+                                closeIsInsideScript = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (!closeIsInsideScript) {
                         return {
-                            start: openMatch.index,
+                            start: openIndex,
                             contentStart: contentStart,
                             contentEnd: closeMatch.index,
                             end: closeMatch.index + closeMatch[0].length
@@ -168,13 +238,13 @@ export function splitScript(script) {
     let inString = false;
     let stringChar = "";
     let inMultiLineComment = false;
+    let escaped = false;
     // Helper function to check if import is complete without semicolon
-    function isImportComplete(line, braceCount, inString) {
+    function isImportComplete(lineIndex, braceCount, inString) {
         // If we have balanced braces and not in a string, check if next non-empty line starts a new statement
         if (braceCount === 0 && !inString) {
             // Look ahead to see if next line starts a new statement/declaration
-            const nextLineIndex = lines.indexOf(line) + 1;
-            for (let i = nextLineIndex; i < lines.length; i++) {
+            for (let i = lineIndex + 1; i < lines.length; i++) {
                 const nextLine = lines[i].trim();
                 if (!nextLine || nextLine.startsWith("//") || nextLine.startsWith("/*")) {
                     continue; // Skip empty lines and comments
@@ -188,6 +258,7 @@ export function splitScript(script) {
         }
         return false;
     }
+    // Process each line, maintaining string/comment state
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const trimmed = line.trim();
@@ -199,13 +270,34 @@ export function splitScript(script) {
             else {
                 body.push(line);
             }
-            if (line.includes("*/")) {
-                inMultiLineComment = false;
+            // Check for end of multi-line comment, tracking strings
+            for (let j = 0; j < line.length; j++) {
+                const char = line[j];
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (char === '\\' && inString) {
+                    escaped = true;
+                    continue;
+                }
+                if (!inString && (char === '"' || char === "'" || char === '`')) {
+                    inString = true;
+                    stringChar = char;
+                }
+                else if (inString && char === stringChar) {
+                    inString = false;
+                    stringChar = "";
+                }
+                else if (!inString && char === '*' && line[j + 1] === '/') {
+                    inMultiLineComment = false;
+                    break;
+                }
             }
             continue;
         }
-        // Check for start of multi-line comment
-        if (line.includes("/*") && !inString) {
+        // Check for start of multi-line comment (only if not in string)
+        if (!inString && line.includes("/*")) {
             inMultiLineComment = true;
             if (inImport) {
                 currentImport.push(line);
@@ -213,15 +305,37 @@ export function splitScript(script) {
             else {
                 body.push(line);
             }
-            if (!line.includes("*/")) {
-                continue;
+            // Check if comment ends on same line
+            for (let j = 0; j < line.length; j++) {
+                const char = line[j];
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (char === '\\' && inString) {
+                    escaped = true;
+                    continue;
+                }
+                if (!inString && (char === '"' || char === "'" || char === '`')) {
+                    inString = true;
+                    stringChar = char;
+                }
+                else if (inString && char === stringChar) {
+                    inString = false;
+                    stringChar = "";
+                }
+                else if (!inString && char === '*' && line[j + 1] === '/') {
+                    inMultiLineComment = false;
+                    break;
+                }
             }
-            else {
-                inMultiLineComment = false;
+            if (!inMultiLineComment) {
+                // Comment ended on same line
+                continue;
             }
         }
-        // Skip single-line comments when not in import
-        if (trimmed.startsWith("//") && !inImport) {
+        // Skip single-line comments when not in import (only if not in string)
+        if (!inString && !inImport && trimmed.startsWith("//")) {
             body.push(line);
             continue;
         }
@@ -230,37 +344,46 @@ export function splitScript(script) {
             body.push(line);
             continue;
         }
-        // Start of import statement
-        if (!inImport && trimmed.startsWith("import")) {
+        // Process the line character by character to maintain string state
+        let lineBraceCount = 0;
+        let lineInString = inString;
+        let lineStringChar = stringChar;
+        let lineEscaped = false;
+        for (let j = 0; j < line.length; j++) {
+            const char = line[j];
+            if (lineEscaped) {
+                lineEscaped = false;
+                continue;
+            }
+            if (char === '\\' && lineInString) {
+                lineEscaped = true;
+                continue;
+            }
+            if (!lineInString && (char === '"' || char === "'" || char === '`')) {
+                lineInString = true;
+                lineStringChar = char;
+            }
+            else if (lineInString && char === lineStringChar) {
+                lineInString = false;
+                lineStringChar = "";
+            }
+            else if (!lineInString && char === '{') {
+                lineBraceCount++;
+            }
+            else if (!lineInString && char === '}') {
+                lineBraceCount--;
+            }
+        }
+        // Start of import statement (only if not inside a string)
+        if (!inImport && !inString && trimmed.startsWith("import")) {
             inImport = true;
             currentImport = [line];
-            braceCount = 0;
-            inString = false;
-            // Count braces and track strings in the import line
-            for (let j = 0; j < line.length; j++) {
-                const char = line[j];
-                if (inString) {
-                    if (char === stringChar && line[j - 1] !== "\\") {
-                        inString = false;
-                        stringChar = "";
-                    }
-                }
-                else {
-                    if (char === '"' || char === "'" || char === "`") {
-                        inString = true;
-                        stringChar = char;
-                    }
-                    else if (char === "{") {
-                        braceCount++;
-                    }
-                    else if (char === "}") {
-                        braceCount--;
-                    }
-                }
-            }
-            // Check if import is complete
+            braceCount = lineBraceCount;
+            inString = lineInString;
+            stringChar = lineStringChar;
+            // Check if import is complete on this line
             if ((trimmed.endsWith(";") ||
-                isImportComplete(trimmed, braceCount, inString)) &&
+                isImportComplete(i, braceCount, inString)) &&
                 braceCount === 0 && !inString) {
                 imports.push(currentImport.join("\n"));
                 currentImport = [];
@@ -269,31 +392,12 @@ export function splitScript(script) {
         } // Continue import statement
         else if (inImport) {
             currentImport.push(line);
-            // Count braces and track strings in the current line
-            for (let j = 0; j < line.length; j++) {
-                const char = line[j];
-                if (inString) {
-                    if (char === stringChar && line[j - 1] !== "\\") {
-                        inString = false;
-                        stringChar = "";
-                    }
-                }
-                else {
-                    if (char === '"' || char === "'" || char === "`") {
-                        inString = true;
-                        stringChar = char;
-                    }
-                    else if (char === "{") {
-                        braceCount++;
-                    }
-                    else if (char === "}") {
-                        braceCount--;
-                    }
-                }
-            }
+            braceCount += lineBraceCount;
+            inString = lineInString;
+            stringChar = lineStringChar;
             // Check if import is complete
             if ((trimmed.endsWith(";") ||
-                isImportComplete(trimmed, braceCount, inString)) &&
+                isImportComplete(i, braceCount, inString)) &&
                 braceCount === 0 && !inString) {
                 imports.push(currentImport.join("\n"));
                 currentImport = [];
@@ -302,11 +406,21 @@ export function splitScript(script) {
         } // Regular body content
         else {
             body.push(line);
+            // Update global string state
+            inString = lineInString;
+            stringChar = lineStringChar;
         }
     }
-    // Handle unterminated import (likely malformed)
+    // Handle unterminated import (likely malformed or still in string)
     if (currentImport.length > 0) {
-        imports.push(currentImport.join("\n"));
+        if (inImport && !inString) {
+            // Import seems complete but wasn't captured properly
+            imports.push(currentImport.join("\n"));
+        }
+        else {
+            // Still in string or incomplete, treat as body
+            body.push(...currentImport);
+        }
     }
     return {
         imports: imports.filter((imp) => imp.trim()),

package/docs/package-lock.json

@@ -8,7 +8,7 @@
       "name": "thyn-app",
       "version": "0.0.0",
       "devDependencies": {
-        "@thyn/core": "^0.0.350",
+        "@thyn/core": "^0.0.352",
         "vite": "^6.3.5"
       }
     },
@@ -742,9 +742,9 @@
       ]
     },
     "node_modules/@thyn/core": {
-      "version": "0.0.350",
-      "resolved": "https://registry.npmjs.org/@thyn/core/-/core-0.0.350.tgz",
-      "integrity": "sha512-SZTB1jjjsXEkZg1BlH7s4Lhe8kWN/74ufNlNMnI86x+9tiyc0yvMLh+GFhe7VkIS//NrEwdgjR3ktpJlGeMEfA==",
+      "version": "0.0.352",
+      "resolved": "https://registry.npmjs.org/@thyn/core/-/core-0.0.352.tgz",
+      "integrity": "sha512-XvVkZ63CdWxF+OIOnLoxPOesQ0OFlfr/1CY4/LNrZO2QTK4/I92cRlbDaW1ajN3YDSuvf7BeEuWZe5hYn8Jd/Q==",
       "dev": true,
       "license": "MIT",
       "dependencies": {

package/docs/package.json

@@ -9,7 +9,7 @@
     "preview": "vite preview"
   },
   "devDependencies": {
-    "@thyn/core": "^0.0.350",
+    "@thyn/core": "^0.0.352",
     "vite": "^6.3.5"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thyn/core",
-  "version": "0.0.351",
+  "version": "0.0.353",
   "type": "module",
   "main": "dist/index.js",
   "exports": {

package/src/plugin/utils.ts

@@ -1,13 +1,14 @@
 export function extractParts(code: string) {
   // Helper to check if a position is inside a string literal or comment
-  function isInsideStringOrComment(code: string, pos: number): boolean {
+  // within a specific range (used for checking script content only)
+  function isInsideStringOrComment(code: string, startPos: number, endPos: number): boolean {
     let inString = false;
     let stringChar = '';
     let escaped = false;
     let inLineComment = false;
     let inBlockComment = false;
     
-    for (let i = 0; i < pos; i++) {
+    for (let i = startPos; i < endPos; i++) {
       const char = code[i];
       const nextChar = code[i + 1];
       
@@ -61,50 +62,127 @@ export function extractParts(code: string) {
     return inString || inLineComment || inBlockComment;
   }
 
-  // Find first real <script> tag (not inside a string)
-  function findScriptSection(code: string): { start: number; contentStart: number; contentEnd: number; end: number; attrs: string } | null {
+  // Find all script tag positions with their boundaries
+  function findScriptBoundaries(code: string): Array<{ start: number; end: number; attrs: string }> {
+    const boundaries = [];
     const openRegex = /<script([^>]*)>/gi;
+    const closeRegex = /<\/script>/gi;
     let openMatch;
     
     while ((openMatch = openRegex.exec(code)) !== null) {
-      if (!isInsideStringOrComment(code, openMatch.index)) {
-        const contentStart = openMatch.index + openMatch[0].length;
+      const openIndex = openMatch.index;
+      const openLength = openMatch[0].length;
+      const attrs = openMatch[1] || '';
+      
+      // Find matching close tag
+      closeRegex.lastIndex = openIndex + openLength;
+      let closeMatch;
+      while ((closeMatch = closeRegex.exec(code)) !== null) {
+        // Check if this close tag is inside a JS string within this script
+        const contentStart = openIndex + openLength;
+        if (!isInsideStringOrComment(code, contentStart, closeMatch.index)) {
+          boundaries.push({
+            start: openIndex,
+            end: closeMatch.index + closeMatch[0].length,
+            attrs
+          });
+          break;
+        }
+      }
+    }
+    
+    return boundaries;
+  }
+
+  // Find the real script section (not inside a string of another script)
+  function findScriptSection(code: string): { start: number; contentStart: number; contentEnd: number; end: number; attrs: string } | null {
+    const allBoundaries = findScriptBoundaries(code);
+    if (allBoundaries.length === 0) return null;
+    
+    // The first script tag is the real one if it's not inside any other script's string
+    // Check each boundary to see if it's inside another script's content
+    for (const boundary of allBoundaries) {
+      let isInsideAnotherScript = false;
+      
+      for (const other of allBoundaries) {
+        if (other === boundary) continue;
         
-        // Find the first </script> that is not inside a string
-        const closeRegex = /<\/script>/gi;
-        let closeMatch;
-        while ((closeMatch = closeRegex.exec(code)) !== null) {
-          if (closeMatch.index >= contentStart && !isInsideStringOrComment(code, closeMatch.index)) {
-            return {
-              start: openMatch.index,
-              contentStart: contentStart,
-              contentEnd: closeMatch.index,
-              end: closeMatch.index + closeMatch[0].length,
-              attrs: openMatch[1] || ''
-            };
+        // Check if this boundary is inside another script's content
+        const otherContentStart = other.start + code.slice(other.start, other.end).indexOf('>') + 1;
+        const otherContentEnd = other.end - code.slice(other.end - 10, other.end).indexOf('<') - 10 + code.slice(other.end - 10, other.end).indexOf('<');
+        
+        if (boundary.start > otherContentStart && boundary.start < other.end) {
+          // This boundary is inside another script's content area
+          // Check if it's inside a JS string
+          if (isInsideStringOrComment(code, otherContentStart, boundary.start)) {
+            isInsideAnotherScript = true;
+            break;
           }
         }
       }
+      
+      if (!isInsideAnotherScript) {
+        // This is the real script section
+        const openTagEnd = code.indexOf('>', boundary.start) + 1;
+        const closeTagStart = code.lastIndexOf('<', boundary.end - 1);
+        return {
+          start: boundary.start,
+          contentStart: openTagEnd,
+          contentEnd: closeTagStart,
+          end: boundary.end,
+          attrs: boundary.attrs
+        };
+      }
     }
+    
     return null;
   }
 
-  // Find first real <style> tag (not inside a string)
+  // Find the real style section (outside of script sections)
   function findStyleSection(code: string): { start: number; contentStart: number; contentEnd: number; end: number } | null {
+    const scriptBoundaries = findScriptBoundaries(code);
     const openRegex = /<style[^>]*>/gi;
+    const closeRegex = /<\/style>/gi;
     let openMatch;
     
     while ((openMatch = openRegex.exec(code)) !== null) {
-      if (!isInsideStringOrComment(code, openMatch.index)) {
-        const contentStart = openMatch.index + openMatch[0].length;
+      const openIndex = openMatch.index;
+      
+      // Check if this style tag is inside any script section
+      let isInsideScript = false;
+      for (const script of scriptBoundaries) {
+        const contentStart = script.start + code.slice(script.start, script.end).indexOf('>') + 1;
+        const contentEnd = script.end - code.slice(script.end - 10, script.end).indexOf('<') - 10 + code.slice(script.end - 10, script.end).indexOf('<');
         
-        // Find the first </style> that is not inside a string
-        const closeRegex = /<\/style>/gi;
+        if (openIndex >= contentStart && openIndex < script.end) {
+          // It's in the script section, check if inside a JS string
+          if (isInsideStringOrComment(code, contentStart, openIndex)) {
+            isInsideScript = true;
+            break;
+          }
+        }
+      }
+      
+      if (!isInsideScript) {
+        // Found a real style tag, now find its close tag
+        const contentStart = openIndex + openMatch[0].length;
+        closeRegex.lastIndex = contentStart;
         let closeMatch;
         while ((closeMatch = closeRegex.exec(code)) !== null) {
-          if (closeMatch.index >= contentStart && !isInsideStringOrComment(code, closeMatch.index)) {
+          // Make sure close tag is also outside scripts
+          let closeIsInsideScript = false;
+          for (const script of scriptBoundaries) {
+            const scriptContentStart = script.start + code.slice(script.start, script.end).indexOf('>') + 1;
+            if (closeMatch.index >= scriptContentStart && closeMatch.index < script.end) {
+              if (isInsideStringOrComment(code, scriptContentStart, closeMatch.index)) {
+                closeIsInsideScript = true;
+                break;
+              }
+            }
+          }
+          if (!closeIsInsideScript) {
             return {
-              start: openMatch.index,
+              start: openIndex,
               contentStart: contentStart,
               contentEnd: closeMatch.index,
               end: closeMatch.index + closeMatch[0].length
@@ -186,20 +264,20 @@ export function splitScript(script: string) {
   const lines = script.split("\n");
   const imports = [];
   const body = [];
-  let currentImport = [];
+  let currentImport: string[] = [];
   let inImport = false;
   let braceCount = 0;
   let inString = false;
   let stringChar = "";
   let inMultiLineComment = false;
+  let escaped = false;
 
   // Helper function to check if import is complete without semicolon
-  function isImportComplete(line, braceCount, inString) {
+  function isImportComplete(lineIndex: number, braceCount: number, inString: boolean): boolean {
     // If we have balanced braces and not in a string, check if next non-empty line starts a new statement
     if (braceCount === 0 && !inString) {
       // Look ahead to see if next line starts a new statement/declaration
-      const nextLineIndex = lines.indexOf(line) + 1;
-      for (let i = nextLineIndex; i < lines.length; i++) {
+      for (let i = lineIndex + 1; i < lines.length; i++) {
         const nextLine = lines[i].trim();
         if (
           !nextLine || nextLine.startsWith("//") || nextLine.startsWith("/*")
@@ -216,6 +294,7 @@ export function splitScript(script: string) {
     return false;
   }
 
+  // Process each line, maintaining string/comment state
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     const trimmed = line.trim();
@@ -228,14 +307,33 @@ export function splitScript(script: string) {
         body.push(line);
       }
 
-      if (line.includes("*/")) {
-        inMultiLineComment = false;
+      // Check for end of multi-line comment, tracking strings
+      for (let j = 0; j < line.length; j++) {
+        const char = line[j];
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === '\\' && inString) {
+          escaped = true;
+          continue;
+        }
+        if (!inString && (char === '"' || char === "'" || char === '`')) {
+          inString = true;
+          stringChar = char;
+        } else if (inString && char === stringChar) {
+          inString = false;
+          stringChar = "";
+        } else if (!inString && char === '*' && line[j + 1] === '/') {
+          inMultiLineComment = false;
+          break;
+        }
       }
       continue;
     }
 
-    // Check for start of multi-line comment
-    if (line.includes("/*") && !inString) {
+    // Check for start of multi-line comment (only if not in string)
+    if (!inString && line.includes("/*")) {
       inMultiLineComment = true;
       if (inImport) {
         currentImport.push(line);
@@ -243,15 +341,37 @@ export function splitScript(script: string) {
         body.push(line);
       }
 
-      if (!line.includes("*/")) {
+      // Check if comment ends on same line
+      for (let j = 0; j < line.length; j++) {
+        const char = line[j];
+        if (escaped) {
+          escaped = false;
+          continue;
+        }
+        if (char === '\\' && inString) {
+          escaped = true;
+          continue;
+        }
+        if (!inString && (char === '"' || char === "'" || char === '`')) {
+          inString = true;
+          stringChar = char;
+        } else if (inString && char === stringChar) {
+          inString = false;
+          stringChar = "";
+        } else if (!inString && char === '*' && line[j + 1] === '/') {
+          inMultiLineComment = false;
+          break;
+        }
+      }
+      
+      if (!inMultiLineComment) {
+        // Comment ended on same line
         continue;
-      } else {
-        inMultiLineComment = false;
       }
     }
 
-    // Skip single-line comments when not in import
-    if (trimmed.startsWith("//") && !inImport) {
+    // Skip single-line comments when not in import (only if not in string)
+    if (!inString && !inImport && trimmed.startsWith("//")) {
       body.push(line);
       continue;
     }
@@ -262,38 +382,50 @@ export function splitScript(script: string) {
       continue;
     }
 
-    // Start of import statement
-    if (!inImport && trimmed.startsWith("import")) {
-      inImport = true;
-      currentImport = [line];
-      braceCount = 0;
-      inString = false;
+    // Process the line character by character to maintain string state
+    let lineBraceCount = 0;
+    let lineInString = inString;
+    let lineStringChar = stringChar;
+    let lineEscaped = false;
 
-      // Count braces and track strings in the import line
-      for (let j = 0; j < line.length; j++) {
-        const char = line[j];
+    for (let j = 0; j < line.length; j++) {
+      const char = line[j];
 
-        if (inString) {
-          if (char === stringChar && line[j - 1] !== "\\") {
-            inString = false;
-            stringChar = "";
-          }
-        } else {
-          if (char === '"' || char === "'" || char === "`") {
-            inString = true;
-            stringChar = char;
-          } else if (char === "{") {
-            braceCount++;
-          } else if (char === "}") {
-            braceCount--;
-          }
-        }
+      if (lineEscaped) {
+        lineEscaped = false;
+        continue;
       }
 
-      // Check if import is complete
+      if (char === '\\' && lineInString) {
+        lineEscaped = true;
+        continue;
+      }
+
+      if (!lineInString && (char === '"' || char === "'" || char === '`')) {
+        lineInString = true;
+        lineStringChar = char;
+      } else if (lineInString && char === lineStringChar) {
+        lineInString = false;
+        lineStringChar = "";
+      } else if (!lineInString && char === '{') {
+        lineBraceCount++;
+      } else if (!lineInString && char === '}') {
+        lineBraceCount--;
+      }
+    }
+
+    // Start of import statement (only if not inside a string)
+    if (!inImport && !inString && trimmed.startsWith("import")) {
+      inImport = true;
+      currentImport = [line];
+      braceCount = lineBraceCount;
+      inString = lineInString;
+      stringChar = lineStringChar;
+
+      // Check if import is complete on this line
       if (
         (trimmed.endsWith(";") ||
-          isImportComplete(trimmed, braceCount, inString)) &&
+          isImportComplete(i, braceCount, inString)) &&
         braceCount === 0 && !inString
       ) {
         imports.push(currentImport.join("\n"));
@@ -303,32 +435,14 @@ export function splitScript(script: string) {
     } // Continue import statement
     else if (inImport) {
       currentImport.push(line);
-
-      // Count braces and track strings in the current line
-      for (let j = 0; j < line.length; j++) {
-        const char = line[j];
-
-        if (inString) {
-          if (char === stringChar && line[j - 1] !== "\\") {
-            inString = false;
-            stringChar = "";
-          }
-        } else {
-          if (char === '"' || char === "'" || char === "`") {
-            inString = true;
-            stringChar = char;
-          } else if (char === "{") {
-            braceCount++;
-          } else if (char === "}") {
-            braceCount--;
-          }
-        }
-      }
+      braceCount += lineBraceCount;
+      inString = lineInString;
+      stringChar = lineStringChar;
 
       // Check if import is complete
       if (
         (trimmed.endsWith(";") ||
-          isImportComplete(trimmed, braceCount, inString)) &&
+          isImportComplete(i, braceCount, inString)) &&
         braceCount === 0 && !inString
       ) {
         imports.push(currentImport.join("\n"));
@@ -338,12 +452,21 @@ export function splitScript(script: string) {
     } // Regular body content
     else {
       body.push(line);
+      // Update global string state
+      inString = lineInString;
+      stringChar = lineStringChar;
     }
   }
 
-  // Handle unterminated import (likely malformed)
+  // Handle unterminated import (likely malformed or still in string)
   if (currentImport.length > 0) {
-    imports.push(currentImport.join("\n"));
+    if (inImport && !inString) {
+      // Import seems complete but wasn't captured properly
+      imports.push(currentImport.join("\n"));
+    } else {
+      // Still in string or incomplete, treat as body
+      body.push(...currentImport);
+    }
   }
 
   return {

package/tests/ImportInString.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import ImportInString from "./ImportInString.thyn";
+
+describe("ImportInString component", () => {
+  it("should not treat imports inside string literals as real imports", () => {
+    const root = ImportInString();
+    expect(root.textContent).toBe("42");
+  });
+
+  it("should include the import statements in the codeSnippet", () => {
+    const root = ImportInString();
+    // The codeSnippet should be available (this tests the script was parsed correctly)
+    expect(root).toBeTruthy();
+  });
+});

package/tests/ImportInString.thyn

@@ -0,0 +1,15 @@
+<script>
+  const codeSnippet = `// main.js
+import { mount } from '@thyn/core';
+import App from './App.thyn';
+
+mount(App, document.body);`;
+
+  const value = 42;
+</script>
+
+<div>{{ value }}</div>
+
+<style>
+  div { color: red; }
+</style>