bare-script 2.3.2 → 3.0.1

package/lib/model.js

@@ -221,7 +221,7 @@ struct FunctionExpression
 /**
  * Validate a BareScript script model
  *
- * @param {Object} script - The [BareScript model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='BareScript'}
+ * @param {Object} script - The [BareScript model](./model/#var.vName='BareScript')
  * @returns {Object} The validated BareScript model
  * @throws [ValidationError]{@link https://craigahobbs.github.io/schema-markdown-js/module-lib_schema.ValidationError.html}
  */
@@ -233,7 +233,7 @@ export function validateScript(script) {
 /**
  * Validate an expression model
  *
- * @param {Object} expr - The [expression model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='Expression'}
+ * @param {Object} expr - The [expression model](./model/#var.vName='Expression')
  * @returns {Object} The validated expression model
  * @throws [ValidationError]{@link https://craigahobbs.github.io/schema-markdown-js/module-lib_schema.ValidationError.html}
  */
@@ -245,7 +245,7 @@ export function validateExpression(expr) {
 /**
  * Lint a BareScript script model
  *
- * @param {Object} script - The [BareScript model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='BareScript'}
+ * @param {Object} script - The [BareScript model](./model/#var.vName='BareScript')
  * @returns {string[]} The array of lint warnings
  */
 export function lintScript(script) {

package/lib/options.js

@@ -0,0 +1,72 @@
+// Licensed under the MIT License
+// https://github.com/craigahobbs/bare-script/blob/main/LICENSE
+
+/** @module lib/options */
+
+
+/**
+ * The BareScript runtime options
+ *
+ * @typedef {Object} ExecuteScriptOptions
+ * @property {boolean} [debug] - If true, execute in debug mode
+ * @property {function} [fetchFn] - The [fetch function]{@link module:lib/options~FetchFn}
+ * @property {Object} [globals] - The global variables
+ * @property {function} [logFn] - The [log function]{@link module:lib/options~LogFn}
+ * @property {number} [maxStatements] - The maximum number of statements; default is 1e9; 0 for no maximum
+ * @property {number} [statementCount] - The current statement count
+ * @property {function} [urlFn] - The [URL modifier function]{@link module:lib/options~URLFn}
+ * @property {string} [systemPrefix] - The system include prefix
+ */
+
+
+/**
+ * The fetch function
+ *
+ * @callback FetchFn
+ * @param {string} url - The URL to fetch
+ * @param {?Object} [options] - The [fetch options]{@link https://developer.mozilla.org/en-US/docs/Web/API/fetch#parameters}
+ * @returns {Promise} The fetch [response promise]{@link https://developer.mozilla.org/en-US/docs/Web/API/Response}
+ */
+
+
+/**
+ * The log function
+ *
+ * @callback LogFn
+ * @param {string} text - The log text
+ */
+
+
+/**
+ * The URL modifier function
+ *
+ * @callback URLFn
+ * @param {string} url - The URL
+ * @returns {string} The modified URL
+ */
+
+
+/**
+ * A [URL modifier function]{@link module:lib/options~URLFn} implementation that fixes up file-relative paths
+ *
+ * @param {string} file - The URL or path to which relative URLs are relative
+ * @param {string} url - The URL or POSIX path to resolve
+ * @returns {string} The resolved URL
+ */
+export function urlFileRelative(file, url) {
+    // URL?
+    if (rURL.test(url)) {
+        return url;
+    }
+
+    // Absolute POSIX path?
+    if (url.startsWith('/')) {
+        return url;
+    }
+
+    // URL is relative POSIX path
+    return `${file.slice(0, file.lastIndexOf('/') + 1)}${url}`;
+}
+
+
+export const rURL = /^[a-z]+:/;

package/lib/optionsNode.js

@@ -0,0 +1,70 @@
+// Licensed under the MIT License
+// https://github.com/craigahobbs/bare-script/blob/main/LICENSE
+
+/** @module lib/optionsNode */
+
+import {readFile, writeFile} from 'node:fs/promises';
+import {stdout} from 'node:process';
+
+
+/**
+ * A [fetch function]{@link module:lib/options~FetchFn} implementation that fetches resources that uses HTTP GET
+ * and POST for URLs, otherwise read-only file system access
+ */
+export function fetchReadOnly(url, options = null, fetchFn = fetch, readFileFn = readFile) {
+    // URL fetch?
+    if (rURL.test(url)) {
+        return fetchFn(url, options);
+    }
+
+    // File write?
+    if ((options ?? null) !== null && 'body' in options) {
+        return {'ok': false};
+    }
+
+    // File read
+    return {
+        'ok': true,
+        'text': () => readFileFn(url, 'utf-8')
+    };
+}
+
+
+/**
+ * A [fetch function]{@link module:lib/options~FetchFn} implementation that fetches resources that uses HTTP GET
+ * and POST for URLs, otherwise read-write file system access
+ */
+export function fetchReadWrite(url, options, fetchFn = fetch, readFileFn = readFile, writeFileFn = writeFile) {
+    // URL fetch?
+    if (rURL.test(url)) {
+        return fetchFn(url, options);
+    }
+
+    // File write?
+    if ((options ?? null) !== null && 'body' in options) {
+        return {
+            'ok': true,
+            'text': async () => {
+                await writeFileFn(url, options.body);
+                return '{}';
+            }
+        };
+    }
+
+    // File read
+    return {
+        'ok': true,
+        'text': () => readFileFn(url, 'utf-8')
+    };
+}
+
+
+export const rURL = /^[a-z]+:/;
+
+
+/**
+ * A [log function]{@link module:lib/options~LogFn} implementation that outputs to stdout
+ */
+export function logStdout(text, stdoutObj = stdout) {
+    stdoutObj.write(`${text}\n`);
+}

package/lib/parser.js

@@ -4,40 +4,12 @@
 /** @module lib/parser */
 
 
-// BareScript regex
-const rScriptLineSplit = /\r?\n/;
-const rScriptContinuation = /\\\s*$/;
-const rScriptComment = /^\s*(?:#.*)?$/;
-const rScriptAssignment = /^\s*(?<name>[A-Za-z_]\w*)\s*=\s*(?<expr>.+)$/;
-const rScriptFunctionBegin = new RegExp(
-    '^(?<async>\\s*async)?\\s*function\\s+(?<name>[A-Za-z_]\\w*)\\s*\\(' +
-        '\\s*(?<args>[A-Za-z_]\\w*(?:\\s*,\\s*[A-Za-z_]\\w*)*)?(?<lastArgArray>\\s*\\.\\.\\.)?\\s*\\)\\s*:\\s*$'
-);
-const rScriptFunctionArgSplit = /\s*,\s*/;
-const rScriptFunctionEnd = /^\s*endfunction\s*$/;
-const rScriptLabel = /^\s*(?<name>[A-Za-z_]\w*)\s*:\s*$/;
-const rScriptJump = /^(?<jump>\s*(?:jump|jumpif\s*\((?<expr>.+)\)))\s+(?<name>[A-Za-z_]\w*)\s*$/;
-const rScriptReturn = /^(?<return>\s*return(?:\s+(?<expr>.+))?)\s*$/;
-const rScriptInclude = /^\s*include\s+(?<delim>')(?<url>(?:\\'|[^'])*)'\s*$/;
-const rScriptIncludeSystem = /^\s*include\s+(?<delim><)(?<url>[^>]*)>\s*$/;
-const rScriptIfBegin = /^\s*if\s+(?<expr>.+)\s*:\s*$/;
-const rScriptIfElseIf = /^\s*elif\s+(?<expr>.+)\s*:\s*$/;
-const rScriptIfElse = /^\s*else\s*:\s*$/;
-const rScriptIfEnd = /^\s*endif\s*$/;
-const rScriptForBegin = /^\s*for\s+(?<value>[A-Za-z_]\w*)(?:\s*,\s*(?<index>[A-Za-z_]\w*))?\s+in\s+(?<values>.+)\s*:\s*$/;
-const rScriptForEnd = /^\s*endfor\s*$/;
-const rScriptWhileBegin = /^\s*while\s+(?<expr>.+)\s*:\s*$/;
-const rScriptWhileEnd = /^\s*endwhile\s*$/;
-const rScriptBreak = /^\s*break\s*$/;
-const rScriptContinue = /^\s*continue\s*$/;
-
-
 /**
  * Parse a BareScript script
  *
- * @param {string|string[]} scriptText - The [script text]{@link https://craigahobbs.github.io/bare-script/language/}
+ * @param {string|string[]} scriptText - The [script text](./language/)
  * @param {number} [startLineNumber = 1] - The script's starting line number
- * @returns {Object} The [BareScript model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='BareScript'}
+ * @returns {Object} The [BareScript model](./model/#var.vName='BareScript')
  * @throws [BareScriptParserError]{@link module:lib/parser.BareScriptParserError}
  */
 export function parseScript(scriptText, startLineNumber = 1) {
@@ -319,7 +291,10 @@ export function parseScript(scriptText, startLineNumber = 1) {
             // Add the for-each header statements
             statements.push(
                 {'expr': {'name': foreach.values, 'expr': parseExpression(matchForBegin.groups.values)}},
-                {'expr': {'name': foreach.length, 'expr': {'function': {'name': 'arrayLength', 'args': [{'variable': foreach.values}]}}}},
+                {'expr': {
+                    'name': foreach.length,
+                    'expr': {'function': {'name': 'arrayLength', 'args': [{'variable': foreach.values}]}}
+                }},
                 {'jump': {'label': foreach.done, 'expr': {'unary': {'op': '!', 'expr': {'variable': foreach.length}}}}},
                 {'expr': {'name': foreach.index, 'expr': {'number': 0}}},
                 {'label': foreach.loop},
@@ -470,48 +445,39 @@ export function parseScript(scriptText, startLineNumber = 1) {
 }
 
 
-// BareScript expression regex
-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 rExprString = /^\s*'((?:\\\\|\\'|[^'])*)'/;
-const rExprStringEscape = /\\([\\'])/g;
-const rExprStringDouble = /^\s*"((?:\\\\|\\"|[^"])*)"/;
-const rExprStringDoubleEscape = /\\([\\"])/g;
-const rExprVariable = /^\s*([A-Za-z_]\w*)/;
-const rExprVariableEx = /^\s*\[\s*((?:\\\]|[^\]])+)\s*\]/;
-const rExprVariableExEscape = /\\([\\\]])/g;
-
-
-// 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([])
-};
+// BareScript regex
+const rScriptLineSplit = /\r?\n/;
+const rScriptContinuation = /\\\s*$/;
+const rScriptComment = /^\s*(?:#.*)?$/;
+const rScriptAssignment = /^\s*(?<name>[A-Za-z_]\w*)\s*=\s*(?<expr>.+)$/;
+const rScriptFunctionBegin = new RegExp(
+    '^(?<async>\\s*async)?\\s*function\\s+(?<name>[A-Za-z_]\\w*)\\s*\\(' +
+        '\\s*(?<args>[A-Za-z_]\\w*(?:\\s*,\\s*[A-Za-z_]\\w*)*)?(?<lastArgArray>\\s*\\.\\.\\.)?\\s*\\)\\s*:\\s*$'
+);
+const rScriptFunctionArgSplit = /\s*,\s*/;
+const rScriptFunctionEnd = /^\s*endfunction\s*$/;
+const rScriptLabel = /^\s*(?<name>[A-Za-z_]\w*)\s*:\s*$/;
+const rScriptJump = /^(?<jump>\s*(?:jump|jumpif\s*\((?<expr>.+)\)))\s+(?<name>[A-Za-z_]\w*)\s*$/;
+const rScriptReturn = /^(?<return>\s*return(?:\s+(?<expr>.+))?)\s*$/;
+const rScriptInclude = /^\s*include\s+(?<delim>')(?<url>(?:\\'|[^'])*)'\s*$/;
+const rScriptIncludeSystem = /^\s*include\s+(?<delim><)(?<url>[^>]*)>\s*$/;
+const rScriptIfBegin = /^\s*if\s+(?<expr>.+)\s*:\s*$/;
+const rScriptIfElseIf = /^\s*elif\s+(?<expr>.+)\s*:\s*$/;
+const rScriptIfElse = /^\s*else\s*:\s*$/;
+const rScriptIfEnd = /^\s*endif\s*$/;
+const rScriptForBegin = /^\s*for\s+(?<value>[A-Za-z_]\w*)(?:\s*,\s*(?<index>[A-Za-z_]\w*))?\s+in\s+(?<values>.+)\s*:\s*$/;
+const rScriptForEnd = /^\s*endfor\s*$/;
+const rScriptWhileBegin = /^\s*while\s+(?<expr>.+)\s*:\s*$/;
+const rScriptWhileEnd = /^\s*endwhile\s*$/;
+const rScriptBreak = /^\s*break\s*$/;
+const rScriptContinue = /^\s*continue\s*$/;
 
 
 /**
  * Parse a BareScript expression
  *
- * @param {string} exprText - The [expression text]{@link https://craigahobbs.github.io/bare-script/language/#expressions}
- * @returns {Object} The [expression model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='Expression'}
+ * @param {string} exprText - The [expression text](./language/#expressions)
+ * @returns {Object} The [expression model](./model/#var.vName='Expression')
  * @throws [BareScriptParserError]{@link module:lib/parser.BareScriptParserError}
  */
 export function parseExpression(exprText) {
@@ -571,6 +537,25 @@ 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([])
+};
+
+
 // Helper function to parse a unary expression
 function parseUnaryExpression(exprText) {
     // Group open?
@@ -604,8 +589,7 @@ function parseUnaryExpression(exprText) {
     if (matchFunctionOpen !== null) {
         let argText = exprText.slice(matchFunctionOpen[0].length);
         const args = [];
-        // eslint-disable-next-line no-constant-condition
-        while (true) {
+        while (true) { // eslint-disable-line no-constant-condition
             // Function close?
             const matchFunctionClose = argText.match(rExprFunctionClose);
             if (matchFunctionClose !== null) {
@@ -680,6 +664,24 @@ function parseUnaryExpression(exprText) {
 }
 
 
+// BareScript expression regex
+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 rExprString = /^\s*'((?:\\\\|\\'|[^'])*)'/;
+const rExprStringEscape = /\\([\\'])/g;
+const rExprStringDouble = /^\s*"((?:\\\\|\\"|[^"])*)"/;
+const rExprStringDoubleEscape = /\\([\\"])/g;
+const rExprVariable = /^\s*([A-Za-z_]\w*)/;
+const rExprVariableEx = /^\s*\[\s*((?:\\\]|[^\]])+)\s*\]/;
+const rExprVariableExEscape = /\\([\\\]])/g;
+
+
 /**
  * A BareScript parser error
  *

package/lib/runtime.js

@@ -4,52 +4,14 @@
 /** @module lib/runtime */
 
 import {defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
-
-
-/**
- * The BareScript runtime options
- *
- * @typedef {Object} ExecuteScriptOptions
- * @property {boolean} [debug] - If true, execute in debug mode
- * @property {function} [fetchFn] - The [fetch function]{@link module:lib/runtime~FetchFn}
- * @property {Object} [globals] - The global variables
- * @property {function} [logFn] - The [log function]{@link module:lib/runtime~LogFn}
- * @property {number} [maxStatements] - The maximum number of statements; default is 1e9; 0 for no maximum
- * @property {number} [statementCount] - The current statement count
- * @property {function} [urlFn] - The [URL modifier function]{@link module:lib/runtime~URLFn}
- * @property {string} [systemPrefix] - The system include prefix
- */
-
-/**
- * The fetch function
- *
- * @callback FetchFn
- * @param {string} url - The URL to fetch
- * @param {?Object} [options] - The [fetch options]{@link https://developer.mozilla.org/en-US/docs/Web/API/fetch#parameters}
- * @returns {Promise} The fetch promise
- */
-
-/**
- * The log function
- *
- * @callback LogFn
- * @param {string} text - The log text
- */
-
-/**
- * The URL modifier function
- *
- * @callback URLFn
- * @param {string} url - The URL
- * @returns {string} The modified URL
- */
+import {valueBoolean, valueCompare, valueString} from './value.js';
 
 
 /**
  * Execute a BareScript model
  *
- * @param {Object} script - The [BareScript model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='BareScript'}
- * @param {Object} [options = {}] - The [script execution options]{@link module:lib/runtime~ExecuteScriptOptions}
+ * @param {Object} script - The [BareScript model](model/#var.vName='BareScript')
+ * @param {Object} [options = {}] - The [script execution options]{@link module:lib/options~ExecuteScriptOptions}
  * @returns The script result
  * @throws [BareScriptRuntimeError]{@link module:lib/runtime.BareScriptRuntimeError}
  */
@@ -74,7 +36,7 @@ export function executeScript(script, options = {}) {
 }
 
 
-export function executeScriptHelper(statements, options, locals) {
+function executeScriptHelper(statements, options, locals) {
     const {globals} = options;
 
     // Iterate each script statement
@@ -85,8 +47,9 @@ export function executeScriptHelper(statements, options, locals) {
         const [statementKey] = Object.keys(statement);
 
         // Increment the statement counter
+        options.statementCount += 1;
         const maxStatements = options.maxStatements ?? defaultMaxStatements;
-        if (maxStatements > 0 && ++options.statementCount > maxStatements) {
+        if (maxStatements > 0 && options.statementCount > maxStatements) {
             throw new BareScriptRuntimeError(`Exceeded maximum script statements (${maxStatements})`);
         }
 
@@ -130,23 +93,7 @@ export function executeScriptHelper(statements, options, locals) {
 
         // Function?
         } else if (statementKey === 'function') {
-            globals[statement.function.name] = (args, fnOptions) => {
-                const funcLocals = {};
-                if ('args' in statement.function) {
-                    const argsLength = args.length;
-                    const funcArgsLength = statement.function.args.length;
-                    const ixArgLast = (statement.function.lastArgArray ?? null) && (funcArgsLength - 1);
-                    for (let ixArg = 0; ixArg < funcArgsLength; ixArg++) {
-                        const argName = statement.function.args[ixArg];
-                        if (ixArg < argsLength) {
-                            funcLocals[argName] = (ixArg === ixArgLast ? args.slice(ixArg) : args[ixArg]);
-                        } else {
-                            funcLocals[argName] = (ixArg === ixArgLast ? [] : null);
-                        }
-                    }
-                }
-                return executeScriptHelper(statement.function.statements, fnOptions, funcLocals);
-            };
+            globals[statement.function.name] = (args, fnOptions) => scriptFunction(statement.function, args, fnOptions);
 
         // Include?
         } else if (statementKey === 'include') {
@@ -158,14 +105,33 @@ export function executeScriptHelper(statements, options, locals) {
 }
 
 
+// Runtime script function implementation
+export function scriptFunction(function_, args, options) {
+    const funcLocals = {};
+    if ('args' in function_) {
+        const argsLength = args.length;
+        const funcArgsLength = function_.args.length;
+        const ixArgLast = (function_.lastArgArray ?? null) && (funcArgsLength - 1);
+        for (let ixArg = 0; ixArg < funcArgsLength; ixArg++) {
+            const argName = function_.args[ixArg];
+            if (ixArg < argsLength) {
+                funcLocals[argName] = (ixArg === ixArgLast ? args.slice(ixArg) : args[ixArg]);
+            } else {
+                funcLocals[argName] = (ixArg === ixArgLast ? [] : null);
+            }
+        }
+    }
+    return executeScriptHelper(function_.statements, options, funcLocals);
+}
+
+
 /**
  * Evaluate an expression model
  *
- * @param {Object} expr - The [expression model]{@link https://craigahobbs.github.io/bare-script/model/#var.vName='Expression'}
- * @param {?Object} [options = null] - The [script execution options]{@link module:lib/runtime~ExecuteScriptOptions}
+ * @param {Object} expr - The [expression model](./model/#var.vName='Expression')
+ * @param {?Object} [options = null] - The [script execution options]{@link module:lib/options~ExecuteScriptOptions}
  * @param {?Object} [locals = null] - The local variables
- * @param {boolean} [builtins = true] - If true, include the
- *     [built-in expression functions]{@link https://craigahobbs.github.io/bare-script/library/expression.html}
+ * @param {boolean} [builtins = true] - If true, include the [built-in expression functions](./library/expression.html)
  * @returns The expression result
  * @throws [BareScriptRuntimeError]{@link module:lib/runtime.BareScriptRuntimeError}
  */
@@ -257,40 +223,90 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
         const binOp = expr.binary.op;
         const leftValue = evaluateExpression(expr.binary.left, options, locals, builtins);
 
-        // Short-circuiting binary operators - evaluate right expression only if necessary
+        // Short-circuiting "and" binary operator
         if (binOp === '&&') {
-            return leftValue && evaluateExpression(expr.binary.right, options, locals, builtins);
+            if (!valueBoolean(leftValue)) {
+                return leftValue;
+            }
+            return evaluateExpression(expr.binary.right, options, locals, builtins);
+
+        // Short-circuiting "or" binary operator
         } else if (binOp === '||') {
-            return leftValue || evaluateExpression(expr.binary.right, options, locals, builtins);
+            if (valueBoolean(leftValue)) {
+                return leftValue;
+            }
+            return evaluateExpression(expr.binary.right, options, locals, builtins);
         }
 
         // Non-short-circuiting binary operators
         const rightValue = evaluateExpression(expr.binary.right, options, locals, builtins);
-        if (binOp === '**') {
-            return leftValue ** rightValue;
+        if (binOp === '+') {
+            // number + number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue + rightValue;
+
+            // string + string
+            } else if (typeof leftValue === 'string' && typeof rightValue === 'string') {
+                return leftValue + rightValue;
+
+            // string + <any>
+            } else if (typeof leftValue === 'string') {
+                return leftValue + valueString(rightValue);
+            } else if (typeof rightValue === 'string') {
+                return valueString(leftValue) + rightValue;
+
+            // datetime + number
+            } else if (leftValue instanceof Date && typeof rightValue === 'number') {
+                return new Date(leftValue.getTime() + rightValue);
+            } else if (typeof leftValue === 'number' && rightValue instanceof Date) {
+                return new Date(leftValue + rightValue.getTime());
+            }
+        } else if (binOp === '-') {
+            // number - number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue - rightValue;
+
+            // datetime - datetime
+            } else if (leftValue instanceof Date && rightValue instanceof Date) {
+                return leftValue - rightValue;
+            }
         } else if (binOp === '*') {
-            return leftValue * rightValue;
+            // number * number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue * rightValue;
+            }
         } else if (binOp === '/') {
-            return leftValue / rightValue;
-        } else if (binOp === '%') {
-            return leftValue % rightValue;
-        } else if (binOp === '+') {
-            return leftValue + rightValue;
-        } else if (binOp === '-') {
-            return leftValue - rightValue;
+            // number / number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue / rightValue;
+            }
+        } else if (binOp === '==') {
+            return valueCompare(leftValue, rightValue) === 0;
+        } else if (binOp === '!=') {
+            return valueCompare(leftValue, rightValue) !== 0;
         } else if (binOp === '<=') {
-            return leftValue <= rightValue;
+            return valueCompare(leftValue, rightValue) <= 0;
         } else if (binOp === '<') {
-            return leftValue < rightValue;
+            return valueCompare(leftValue, rightValue) < 0;
         } else if (binOp === '>=') {
-            return leftValue >= rightValue;
+            return valueCompare(leftValue, rightValue) >= 0;
         } else if (binOp === '>') {
-            return leftValue > rightValue;
-        } else if (binOp === '==') {
-            return leftValue === rightValue;
+            return valueCompare(leftValue, rightValue) > 0;
+        } else if (binOp === '%') {
+            // number % number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue % rightValue;
+            }
+        } else {
+            // binOp === '**'
+            // number ** number
+            if (typeof leftValue === 'number' && typeof rightValue === 'number') {
+                return leftValue ** rightValue;
+            }
         }
-        // else if (binOp === '!=')
-        return leftValue !== rightValue;
+
+        // Invalid operation values
+        return null;
     }
 
     // Unary expression
@@ -298,10 +314,13 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
         const unaryOp = expr.unary.op;
         const value = evaluateExpression(expr.unary.expr, options, locals, builtins);
         if (unaryOp === '!') {
-            return !value;
+            return !valueBoolean(value);
+        } else if (unaryOp === '-' && typeof value === 'number') {
+            return -value;
         }
-        // else if (unaryOp === '-')
-        return -value;
+
+        // Invalid operation value
+        return null;
     }
 
     // Expression group