mrmd-js 2.2.0 → 2.3.0

package/dist/index.cjs

@@ -1035,48 +1035,96 @@ function createMainContext(options) {
  */
 
 /**
- * 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
@@ -1789,24 +1837,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
@@ -1830,16 +2058,16 @@ function wrapWithLastExpression(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;
@@ -1933,7 +2161,7 @@ class JavaScriptExecutor extends BaseExecutor {
     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)