jslike 1.0.0 → 1.1.0

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "jslike",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Production-ready JavaScript interpreter with full ES6+ support using Acorn parser",
   "main": "src/index.js",
   "type": "module",
+  "exports": {
+    ".": "./src/index.js",
+    "./validator": "./src/validator/index.js",
+    "./editor/monaco": "./src/editor/monaco/index.js",
+    "./src/editor/wang-prism": "./src/editor/wang-prism.js"
+  },
   "bin": {
     "jslike": "./bin/jslike.js"
   },

package/src/editor/monaco/index.js

@@ -0,0 +1,234 @@
+// Wang Language Definition for Monaco Editor
+export const wangLanguage = {
+  defaultToken: 'invalid',
+  tokenPostfix: '.wang',
+
+  keywords: [
+    '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',
+    'this',
+    'super',
+    'new',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+  ],
+
+  typeKeywords: [],
+
+  operators: [
+    '=>',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '===',
+    '!==',
+    '==',
+    '!=',
+    '<=',
+    '>=',
+    '<<',
+    '>>',
+    '>>>',
+    '&&',
+    '||',
+    '??',
+    '?.',
+    '...',
+    '++',
+    '--',
+    '**',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '&',
+    '|',
+    '^',
+    '~',
+    '!',
+    '?',
+    ':',
+    '=',
+    '<',
+    '>',
+  ],
+
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+
+  tokenizer: {
+    root: [
+      // Identifiers and keywords
+      [
+        /[a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            '@keywords': 'keyword',
+            'true|false|null|undefined': 'constant',
+            '@default': 'identifier',
+          },
+        },
+      ],
+
+      // Whitespace
+      { include: '@whitespace' },
+
+      // Delimiters and operators
+      [/[{}()\[\]]/, '@brackets'],
+      [/[<>](?!@symbols)/, '@brackets'],
+      [
+        /@symbols/,
+        {
+          cases: {
+            '@operators': 'operator',
+            '@default': '',
+          },
+        },
+      ],
+
+      // Numbers
+      [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+      [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+      [/\d+/, 'number'],
+
+      // Delimiter
+      [/[;,.]/, 'delimiter'],
+
+      // Strings
+      [/"([^"\\]|\\.)*$/, 'string.invalid'],
+      [/'([^'\\]|\\.)*$/, 'string.invalid'],
+      [/"/, 'string', '@string_double'],
+      [/'/, 'string', '@string_single'],
+
+      // Template literals
+      [/`/, 'string.template', '@template'],
+
+      // Regular expressions
+      [/\/(?=([^\/\\]|\\.)+\/)/, 'regexp', '@regexp'],
+    ],
+
+    whitespace: [
+      [/[ \t\r\n]+/, ''],
+      [/\/\*/, 'comment', '@comment'],
+      [/\/\/.*$/, 'comment'],
+    ],
+
+    comment: [
+      [/[^\/*]+/, 'comment'],
+      [/\*\//, 'comment', '@pop'],
+      [/[\/*]/, 'comment'],
+    ],
+
+    string_double: [
+      [/[^\\"]+/, 'string'],
+      [/@escapes/, 'string.escape'],
+      [/\\./, 'string.escape.invalid'],
+      [/"/, 'string', '@pop'],
+    ],
+
+    string_single: [
+      [/[^\\']+/, 'string'],
+      [/@escapes/, 'string.escape'],
+      [/\\./, 'string.escape.invalid'],
+      [/'/, 'string', '@pop'],
+    ],
+
+    template: [
+      [/[^`\\$]+/, 'string.template'],
+      [/@escapes/, 'string.escape'],
+      [/\\./, 'string.escape.invalid'],
+      [/\${/, { token: 'delimiter.bracket', next: '@templateExpression' }],
+      [/`/, 'string.template', '@pop'],
+    ],
+
+    templateExpression: [[/}/, { token: 'delimiter.bracket', next: '@pop' }], { include: 'root' }],
+
+    regexp: [
+      [
+        /(\{)(\d+(?:,\d*)?)(\})/,
+        ['regexp.escape.control', 'regexp.escape.control', 'regexp.escape.control'],
+      ],
+      [/(\[)([^\]\\]|\\.)*(\])/, 'regexp.escape.control'],
+      [/(\()(\?:|\?=|\?!)/, ['regexp.escape.control', 'regexp.escape.control']],
+      [/[()]/, 'regexp.escape.control'],
+      [/@escapes/, 'regexp.escape'],
+      [/\\./, 'regexp.escape'],
+      [/\/[gimsuy]*/, { token: 'regexp', bracket: '@close', next: '@pop' }],
+      [/./, 'regexp'],
+    ],
+  },
+};
+
+// Register the language with Monaco
+export function registerWangLanguage(monaco) {
+  monaco.languages.register({ id: 'wang' });
+  monaco.languages.setMonarchTokensProvider('wang', wangLanguage);
+
+  // Configuration for brackets and auto-closing
+  monaco.languages.setLanguageConfiguration('wang', {
+    comments: {
+      lineComment: '//',
+      blockComment: ['/*', '*/'],
+    },
+    brackets: [
+      ['{', '}'],
+      ['[', ']'],
+      ['(', ')'],
+    ],
+    autoClosingPairs: [
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '"', close: '"', notIn: ['string'] },
+      { open: "'", close: "'", notIn: ['string'] },
+      { open: '`', close: '`', notIn: ['string'] },
+      { open: '/*', close: '*/' },
+    ],
+    surroundingPairs: [
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+      { open: '`', close: '`' },
+    ],
+    folding: {
+      markers: {
+        start: new RegExp('^\\s*//\\s*#?region\\b'),
+        end: new RegExp('^\\s*//\\s*#?endregion\\b'),
+      },
+    },
+    indentationRules: {
+      increaseIndentPattern: new RegExp('^.*(\\{[^}]*|\\([^)]*|\\[[^\\]]*)$'),
+      decreaseIndentPattern: new RegExp('^\\s*(\\}|\\)|\\])'),
+    },
+  });
+}

package/src/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/src/index.js

@@ -335,3 +335,46 @@ 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/src/interpreter/index.js

@@ -42,6 +42,13 @@ export class WangInterpreter {
     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();
@@ -164,11 +171,31 @@ export class InMemoryModuleResolver {
     this.modules = new Map();
   }
 
-  addModule(name, code) {
-    this.modules.set(name, code);
+  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 resolve(name) {
-    return this.modules.get(name);
+  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;
   }
 }

package/src/interpreter/interpreter.js

@@ -1199,11 +1199,14 @@ export class Interpreter {
       moduleExports = this.moduleCache.get(modulePath);
     } else {
       // Resolve and load module code
-      const moduleCode = await this.moduleResolver.resolve(modulePath);
-      if (!moduleCode) {
+      const resolution = await this.moduleResolver.resolve(modulePath);
+      if (!resolution) {
         throw new Error(`Cannot find module '${modulePath}'`);
       }
 
+      // Handle both old (string) and new (ModuleResolution) formats
+      const moduleCode = typeof resolution === 'string' ? resolution : resolution.code;
+
       // Parse and execute module in its own environment
       const moduleAst = acornParse(moduleCode, {
         ecmaVersion: 2020,

package/src/validator/index.js

@@ -0,0 +1,103 @@
+/**
+ * WangValidator - Syntax validation for Wang/JSLike code
+ */
+
+import { parse, preprocessCode } from '../index.js';
+
+export class WangValidator {
+  /**
+   * Validate code and return validation result
+   * @param {string} code - The code to validate
+   * @param {object} options - Validation options
+   * @param {boolean} options.includeAST - Whether to include AST in result
+   * @returns {object} Validation result
+   */
+  validate(code, options = {}) {
+    try {
+      // Preprocess code (handles ASI, etc.)
+      const processed = preprocessCode(code);
+
+      // Parse the code
+      const ast = parse(processed);
+
+      return {
+        valid: true,
+        ast: options.includeAST ? ast : undefined
+      };
+    } catch (error) {
+      // Extract line and column from error
+      const line = error.loc?.line || 1;
+      const column = error.loc?.column || 0;
+
+      // Generate suggestion for common errors
+      const suggestion = this.getSuggestion(error, code);
+
+      return {
+        valid: false,
+        error: {
+          message: error.message,
+          line,
+          column,
+          suggestion
+        }
+      };
+    }
+  }
+
+  /**
+   * Generate suggestions for common syntax errors
+   * @param {Error} error - The parse error
+   * @param {string} code - The original code
+   * @returns {string|undefined} Suggestion text
+   */
+  getSuggestion(error, code) {
+    const message = error.message.toLowerCase();
+
+    // Common error patterns and suggestions
+    if (message.includes('unexpected token')) {
+      if (message.includes('}')) {
+        return 'Check for missing opening brace or extra closing brace';
+      }
+      if (message.includes('{')) {
+        return 'Check for missing closing brace or misplaced opening brace';
+      }
+      if (message.includes(')')) {
+        return 'Check for missing opening parenthesis or extra closing parenthesis';
+      }
+      if (message.includes('(')) {
+        return 'Check for missing closing parenthesis';
+      }
+      return 'Check syntax near the error location';
+    }
+
+    if (message.includes('unterminated string')) {
+      return 'Add closing quote to string literal';
+    }
+
+    if (message.includes('unterminated template')) {
+      return 'Add closing backtick to template literal';
+    }
+
+    if (message.includes('identifier expected')) {
+      return 'Provide a valid identifier name';
+    }
+
+    if (message.includes('unexpected end of input')) {
+      return 'Check for unclosed brackets, braces, or parentheses';
+    }
+
+    if (message.includes('invalid left-hand side')) {
+      return 'Check that assignment target is a valid variable or property';
+    }
+
+    if (message.includes('duplicate parameter')) {
+      return 'Remove duplicate parameter name in function definition';
+    }
+
+    if (message.includes('strict mode')) {
+      return 'This syntax is not allowed in strict mode';
+    }
+
+    return undefined;
+  }
+}