jslike 1.4.0 → 1.4.1

package/dist/esm/editor/wang-prism.js

@@ -0,0 +1,136 @@
+// Wang Language Definition for Prism.js
+/* global Prism */
+(function (Prism) {
+  Prism.languages.wang = {
+    // Comments
+    comment: [
+      {
+        pattern: /\/\*[\s\S]*?\*\//,
+        greedy: true,
+      },
+      {
+        pattern: /\/\/.*/,
+        greedy: true,
+      },
+    ],
+
+    // Template literals with interpolation
+    'template-string': {
+      pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+      greedy: true,
+      inside: {
+        'template-punctuation': {
+          pattern: /^`|`$/,
+          alias: 'string',
+        },
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+          lookbehind: true,
+          inside: {
+            'interpolation-punctuation': {
+              pattern: /^\$\{|\}$/,
+              alias: 'punctuation',
+            },
+            rest: Prism.languages.wang,
+          },
+        },
+        string: /[\s\S]+/,
+      },
+    },
+
+    // Strings
+    string: [
+      {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: true,
+      },
+    ],
+
+    // Regular expressions
+    regex: {
+      pattern: /\/(?:\\.|[^\/\\\r\n])+\/[gimsuy]*/,
+      greedy: true,
+      inside: {
+        'regex-delimiter': {
+          pattern: /^\/|\/[gimsuy]*$/,
+          alias: 'punctuation',
+        },
+        'regex-flags': {
+          pattern: /[gimsuy]+$/,
+          alias: 'keyword',
+        },
+      },
+    },
+
+    // Keywords
+    keyword:
+      /\b(?:let|const|var|if|else|for|while|do|break|continue|return|function|class|extends|constructor|async|await|import|export|from|as|try|catch|finally|throw|new|this|super|typeof|instanceof|in|of)\b/,
+
+    // Boolean and null values
+    boolean: /\b(?:true|false)\b/,
+    null: /\b(?:null|undefined)\b/,
+
+    // Numbers
+    number: /\b(?:0x[\dA-Fa-f]+|0b[01]+|0o[0-7]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)\b/,
+
+    // Arrow function operator
+    'arrow-operator': {
+      pattern: /=>/,
+      alias: 'operator',
+    },
+
+    // Operators (order matters for matching)
+    operator:
+      /\+\+|--|===|!==|==|!=|<=|>=|<<|>>>|>>|&&|\|\||[?]{2}|\?\.|\.{3}|\*\*|\+=|-=|\*=|\/=|[+\-*/%<>&|^~!?:]=?/,
+
+    // Punctuation
+    punctuation: /[{}[\];(),.:]/,
+
+    // Functions (pattern for function calls)
+    function: /\b[a-zA-Z_$][\w$]*(?=\s*\()/,
+
+    // Class names (after class or extends)
+    'class-name': {
+      pattern: /(\b(?:class|extends)\s+)[a-zA-Z_$][\w$]*/,
+      lookbehind: true,
+    },
+
+    // Property names in object literals
+    property: {
+      pattern:
+        /((?:^|[,{])[ \t]*)(?:(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*|"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*')(?=\s*:)/m,
+      lookbehind: true,
+      greedy: true,
+    },
+
+    // Variables and identifiers (must come last)
+    variable: /\b[a-zA-Z_$][\w$]*/,
+  };
+
+  // Set wang as an alias for javascript-like highlighting
+  Prism.languages.wang['class-name'].pattern = /(\b(?:class|extends|new)\s+)[a-zA-Z_$][\w$]*/;
+
+  // Hook to handle special Wang syntax
+  Prism.hooks.add('before-tokenize', function (env) {
+    if (env.language !== 'wang') {
+      return;
+    }
+  });
+
+  // Hook to add special classes for Wang-specific features
+  Prism.hooks.add('wrap', function (env) {
+    if (env.language !== 'wang') {
+      return;
+    }
+
+    // Add special class for Wang keywords
+    if (env.type === 'keyword' && ['import', 'export', 'from', 'as'].includes(env.content)) {
+      env.classes.push('wang-module');
+    }
+  });
+})(Prism);
+
+// Export for module systems
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = Prism.languages.wang;
+}

package/dist/esm/errors/enhanced-error.js

@@ -0,0 +1,124 @@
+/**
+ * Enhanced error classes for better developer experience
+ */
+
+// Simple Levenshtein distance for "did you mean" suggestions
+function levenshteinDistance(a, b) {
+  const matrix = [];
+
+  for (let i = 0; i <= b.length; i++) {
+    matrix[i] = [i];
+  }
+
+  for (let j = 0; j <= a.length; j++) {
+    matrix[0][j] = j;
+  }
+
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      if (b.charAt(i - 1) === a.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+
+  return matrix[b.length][a.length];
+}
+
+// Find similar strings for suggestions
+function findSimilar(target, candidates, maxDistance = 3) {
+  const suggestions = [];
+
+  for (const candidate of candidates) {
+    const distance = levenshteinDistance(target.toLowerCase(), candidate.toLowerCase());
+    if (distance <= maxDistance && distance > 0) {
+      suggestions.push({ name: candidate, distance });
+    }
+  }
+
+  return suggestions
+    .sort((a, b) => a.distance - b.distance)
+    .slice(0, 3)
+    .map(s => s.name);
+}
+
+// Get available methods/properties on an object
+function getAvailableMethods(obj) {
+  if (obj === null || obj === undefined) return [];
+
+  const methods = new Set();
+
+  // Get own properties
+  Object.getOwnPropertyNames(obj).forEach(name => {
+    if (typeof obj[name] === 'function') {
+      methods.add(name);
+    }
+  });
+
+  // Get prototype methods
+  let proto = Object.getPrototypeOf(obj);
+  while (proto && proto !== Object.prototype) {
+    Object.getOwnPropertyNames(proto).forEach(name => {
+      if (typeof proto[name] === 'function' && name !== 'constructor') {
+        methods.add(name);
+      }
+    });
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return Array.from(methods).sort();
+}
+
+export class EnhancedTypeError extends TypeError {
+  constructor(message, context = {}) {
+    super(message);
+    this.name = 'TypeError';
+    this.objectName = context.objectName || 'object';
+    this.methodName = context.methodName || 'method';
+    this.objectValue = context.objectValue;
+    this.availableMethods = context.availableMethods || [];
+    this.suggestions = context.suggestions || [];
+  }
+
+  getFormattedMessage() {
+    let formatted = this.message;
+
+    // Add available methods
+    if (this.availableMethods.length > 0) {
+      const methodList = this.availableMethods.slice(0, 10).join(', ');
+      const more = this.availableMethods.length > 10
+        ? ` (and ${this.availableMethods.length - 10} more)`
+        : '';
+      formatted += `\n\nAvailable methods on '${this.objectName}': ${methodList}${more}`;
+    }
+
+    // Add suggestions
+    if (this.suggestions.length > 0) {
+      formatted += `\n\nDid you mean: ${this.suggestions.join(', ')}?`;
+    }
+
+    return formatted;
+  }
+}
+
+export function createMethodNotFoundError(objectName, methodName, objectValue) {
+  const availableMethods = getAvailableMethods(objectValue);
+  const suggestions = findSimilar(methodName, availableMethods);
+
+  const message = `TypeError when calling method '${methodName}' on object '${objectName}': ` +
+    `Expected: function, Received: undefined`;
+
+  return new EnhancedTypeError(message, {
+    objectName,
+    methodName,
+    objectValue,
+    availableMethods,
+    suggestions
+  });
+}

package/dist/esm/index.js

@@ -0,0 +1,182 @@
+// Use bundled Acorn parser for zero runtime dependencies
+import { parse as acornParse } from './parser.js';
+import { Interpreter } from './interpreter/interpreter.js';
+import { Environment, ReturnValue } from './runtime/environment.js';
+import { createGlobalEnvironment } from './runtime/builtins.js';
+
+// Helper to detect if code contains module syntax or top-level await
+function containsModuleSyntax(code) {
+  // Trigger module mode for:
+  // 1. import/export statements
+  // 2. Top-level await (await not inside a function)
+  if (/^\s*(import|export)\s+/m.test(code)) {
+    return true;
+  }
+
+  // Check for top-level await (simple heuristic: await at start of line or after statement)
+  // This isn't perfect but handles common cases, including await in template literals
+  // Also matches await after operators like || or && or = or inside parentheses
+  if (/^await\s+/m.test(code) || /[;\n{(|&=]\s*await\s+/.test(code)) {
+    return true;
+  }
+
+  return false;
+}
+
+
+export function parse(code, options = {}) {
+  // Determine sourceType: use 'module' ONLY if explicitly requested or if code has imports/exports
+  // Default to 'script' for better compatibility with labeled statements
+  let sourceType = options.sourceType || 'script';
+  if (!options.sourceType && containsModuleSyntax(code)) {
+    sourceType = 'module';
+  }
+
+  // Parse with Acorn
+  try {
+    return acornParse(code, {
+      ecmaVersion: 2022,  // Support ES2022 features (including top-level await)
+      sourceType: sourceType,
+      locations: true,     // Track source locations for better error messages
+      allowReturnOutsideFunction: true  // Allow top-level return statements
+    });
+  } catch (error) {
+    // Reformat error message for consistency
+    throw new SyntaxError(
+      `Parse error at line ${error.loc?.line || '?'}: ${error.message}`
+    );
+  }
+}
+
+// Helper to detect if AST contains import/export declarations
+function containsModuleDeclarations(node) {
+  if (!node || typeof node !== 'object') return false;
+
+  if (node.type === 'ImportDeclaration' ||
+      node.type === 'ExportNamedDeclaration' ||
+      node.type === 'ExportDefaultDeclaration' ||
+      node.type === 'ExportAllDeclaration') {
+    return true;
+  }
+
+  // Check Program body for module declarations
+  if (node.type === 'Program' && node.body) {
+    for (const statement of node.body) {
+      if (containsModuleDeclarations(statement)) return true;
+    }
+  }
+
+  return false;
+}
+
+// Helper to detect if AST contains top-level await expressions
+function containsTopLevelAwait(node) {
+  if (!node || typeof node !== 'object') return false;
+
+  if (node.type === 'AwaitExpression') return true;
+
+  // Don't recurse into function bodies (they handle their own await)
+  if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') {
+    return false;
+  }
+
+  // Check all properties
+  for (const key in node) {
+    if (key === 'loc' || key === 'range') continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (containsTopLevelAwait(item)) return true;
+      }
+    } else if (typeof value === 'object') {
+      if (containsTopLevelAwait(value)) return true;
+    }
+  }
+
+  return false;
+}
+
+export async function execute(code, env = null, options = {}) {
+  // Parse the code
+  const ast = parse(code, options);
+
+  // Create global environment if not provided
+  if (!env) {
+    env = createGlobalEnvironment(new Environment());
+  }
+
+  // Create interpreter with module resolver and abort signal if provided
+  const interpreter = new Interpreter(env, {
+    moduleResolver: options.moduleResolver,
+    abortSignal: options.abortSignal
+  });
+
+  // Use async evaluation if:
+  // 1. Explicitly requested module mode
+  // 2. AST contains import/export declarations
+  // 3. Code contains top-level await
+  const needsAsync = options.sourceType === 'module' ||
+                     containsModuleDeclarations(ast) ||
+                     containsTopLevelAwait(ast);
+
+  if (needsAsync) {
+    const result = await interpreter.evaluateAsync(ast, env);
+    return result instanceof ReturnValue ? result.value : result;
+  } else {
+    const result = interpreter.evaluate(ast, env);
+    return result instanceof ReturnValue ? result.value : result;
+  }
+}
+
+export function createEnvironment() {
+  return createGlobalEnvironment(new Environment());
+}
+
+// Export utility functions for CLI tools
+export const isTopLevelAwait = containsModuleSyntax;
+
+export { Interpreter } from './interpreter/interpreter.js';
+export { Environment } from './runtime/environment.js';
+export { WangInterpreter, InMemoryModuleResolver } from './interpreter/index.js';
+
+/**
+ * Abstract base class for module resolution
+ * Extend this class to implement custom module loading strategies
+ */
+export class ModuleResolver {
+  /**
+   * Resolve a module and return its code
+   * @param {string} modulePath - The module path to resolve
+   * @param {string} [fromPath] - The path of the importing module
+   * @returns {Promise<ModuleResolution>} The resolved module
+   */
+  async resolve(modulePath, fromPath) {
+    throw new Error('ModuleResolver.resolve() must be implemented by subclass');
+  }
+
+  /**
+   * Check if a module exists
+   * @param {string} modulePath - The module path to check
+   * @param {string} [fromPath] - The path of the importing module
+   * @returns {Promise<boolean>} Whether the module exists
+   */
+  async exists(modulePath, fromPath) {
+    throw new Error('ModuleResolver.exists() must be implemented by subclass');
+  }
+
+  /**
+   * List available modules
+   * @param {string} [prefix] - Optional prefix to filter modules
+   * @returns {Promise<string[]>} List of module paths
+   */
+  async list(prefix) {
+    throw new Error('ModuleResolver.list() must be implemented by subclass');
+  }
+}
+
+/**
+ * @typedef {Object} ModuleResolution
+ * @property {string} code - The module source code
+ * @property {string} path - The resolved module path
+ * @property {any} [metadata] - Optional metadata about the module
+ */

package/dist/esm/interpreter/index.js

@@ -0,0 +1,201 @@
+/**
+ * WangInterpreter compatibility adapter for JSLike
+ * Maps Wang's interpreter API to JSLike's API
+ */
+
+import { execute, createEnvironment } from '../index.js';
+
+export class WangInterpreter {
+  constructor(options = {}) {
+    this.options = options;
+    this.moduleResolver = options.moduleResolver;
+    this.functions = options.functions || {};
+    // Create a persistent environment for setVariable support
+    this.persistentEnv = null;
+  }
+
+  setVariable(name, value) {
+    // If persistent environment doesn't exist, create it
+    if (!this.persistentEnv) {
+      this.persistentEnv = createEnvironment();
+
+      // Add custom functions
+      for (const [funcName, func] of Object.entries(this.functions)) {
+        if (this.persistentEnv.has(funcName)) {
+          this.persistentEnv.set(funcName, func);
+        } else {
+          this.persistentEnv.define(funcName, func);
+        }
+      }
+    }
+
+    // Set the variable in persistent environment
+    if (this.persistentEnv.has(name)) {
+      this.persistentEnv.set(name, value);
+    } else {
+      this.persistentEnv.define(name, value);
+    }
+  }
+
+  // Alias for setVariable - specifically for binding functions
+  bindFunction(name, func) {
+    return this.setVariable(name, func);
+  }
+
+  // Expose global context for accessing variables after execution
+  get globalContext() {
+    return {
+      variables: this.persistentEnv?.vars || new Map()
+    };
+  }
+
+  createExecutionEnvironment() {
+    // Create fresh environment for each execution
+    const env = createEnvironment();
+
+    // Add custom functions to environment, overriding built-ins if needed
+    for (const [name, func] of Object.entries(this.functions)) {
+      // Use set() to override existing variables instead of define()
+      if (env.has(name)) {
+        env.set(name, func);
+      } else {
+        env.define(name, func);
+      }
+    }
+
+    return env;
+  }
+
+  async execute(code, initialEnv = undefined, userOptions = {}) {
+    // Use provided environment, persistent environment, or create fresh one
+    const env = initialEnv || this.persistentEnv || this.createExecutionEnvironment();
+
+    // Setup console capture if withMetadata option is enabled
+    const withMetadata = userOptions.withMetadata || false;
+    const capturedLogs = [];
+
+    if (withMetadata) {
+      // Override log/warn/error functions to capture calls
+      const createCapture = (type) => {
+        return (...args) => {
+          capturedLogs.push({
+            type,
+            args,
+            timestamp: Date.now()
+          });
+          // Still output to console
+          console[type](...args);
+          return undefined;
+        };
+      };
+
+      env.set('log', createCapture('log'));
+      env.set('warn', createCapture('warn'));
+      env.set('error', createCapture('error'));
+    }
+
+    // Check if code contains top-level return statements
+    // Need to detect `return` at start of line, but NOT inside function bodies
+    // Simple heuristic: check if braces are balanced before the return statement
+    const hasTopLevelReturn = this.hasTopLevelReturn(code);
+
+    // Prepare execution options
+    const options = {
+      moduleResolver: this.moduleResolver
+      // sourceType will be auto-detected from code
+    };
+
+    let result;
+    if (hasTopLevelReturn) {
+      // Wrap code in async IIFE to support top-level return statements
+      const wrappedCode = `(async function() { ${code} })()`;
+      try {
+        result = await execute(wrappedCode, env, options);
+      } catch (error) {
+        throw error;
+      }
+    } else {
+      // Execute directly - JSLike returns last evaluated expression
+      try {
+        result = await execute(code, env, options);
+      } catch (error) {
+        throw error;
+      }
+    }
+
+    // Return result with metadata if requested
+    if (withMetadata) {
+      return {
+        result,
+        metadata: {
+          logs: capturedLogs
+        }
+      };
+    }
+
+    return result;
+  }
+
+  hasTopLevelReturn(code) {
+    const lines = code.split('\n');
+    let braceDepth = 0;
+
+    for (const line of lines) {
+      // Check if this line has a return statement at the start (ignoring whitespace)
+      const trimmed = line.trim();
+      if (trimmed.startsWith('return ') || trimmed === 'return') {
+        // If we're at brace depth 0, it's a top-level return
+        if (braceDepth === 0) {
+          return true;
+        }
+      }
+
+      // Count braces on this line (after checking for return)
+      for (const char of line) {
+        if (char === '{') braceDepth++;
+        if (char === '}') braceDepth--;
+      }
+    }
+
+    return false;
+  }
+
+  async executeModule(code) {
+    // Same as execute for now - modules are handled by execute()
+    return await this.execute(code);
+  }
+}
+
+export class InMemoryModuleResolver {
+  constructor() {
+    this.modules = new Map();
+  }
+
+  addModule(name, code, metadata) {
+    this.modules.set(name, { code, metadata });
+  }
+
+  async resolve(modulePath, fromPath) {
+    const module = this.modules.get(modulePath);
+    if (!module) {
+      return null;
+    }
+    return {
+      code: typeof module === 'string' ? module : module.code,
+      path: modulePath,
+      metadata: module.metadata
+    };
+  }
+
+  async exists(modulePath, fromPath) {
+    return this.modules.has(modulePath);
+  }
+
+  async list(prefix) {
+    const paths = Array.from(this.modules.keys());
+    if (prefix) {
+      return paths.filter(p => p.startsWith(prefix));
+    }
+    return paths;
+  }
+}