bare-script 3.6.0 → 3.7.0

package/README.md

@@ -36,7 +36,7 @@ function or the
 [executeScriptAsync](https://craigahobbs.github.io/bare-script/module-lib_runtimeAsync.html#.executeScriptAsync)
 function. For example:
 
-~~~ javascript
+``` javascript
 import {executeScript} from 'bare-script/lib/runtime.js';
 import {parseScript} from 'bare-script/lib/parser.js';
 
@@ -53,13 +53,13 @@ return N + ' times 2 is ' + double(N)
 // Execute the script
 const globals = {'N': 10};
 console.log(executeScript(script, {globals}));
-~~~
+```
 
 This outputs:
 
-~~~
+```
 10 times 2 is 20
-~~~
+```
 
 
 ### The BareScript Library
@@ -73,7 +73,7 @@ of the
 [arrayLength](https://craigahobbs.github.io/bare-script/library/#var.vGroup='Array'&arraylength)
 functions.
 
-~~~ javascript
+``` javascript
 import {executeScriptAsync} from 'bare-script/lib/runtimeAsync.js';
 import {parseScript} from 'bare-script/lib/parser.js';
 
@@ -88,13 +88,13 @@ return 'The BareScript Library has ' + arrayLength(objectGet(docs, 'functions'))
 
 // Execute the script
 console.log(await executeScriptAsync(script, {'fetchFn': fetch}));
-~~~
+```
 
 This outputs:
 
-~~~
+```
 The BareScript Library has 105 functions
-~~~
+```
 
 
 ## Evaluating BareScript Expressions
@@ -115,7 +115,7 @@ a set of built-in, spreadsheet-like functions.
 
 For example:
 
-~~~ javascript
+``` javascript
 import {evaluateExpression} from 'bare-script/lib/runtime.js';
 import {parseExpression} from 'bare-script/lib/parser.js';
 
@@ -125,13 +125,13 @@ const expr = parseExpression('2 * max(a, b, c)');
 // Evaluate the expression
 const variables = {'a': 1, 'b': 2, 'c': 3};
 console.log(evaluateExpression(expr, null, variables))
-~~~
+```
 
 This outputs:
 
-~~~
+```
 6
-~~~
+```
 
 
 ## The BareScript Command-Line Interface (CLI)
@@ -139,9 +139,9 @@ This outputs:
 You can run BareScript from the command line using the BareScript CLI, "bare". BareScript script
 files use the ".bare" file extension.
 
-~~~
+```
 bare script.bare
-~~~
+```
 
 **Note:** In the BareScript CLI, import statements and the
 [systemFetch](https://craigahobbs.github.io/bare-script/library/#var.vGroup='System'&systemfetch)
@@ -163,15 +163,15 @@ with functions for dynamically rendering Markdown text, drawing SVG images, etc.
 
 For example:
 
-```
+~~~
 # Markdown Application
 
 This is a Markdown document with embedded BareScript:
 
-~~~ markdown-script
+``` markdown-script
 markdownPrint('Hello, Markdown!')
-~~~
 ```
+~~~
 
 
 ## Development
@@ -179,6 +179,6 @@ markdownPrint('Hello, Markdown!')
 This package is developed using [javascript-build](https://github.com/craigahobbs/javascript-build#readme).
 It was started using [javascript-template](https://github.com/craigahobbs/javascript-template#readme) as follows:
 
-~~~
+```
 template-specialize javascript-template/template/ bare-script/ -k package bare-script -k name 'Craig A. Hobbs' -k email 'craigahobbs@gmail.com' -k github 'craigahobbs' -k noapp 1
-~~~
+```

package/lib/library.js

@@ -78,6 +78,21 @@ const arrayExtendArgs = valueArgsModel([
 ]);
 
 
+// $function: arrayFlat
+// $group: Array
+// $doc: Flat an array hierarchy
+// $arg array: The array to flat
+// $return: The flated array
+function arrayFlat(args) {
+    const [array] = valueArgsValidate(arrayFlatArgs, args);
+    return array.flat(Infinity);
+}
+
+const arrayFlatArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'}
+]);
+
+
 // $function: arrayGet
 // $group: Array
 // $doc: Get an array element
@@ -365,7 +380,7 @@ export const coverageGlobalName = '__bareScriptCoverage';
 // $function: coverageGlobalGet
 // $group: Coverage
 // $doc: Get the coverage global object
-// $return: The [coverage global object](https://craigahobbs.github.io/bare-script/model/#var.vName='BareScript')
+// $return: The [coverage global object](https://craigahobbs.github.io/bare-script/model/#var.vName='CoverageGlobal')
 function coverageGlobalGet(unusedArgs, options) {
     const globals = (options !== null ? (options.globals ?? null) : null);
     return globals !== null ? (globals[coverageGlobalName] ?? null) : null;
@@ -2133,6 +2148,7 @@ export const scriptFunctions = {
     arrayCopy,
     arrayDelete,
     arrayExtend,
+    arrayFlat,
     arrayGet,
     arrayIndexOf,
     arrayJoin,
@@ -2247,6 +2263,7 @@ export const scriptFunctions = {
 export const expressionFunctionMap = {
     'abs': 'mathAbs',
     'acos': 'mathAcos',
+    'arrayNew': 'arrayNew',
     'asin': 'mathAsin',
     'atan': 'mathAtan',
     'atan2': 'mathAtan2',
@@ -2271,6 +2288,7 @@ export const expressionFunctionMap = {
     'minute': 'datetimeMinute',
     'month': 'datetimeMonth',
     'now': 'datetimeNow',
+    'objectNew': 'objectNew',
     'parseInt': 'numberParseInt',
     'parseFloat': 'numberParseFloat',
     'pi': 'mathPi',

package/lib/parser.js

@@ -82,7 +82,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
                 const exprStatement = {
                     'expr': {
                         'name': matchAssignment.groups.name,
-                        'expr': parseExpression(matchAssignment.groups.expr, lineNumber, scriptName),
+                        'expr': parseExpression(matchAssignment.groups.expr, lineNumber, scriptName, true),
                         ...statementBase
                     }
                 };
@@ -151,7 +151,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
             const ifthen = {
                 'jump': {
                     'label': `__bareScriptIf${labelIndex}`,
-                    'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfBegin.groups.expr, lineNumber, scriptName)}},
+                    'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfBegin.groups.expr, lineNumber, scriptName, true)}},
                     ...statementBase
                 },
                 'done': `__bareScriptDone${labelIndex}`,
@@ -186,7 +186,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
             const prevLabel = ifthen.jump.label;
             ifthen.jump = {
                 'label': `__bareScriptIf${labelIndex}`,
-                'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfElseIf.groups.expr, lineNumber, scriptName)}},
+                'expr': {'unary': {'op': '!', 'expr': parseExpression(matchIfElseIf.groups.expr, lineNumber, scriptName, true)}},
                 ...statementBase
             };
             labelIndex += 1;
@@ -252,7 +252,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
                 'loop': `__bareScriptLoop${labelIndex}`,
                 'continue': `__bareScriptLoop${labelIndex}`,
                 'done': `__bareScriptDone${labelIndex}`,
-                'expr': parseExpression(matchWhileBegin.groups.expr, lineNumber, scriptName),
+                'expr': parseExpression(matchWhileBegin.groups.expr, lineNumber, scriptName, true),
                 line,
                 'lineNumber': startLineNumber + ixLine
             };
@@ -307,7 +307,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
             statements.push(
                 {'expr': {
                     'name': foreach.values,
-                    'expr': parseExpression(matchForBegin.groups.values, lineNumber, scriptName),
+                    'expr': parseExpression(matchForBegin.groups.values, lineNumber, scriptName, true),
                     ...statementBase
                 }},
                 {'expr': {
@@ -407,7 +407,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
             const jumpStatement = {'jump': {'label': matchJump.groups.name, ...statementBase}};
             if (typeof matchJump.groups.expr !== 'undefined') {
                 try {
-                    jumpStatement.jump.expr = parseExpression(matchJump.groups.expr, lineNumber, scriptName);
+                    jumpStatement.jump.expr = parseExpression(matchJump.groups.expr, lineNumber, scriptName, true);
                 } catch (error) {
                     const columnNumber = matchJump.groups.jump.length - matchJump.groups.expr.length - 1 + error.columnNumber;
                     throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
@@ -423,7 +423,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
             const returnStatement = {'return': {...statementBase}};
             if (typeof matchReturn.groups.expr !== 'undefined') {
                 try {
-                    returnStatement.return.expr = parseExpression(matchReturn.groups.expr, lineNumber, scriptName);
+                    returnStatement.return.expr = parseExpression(matchReturn.groups.expr, lineNumber, scriptName, true);
                 } catch (error) {
                     const columnNumber = matchReturn.groups.return.length - matchReturn.groups.expr.length + error.columnNumber;
                     throw new BareScriptParserError(error.error, line, columnNumber, startLineNumber + ixLine, scriptName);
@@ -437,7 +437,9 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
         const matchInclude = line.match(rScriptInclude) || line.match(rScriptIncludeSystem);
         if (matchInclude !== null) {
             const {delim} = matchInclude.groups;
-            const url = (delim === '<' ? matchInclude.groups.url : matchInclude.groups.url.replace(rExprStringEscape, '$1'));
+            const url = (
+                delim === '<' ? matchInclude.groups.url : matchInclude.groups.url.replace(rExprStringEscapes, replaceStringEscape)
+            );
             let includeStatement = (statements.length ? statements[statements.length - 1] : null);
             if (includeStatement === null || !('include' in includeStatement)) {
                 includeStatement = {'include': {'includes': [], ...statementBase}};
@@ -451,7 +453,7 @@ export function parseScript(scriptText, startLineNumber = 1, scriptName = null)
 
         // Expression
         try {
-            const exprStatement = {'expr': {'expr': parseExpression(line, lineNumber, scriptName), ...statementBase}};
+            const exprStatement = {'expr': {'expr': parseExpression(line, lineNumber, scriptName, true), ...statementBase}};
             statements.push(exprStatement);
         } catch (error) {
             throw new BareScriptParserError(error.error, line, error.columnNumber, startLineNumber + ixLine, scriptName);
@@ -505,12 +507,15 @@ const rScriptContinue = new RegExp(`^\\s*continue${rPartComment}`);
  * Parse a BareScript expression
  *
  * @param {string} exprText - The [expression text](./language/#expressions)
+ * @param {number} [lineNumber = 1] - The script line number
+ * @param {?string} [scriptName = null] - The script name
+ * @param {boolean} [arrayLiterals = false] - If True, allow parsing of array literals
  * @returns {Object} The [expression model](./model/#var.vName='Expression')
  * @throws [BareScriptParserError]{@link module:lib/parser.BareScriptParserError}
  */
-export function parseExpression(exprText, lineNumber = null, scriptName = null) {
+export function parseExpression(exprText, lineNumber = null, scriptName = null, arrayLiterals = false) {
     try {
-        const [expr, nextText] = parseBinaryExpression(exprText, null);
+        const [expr, nextText] = parseBinaryExpression(exprText, null, arrayLiterals);
         if (nextText.trim() !== '') {
             throw new BareScriptParserError('Syntax error', nextText, 1, lineNumber, scriptName);
         }
@@ -523,7 +528,7 @@ export function parseExpression(exprText, lineNumber = null, scriptName = null)
 
 
 // Helper function to parse a binary operator expression chain
-function parseBinaryExpression(exprText, binLeftExpr) {
+function parseBinaryExpression(exprText, binLeftExpr, arrayLiterals) {
     // Parse the binary operator's left unary expression if none was passed
     let leftExpr;
     let binText;
@@ -531,7 +536,7 @@ function parseBinaryExpression(exprText, binLeftExpr) {
         binText = exprText;
         leftExpr = binLeftExpr;
     } else {
-        [leftExpr, binText] = parseUnaryExpression(exprText);
+        [leftExpr, binText] = parseUnaryExpression(exprText, arrayLiterals);
     }
 
     // Match a binary operator - if not found, return the left expression
@@ -548,7 +553,7 @@ function parseBinaryExpression(exprText, binLeftExpr) {
     const rightText = binText.slice(matchBinaryOp[0].length);
 
     // Parse the right sub-expression
-    const [rightExpr, nextText] = parseUnaryExpression(rightText);
+    const [rightExpr, nextText] = parseUnaryExpression(rightText, arrayLiterals);
 
     // Create the binary expression - re-order for binary operators as necessary
     let binExpr;
@@ -566,7 +571,7 @@ function parseBinaryExpression(exprText, binLeftExpr) {
     }
 
     // Parse the next binary expression in the chain
-    return parseBinaryExpression(nextText, binExpr);
+    return parseBinaryExpression(nextText, binExpr, arrayLiterals);
 }
 
 
@@ -595,12 +600,12 @@ const binaryReorder = {
 
 
 // Helper function to parse a unary expression
-function parseUnaryExpression(exprText) {
+function parseUnaryExpression(exprText, arrayLiterals) {
     // Group open?
     const matchGroupOpen = exprText.match(rExprGroupOpen);
     if (matchGroupOpen !== null) {
         const groupText = exprText.slice(matchGroupOpen[0].length);
-        const [expr, nextText] = parseBinaryExpression(groupText, null);
+        const [expr, nextText] = parseBinaryExpression(groupText, null, arrayLiterals);
         const matchGroupClose = nextText.match(rExprGroupClose);
         if (matchGroupClose === null) {
             throw new BareScriptParserError('Unmatched parenthesis', exprText, 1, null, null);
@@ -620,7 +625,7 @@ function parseUnaryExpression(exprText) {
     // String?
     const matchString = exprText.match(rExprString);
     if (matchString !== null) {
-        const string = matchString[1].replace(rExprStringEscape, '$1');
+        const string = matchString[1].replace(rExprStringEscapes, replaceStringEscape);
         const expr = {'string': string};
         return [expr, exprText.slice(matchString[0].length)];
     }
@@ -628,7 +633,7 @@ function parseUnaryExpression(exprText) {
     // String (double quotes)?
     const matchStringDouble = exprText.match(rExprStringDouble);
     if (matchStringDouble !== null) {
-        const string = matchStringDouble[1].replace(rExprStringDoubleEscape, '$1');
+        const string = matchStringDouble[1].replace(rExprStringEscapes, replaceStringEscape);
         const expr = {'string': string};
         return [expr, exprText.slice(matchStringDouble[0].length)];
     }
@@ -637,7 +642,7 @@ function parseUnaryExpression(exprText) {
     const matchUnary = exprText.match(rExprUnaryOp);
     if (matchUnary !== null) {
         const unaryText = exprText.slice(matchUnary[0].length);
-        const [expr, nextText] = parseUnaryExpression(unaryText);
+        const [expr, nextText] = parseUnaryExpression(unaryText, arrayLiterals);
         const unaryExpr = {
             'unary': {
                 'op': matchUnary[1],
@@ -670,9 +675,9 @@ function parseUnaryExpression(exprText) {
             }
 
             // Get the argument
-            const [argExpr, nextArgText] = parseBinaryExpression(argText, null);
-            args.push(argExpr);
+            const [argExpr, nextArgText] = parseBinaryExpression(argText, null, arrayLiterals);
             argText = nextArgText;
+            args.push(argExpr);
         }
 
         const fnExpr = {
@@ -684,6 +689,84 @@ function parseUnaryExpression(exprText) {
         return [fnExpr, argText];
     }
 
+    // Object creation?
+    const matchObjectOpen = exprText.match(rExprObjectOpen);
+    if (matchObjectOpen !== null) {
+        let argText = exprText.slice(matchObjectOpen[0].length);
+        const args = [];
+        while (true) {
+            // Object close?
+            const matchObjectClose = argText.match(rExprObjectClose);
+            if (matchObjectClose !== null) {
+                argText = argText.slice(matchObjectClose[0].length);
+                break;
+            }
+
+            // Object key/value separator
+            if (args.length !== 0) {
+                const matchObjectSeparator = argText.match(rExprObjectSeparator2);
+                if (matchObjectSeparator === null) {
+                    throw new BareScriptParserError('Syntax error', argText, 1, null, null);
+                }
+                argText = argText.slice(matchObjectSeparator[0].length);
+            }
+
+            // Get the key
+            const [argKey, nextArgText] = parseBinaryExpression(argText, null, arrayLiterals);
+            argText = nextArgText;
+            args.push(argKey);
+
+            // Object key separator
+            if (args.length !== 0) {
+                const matchObjectSeparator = argText.match(rExprObjectSeparator);
+                if (matchObjectSeparator === null) {
+                    throw new BareScriptParserError('Syntax error', argText, 1, null, null);
+                }
+                argText = argText.slice(matchObjectSeparator[0].length);
+            }
+
+            // Get the value
+            const [argValue, nextArgText2] = parseBinaryExpression(argText, null, arrayLiterals);
+            argText = nextArgText2;
+            args.push(argValue);
+        }
+        const fnExpr = {'function': {'name': 'objectNew', 'args': args}};
+        return [fnExpr, argText];
+    }
+
+    // Array creation?
+    if (arrayLiterals) {
+        const matchArrayOpen = exprText.match(rExprArrayOpen);
+        if (matchArrayOpen !== null) {
+            let argText = exprText.slice(matchArrayOpen[0].length);
+            const args = [];
+            while (true) {
+                // Array close?
+                const matchArrayClose = argText.match(rExprArrayClose);
+                if (matchArrayClose !== null) {
+                    argText = argText.slice(matchArrayClose[0].length);
+                    break;
+                }
+
+                // Array value separator
+                if (args.length !== 0) {
+                    const matchArraySeparator = argText.match(rExprArraySeparator);
+                    if (matchArraySeparator === null) {
+                        throw new BareScriptParserError('Syntax error', argText, 1, null, null);
+                    }
+                    argText = argText.slice(matchArraySeparator[0].length);
+                }
+
+                // Get the value
+                const [argValue, nextArgText2] = parseBinaryExpression(argText, null, arrayLiterals);
+                argText = nextArgText2;
+                args.push(argValue);
+            }
+            const fnExpr = {'function': {'name': 'arrayNew', 'args': args}};
+            return [fnExpr, argText];
+        }
+    }
+
     // Variable?
     const matchVariable = exprText.match(rExprVariable);
     if (matchVariable !== null) {
@@ -692,11 +775,13 @@ function parseUnaryExpression(exprText) {
     }
 
     // Variable (brackets)?
-    const matchVariableEx = exprText.match(rExprVariableEx);
-    if (matchVariableEx !== null) {
-        const variableName = matchVariableEx[1].replace(rExprVariableExEscape, '$1');
-        const expr = {'variable': variableName};
-        return [expr, exprText.slice(matchVariableEx[0].length)];
+    if (!arrayLiterals) {
+        const matchVariableEx = exprText.match(rExprVariableEx);
+        if (matchVariableEx !== null) {
+            const variableName = matchVariableEx[1].replace(rExprVariableExEscape, '$1');
+            const expr = {'variable': variableName};
+            return [expr, exprText.slice(matchVariableEx[0].length)];
+        }
     }
 
     throw new BareScriptParserError('Syntax error', exprText, 1, null, null);
@@ -713,15 +798,42 @@ const rExprFunctionClose = /^\s*\)/;
 const rExprGroupOpen = /^\s*\(/;
 const rExprGroupClose = /^\s*\)/;
 const rExprNumber = /^\s*(0x[A-Fa-f0-9]+|[+-]?\d+(?:\.\d*)?(?:e[+-]?\d+)?)/;
+const rExprArrayOpen = /^\s*\[/;
+const rExprArraySeparator = /^\s*,/;
+const rExprArrayClose = /^\s*\]/;
+const rExprObjectOpen = /^\s*\{/;
+const rExprObjectSeparator = /^\s*:/;
+const rExprObjectSeparator2 = /^\s*,/;
+const rExprObjectClose = /^\s*\}/;
 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;
 
 
+// String literal escapes
+const rExprStringEscapes = /(?<!\\)\\([nrtbf'"\\]|u[0-9a-fA-F]{4})/g;
+
+function replaceStringEscape(unusedMatch, esc) {
+    if (esc.startsWith('u')) {
+        return String.fromCharCode(parseInt(esc.slice(1), 16));
+    }
+    return exprStringEscapes[esc];
+}
+
+const exprStringEscapes = {
+    'n': '\n',
+    'r': '\r',
+    't': '\t',
+    'b': '\b',
+    'f': '\f',
+    "'": "'",
+    '"': '"',
+    '\\': '\\'
+};
+
+
 /**
  * A BareScript parser error
  *

package/package.json

@@ -1,7 +1,7 @@
 {
     "type": "module",
     "name": "bare-script",
-    "version": "3.6.0",
+    "version": "3.7.0",
     "description": "BareScript; a lightweight scripting and expression language",
     "keywords": [
         "expression",