pacc 8.2.0 → 8.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pacc",
-  "version": "8.2.0",
+  "version": "8.3.0",
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -42,7 +42,7 @@
     "browser-ava": "^2.3.51",
     "c8": "^10.1.3",
     "documentation": "^14.0.3",
-    "semantic-release": "^25.0.2",
+    "semantic-release": "^25.0.3",
     "typescript": "^5.9.3"
   },
   "engines": {

package/src/ast.mjs

@@ -30,40 +30,12 @@ export function binopError(op, left, right) {
 }
 
 export function binop(op, left, right, fallback) {
-  switch (op) {
-    case DOUBLE_BAR:
-      return left || right;
-    case DOUBLE_AMPERSAND:
-      return left && right;
-    case EQUAL:
-      return left == right;
-    case NOT_EQUAL:
-      return left != right;
-    case GREATER:
-      return left > right;
-    case LESS:
-      return left < right;
-    case GREATER_EQUAL:
-      return left >= right;
-    case LESS_EQUAL:
-      return left <= right;
-    case PLUS:
-      return left + right;
-    case MINUS:
-      return left - right;
-    case STAR:
-      return left * right;
-    case DIVIDE:
-      return left / right;
-  }
+
+  if(op.binop) { return op.binop(left,right); }
 
   return fallback(op, left, right);
 }
 
-export const ASTNodeTrue = {
-  eval: () => true
-};
-
 export function binopEval(node, current, context) {
   return binop(
     node.token,
@@ -75,6 +47,19 @@ export function binopEval(node, current, context) {
   );
 }
 
+export function ASTBinop(token, left, right) {
+  if (!left.eval && !right.eval) {
+    return binop(token, left, right, binopError);
+  }
+
+  return {
+    eval: binopEval,
+    token,
+    left,
+    right
+  };
+}
+
 export function pathEval(node, current, context) {
   let collection = false;
   let first = true;
@@ -91,9 +76,9 @@ export function pathEval(node, current, context) {
               current = current.map(x => x[item]);
             } else {
               current =
-                (current instanceof Map ? current.get(item) : current[item]);
+                current instanceof Map ? current.get(item) : current[item];
 
-              if(first && current === undefined) {
+              if (first && current === undefined) {
                 current = context.getGlobal(item);
               }
             }
@@ -120,3 +105,7 @@ export function functionEval(node, current, context) {
   );
   return context.getGlobal(node.path[0])(...args);
 }
+
+export const ASTTrue = {
+  eval: () => true
+};

package/src/expression.mjs

@@ -11,12 +11,11 @@ import {
 } from "./tokens.mjs";
 
 import {
-  binopError,
-  binop,
   binopEval,
   pathEval,
   functionEval,
-  ASTNodeTrue
+  ASTTrue,
+  ASTBinop
 } from "./ast.mjs";
 
 /**
@@ -65,7 +64,7 @@ export function parse(input, context = {}) {
           case OPEN_BRACKET: {
             if (token === CLOSE_BRACKET) {
               advance();
-              return ASTNodeTrue;
+              return ASTTrue;
             }
 
             const node = expression(0);
@@ -101,38 +100,16 @@ export function parse(input, context = {}) {
 
   const led = (last, left) => {
     switch (last.type) {
-      case "infixr": {
-        const right = expression(last.precedence - 1);
-        if (typeof left === typeof right) {
-          switch (typeof left) {
-            case "string":
-            case "number":
-            case "bigint":
-            case "boolean":
-              return binop(last, left, right, binopError);
-          }
-        }
-
-        return {
-          eval: binopEval,
-          token: last,
-          left,
-          right
-        };
-      }
+      case "infixr":
+        return ASTBinop(last, left, expression(last.precedence - 1));
 
       case "infix": {
         let right = expression(last.precedence);
 
-        if (typeof left === typeof right) {
-          switch (typeof left) {
-            case "string":
-            case "number":
-            case "bigint":
-            case "boolean":
-              return binop(last, left, right, binopError);
-          }
+        if (last.binop) {
+          return ASTBinop(last, left, right);
         }
+
         if (last === DOT) {
           if (left.path) {
             left.path.push(...right.path);
@@ -178,7 +155,7 @@ export function parse(input, context = {}) {
           case OPEN_BRACKET: {
             if (token === CLOSE_BRACKET) {
               advance();
-              left.path.push(ASTNodeTrue);
+              left.path.push(ASTTrue);
             } else {
               const predicate = expression(0);
               expect(CLOSE_BRACKET);

package/src/tokens.mjs

@@ -11,29 +11,80 @@ const lookup = {};
 /**
  *
  * @param {string} str
+ * @param {number} [precedence]
+ * @param {string} [type]
  * @returns {Token}
  */
-function createToken(str, precedence = 0, type) {
+function createToken(str, precedence = 0, type, binop) {
   const token = { str, precedence, type };
+  if (binop) {
+    token.binop = binop;
+  }
   lookup[str] = [token];
   return token;
 }
 
-export /** @type {Token} */ const PLUS = createToken("+", 50, "infix");
-export /** @type {Token} */ const MINUS = createToken("-", 50, "infix");
-export /** @type {Token} */ const STAR = createToken("*", 60, "infix");
-export /** @type {Token} */ const DIVIDE = createToken("/", 60, "infix");
+export /** @type {Token} */ const PLUS = createToken(
+  "+",
+  50,
+  "infix",
+  (left, right) => left + right
+);
+export /** @type {Token} */ const MINUS = createToken(
+  "-",
+  50,
+  "infix",
+  (left, right) => left - right
+);
+export /** @type {Token} */ const STAR = createToken(
+  "*",
+  60,
+  "infix",
+  (left, right) => left * right
+);
+export /** @type {Token} */ const DIVIDE = createToken(
+  "/",
+  60,
+  "infix",
+  (left, right) => left / right
+);
 export /** @type {Token} */ const NOT = createToken("!");
-export /** @type {Token} */ const NOT_EQUAL = createToken("!=", 40, "infixr");
-export /** @type {Token} */ const EQUAL = createToken("=", 40, "infixr");
-export /** @type {Token} */ const GREATER = createToken(">", 40, "infixr");
+export /** @type {Token} */ const NOT_EQUAL = createToken(
+  "!=",
+  40,
+  "infixr",
+  (left, right) => left != right
+);
+export /** @type {Token} */ const EQUAL = createToken(
+  "=",
+  40,
+  "infixr",
+  (left, right) => left == right
+);
+export /** @type {Token} */ const GREATER = createToken(
+  ">",
+  40,
+  "infixr",
+  (left, right) => left > right
+);
 export /** @type {Token} */ const GREATER_EQUAL = createToken(
   ">=",
   40,
-  "infixr"
+  "infixr",
+  (left, right) => left >= right
+);
+export /** @type {Token} */ const LESS = createToken(
+  "<",
+  40,
+  "infixr",
+  (left, right) => left < right
+);
+export /** @type {Token} */ const LESS_EQUAL = createToken(
+  "<=",
+  40,
+  "infixr",
+  (left, right) => left <= right
 );
-export /** @type {Token} */ const LESS = createToken("<", 40, "infixr");
-export /** @type {Token} */ const LESS_EQUAL = createToken("<=", 40, "infixr");
 export /** @type {Token} */ const OPEN_ROUND = createToken("(", 40, "prefix");
 export /** @type {Token} */ const CLOSE_ROUND = createToken(")", 0, "infix");
 export /** @type {Token} */ const OPEN_BRACKET = createToken("[", 10, "prefix");
@@ -41,7 +92,7 @@ export /** @type {Token} */ const CLOSE_BRACKET = createToken("]", 0, "infix");
 export /** @type {Token} */ const OPEN_CURLY = createToken("{");
 export /** @type {Token} */ const CLOSE_CURLY = createToken("}");
 export /** @type {Token} */ const QUESTION = createToken("?", 20, "infix");
-export /** @type {Token} */ const COLON = createToken(":", "infix");
+export /** @type {Token} */ const COLON = createToken(":", undefined, "infix");
 export /** @type {Token} */ const SEMICOLON = createToken(";");
 export /** @type {Token} */ const COMMA = createToken(",");
 export /** @type {Token} */ const DOT = createToken(".", 80, "infix");
@@ -49,10 +100,16 @@ export /** @type {Token} */ const AMPERSAND = createToken("&");
 export /** @type {Token} */ const DOUBLE_AMPERSAND = createToken(
   "&&",
   30,
-  "infixr"
+  "infixr",
+  (left, right) => left && right
 );
 export /** @type {Token} */ const BAR = createToken("|");
-export /** @type {Token} */ const DOUBLE_BAR = createToken("||", 30, "infixr");
+export /** @type {Token} */ const DOUBLE_BAR = createToken(
+  "||",
+  30,
+  "infixr",
+  (left, right) => left || right
+);
 export /** @type {Token} */ const IDENTIFIER = createToken("IDENTIFIER", 0);
 export /** @type {Token} */ const EOF = createToken("EOF", -1, "eof");
 

package/types/ast.d.mts

@@ -12,9 +12,10 @@
 export function binopError(op: Token, left: AST, right: AST): void;
 export function binop(op: any, left: any, right: any, fallback: any): any;
 export function binopEval(node: any, current: any, context: any): any;
+export function ASTBinop(token: any, left: any, right: any): any;
 export function pathEval(node: any, current: any, context: any): any;
 export function functionEval(node: any, current: any, context: any): any;
-export namespace ASTNodeTrue {
+export namespace ASTTrue {
     function eval(): boolean;
 }
 export type AST = {