mrmd-js 2.1.0 → 2.3.0

package/dist/mrmd-js.iife.js

@@ -1036,48 +1036,96 @@ var mrmdJs = (function (exports) {
    */
 
   /**
-   * Extract all variable names that will be declared by the code.
-   * Handles var, let, const, function, and class declarations.
+   * Extract top-level variable names declared by the code.
+   * Handles top-level var/let/const, function, class, and bare assignments.
    *
    * @param {string} code - Source code
    * @returns {string[]} Array of declared variable names
    *
    * @example
-   * extractDeclaredVariables('const x = 1; let { a, b } = obj; function foo() {}')
-   * // Returns: ['x', 'a', 'b', 'foo']
+   * extractDeclaredVariables('const x = 1; function foo() {}')
+   * // Returns: ['x', 'foo']
    */
   function extractDeclaredVariables(code) {
     const variables = new Set();
 
-    // Remove strings, comments to avoid false matches
+    // Remove strings/comments, then mask nested scopes so we only inspect top-level declarations.
     const cleaned = removeStringsAndComments(code);
+    const topLevel = maskNestedScopes(cleaned);
 
-    // Match var/let/const declarations
-    // Handles: const x = 1, let x = 1, var x = 1
-    // Handles: const { a, b } = obj, const [a, b] = arr
-    const varPattern = /\b(?:var|let|const)\s+([^=;]+?)(?:\s*=|\s*;|\s*$)/g;
+    // Match top-level var/let/const declarations (simple/comma-separated identifiers).
+    // This intentionally excludes nested function/local declarations.
+    const varPattern = /(?:^|[;\n])\s*(?:var|let|const)\s+([^\n;]+)/gm;
 
     let match;
-    while ((match = varPattern.exec(cleaned)) !== null) {
-      const declaration = match[1].trim();
-      extractNamesFromPattern(declaration, variables);
+    while ((match = varPattern.exec(topLevel)) !== null) {
+      const fullStart = match.index;
+      const fullEnd = fullStart + match[0].length;
+      const originalStatement = cleaned.slice(fullStart, fullEnd);
+      const originalDeclMatch = originalStatement.match(/(?:^|[;\n])\s*(?:var|let|const)\s+([^\n;]+)/m);
+      const declaration = (originalDeclMatch?.[1] || match[1]).trim();
+      const parts = splitByComma(declaration);
+      for (const part of parts) {
+        const candidate = part.split('=')[0].trim();
+        extractNamesFromPattern(candidate, variables);
+      }
     }
 
-    // Match function declarations
+    // Match top-level function declarations
     const funcPattern = /\bfunction\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
-    while ((match = funcPattern.exec(cleaned)) !== null) {
+    while ((match = funcPattern.exec(topLevel)) !== null) {
       variables.add(match[1]);
     }
 
-    // Match class declarations
+    // Match top-level class declarations
     const classPattern = /\bclass\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g;
-    while ((match = classPattern.exec(cleaned)) !== null) {
+    while ((match = classPattern.exec(topLevel)) !== null) {
       variables.add(match[1]);
     }
 
+    // Match top-level bare assignments (e.g., x = 10, data = [...])
+    // These create globals in notebook/REPL contexts
+    const assignPattern = /(?:^|[;\n])\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=(?![=>])/gm;
+    while ((match = assignPattern.exec(topLevel)) !== null) {
+      const name = match[1];
+      // Skip keywords that precede = in other contexts
+      if (!['if', 'else', 'while', 'for', 'return', 'throw', 'typeof', 'delete', 'void', 'new', 'in', 'of', 'switch', 'case', 'default', 'try', 'catch', 'finally', 'do', 'break', 'continue', 'with', 'yield', 'await', 'async', 'import', 'export', 'var', 'let', 'const', 'function', 'class', 'this'].includes(name)) {
+        variables.add(name);
+      }
+    }
+
     return Array.from(variables);
   }
 
+  /**
+   * Keep only top-level text, replacing nested scope contents with spaces.
+   * This avoids tracking local variables declared inside functions/blocks.
+   *
+   * @param {string} code
+   * @returns {string}
+   */
+  function maskNestedScopes(code) {
+    let result = '';
+    let braceDepth = 0;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+
+    for (let i = 0; i < code.length; i++) {
+      const ch = code[i];
+      const isTopLevel = braceDepth === 0 && parenDepth === 0 && bracketDepth === 0;
+      result += isTopLevel ? ch : ' ';
+
+      if (ch === '{') braceDepth++;
+      else if (ch === '}') braceDepth = Math.max(0, braceDepth - 1);
+      else if (ch === '(') parenDepth++;
+      else if (ch === ')') parenDepth = Math.max(0, parenDepth - 1);
+      else if (ch === '[') bracketDepth++;
+      else if (ch === ']') bracketDepth = Math.max(0, bracketDepth - 1);
+    }
+
+    return result;
+  }
+
   /**
    * Extract variable names from a destructuring pattern or simple identifier
    * @param {string} pattern
@@ -1790,24 +1838,204 @@ ${code}
 })()`;
   }
 
+  /**
+   * In notebook/REPL flows, users often type bare object literals:
+   *   { "a": 1, b: 2 }
+   * JavaScript parses this as a block statement unless wrapped.
+   * This heuristic wraps likely trailing object literals with parentheses.
+   *
+   * @param {string} code
+   * @returns {string}
+   */
+  const OBJECT_LITERAL_PREFIX_RE = /^\s*(?:[a-zA-Z_$][a-zA-Z0-9_$]*|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\[[^\]]+\])\s*:\s*/s;
+
+  function looksLikeObjectLiteralBlock(blockSource) {
+    if (!blockSource.startsWith('{') || !blockSource.endsWith('}')) {
+      return false;
+    }
+
+    const inner = blockSource.slice(1, -1);
+    const propertyPrefix = inner.match(OBJECT_LITERAL_PREFIX_RE);
+    if (!propertyPrefix) {
+      return false;
+    }
+
+    // Avoid wrapping likely label statements: { foo: while (...) { ... } }
+    const afterColon = inner.slice(propertyPrefix[0].length).trimStart();
+    return !/^(?:while|for|if|switch|try|do|break|continue)\b/.test(afterColon);
+  }
+
+  function findTopLevelBraceRanges(code) {
+    const ranges = [];
+    let depth = 0;
+    let start = -1;
+    let i = 0;
+
+    let inSingle = false;
+    let inDouble = false;
+    let inTemplate = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+
+    while (i < code.length) {
+      const ch = code[i];
+      const next = code[i + 1];
+
+      if (inLineComment) {
+        if (ch === '\n') inLineComment = false;
+        i++;
+        continue;
+      }
+      if (inBlockComment) {
+        if (ch === '*' && next === '/') {
+          inBlockComment = false;
+          i += 2;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (inSingle) {
+        if (ch === '\\') {
+          i += 2;
+          continue;
+        }
+        if (ch === '\'') inSingle = false;
+        i++;
+        continue;
+      }
+      if (inDouble) {
+        if (ch === '\\') {
+          i += 2;
+          continue;
+        }
+        if (ch === '"') inDouble = false;
+        i++;
+        continue;
+      }
+      if (inTemplate) {
+        if (ch === '\\') {
+          i += 2;
+          continue;
+        }
+        if (ch === '`') inTemplate = false;
+        i++;
+        continue;
+      }
+
+      if (ch === '/' && next === '/') {
+        inLineComment = true;
+        i += 2;
+        continue;
+      }
+      if (ch === '/' && next === '*') {
+        inBlockComment = true;
+        i += 2;
+        continue;
+      }
+      if (ch === '\'') {
+        inSingle = true;
+        i++;
+        continue;
+      }
+      if (ch === '"') {
+        inDouble = true;
+        i++;
+        continue;
+      }
+      if (ch === '`') {
+        inTemplate = true;
+        i++;
+        continue;
+      }
+
+      if (ch === '{') {
+        if (depth === 0) start = i;
+        depth++;
+      } else if (ch === '}' && depth > 0) {
+        depth--;
+        if (depth === 0 && start >= 0) {
+          ranges.push([start, i + 1]);
+          start = -1;
+        }
+      }
+
+      i++;
+    }
+
+    return ranges;
+  }
+
+  function normalizeStandaloneObjectLiteral(code) {
+    const source = String(code || '');
+    if (!source.trim()) return code;
+
+    // Ignore trailing whitespace and semicolons when locating the final statement.
+    let logicalEnd = source.length;
+    while (logicalEnd > 0 && /\s/.test(source[logicalEnd - 1])) logicalEnd--;
+    while (logicalEnd > 0 && source[logicalEnd - 1] === ';') logicalEnd--;
+    while (logicalEnd > 0 && /\s/.test(source[logicalEnd - 1])) logicalEnd--;
+    if (logicalEnd === 0 || source[logicalEnd - 1] !== '}') {
+      return code;
+    }
+
+    const segment = source.slice(0, logicalEnd);
+    const ranges = findTopLevelBraceRanges(segment);
+    if (ranges.length === 0) {
+      return code;
+    }
+
+    const [blockStart, blockEnd] = ranges[ranges.length - 1];
+    if (blockEnd !== logicalEnd) {
+      return code;
+    }
+
+    // Be conservative when the block follows another token that could require a
+    // statement block (e.g. if (...) { ... }).
+    if (blockStart > 0) {
+      let prev = blockStart - 1;
+      while (prev >= 0 && /\s/.test(source[prev])) prev--;
+      if (prev >= 0 && source[prev] !== ';' && source[prev] !== '}') {
+        return code;
+      }
+    }
+
+    const blockSource = segment.slice(blockStart, blockEnd);
+    if (!looksLikeObjectLiteralBlock(blockSource)) {
+      return code;
+    }
+
+    return `${source.slice(0, blockStart)}(${blockSource})${source.slice(logicalEnd)}`;
+  }
+
   /**
    * Wrap code and capture the last expression value
    *
    * @param {string} code - Source code
+   * @param {string[]} [persistentVars=[]] - Variables to copy to globalThis after async execution
    * @returns {string} Wrapped code that returns last expression
    */
-  function wrapWithLastExpression(code) {
+  function wrapWithLastExpression(code, persistentVars = []) {
     // Auto-insert awaits for common async patterns (fetch, import, .json(), etc.)
     // This makes JavaScript feel more linear like Python/R/Julia
     const autoAwaitedCode = autoInsertAwaits(code);
+    const replFriendlyCode = normalizeStandaloneObjectLiteral(autoAwaitedCode);
 
     // Check if code needs async (either explicit await or auto-inserted)
-    const needsAsync = hasTopLevelAwait(autoAwaitedCode);
+    const needsAsync = hasTopLevelAwait(replFriendlyCode);
+
+    const persistenceLines = Array.isArray(persistentVars)
+      ? persistentVars
+          .filter((name) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name))
+          .map((name) => `if (typeof ${name} !== 'undefined') globalThis[${JSON.stringify(name)}] = ${name};`)
+          .join('\n')
+      : '';
 
     if (needsAsync) {
       // For code with await, wrap in async IIFE
       // This allows await to work at the "top level" of the user's code
-      const asyncWrappedCode = `(async () => {\n${autoAwaitedCode}\n})()`;
+      // Keep user completion value via try/finally, while persisting top-level vars.
+      const asyncWrappedCode = `(async () => {\ntry {\n${replFriendlyCode}\n} finally {\n${persistenceLines}\n}\n})()`;
 
       // Now wrap to capture the result
       // Use indirect eval (0, eval)() to run in global scope so var declarations persist
@@ -1831,16 +2059,16 @@ ${code}
 
     // No async needed - use simpler synchronous wrapper
     // Use indirect eval (0, eval)() to run in global scope so var declarations persist
-    // Note: Still use autoAwaitedCode in case auto-awaits were added but hasTopLevelAwait missed them
+    // Note: use replFriendlyCode so bare object literals return as expressions.
     const wrapped = `
 ;(function() {
   let __result__;
   try {
-    __result__ = (0, eval)(${JSON.stringify(autoAwaitedCode)});
+    __result__ = (0, eval)(${JSON.stringify(replFriendlyCode)});
   } catch (e) {
     if (e instanceof SyntaxError) {
       // Code might be statements, not expression
-      (0, eval)(${JSON.stringify(autoAwaitedCode)});
+      (0, eval)(${JSON.stringify(replFriendlyCode)});
       __result__ = undefined;
     } else {
       throw e;
@@ -1934,7 +2162,7 @@ ${code}
       const transformed = transformForPersistence(code);
 
       // Wrap to capture last expression value and support async
-      const wrapped = wrapWithLastExpression(transformed);
+      const wrapped = wrapWithLastExpression(transformed, declaredVars);
 
       try {
         // Execute in context (pass execId for input() support)