bare-script 3.3.2 → 3.5.0

package/lib/model.js

@@ -162,6 +162,12 @@ enum BinaryExpressionOperator
     # Subtraction
     "-"
 
+    # Bitwise left shift
+    "<<"
+
+    # Bitwise right shift
+    ">>"
+
     # Less than or equal
     "<="
 
@@ -180,6 +186,15 @@ enum BinaryExpressionOperator
     # Not equal
     "!="
 
+    # Bitwise AND
+    "&"
+
+    # Bitwise XOR
+    "^"
+
+    # Bitwise OR
+    "|"
+
     # Logical AND
     "&&"
 
@@ -206,6 +221,9 @@ enum UnaryExpressionOperator
     # Logical NOT
     "!"
 
+    # Bitwise NOT
+    "~"
+
 
 # A function expression
 struct FunctionExpression

package/lib/parser.js

@@ -539,18 +539,23 @@ function parseBinaryExpression(exprText, binLeftExpr = null) {
 
 // Binary operator re-order map
 const binaryReorder = {
-    '**': new Set(['*', '/', '%', '+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||']),
-    '*': new Set(['+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||']),
-    '/': new Set(['+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||']),
-    '%': new Set(['+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||']),
-    '+': new Set(['<=', '<', '>=', '>', '==', '!=', '&&', '||']),
-    '-': new Set(['<=', '<', '>=', '>', '==', '!=', '&&', '||']),
-    '<=': new Set(['==', '!=', '&&', '||']),
-    '<': new Set(['==', '!=', '&&', '||']),
-    '>=': new Set(['==', '!=', '&&', '||']),
-    '>': new Set(['==', '!=', '&&', '||']),
-    '==': new Set(['&&', '||']),
-    '!=': new Set(['&&', '||']),
+    '**': new Set(['*', '/', '%', '+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '*': new Set(['+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '/': new Set(['+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '%': new Set(['+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '+': new Set(['<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '-': new Set(['<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '<<': new Set(['<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '>>': new Set(['<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||']),
+    '<=': new Set(['==', '!=', '&', '^', '|', '&&', '||']),
+    '<': new Set(['==', '!=', '&', '^', '|', '&&', '||']),
+    '>=': new Set(['==', '!=', '&', '^', '|', '&&', '||']),
+    '>': new Set(['==', '!=', '&', '^', '|', '&&', '||']),
+    '==': new Set(['&', '^', '|', '&&', '||']),
+    '!=': new Set(['&', '^', '|', '&&', '||']),
+    '&': new Set(['^', '|', '&&', '||']),
+    '^': new Set(['|', '&&', '||']),
+    '|': new Set(['&&', '||']),
     '&&': new Set(['||']),
     '||': new Set([])
 };
@@ -570,6 +575,31 @@ function parseUnaryExpression(exprText) {
         return [{'group': expr}, nextText.slice(matchGroupClose[0].length)];
     }
 
+    // Number?
+    const matchNumber = exprText.match(rExprNumber);
+    if (matchNumber !== null) {
+        const [numberStr] = matchNumber;
+        const number = (numberStr.startsWith('0x') ? parseInt(numberStr, 16) : parseFloat(numberStr));
+        const expr = {'number': number};
+        return [expr, exprText.slice(matchNumber[0].length)];
+    }
+
+    // String?
+    const matchString = exprText.match(rExprString);
+    if (matchString !== null) {
+        const string = matchString[1].replace(rExprStringEscape, '$1');
+        const expr = {'string': string};
+        return [expr, exprText.slice(matchString[0].length)];
+    }
+
+    // String (double quotes)?
+    const matchStringDouble = exprText.match(rExprStringDouble);
+    if (matchStringDouble !== null) {
+        const string = matchStringDouble[1].replace(rExprStringDoubleEscape, '$1');
+        const expr = {'string': string};
+        return [expr, exprText.slice(matchStringDouble[0].length)];
+    }
+
     // Unary operator?
     const matchUnary = exprText.match(rExprUnaryOp);
     if (matchUnary !== null) {
@@ -621,30 +651,6 @@ function parseUnaryExpression(exprText) {
         return [fnExpr, argText];
     }
 
-    // Number?
-    const matchNumber = exprText.match(rExprNumber);
-    if (matchNumber !== null) {
-        const number = parseFloat(matchNumber[1]);
-        const expr = {'number': number};
-        return [expr, exprText.slice(matchNumber[0].length)];
-    }
-
-    // String?
-    const matchString = exprText.match(rExprString);
-    if (matchString !== null) {
-        const string = matchString[1].replace(rExprStringEscape, '$1');
-        const expr = {'string': string};
-        return [expr, exprText.slice(matchString[0].length)];
-    }
-
-    // String (double quotes)?
-    const matchStringDouble = exprText.match(rExprStringDouble);
-    if (matchStringDouble !== null) {
-        const string = matchStringDouble[1].replace(rExprStringDoubleEscape, '$1');
-        const expr = {'string': string};
-        return [expr, exprText.slice(matchStringDouble[0].length)];
-    }
-
     // Variable?
     const matchVariable = exprText.match(rExprVariable);
     if (matchVariable !== null) {
@@ -665,14 +671,14 @@ function parseUnaryExpression(exprText) {
 
 
 // BareScript expression regex
-const rExprBinaryOp = /^\s*(\*\*|\*|\/|%|\+|-|<=|<|>=|>|==|!=|&&|\|\|)/;
-const rExprUnaryOp = /^\s*(!|-)/;
+const rExprBinaryOp = /^\s*(\*\*|\*|\/|%|\+|-|<<|>>|<=|<|>=|>|==|!=|&&|\|\||&|\^|\|)/;
+const rExprUnaryOp = /^\s*(!|-|~)/;
 const rExprFunctionOpen = /^\s*([A-Za-z_]\w+)\s*\(/;
 const rExprFunctionSeparator = /^\s*,/;
 const rExprFunctionClose = /^\s*\)/;
 const rExprGroupOpen = /^\s*\(/;
 const rExprGroupClose = /^\s*\)/;
-const rExprNumber = /^\s*([+-]?\d+(?:\.\d*)?(?:e[+-]\d+)?)/;
+const rExprNumber = /^\s*(0x[A-Fa-f0-9]+|[+-]?\d+(?:\.\d*)?(?:e[+-]?\d+)?)/;
 const rExprString = /^\s*'((?:\\\\|\\'|[^'])*)'/;
 const rExprStringEscape = /\\([\\'])/g;
 const rExprStringDouble = /^\s*"((?:\\\\|\\"|[^"])*)"/;

package/lib/runtime.js

@@ -300,12 +300,37 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
             if (typeof leftValue === 'number' && typeof rightValue === 'number') {
                 return leftValue % rightValue;
             }
-        } else {
-            // binOp === '**'
+        } else if (binOp === '**') {
             // number ** number
             if (typeof leftValue === 'number' && typeof rightValue === 'number') {
                 return leftValue ** rightValue;
             }
+        } else if (binOp === '&') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue & rightValue;
+            }
+        } else if (binOp === '|') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue | rightValue;
+            }
+        } else if (binOp === '^') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue ^ rightValue;
+            }
+        } else if (binOp === '<<') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue << rightValue;
+            }
+        } else {
+            // if (binOp === '>>')
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue >> rightValue;
+            }
         }
 
         // Invalid operation values
@@ -318,8 +343,15 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
         const value = evaluateExpression(expr.unary.expr, options, locals, builtins);
         if (unaryOp === '!') {
             return !valueBoolean(value);
-        } else if (unaryOp === '-' && typeof value === 'number') {
-            return -value;
+        } else if (unaryOp === '-') {
+            if (typeof value === 'number') {
+                return -value;
+            }
+        } else {
+            // if (unaryOp === '~'
+            if (typeof value === 'number' && Math.floor(value) === value) {
+                return ~value;
+            }
         }
 
         // Invalid operation value

package/lib/runtimeAsync.js

@@ -371,12 +371,37 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
             if (typeof leftValue === 'number' && typeof rightValue === 'number') {
                 return leftValue % rightValue;
             }
-        } else {
-            // binOp === '**'
+        } else if (binOp === '**') {
             // number ** number
             if (typeof leftValue === 'number' && typeof rightValue === 'number') {
                 return leftValue ** rightValue;
             }
+        } else if (binOp === '&') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue & rightValue;
+            }
+        } else if (binOp === '|') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue | rightValue;
+            }
+        } else if (binOp === '^') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue ^ rightValue;
+            }
+        } else if (binOp === '<<') {
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue << rightValue;
+            }
+        } else {
+            // if (binOp === '>>')
+            if (typeof leftValue === 'number' && Math.floor(leftValue) === leftValue &&
+                typeof rightValue === 'number' && Math.floor(rightValue) === rightValue) {
+                return leftValue >> rightValue;
+            }
         }
 
         // Invalid operation values
@@ -389,8 +414,15 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
         const value = await evaluateExpressionAsync(expr.unary.expr, options, locals, builtins);
         if (unaryOp === '!') {
             return !valueBoolean(value);
-        } else if (unaryOp === '-' && typeof value === 'number') {
-            return -value;
+        } else if (unaryOp === '-') {
+            if (typeof value === 'number') {
+                return -value;
+            }
+        } else {
+            // if (unaryOp === '~'
+            if (typeof value === 'number' && Math.floor(value) === value) {
+                return ~value;
+            }
         }
 
         // Invalid operation value

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "bare-script",
-    "version": "3.3.2",
+    "version": "3.5.0",
     "description": "BareScript; a lightweight scripting and expression language",
     "keywords": [
         "expression",
@@ -31,7 +31,7 @@
     },
     "devDependencies": {
         "c8": "~10.1",
-        "eslint": "~9.28",
+        "eslint": "~9.35",
         "jsdoc": "~4.0"
     }
 }