bare-script 3.5.5 → 3.6.0

package/lib/runtime.js

@@ -4,7 +4,7 @@
 /** @module lib/runtime */
 
 import {ValueArgsError, valueBoolean, valueCompare, valueString} from './value.js';
-import {defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
+import {coverageGlobalName, defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
 
 
 /**
@@ -32,11 +32,11 @@ export function executeScript(script, options = {}) {
 
     // Execute the script
     options.statementCount = 0;
-    return executeScriptHelper(script.statements, options, null);
+    return executeScriptHelper(script, script.statements, options, null);
 }
 
 
-function executeScriptHelper(statements, options, locals) {
+function executeScriptHelper(script, statements, options, locals) {
     const {globals} = options;
 
     // Iterate each script statement
@@ -50,12 +50,19 @@ function executeScriptHelper(statements, options, locals) {
         options.statementCount = (options.statementCount ?? 0) + 1;
         const maxStatements = options.maxStatements ?? defaultMaxStatements;
         if (maxStatements > 0 && options.statementCount > maxStatements) {
-            throw new BareScriptRuntimeError(`Exceeded maximum script statements (${maxStatements})`);
+            throw new BareScriptRuntimeError(script, statement, `Exceeded maximum script statements (${maxStatements})`);
+        }
+
+        // Record the statement coverage
+        const coverageGlobal = globals[coverageGlobalName] ?? null;
+        const hasCoverage = coverageGlobal !== null && typeof coverageGlobal === 'object' && coverageGlobal.enabled && !script.system;
+        if (hasCoverage) {
+            recordStatementCoverage(script, statement, statementKey, coverageGlobal);
         }
 
         // Expression?
         if (statementKey === 'expr') {
-            const exprValue = evaluateExpression(statement.expr.expr, options, locals, false);
+            const exprValue = evaluateExpression(statement.expr.expr, options, locals, false, script, statement);
             if ('name' in statement.expr) {
                 if (locals !== null) {
                     locals[statement.expr.name] = exprValue;
@@ -67,14 +74,14 @@ function executeScriptHelper(statements, options, locals) {
         // Jump?
         } else if (statementKey === 'jump') {
             // Evaluate the expression (if any)
-            if (!('expr' in statement.jump) || evaluateExpression(statement.jump.expr, options, locals, false)) {
+            if (!('expr' in statement.jump) || evaluateExpression(statement.jump.expr, options, locals, false, script, statement)) {
                 // Find the label
                 if (labelIndexes !== null && statement.jump.label in labelIndexes) {
                     ixStatement = labelIndexes[statement.jump.label];
                 } else {
-                    const ixLabel = statements.findIndex((stmt) => stmt.label === statement.jump.label);
+                    const ixLabel = statements.findIndex((stmt) => 'label' in stmt && stmt.label.name === statement.jump.label);
                     if (ixLabel === -1) {
-                        throw new BareScriptRuntimeError(`Unknown jump label "${statement.jump.label}"`);
+                        throw new BareScriptRuntimeError(script, statement, `Unknown jump label "${statement.jump.label}"`);
                     }
                     if (labelIndexes === null) {
                         labelIndexes = {};
@@ -82,22 +89,29 @@ function executeScriptHelper(statements, options, locals) {
                     labelIndexes[statement.jump.label] = ixLabel;
                     ixStatement = ixLabel;
                 }
+
+                // Record the label statement coverage
+                if (hasCoverage) {
+                    const labelStatement = statements[ixStatement];
+                    const [labelStatementKey] = Object.keys(labelStatement);
+                    recordStatementCoverage(script, labelStatement, labelStatementKey, coverageGlobal);
+                }
             }
 
         // Return?
         } else if (statementKey === 'return') {
             if ('expr' in statement.return) {
-                return evaluateExpression(statement.return.expr, options, locals, false);
+                return evaluateExpression(statement.return.expr, options, locals, false, script, statement);
             }
             return null;
 
         // Function?
         } else if (statementKey === 'function') {
-            globals[statement.function.name] = (args, fnOptions) => scriptFunction(statement.function, args, fnOptions);
+            globals[statement.function.name] = (args, fnOptions) => scriptFunction(script, statement.function, args, fnOptions);
 
         // Include?
         } else if (statementKey === 'include') {
-            throw new BareScriptRuntimeError(`Include of "${statement.include.includes[0].url}" within non-async scope`);
+            throw new BareScriptRuntimeError(script, statement, `Include of "${statement.include.includes[0].url}" within non-async scope`);
         }
     }
 
@@ -105,8 +119,41 @@ function executeScriptHelper(statements, options, locals) {
 }
 
 
+// Helper function to record statement coverage
+export function recordStatementCoverage(script, statement, statementKey, coverageGlobal) {
+    // Get the script name and statement line number
+    const scriptName = script.scriptName ?? null;
+    const lineno = statement[statementKey].lineNumber ?? null;
+    if (scriptName === null || lineno === null) {
+        return;
+    }
+
+    // Record the statement/lineno coverage
+    let scripts = coverageGlobal.scripts ?? null;
+    if (scripts === null) {
+        scripts = {};
+        coverageGlobal.scripts = scripts;
+    }
+    let scriptCoverage = scripts[scriptName] ?? null;
+    if (scriptCoverage === null) {
+        scriptCoverage = {'script': script, 'covered': {}};
+        scripts[scriptName] = scriptCoverage;
+    }
+
+    // Increment the statement coverage count
+    const linenoStr = String(lineno);
+    const coveredStatements = scriptCoverage.covered;
+    let coveredStatement = coveredStatements[linenoStr] ?? null;
+    if (coveredStatement === null) {
+        coveredStatement = {'statement': statement, 'count': 0};
+        coveredStatements[linenoStr] = coveredStatement;
+    }
+    coveredStatement.count += 1;
+}
+
+
 // Runtime script function implementation
-export function scriptFunction(function_, args, options) {
+export function scriptFunction(script, function_, args, options) {
     const funcLocals = {};
     if ('args' in function_) {
         const argsLength = args.length;
@@ -121,7 +168,7 @@ export function scriptFunction(function_, args, options) {
             }
         }
     }
-    return executeScriptHelper(function_.statements, options, funcLocals);
+    return executeScriptHelper(script, function_.statements, options, funcLocals);
 }
 
 
@@ -135,7 +182,7 @@ export function scriptFunction(function_, args, options) {
  * @returns The expression result
  * @throws [BareScriptRuntimeError]{@link module:lib/runtime.BareScriptRuntimeError}
  */
-export function evaluateExpression(expr, options = null, locals = null, builtins = true) {
+export function evaluateExpression(expr, options = null, locals = null, builtins = true, script = null, statement = null) {
     const [exprKey] = Object.keys(expr);
     const globals = (options !== null ? (options.globals ?? null) : null);
 
@@ -174,14 +221,14 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
         const funcName = expr.function.name;
         if (funcName === 'if') {
             const [valueExpr = null, trueExpr = null, falseExpr = null] = expr.function.args ?? [];
-            const value = (valueExpr !== null ? evaluateExpression(valueExpr, options, locals, builtins) : false);
+            const value = (valueExpr !== null ? evaluateExpression(valueExpr, options, locals, builtins, script, statement) : false);
             const resultExpr = (value ? trueExpr : falseExpr);
-            return resultExpr !== null ? evaluateExpression(resultExpr, options, locals, builtins) : null;
+            return resultExpr !== null ? evaluateExpression(resultExpr, options, locals, builtins, script, statement) : null;
         }
 
         // Compute the function arguments
         const funcArgs = 'args' in expr.function
-            ? expr.function.args.map((arg) => evaluateExpression(arg, options, locals, builtins))
+            ? expr.function.args.map((arg) => evaluateExpression(arg, options, locals, builtins, script, statement))
             : null;
 
         // Global/local function?
@@ -195,7 +242,7 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
         if (funcValue !== null) {
             // Async function called within non-async execution?
             if (typeof funcValue === 'function' && funcValue.constructor.name === 'AsyncFunction') {
-                throw new BareScriptRuntimeError(`Async function "${funcName}" called within non-async scope`);
+                throw new BareScriptRuntimeError(script, statement, `Async function "${funcName}" called within non-async scope`);
             }
 
             // Call the function
@@ -209,7 +256,10 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
 
                 // Log and return null
                 if (options !== null && 'logFn' in options && options.debug) {
-                    options.logFn(`BareScript: Function "${funcName}" failed with error: ${error.message}`);
+                    const errorMessage = new BareScriptRuntimeError(
+                        script, statement, `BareScript: Function "${funcName}" failed with error: ${error.message}`
+                    );
+                    options.logFn(errorMessage.message);
                 }
                 if (error instanceof ValueArgsError) {
                     return error.returnValue;
@@ -218,31 +268,31 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
             }
         }
 
-        throw new BareScriptRuntimeError(`Undefined function "${funcName}"`);
+        throw new BareScriptRuntimeError(script, statement, `Undefined function "${funcName}"`);
     }
 
     // Binary expression
     if (exprKey === 'binary') {
         const binOp = expr.binary.op;
-        const leftValue = evaluateExpression(expr.binary.left, options, locals, builtins);
+        const leftValue = evaluateExpression(expr.binary.left, options, locals, builtins, script, statement);
 
         // Short-circuiting "and" binary operator
         if (binOp === '&&') {
             if (!valueBoolean(leftValue)) {
                 return leftValue;
             }
-            return evaluateExpression(expr.binary.right, options, locals, builtins);
+            return evaluateExpression(expr.binary.right, options, locals, builtins, script, statement);
 
         // Short-circuiting "or" binary operator
         } else if (binOp === '||') {
             if (valueBoolean(leftValue)) {
                 return leftValue;
             }
-            return evaluateExpression(expr.binary.right, options, locals, builtins);
+            return evaluateExpression(expr.binary.right, options, locals, builtins, script, statement);
         }
 
         // Non-short-circuiting binary operators
-        const rightValue = evaluateExpression(expr.binary.right, options, locals, builtins);
+        const rightValue = evaluateExpression(expr.binary.right, options, locals, builtins, script, statement);
         if (binOp === '+') {
             // number + number
             if (typeof leftValue === 'number' && typeof rightValue === 'number') {
@@ -340,7 +390,7 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
     // Unary expression
     if (exprKey === 'unary') {
         const unaryOp = expr.unary.op;
-        const value = evaluateExpression(expr.unary.expr, options, locals, builtins);
+        const value = evaluateExpression(expr.unary.expr, options, locals, builtins, script, statement);
         if (unaryOp === '!') {
             return !valueBoolean(value);
         } else if (unaryOp === '-') {
@@ -360,7 +410,7 @@ export function evaluateExpression(expr, options = null, locals = null, builtins
 
     // Expression group
     // else if (exprKey === 'group')
-    return evaluateExpression(expr.group, options, locals, builtins);
+    return evaluateExpression(expr.group, options, locals, builtins, script, statement);
 }
 
 
@@ -375,8 +425,17 @@ export class BareScriptRuntimeError extends Error {
      *
      * @param {string} message - The runtime error message
      */
-    constructor(message) {
-        super(message);
+    constructor(script, statement, message) {
+        let messageScript;
+        if (script !== null && statement !== null) {
+            const [statementKey] = Object.keys(statement);
+            const scriptName = script.scriptName ?? '';
+            const lineno = statement[statementKey].lineNumber ?? '';
+            messageScript = (scriptName && lineno ? `${scriptName}:${lineno}: ${message}` : message);
+        } else {
+            messageScript = message;
+        }
+        super(messageScript);
         this.name = this.constructor.name;
     }
 }

package/lib/runtimeAsync.js

@@ -3,11 +3,11 @@
 
 /** @module lib/runtimeAsync */
 
-import {BareScriptParserError, parseScript} from './parser.js';
-import {BareScriptRuntimeError, evaluateExpression, scriptFunction} from './runtime.js';
+import {BareScriptRuntimeError, evaluateExpression, recordStatementCoverage, scriptFunction} from './runtime.js';
 import {ValueArgsError, valueBoolean, valueCompare, valueString} from './value.js';
-import {defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
+import {coverageGlobalName, defaultMaxStatements, expressionFunctions, scriptFunctions} from './library.js';
 import {lintScript} from './model.js';
+import {parseScript} from './parser.js';
 import {urlFileRelative} from './options.js';
 
 
@@ -37,11 +37,11 @@ export function executeScriptAsync(script, options = {}) {
 
     // Execute the script
     options.statementCount = 0;
-    return executeScriptHelperAsync(script.statements, options, null);
+    return executeScriptHelperAsync(script, script.statements, options, null);
 }
 
 
-async function executeScriptHelperAsync(statements, options, locals) {
+async function executeScriptHelperAsync(script, statements, options, locals) {
     const {globals} = options;
 
     // Iterate each script statement
@@ -55,12 +55,19 @@ async function executeScriptHelperAsync(statements, options, locals) {
         options.statementCount = (options.statementCount ?? 0) + 1;
         const maxStatements = options.maxStatements ?? defaultMaxStatements;
         if (maxStatements > 0 && options.statementCount > maxStatements) {
-            throw new BareScriptRuntimeError(`Exceeded maximum script statements (${maxStatements})`);
+            throw new BareScriptRuntimeError(script, statement, `Exceeded maximum script statements (${maxStatements})`);
+        }
+
+        // Record the statement coverage
+        const coverageGlobal = globals[coverageGlobalName] ?? null;
+        const hasCoverage = coverageGlobal !== null && typeof coverageGlobal === 'object' && coverageGlobal.enabled && !script.system;
+        if (hasCoverage) {
+            recordStatementCoverage(script, statement, statementKey, coverageGlobal);
         }
 
         // Expression?
         if (statementKey === 'expr') {
-            const exprValue = await evaluateExpressionAsync(statement.expr.expr, options, locals, false);
+            const exprValue = await evaluateExpressionAsync(statement.expr.expr, options, locals, false, script, statement);
             if ('name' in statement.expr) {
                 if (locals !== null) {
                     locals[statement.expr.name] = exprValue;
@@ -72,14 +79,15 @@ async function executeScriptHelperAsync(statements, options, locals) {
         // Jump?
         } else if (statementKey === 'jump') {
             // Evaluate the expression (if any)
-            if (!('expr' in statement.jump) || await evaluateExpressionAsync(statement.jump.expr, options, locals, false)) {
+            if (!('expr' in statement.jump) ||
+                await evaluateExpressionAsync(statement.jump.expr, options, locals, false, script, statement)) {
                 // Find the label
                 if (labelIndexes !== null && statement.jump.label in labelIndexes) {
                     ixStatement = labelIndexes[statement.jump.label];
                 } else {
-                    const ixLabel = statements.findIndex((stmt) => stmt.label === statement.jump.label);
+                    const ixLabel = statements.findIndex((stmt) => 'label' in stmt && stmt.label.name === statement.jump.label);
                     if (ixLabel === -1) {
-                        throw new BareScriptRuntimeError(`Unknown jump label "${statement.jump.label}"`);
+                        throw new BareScriptRuntimeError(script, statement, `Unknown jump label "${statement.jump.label}"`);
                     }
                     if (labelIndexes === null) {
                         labelIndexes = {};
@@ -87,22 +95,30 @@ async function executeScriptHelperAsync(statements, options, locals) {
                     labelIndexes[statement.jump.label] = ixLabel;
                     ixStatement = ixLabel;
                 }
+
+                // Record the label statement coverage
+                if (hasCoverage) {
+                    const labelStatement = statements[ixStatement];
+                    const [labelStatementKey] = Object.keys(labelStatement);
+                    recordStatementCoverage(script, labelStatement, labelStatementKey, coverageGlobal);
+                }
             }
 
         // Return?
         } else if (statementKey === 'return') {
             if ('expr' in statement.return) {
-                return evaluateExpressionAsync(statement.return.expr, options, locals, false);
+                return evaluateExpressionAsync(statement.return.expr, options, locals, false, script, statement);
             }
             return null;
 
         // Function?
         } else if (statementKey === 'function') {
             if (statement.function.async) {
-                // eslint-disable-next-line require-await
-                globals[statement.function.name] = async (args, fnOptions) => scriptFunctionAsync(statement.function, args, fnOptions);
+                globals[statement.function.name] =
+                    // eslint-disable-next-line require-await
+                    async (args, fnOptions) => scriptFunctionAsync(script, statement.function, args, fnOptions);
             } else {
-                globals[statement.function.name] = (args, fnOptions) => scriptFunction(statement.function, args, fnOptions);
+                globals[statement.function.name] = (args, fnOptions) => scriptFunction(script, statement.function, args, fnOptions);
             }
 
         // Include?
@@ -110,48 +126,49 @@ async function executeScriptHelperAsync(statements, options, locals) {
             // Fetch the include script text
             const urlFn = options.urlFn ?? null;
             const includeURLs = statement.include.includes.map(({url, system = false}) => {
+                let includeURL;
                 if (system && 'systemPrefix' in options) {
-                    return urlFileRelative(options.systemPrefix, url);
+                    includeURL = urlFileRelative(options.systemPrefix, url);
+                } else {
+                    includeURL = (urlFn !== null ? urlFn(url) : url);
                 }
-                return urlFn !== null ? urlFn(url) : url;
+                return {includeURL, 'systemInclude': system};
             });
-            const responses = await Promise.all(includeURLs.map(async (url) => {
+            const responses = await Promise.all(includeURLs.map(async ({includeURL, systemInclude}) => {
                 try {
-                    return 'fetchFn' in options ? await options.fetchFn(url) : null;
+                    const response = ('fetchFn' in options ? await options.fetchFn(includeURL) : null);
+                    return {response, systemInclude};
                 } catch {
-                    return null;
+                    return {'response': null, systemInclude};
                 }
             }));
-            const scriptTexts = await Promise.all(responses.map(async (response) => {
+            const includeTexts = await Promise.all(responses.map(async ({response, systemInclude}) => {
                 try {
-                    return response !== null && response.ok ? await response.text() : null;
+                    const includeText = (response !== null && response.ok ? await response.text() : null);
+                    return {includeText, systemInclude};
                 } catch {
-                    return null;
+                    return {'includeText': null, systemInclude};
                 }
             }));
 
             // Parse and execute each script
-            for (const [ixScriptText, scriptText] of scriptTexts.entries()) {
-                const includeURL = includeURLs[ixScriptText];
+            for (const [ixScriptText, {includeText, systemInclude}] of includeTexts.entries()) {
+                const {includeURL} = includeURLs[ixScriptText];
 
                 // Error?
-                if (scriptText === null) {
-                    throw new BareScriptRuntimeError(`Include of "${includeURL}" failed`);
+                if (includeText === null) {
+                    throw new BareScriptRuntimeError(script, statement, `Include of "${includeURL}" failed`);
                 }
 
                 // Parse the include script
-                let scriptModel;
-                try {
-                    scriptModel = parseScript(scriptText);
-                } catch (error) {
-                    throw new BareScriptParserError(
-                        error.error, error.line, error.columnNumber, error.lineNumber, `Included from "${includeURL}"`
-                    );
+                const includeScript = parseScript(includeText, 1, includeURL);
+                if (systemInclude) {
+                    includeScript.system = true;
                 }
 
                 // Run the bare-script linter?
                 if ('logFn' in options && options.debug) {
-                    const warnings = lintScript(scriptModel);
+                    const warnings = lintScript(includeScript);
                     const warningPrefix = `BareScript: Include "${includeURL}" static analysis...`;
                     if (warnings.length) {
                         options.logFn(`${warningPrefix} ${warnings.length} warning${warnings.length > 1 ? 's' : ''}:`);
@@ -164,7 +181,7 @@ async function executeScriptHelperAsync(statements, options, locals) {
                 // Execute the include script
                 const includeOptions = {...options};
                 includeOptions.urlFn = (url) => urlFileRelative(includeURL, url);
-                await executeScriptHelperAsync(scriptModel.statements, includeOptions, null);
+                await executeScriptHelperAsync(includeScript, includeScript.statements, includeOptions, null);
             }
         }
     }
@@ -174,7 +191,7 @@ async function executeScriptHelperAsync(statements, options, locals) {
 
 
 // Runtime script async function implementation
-function scriptFunctionAsync(function_, args, options) {
+function scriptFunctionAsync(script, function_, args, options) {
     const funcLocals = {};
     if ('args' in function_) {
         const argsLength = args.length;
@@ -189,7 +206,7 @@ function scriptFunctionAsync(function_, args, options) {
             }
         }
     }
-    return executeScriptHelperAsync(function_.statements, options, funcLocals);
+    return executeScriptHelperAsync(script, function_.statements, options, funcLocals);
 }
 
 
@@ -205,14 +222,14 @@ function scriptFunctionAsync(function_, args, options) {
  * @returns The expression result
  * @throws [BareScriptRuntimeError]{@link module:lib/runtime.BareScriptRuntimeError}
  */
-export async function evaluateExpressionAsync(expr, options = null, locals = null, builtins = true) {
+export async function evaluateExpressionAsync(expr, options = null, locals = null, builtins = true, script = null, statement = null) {
     const [exprKey] = Object.keys(expr);
     const globals = (options !== null ? (options.globals ?? null) : null);
 
     // If this expression does not require async then evaluate non-async
     const hasSubExpr = (exprKey !== 'number' && exprKey !== 'string' && exprKey !== 'variable');
     if (hasSubExpr && !isAsyncExpr(expr, globals, locals)) {
-        return evaluateExpression(expr, options, locals, builtins);
+        return evaluateExpression(expr, options, locals, builtins, script, statement);
     }
 
     // Number
@@ -250,15 +267,17 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
         const funcName = expr.function.name;
         if (funcName === 'if') {
             const [valueExpr, trueExpr = null, falseExpr = null] = expr.function.args;
-            const value = await evaluateExpressionAsync(valueExpr, options, locals, builtins);
+            const value = await evaluateExpressionAsync(valueExpr, options, locals, builtins, script, statement);
             const resultExpr = (value ? trueExpr : falseExpr);
-            return resultExpr !== null ? evaluateExpressionAsync(resultExpr, options, locals, builtins) : null;
+            return resultExpr !== null ? evaluateExpressionAsync(resultExpr, options, locals, builtins, script, statement) : null;
         }
 
         // Compute the function arguments
         const funcArgs = 'args' in expr.function
-            ? await Promise.all(expr.function.args.map((arg) => evaluateExpressionAsync(arg, options, locals, builtins)))
-            : null;
+              ? await Promise.all(expr.function.args.map(
+                  (arg) => evaluateExpressionAsync(arg, options, locals, builtins, script, statement)
+              ))
+              : null;
 
         // Global/local function?
         let funcValue = (locals !== null ? locals[funcName] : undefined);
@@ -289,20 +308,20 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
             }
         }
 
-        throw new BareScriptRuntimeError(`Undefined function "${funcName}"`);
+        throw new BareScriptRuntimeError(script, statement, `Undefined function "${funcName}"`);
     }
 
     // Binary expression
     if (exprKey === 'binary') {
         const binOp = expr.binary.op;
-        const leftValue = await evaluateExpressionAsync(expr.binary.left, options, locals, builtins);
+        const leftValue = await evaluateExpressionAsync(expr.binary.left, options, locals, builtins, script, statement);
 
         // Short-circuiting "and" binary operator
         if (binOp === '&&') {
             if (!valueBoolean(leftValue)) {
                 return leftValue;
             }
-            return evaluateExpressionAsync(expr.binary.right, options, locals, builtins);
+            return evaluateExpressionAsync(expr.binary.right, options, locals, builtins, script, statement);
 
         // Short-circuiting "or" binary operator
         } else if (binOp === '||') {
@@ -313,7 +332,7 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
         }
 
         // Non-short-circuiting binary operators
-        const rightValue = await evaluateExpressionAsync(expr.binary.right, options, locals, builtins);
+        const rightValue = await evaluateExpressionAsync(expr.binary.right, options, locals, builtins, script, statement);
         if (binOp === '+') {
             // number + number
             if (typeof leftValue === 'number' && typeof rightValue === 'number') {
@@ -411,7 +430,7 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
     // Unary expression
     if (exprKey === 'unary') {
         const unaryOp = expr.unary.op;
-        const value = await evaluateExpressionAsync(expr.unary.expr, options, locals, builtins);
+        const value = await evaluateExpressionAsync(expr.unary.expr, options, locals, builtins, script, statement);
         if (unaryOp === '!') {
             return !valueBoolean(value);
         } else if (unaryOp === '-') {
@@ -431,7 +450,7 @@ export async function evaluateExpressionAsync(expr, options = null, locals = nul
 
     // Expression group
     // else if (exprKey === 'group')
-    return evaluateExpressionAsync(expr.group, options, locals, builtins);
+    return evaluateExpressionAsync(expr.group, options, locals, builtins, script, statement);
 }
 
 

package/package.json

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