jslike 1.4.0 → 1.4.1

package/dist/esm/ast/nodes.js

@@ -0,0 +1,236 @@
+// AST Node Constructors
+
+export const Program = (body) => ({
+  type: 'Program',
+  body
+});
+
+export const Literal = (value) => ({
+  type: 'Literal',
+  value
+});
+
+export const Identifier = (name) => ({
+  type: 'Identifier',
+  name
+});
+
+export const BinaryExpression = (operator, left, right) => ({
+  type: 'BinaryExpression',
+  operator,
+  left,
+  right
+});
+
+export const UnaryExpression = (operator, argument, prefix = true) => ({
+  type: 'UnaryExpression',
+  operator,
+  argument,
+  prefix
+});
+
+export const UpdateExpression = (operator, argument, prefix = true) => ({
+  type: 'UpdateExpression',
+  operator,
+  argument,
+  prefix
+});
+
+export const AssignmentExpression = (operator, left, right) => ({
+  type: 'AssignmentExpression',
+  operator,
+  left,
+  right
+});
+
+export const LogicalExpression = (operator, left, right) => ({
+  type: 'LogicalExpression',
+  operator,
+  left,
+  right
+});
+
+export const ConditionalExpression = (test, consequent, alternate) => ({
+  type: 'ConditionalExpression',
+  test,
+  consequent,
+  alternate
+});
+
+export const CallExpression = (callee, args) => ({
+  type: 'CallExpression',
+  callee,
+  arguments: args
+});
+
+export const MemberExpression = (object, property, computed = false) => ({
+  type: 'MemberExpression',
+  object,
+  property,
+  computed
+});
+
+export const ArrayExpression = (elements) => ({
+  type: 'ArrayExpression',
+  elements
+});
+
+export const ObjectExpression = (properties) => ({
+  type: 'ObjectExpression',
+  properties
+});
+
+export const Property = (key, value, shorthand = false) => ({
+  type: 'Property',
+  key,
+  value,
+  shorthand
+});
+
+export const FunctionExpression = (id, params, body) => ({
+  type: 'FunctionExpression',
+  id,
+  params,
+  body
+});
+
+export const ArrowFunctionExpression = (params, body, expression = false) => ({
+  type: 'ArrowFunctionExpression',
+  params,
+  body,
+  expression
+});
+
+export const VariableDeclaration = (kind, declarations) => ({
+  type: 'VariableDeclaration',
+  kind,
+  declarations
+});
+
+export const VariableDeclarator = (id, init = null) => ({
+  type: 'VariableDeclarator',
+  id,
+  init
+});
+
+export const FunctionDeclaration = (id, params, body) => ({
+  type: 'FunctionDeclaration',
+  id,
+  params,
+  body
+});
+
+export const BlockStatement = (body) => ({
+  type: 'BlockStatement',
+  body
+});
+
+export const ExpressionStatement = (expression) => ({
+  type: 'ExpressionStatement',
+  expression
+});
+
+export const ReturnStatement = (argument = null) => ({
+  type: 'ReturnStatement',
+  argument
+});
+
+export const IfStatement = (test, consequent, alternate = null) => ({
+  type: 'IfStatement',
+  test,
+  consequent,
+  alternate
+});
+
+export const WhileStatement = (test, body) => ({
+  type: 'WhileStatement',
+  test,
+  body
+});
+
+export const DoWhileStatement = (body, test) => ({
+  type: 'DoWhileStatement',
+  body,
+  test
+});
+
+export const ForStatement = (init, test, update, body) => ({
+  type: 'ForStatement',
+  init,
+  test,
+  update,
+  body
+});
+
+export const ForInStatement = (left, right, body) => ({
+  type: 'ForInStatement',
+  left,
+  right,
+  body
+});
+
+export const ForOfStatement = (left, right, body) => ({
+  type: 'ForOfStatement',
+  left,
+  right,
+  body
+});
+
+export const BreakStatement = (label = null) => ({
+  type: 'BreakStatement',
+  label
+});
+
+export const ContinueStatement = (label = null) => ({
+  type: 'ContinueStatement',
+  label
+});
+
+export const ThrowStatement = (argument) => ({
+  type: 'ThrowStatement',
+  argument
+});
+
+export const TryStatement = (block, handler = null, finalizer = null) => ({
+  type: 'TryStatement',
+  block,
+  handler,
+  finalizer
+});
+
+export const CatchClause = (param, body) => ({
+  type: 'CatchClause',
+  param,
+  body
+});
+
+export const SwitchStatement = (discriminant, cases) => ({
+  type: 'SwitchStatement',
+  discriminant,
+  cases
+});
+
+export const SwitchCase = (test, consequent) => ({
+  type: 'SwitchCase',
+  test,
+  consequent
+});
+
+export const NewExpression = (callee, args) => ({
+  type: 'NewExpression',
+  callee,
+  arguments: args
+});
+
+export const ThisExpression = () => ({
+  type: 'ThisExpression'
+});
+
+export const SequenceExpression = (expressions) => ({
+  type: 'SequenceExpression',
+  expressions
+});
+
+export const EmptyStatement = () => ({
+  type: 'EmptyStatement'
+});

package/dist/esm/cli/wang-run.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+import { readFile } from 'fs/promises';
+import { stdin } from 'process';
+import { execute } from '../index.js';
+
+const args = process.argv.slice(2);
+
+// Parse flags
+const verbose = args.includes('--verbose');
+const quiet = args.includes('--quiet');
+const help = args.includes('--help') || args.includes('-h');
+
+// Filter out flags to get file path
+const filePath = args.find(arg => !arg.startsWith('--') && arg !== '-h');
+
+if (help) {
+  console.log(`
+Wang Language Runtime
+
+Usage:
+  wang-run <file>           Execute a Wang file
+  wang-run -                Read from stdin
+  wang-run --help           Show this help message
+
+Options:
+  --verbose                 Show detailed execution information
+  --quiet                   Suppress extra output
+  -h, --help                Show this help message
+
+Examples:
+  wang-run script.wang
+  echo "console.log('test')" | wang-run -
+  `.trim());
+  process.exit(0);
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function run() {
+  try {
+    let code;
+
+    if (filePath === '-') {
+      // Read from stdin
+      code = await readStdin();
+    } else if (filePath) {
+      // Read from file
+      code = await readFile(filePath, 'utf8');
+    } else {
+      console.error('Error: No input file specified');
+      console.error('Use --help for usage information');
+      process.exit(1);
+    }
+
+    if (verbose) {
+      console.log('🚀 Executing Wang code...');
+    }
+
+    // Execute the code
+    await execute(code);
+
+    if (verbose) {
+      console.log('✅ Execution completed successfully');
+    }
+
+    process.exit(0);
+  } catch (error) {
+    // For file not found errors, show generic error message
+    if (error.code === 'ENOENT') {
+      console.error('Error:', error.message);
+    } else {
+      console.error('❌ Execution failed:');
+      console.error(error.message);
+      if (verbose) {
+        console.error(error.stack);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+run();

package/dist/esm/cli/wang-validate.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+import { readFile } from 'fs/promises';
+import { stdin } from 'process';
+import { parse } from 'acorn';
+import { isTopLevelAwait } from '../index.js';
+
+const args = process.argv.slice(2);
+
+// Parse flags
+const showAst = args.includes('--ast');
+const help = args.includes('--help') || args.includes('-h');
+
+// Filter out flags to get file path
+const filePath = args.find(arg => !arg.startsWith('--') && arg !== '-h');
+
+if (help) {
+  console.log(`
+Wang Language Validator
+
+Usage:
+  wang-validate <file>      Validate a Wang file
+  wang-validate -           Read from stdin
+  wang-validate --help      Show this help message
+
+Options:
+  --ast                     Show the Abstract Syntax Tree
+  -h, --help                Show this help message
+
+Examples:
+  wang-validate script.wang
+  echo "let x = 1" | wang-validate -
+  wang-validate script.wang --ast
+  `.trim());
+  process.exit(0);
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function validate() {
+  try {
+    let code;
+
+    if (filePath === '-') {
+      // Read from stdin
+      code = await readStdin();
+    } else if (filePath) {
+      // Read from file
+      code = await readFile(filePath, 'utf8');
+    } else {
+      console.error('Error: No input file specified');
+      console.error('Use --help for usage information');
+      process.exit(1);
+    }
+
+    // Check for top-level await
+    const hasAwait = isTopLevelAwait(code);
+
+    // Parse the code to validate syntax
+    const ast = parse(code, {
+      ecmaVersion: 'latest',
+      sourceType: hasAwait ? 'module' : 'script',
+      locations: true
+    });
+
+    console.log('✅ Valid Wang syntax');
+
+    if (showAst) {
+      console.log('\nAST:');
+      console.log(JSON.stringify(ast, null, 2));
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Invalid Wang syntax:');
+    console.error(error.message);
+    process.exit(1);
+  }
+}
+
+validate();

package/dist/esm/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*(\\}|\\)|\\])'),
+    },
+  });
+}