starlight-cli 1.1.1 → 1.1.3

package/dist/index.js

@@ -1392,7 +1392,6 @@ class Environment {
   if (name in this.store) return this.store[name];
   if (this.parent) return this.parent.get(name, node, source);
 
-  // Only suggest for top-level variable/function names
   let suggestion = null;
   if (node && source) {
     suggestion = this.suggest?.(name, this) || null;
@@ -1427,7 +1426,6 @@ class Evaluator {
     this.setupBuiltins();
   }
 suggest(name, env) {
-  // Collect all variable/function names from the environment chain
   const names = new Set();
   let current = env;
   while (current) {
@@ -1441,11 +1439,10 @@ suggest(name, env) {
   let bestScore = Infinity;
 
   for (const item of names) {
-    // simple edit distance approximation
     const dist = Math.abs(item.length - name.length) +
       [...name].filter((c, i) => c !== item[i]).length;
 
-    if (dist < bestScore && dist <= 2) { // max distance 2
+    if (dist < bestScore && dist <= 2) { 
       bestScore = dist;
       best = item;
     }
@@ -1454,58 +1451,50 @@ suggest(name, env) {
   return best;
 }
 
-
 formatValue(value, seen = new Set()) {
-  // Circular reference handling
+  const color = __nccwpck_require__(55);
+
   if (typeof value === 'object' && value !== null) {
-    if (seen.has(value)) return '[Circular]';
+    if (seen.has(value)) return color.red('[Circular]');
     seen.add(value);
   }
 
-  // Python-style null / undefined
-  if (value === null) return 'None';
-  if (value === undefined) return 'undefined';
+  if (value === null) return color.yellow('None');
+  if (value === undefined) return color.yellow('undefined');
 
   const t = typeof value;
 
-  // Strings (no quotes)
-  if (t === 'string') return value;
+  if (t === 'string') return color.cyan(value);
 
-  // Numbers
-  if (t === 'number') return String(value);
+  if (t === 'number') return color.green(String(value));
 
-  // Booleans (Python-style)
-  if (t === 'boolean') return value ? 'True' : 'False';
+  if (t === 'boolean') return color.yellow(value ? 'true' : 'false');
 
-  // Native JS functions
   if (t === 'function') {
-    return value.name
-      ? `<function ${value.name}>`
-      : '<function>';
+    return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
   }
 
-  // Arrays
   if (Array.isArray(value)) {
-    return '[' + value.map(v => this.formatValue(v, seen)).join(', ') + ']';
+    const items = value.map(v => this.formatValue(v, seen));
+    return color.white('[ ' + items.join(', ') + ' ]');
   }
 
-  // Objects (including user-defined functions)
   if (t === 'object') {
-    // Detect user-defined functions (AST-based)
     if (value.params && value.body) {
-      return value.name
-        ? `<function ${value.name}>`
-        : '<function>';
+      return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
     }
 
     const entries = Object.entries(value).map(
-      ([k, v]) => `${k}: ${this.formatValue(v, seen)}`
+      ([k, v]) => color.magenta(`${k}: `) + this.formatValue(v, seen)
     );
-    return '{ ' + entries.join(', ') + ' }';
+    return color.magenta('{ ') + entries.join(color.magenta(', ')) + color.magenta(' }');
   }
 
-  // Fallback
-  return String(value);
+  try {
+    return String(value);
+  } catch {
+    return color.red('[Unprintable]');
+  }
 }
 
 
@@ -1580,7 +1569,6 @@ this.global.define('fetch', async (url, options = {}) => {
   };
 });
 
-// GET request
 this.global.define('get', async (url) => {
   const res = await fetch(url);
   return await res.json();
@@ -1627,6 +1615,11 @@ case 'ForInStatement':
   return await this.evalFor(node, env);
 case 'DoTrackStatement':
   return await this.evalDoTrack(node, env);
+case 'StartStatement':
+  return await this.evalStartStatement(node, env);
+
+case 'RaceClause':
+  return await this.evalRaceClause(node, env);
 
     case 'BreakStatement': throw new BreakSignal();
     case 'ContinueStatement': throw new ContinueSignal();
@@ -1655,14 +1648,14 @@ case 'DoTrackStatement':
   const callee = await this.evaluate(node.callee, env);
 
   if (typeof callee === 'object' && callee.body) {
-    const evaluator = this; // <- capture the current evaluator
+    const evaluator = this; 
     const Constructor = function(...args) {
       const newEnv = new Environment(callee.env);
       newEnv.define('this', this);
       for (let i = 0; i < callee.params.length; i++) {
         newEnv.define(callee.params[i], args[i]);
       }
-      return evaluator.evaluate(callee.body, newEnv); // use captured evaluator
+      return evaluator.evaluate(callee.body, newEnv);
     };
 
     const args = [];
@@ -1700,13 +1693,78 @@ async evalProgram(node, env) {
   return result;
 }
 
+async evalStartStatement(node, env) {
+  try {
+    const value = await this.evaluate(node.discriminant, env);
+    let executing = false;
+    for (const c of node.cases) {
+      try {
+        if (!executing) {
+          const testValue = await this.evaluate(c.test, env);
+          if (testValue === value) executing = true;
+        }
+
+        if (executing) {
+          await this.evaluate(c.consequent, new Environment(env));
+        }
+      } catch (caseErr) {
+        if (caseErr instanceof BreakSignal) break;
+        if (caseErr instanceof RuntimeError ||
+            caseErr instanceof ReturnValue ||
+            caseErr instanceof ContinueSignal) {
+          throw caseErr; // propagate signals
+        }
+
+        throw new RuntimeError(
+          caseErr.message || 'Error evaluating case in start statement',
+          c,
+          this.source
+        );
+      }
+    }
+
+    return null;
+  } catch (err) {
+    if (err instanceof RuntimeError ||
+        err instanceof ReturnValue ||
+        err instanceof BreakSignal ||
+        err instanceof ContinueSignal) {
+      throw err;
+    }
+    throw new RuntimeError(
+      err.message || 'Error evaluating start statement',
+      node,
+      this.source
+    );
+  }
+}
+
+
+async evalRaceClause(node, env) {
+  try {
+    const testValue = await this.evaluate(node.test, env);
+    const result = await this.evaluate(node.consequent, new Environment(env));
+    return { testValue, result };
+  } catch (err) {
+    if (err instanceof RuntimeError ||
+        err instanceof ReturnValue ||
+        err instanceof BreakSignal ||
+        err instanceof ContinueSignal) {
+      throw err; 
+    }
+    throw new RuntimeError(
+      err.message || 'Error evaluating race clause',
+      node,
+      this.source
+    );
+  }
+}
 
 async evalDoTrack(node, env) {
   try {
     return await this.evaluate(node.body, env);
   } catch (err) {
     if (!node.handler) {
-      // Wrap any raw error into RuntimeError with line info
       if (err instanceof RuntimeError) throw err;
       throw new RuntimeError(err.message || 'Error in doTrack body', node.body, this.source);
     }
@@ -1717,7 +1775,6 @@ async evalDoTrack(node, env) {
     try {
       return await this.evaluate(node.handler, trackEnv);
     } catch (handlerErr) {
-      // Wrap handler errors as well
       if (handlerErr instanceof RuntimeError) throw handlerErr;
       throw new RuntimeError(handlerErr.message || 'Error in doTrack handler', node.handler, this.source);
     }
@@ -1836,23 +1893,23 @@ async evalAssignment(node, env) {
   const left = node.left;
 
   if (left.type === 'Identifier') return env.set(left.name, rightVal);
-  if (left.type === 'MemberExpression') {
-  const obj = await this.evaluate(left.object, env);
-  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-  obj[left.property] = rightVal;
-  return rightVal;
-}
-if (left.type === 'IndexExpression') {
-  const obj = await this.evaluate(left.object, env);
-  const idx = await this.evaluate(left.indexer, env);
-  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-  obj[idx] = rightVal;
-  return rightVal;
-}
 
+  if (left.type === 'MemberExpression') {
+    const obj = await this.evaluate(left.object, env);
+    if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
+    obj[left.property] = rightVal; // dynamic creation of new properties allowed
+    return rightVal;
+  }
 
- throw new RuntimeError('Invalid assignment target', node, this.source);
+  if (left.type === 'IndexExpression') {
+    const obj = await this.evaluate(left.object, env);
+    const idx = await this.evaluate(left.indexer, env);
+    if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
+    obj[idx] = rightVal; // dynamic creation allowed
+    return rightVal;
+  }
 
+  throw new RuntimeError('Invalid assignment target', node, this.source);
 }
 
 async evalCompoundAssignment(node, env) {
@@ -1860,13 +1917,13 @@ async evalCompoundAssignment(node, env) {
   let current;
 
   if (left.type === 'Identifier') current = env.get(left.name, left, this.source);
-  else if (left.type === 'MemberExpression') current = await this.evalMember(left, env);
-  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env);
+  else if (left.type === 'MemberExpression') current = await this.evalMember(left, env) ?? 0;
+  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env) ?? 0;
   else throw new RuntimeError('Invalid compound assignment target', node, this.source);
 
-
   const rhs = await this.evaluate(node.right, env);
   let computed;
+
   switch (node.operator) {
     case 'PLUSEQ': computed = current + rhs; break;
     case 'MINUSEQ': computed = current - rhs; break;
@@ -1874,16 +1931,18 @@ async evalCompoundAssignment(node, env) {
     case 'SLASHEQ': computed = current / rhs; break;
     case 'MODEQ': computed = current % rhs; break;
     default: throw new RuntimeError(`Unknown compound operator: ${node.operator}`, node, this.source);
-
   }
 
   if (left.type === 'Identifier') env.set(left.name, computed);
-  else if (left.type === 'MemberExpression') await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
-  else await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+  else if (left.type === 'MemberExpression') 
+    await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+  else 
+    await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
 
   return computed;
 }
 
+
 async evalSldeploy(node, env) {
   const val = await this.evaluate(node.expr, env);
   console.log(this.formatValue(val));
@@ -1891,6 +1950,7 @@ async evalSldeploy(node, env) {
 }
 
 
+
 async evalAsk(node, env) {
   const prompt = await this.evaluate(node.prompt, env);
 
@@ -1997,11 +2057,7 @@ async evalWhile(node, env) {
   }
   return null;
 }
-
 async evalFor(node, env) {
-  // -------------------------------
-  // Python-style: for x in iterable (with optional 'let')
-  // -------------------------------
   if (node.type === 'ForInStatement') {
     const iterable = await this.evaluate(node.iterable, env);
 
@@ -2009,11 +2065,8 @@ async evalFor(node, env) {
       throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
     }
 
-    const loopVar = node.variable; // STRING from parser
-
+    const loopVar = node.variable; // string name of the loop variable
     const createLoopEnv = () => node.letKeyword ? new Environment(env) : env;
-
-    // Arrays
     if (Array.isArray(iterable)) {
       for (const value of iterable) {
         const loopEnv = createLoopEnv();
@@ -2028,7 +2081,6 @@ async evalFor(node, env) {
         }
       }
     }
-    // Objects (keys)
     else {
       for (const key of Object.keys(iterable)) {
         const loopEnv = createLoopEnv();
@@ -2047,9 +2099,6 @@ async evalFor(node, env) {
     return null;
   }
 
-  // -------------------------------
-  // C-style for loop
-  // -------------------------------
   const local = new Environment(env);
 
   if (node.init) await this.evaluate(node.init, local);
@@ -2071,6 +2120,7 @@ async evalFor(node, env) {
 
   return null;
 }
+
 evalFunctionDeclaration(node, env) {
   if (!node.name || typeof node.name !== 'string') {
     throw new RuntimeError('Function declaration requires a valid name', node, this.source);
@@ -2133,18 +2183,17 @@ async evalIndex(node, env) {
   const obj = await this.evaluate(node.object, env);
   const idx = await this.evaluate(node.indexer, env);
 
-  if (obj == null) throw new RuntimeError('Indexing null or undefined', node, this.source);
-
-  if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-    throw new RuntimeError('Array index out of bounds', node, this.source);
+  if (obj == null) throw new RuntimeError('Cannot index null or undefined', node, this.source);
+  if (Array.isArray(obj)) {
+    if (idx < 0 || idx >= obj.length) return undefined;
+    return obj[idx];
   }
-  if (typeof obj === 'object' && !(idx in obj)) {
-    throw new RuntimeError(`Property '${idx}' does not exist`, node, this.source);
+  if (typeof obj === 'object') {
+    return obj[idx]; // undefined if missing
   }
 
-  return obj[idx];
+  return undefined;
 }
-
 async evalObject(node, env) {
   const out = {};
   for (const p of node.props) {
@@ -2153,19 +2202,22 @@ async evalObject(node, env) {
     }
     const key = await this.evaluate(p.key, env);
     const value = await this.evaluate(p.value, env);
-    out[key] = value;
+    out[key] = value; // dynamic property assignment
   }
   return out;
 }
 
 
+
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
- if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
-if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node, this.source);
+
+  if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+
   return obj[node.property];
 }
 
+
 async evalUpdate(node, env) {
   const arg = node.argument;
   const getCurrent = async () => {
@@ -2233,7 +2285,7 @@ class Lexer {
       'break', 'continue', 'func', 'return',
       'true', 'false', 'null',
       'ask', 'define', 'import', 'from', 'as',
-      'async', 'await', 'new', 'in', 'do', 'track'
+      'async', 'await', 'new', 'in', 'do', 'track', 'start', 'race'
     ];
 }
 
@@ -2496,6 +2548,7 @@ class Parser {
       case 'WHILE': return this.whileStatement();
       case 'FOR': return this.forStatement();
       case 'DO': return this.doTrackStatement();
+      case 'START': return this.startStatement();
       case 'BREAK': return this.breakStatement();
       case 'CONTINUE': return this.continueStatement();
       case 'FUNC': return this.funcDeclaration();
@@ -2507,9 +2560,9 @@ class Parser {
     }
   }
 varDeclaration() {
-  const t = this.current; // LET token
+  const t = this.current; 
   this.eat('LET');
-  const idToken = this.current; // identifier token
+  const idToken = this.current; 
   const id = idToken.value;
   this.eat('IDENTIFIER');
 
@@ -2519,7 +2572,6 @@ varDeclaration() {
     expr = this.expression();
   }
 
-  // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
   return { 
@@ -2530,9 +2582,49 @@ varDeclaration() {
     column: t.column 
   };
 }
+startStatement() {
+  const t = this.current; 
+  this.eat('START');
+
+  const discriminant = this.expression();
+
+  this.eat('LBRACE');
+
+  const cases = [];
+
+  while (this.current.type === 'RACE') {
+    cases.push(this.raceClause());
+  }
+
+  this.eat('RBRACE');
+
+  return {
+    type: 'StartStatement',
+    discriminant,
+    cases,
+    line: t.line,
+    column: t.column
+  };
+}
+raceClause() {
+  const t = this.current; 
+  this.eat('RACE');
+
+  const test = this.expression();
+
+  const consequent = this.block();
+
+  return {
+    type: 'RaceClause',
+    test,
+    consequent,
+    line: t.line,
+    column: t.column
+  };
+}
 
 sldeployStatement() {
-  const t = this.current; // SLDEPLOY token
+  const t = this.current; 
   this.eat('SLDEPLOY');
   const expr = this.expression();
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
@@ -2545,7 +2637,7 @@ sldeployStatement() {
 }
 
 doTrackStatement() {
-  const t = this.current; // DO token
+  const t = this.current;
   this.eat('DO');
 
   const body = this.block();
@@ -2566,9 +2658,9 @@ doTrackStatement() {
 }
 
 defineStatement() {
-  const t = this.current; // DEFINE token
+  const t = this.current; 
   this.eat('DEFINE');
-  const idToken = this.current; // identifier token
+  const idToken = this.current; 
   const id = idToken.value;
   this.eat('IDENTIFIER');
 
@@ -2590,7 +2682,7 @@ defineStatement() {
 }
 
 asyncFuncDeclaration() {
-  const t = this.current; // first token of function (identifier)
+  const t = this.current;
   const name = this.current.value;
   this.eat('IDENTIFIER');
 
@@ -2608,7 +2700,6 @@ asyncFuncDeclaration() {
     }
     this.eat('RPAREN');
   } else {
-    // no parentheses: single param as Python style
     if (this.current.type === 'IDENTIFIER') {
       params.push(this.current.value);
       this.eat('IDENTIFIER');
@@ -2628,7 +2719,7 @@ asyncFuncDeclaration() {
 }
 
 ifStatement() {
-  const t = this.current; // IF token
+  const t = this.current;
   this.eat('IF');
 
   let test;
@@ -2637,7 +2728,6 @@ ifStatement() {
     test = this.expression();
     this.eat('RPAREN');
   } else {
-    // Python style: no parentheses
     test = this.expression();
   }
 
@@ -2661,7 +2751,7 @@ ifStatement() {
 }
 
 whileStatement() {
-  const t = this.current; // WHILE token
+  const t = this.current; 
   this.eat('WHILE');
 
   let test;
@@ -2684,7 +2774,7 @@ whileStatement() {
 }
 
 importStatement() {
-  const t = this.current; // IMPORT token
+  const t = this.current; 
   this.eat('IMPORT');
 
   let specifiers = [];
@@ -2743,7 +2833,6 @@ forStatement() {
   const t = this.current; // FOR token
   this.eat('FOR');
 
-  // --- Python-style: for variable in iterable (supports optional 'let') ---
   if ((this.current.type === 'LET' && this.peekType() === 'IDENTIFIER' && this.peekType(2) === 'IN') ||
       (this.current.type === 'IDENTIFIER' && this.peekType() === 'IN')) {
 
@@ -2784,7 +2873,6 @@ forStatement() {
     };
   }
 
-  // --- C-style: for(init; test; update) ---
   let init = null;
   let test = null;
   let update = null;
@@ -2792,22 +2880,18 @@ forStatement() {
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
 
-    // init
     if (this.current.type !== 'SEMICOLON') {
       init = this.current.type === 'LET' ? this.varDeclaration() : this.expressionStatement();
     } else {
       this.eat('SEMICOLON');
     }
 
-    // test
     if (this.current.type !== 'SEMICOLON') test = this.expression();
     this.eat('SEMICOLON');
 
-    // update
     if (this.current.type !== 'RPAREN') update = this.expression();
     this.eat('RPAREN');
   } else {
-    // fallback: single expression (rare, mostly handled above)
     init = this.expression();
     if (this.current.type === 'IN') {
       this.eat('IN');
@@ -2830,21 +2914,19 @@ forStatement() {
 breakStatement() {
   const t = this.current; // BREAK token
   this.eat('BREAK');
-  // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
   return { type: 'BreakStatement', line: t.line, column: t.column };
 }
 
 continueStatement() {
-  const t = this.current; // CONTINUE token
+  const t = this.current; 
   this.eat('CONTINUE');
-  // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
   return { type: 'ContinueStatement', line: t.line, column: t.column };
 }
 
 funcDeclaration() {
-  const t = this.current; // FUNC token
+  const t = this.current; 
   this.eat('FUNC');
   const nameToken = this.current;
   const name = nameToken.value;
@@ -2866,7 +2948,6 @@ funcDeclaration() {
     }
     this.eat('RPAREN');
   } else {
-    // Python-style: single param without parentheses
     if (this.current.type === 'IDENTIFIER') {
       const paramToken = this.current;
       params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
@@ -2887,7 +2968,6 @@ returnStatement() {
     argument = this.expression();
   }
 
-  // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
   return { type: 'ReturnStatement', argument, line: t.line, column: t.column };
@@ -2905,9 +2985,8 @@ block() {
 }
 
 expressionStatement() {
-  const exprToken = this.current; // first token of the expression
+  const exprToken = this.current;
   const expr = this.expression();
-  // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
   return { type: 'ExpressionStatement', expression: expr, line: exprToken.line, column: exprToken.column };
 }
@@ -3020,7 +3099,6 @@ unary() {
     };
   }
 
-  // Python-like: ignore ++ and -- if not used
   if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
     const op = t.type;
     this.eat(op);
@@ -3060,7 +3138,7 @@ postfix() {
       const args = [];
       while (this.current.type !== 'RPAREN' && this.current.type !== 'EOF') {
         args.push(this.expression());
-        if (this.current.type === 'COMMA') this.eat('COMMA'); // optional comma
+        if (this.current.type === 'COMMA') this.eat('COMMA');
       }
       if (this.current.type === 'RPAREN') this.eat('RPAREN');
       node = { type: 'CallExpression', callee: node, arguments: args, line: startLine, column: startCol };
@@ -3237,11 +3315,11 @@ arrowFunction(params) {
     this.eat('LBRACE');
     const props = [];
     while (this.current.type !== 'RBRACE') {
-      const key = this.expression(); // Flexible key: can be any expression
+      const key = this.expression(); 
       this.eat('COLON');
       const value = this.expression();
       props.push({ key, value });
-      if (this.current.type === 'COMMA') this.eat('COMMA'); // optional trailing comma
+      if (this.current.type === 'COMMA') this.eat('COMMA');
     }
     this.eat('RBRACE');
     return { type: 'ObjectExpression', props, line: startLine, column: startCol };
@@ -3307,6 +3385,53 @@ module.exports = require("path");
 "use strict";
 module.exports = require("readline");
 
+/***/ }),
+
+/***/ 55:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+"use strict";
+__nccwpck_require__.r(__webpack_exports__);
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   blue: () => (/* binding */ blue),
+/* harmony export */   brightBlue: () => (/* binding */ brightBlue),
+/* harmony export */   brightCyan: () => (/* binding */ brightCyan),
+/* harmony export */   brightGreen: () => (/* binding */ brightGreen),
+/* harmony export */   brightMagenta: () => (/* binding */ brightMagenta),
+/* harmony export */   brightRed: () => (/* binding */ brightRed),
+/* harmony export */   brightWhite: () => (/* binding */ brightWhite),
+/* harmony export */   brightYellow: () => (/* binding */ brightYellow),
+/* harmony export */   cyan: () => (/* binding */ cyan),
+/* harmony export */   gray: () => (/* binding */ gray),
+/* harmony export */   green: () => (/* binding */ green),
+/* harmony export */   magenta: () => (/* binding */ magenta),
+/* harmony export */   red: () => (/* binding */ red),
+/* harmony export */   white: () => (/* binding */ white),
+/* harmony export */   yellow: () => (/* binding */ yellow)
+/* harmony export */ });
+const RESET = "\x1b[0m";
+
+function wrap(code, text) {
+  return code + String(text) + RESET;
+}
+
+const red = text => wrap("\x1b[31m", text);
+const green = text => wrap("\x1b[32m", text);
+const yellow = text => wrap("\x1b[33m", text);
+const blue = text => wrap("\x1b[34m", text);
+const magenta = text => wrap("\x1b[35m", text);
+const cyan = text => wrap("\x1b[36m", text);
+const white = text => wrap("\x1b[37m", text);
+const gray = text => wrap("\x1b[90m", text);
+const brightRed = text => wrap("\x1b[91m", text);
+const brightGreen = text => wrap("\x1b[92m", text);
+const brightYellow = text => wrap("\x1b[93m", text);
+const brightBlue = text => wrap("\x1b[94m", text);
+const brightMagenta = text => wrap("\x1b[95m", text);
+const brightCyan = text => wrap("\x1b[96m", text);
+const brightWhite = text => wrap("\x1b[97m", text);
+
+
 /***/ })
 
 /******/ 	});
@@ -3342,6 +3467,34 @@ module.exports = require("readline");
 /******/ 	}
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__nccwpck_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__nccwpck_require__.o(definition, key) && !__nccwpck_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__nccwpck_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__nccwpck_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/compat */
 /******/ 	
 /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
@@ -3359,7 +3512,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.1';
+const VERSION = '1.1.3';
 
 const COLOR = {
     reset: '\x1b[0m',