@halleyassist/rule-templater 0.0.17 → 0.0.19

package/index.d.ts

@@ -3,9 +3,14 @@ export interface VariablePosition {
     end: number;
 }
 
+export interface TemplateFilterCall {
+    name: string;
+    args: any[];
+}
+
 export interface VariableInfo {
     name: string;
-    filters: string[];
+    filters: Array<string | TemplateFilterCall>;
     positions: VariablePosition[];
 }
 
@@ -134,6 +139,8 @@ export class GeneralTemplate {
 
     extractVariables(): VariableInfo[];
 
+    validate(): ValidationResult;
+
     prepare(variables: Variables): string;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-templater",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleTemplate.production.js",
   "browser": "./dist/rule-templater.browser.js",

package/src/GeneralTemplate.js

@@ -1,5 +1,7 @@
 const TemplateFilters = require('./TemplateFilters');
 
+const FILTER_PATTERN = /([A-Za-z_][A-Za-z0-9_]*)(?:\((.*)\))?$/;
+
 class GeneralTemplate {
     constructor(templateText) {
         this.templateText = templateText;
@@ -52,6 +54,33 @@ class GeneralTemplate {
         return this.getVariables();
     }
 
+    validate() {
+        const errors = [];
+        const warnings = [];
+        const seenFilterErrors = new Set();
+
+        for (const variableInfo of this.getVariables()) {
+            for (const filter of variableInfo.filters || []) {
+                const filterName = typeof filter === 'string' ? filter : filter?.name;
+                if (filterName && TemplateFilters[filterName]) {
+                    continue;
+                }
+
+                const errorMessage = `Unknown filter '${filterName || filter}' for variable '${variableInfo.name}'`;
+                if (!seenFilterErrors.has(errorMessage)) {
+                    errors.push(errorMessage);
+                    seenFilterErrors.add(errorMessage);
+                }
+            }
+        }
+
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+
     prepare(variables) {
         if (!variables || typeof variables !== 'object') {
             throw new Error('Variables must be provided as an object');
@@ -76,12 +105,15 @@ class GeneralTemplate {
             varData = Object.assign({}, varData);
 
             if (parsedExpression.filters && parsedExpression.filters.length > 0) {
-                for (const filterName of parsedExpression.filters) {
-                    if (!TemplateFilters[filterName]) {
-                        throw new Error(`Unknown filter '${filterName}'`);
+                for (const filter of parsedExpression.filters) {
+                    const filterName = typeof filter === 'string' ? filter : filter?.name;
+                    const filterArgs = typeof filter === 'string' ? [] : (Array.isArray(filter?.args) ? filter.args : []);
+
+                    if (!filterName || !TemplateFilters[filterName]) {
+                        throw new Error(`Unknown filter '${filterName || filter}'`);
                     }
 
-                    TemplateFilters[filterName](varData);
+                    TemplateFilters[filterName](varData, ...filterArgs);
                 }
             }
 
@@ -101,21 +133,69 @@ class GeneralTemplate {
 
         return {
             name: segments[0],
-            filters: segments.slice(1)
+            filters: segments.slice(1).map(segment => this._parseFilter(segment))
+        };
+    }
+
+    _parseFilter(segment) {
+        const match = segment.match(FILTER_PATTERN);
+        if (!match) {
+            return {
+                name: segment,
+                args: []
+            };
+        }
+
+        const [, name, rawArgs] = match;
+        return {
+            name,
+            args: this._parseFilterArgs(rawArgs)
         };
     }
 
+    _parseFilterArgs(rawArgs) {
+        if (!rawArgs || !rawArgs.trim()) {
+            return [];
+        }
+
+        return rawArgs.split(',').map(arg => this._parseFilterArgValue(arg.trim()));
+    }
+
+    _parseFilterArgValue(rawArg) {
+        if ((rawArg.startsWith('"') && rawArg.endsWith('"')) || (rawArg.startsWith("'") && rawArg.endsWith("'"))) {
+            return rawArg.slice(1, -1);
+        }
+
+        if (rawArg === 'true') {
+            return true;
+        }
+
+        if (rawArg === 'false') {
+            return false;
+        }
+
+        if (rawArg === 'null') {
+            return null;
+        }
+
+        if (rawArg !== '' && !Number.isNaN(Number(rawArg))) {
+            return Number(rawArg);
+        }
+
+        return rawArg;
+    }
+
     _serializeVariable(varData) {
         if (varData.value === null || varData.value === undefined) {
             return '';
         }
 
-        if (varData.type === 'time period' || varData.type === 'time period ago') {
-            let ret = `${varData.value.from} TO ${varData.value.to}`;
-            if (varData.value.ago) {
-                ret += ` AGO ${varData.value.ago[0]} ${varData.value.ago[1]}`;
-            }
-            return ret;
+        if (varData.type === 'time period') {
+            return `BETWEEN ${varData.value.from} AND ${varData.value.to}`;
+        }
+
+        if (varData.type === 'time period ago') {
+            return `${varData.value.ago[0]} ${varData.value.ago[1]} AGO BETWEEN ${varData.value.from} AND ${varData.value.to}`;
         }
 
         return String(varData.value);

package/src/RuleTemplate.ebnf.js

@@ -23,18 +23,9 @@ const grammar = `
 
     template_filter_arg  ::= value | template_value
 
-    number_atom          ::= number | template_value
-    number_time_atom     ::= number_time | template_value WS+ unit | template_value
-    tod_atom             ::= number_tod | template_value
-    dow_atom             ::= dow | template_value
-    between_time_only_atom ::= between_time_only | template_value
-    between_tod_only_atom  ::= between_tod_only | template_value
-
     string_atom          ::= string
     boolean_atom         ::= false | true
     time_value_atom      ::= number_tod
-    time_period_atom     ::= time_value_atom WS* "TO" WS* time_value_atom
-    time_period_ago_atom ::= time_value_atom WS* "TO" WS* time_value_atom WS+ AGO WS+ number WS+ unit
 
     object_atom          ::= json_object
     json_value           ::= string | number | false | true | null | json_array | json_object

package/src/RuleTemplate.js

@@ -28,7 +28,7 @@ const AllowedTypeMapping = {
     'number': ['number_atom', 'math_expr'],
     'boolean': ['boolean_atom', 'boolean_expr'],
     'time period': ['time_period_atom'],
-    'time period ago': ['time_period_atom'],
+    'time period ago': ['time_period_ago_atom'],
     'time value': ['time_value_atom', 'tod_atom'],
     'number time': ['number_atom'],
     'string array': ['string_array'],
@@ -49,12 +49,71 @@ for(const rule of TemplateGrammar){
     }
 }
 
-// Add template_value as an alternative to value_atom so templates can be parsed
-const valueAtomIdx = extendedGrammar.findIndex(r => r.name === 'value_atom');
-if (valueAtomIdx !== -1) {
-    extendedGrammar[valueAtomIdx] = Object.assign({}, extendedGrammar[valueAtomIdx]);
-    extendedGrammar[valueAtomIdx].bnf = extendedGrammar[valueAtomIdx].bnf.concat([['template_value']]);
-}
+const cloneRule = (ruleName) => {
+    const idx = extendedGrammar.findIndex(rule => rule.name === ruleName);
+    if (idx === -1) {
+        return null;
+    }
+
+    extendedGrammar[idx] = Object.assign({}, extendedGrammar[idx], {
+        bnf: extendedGrammar[idx].bnf.map(alt => Array.isArray(alt) ? alt.slice() : alt)
+    });
+
+    return extendedGrammar[idx];
+};
+
+const appendAlternative = (ruleName, alternative) => {
+    const rule = cloneRule(ruleName);
+    if (!rule) {
+        return;
+    }
+
+    const exists = rule.bnf.some(existing => JSON.stringify(existing) === JSON.stringify(alternative));
+    if (!exists) {
+        rule.bnf.push(alternative);
+    }
+};
+
+const replaceRule = (ruleName, bnf) => {
+    const idx = extendedGrammar.findIndex(rule => rule.name === ruleName);
+    if (idx === -1) {
+        extendedGrammar.push({name: ruleName, bnf});
+        return;
+    }
+
+    extendedGrammar[idx] = Object.assign({}, extendedGrammar[idx], {
+        bnf: bnf.map(alt => alt.slice())
+    });
+};
+
+appendAlternative('number_atom', ['template_value']);
+appendAlternative('number_time_atom', ['template_value', 'WS+', 'unit']);
+appendAlternative('number_time_atom', ['template_value']);
+appendAlternative('tod_atom', ['template_value']);
+appendAlternative('dow_atom', ['template_value']);
+appendAlternative('between_time_only_atom', ['template_value']);
+appendAlternative('between_tod_only_atom', ['template_value']);
+appendAlternative('string_atom', ['template_value']);
+appendAlternative('boolean_atom', ['template_value']);
+appendAlternative('time_value_atom', ['template_value']);
+appendAlternative('time_period_atom', ['template_value']);
+appendAlternative('time_period_ago_atom', ['template_value']);
+appendAlternative('object_atom', ['template_value']);
+appendAlternative('string_array', ['template_value']);
+appendAlternative('number_array', ['template_value']);
+appendAlternative('boolean_array', ['template_value']);
+appendAlternative('object_array', ['template_value']);
+
+replaceRule('argument', [
+    ['number_time_atom', 'WS*'],
+    ['statement', 'WS*']
+]);
+
+replaceRule('simple_result', [
+    ['fcall'],
+    ['number_time_atom'],
+    ['value']
+]);
 
 // Export the parser rules for potential external use
 const ParserRules = extendedGrammar;
@@ -185,11 +244,13 @@ class RuleTemplate {
         
         // Extract filters
         const filters = [];
+        const filterCalls = [];
         for (const child of templateExpr.children || []) {
             if (child.type === 'template_filter_call') {
-                const filterName = this._extractFilterName(child);
-                if (filterName) {
-                    filters.push(filterName);
+                const filterCall = this._extractFilterCall(child);
+                if (filterCall) {
+                    filters.push(filterCall.name);
+                    filterCalls.push(filterCall);
                 }
             }
         }
@@ -198,18 +259,84 @@ class RuleTemplate {
         const start = node.start;
         const end = node.end;
         
-        return { name, filters, start, end };
+        return { name, filters, filterCalls, start, end };
     }
 
     /**
-     * Extract filter name from template_filter_call node
+     * Extract filter call from template_filter_call node
      * @private
      */
-    _extractFilterName(node) {
+    _extractFilterCall(node) {
         const filterNameNode = node.children?.find(c => c.type === 'template_filter_name');
         if (!filterNameNode || !filterNameNode.text) return null;
-        
-        return filterNameNode.text.trim();
+
+        const argsNode = node.children?.find(c => c.type === 'template_filter_args');
+
+        return {
+            name: filterNameNode.text.trim(),
+            args: this._extractFilterArgs(argsNode)
+        };
+    }
+
+    _extractFilterArgs(node) {
+        if (!node || !Array.isArray(node.children)) {
+            return [];
+        }
+
+        return node.children
+            .filter(child => child.type === 'template_filter_arg')
+            .map(child => this._extractFilterArgValue(child));
+    }
+
+    _extractFilterArgValue(node) {
+        if (!node || !Array.isArray(node.children) || node.children.length === 0) {
+            return this._normalizeFilterArgText(node?.text?.trim() || '');
+        }
+
+        const child = node.children[0];
+        if (!child) {
+            return this._normalizeFilterArgText(node.text?.trim() || '');
+        }
+
+        if (child.type === 'value' && Array.isArray(child.children) && child.children.length > 0) {
+            return this._extractFilterArgValue(child);
+        }
+
+        if (child.type === 'string') {
+            try {
+                return JSON.parse(child.text);
+            } catch (error) {
+                return this._normalizeFilterArgText(child.text);
+            }
+        }
+
+        if (child.type === 'number') {
+            return Number(child.text);
+        }
+
+        if (child.type === 'true') {
+            return true;
+        }
+
+        if (child.type === 'false') {
+            return false;
+        }
+
+        if (child.type === 'null') {
+            return null;
+        }
+
+        return this._normalizeFilterArgText(child.text?.trim() || node.text?.trim() || '');
+    }
+
+    _normalizeFilterArgText(text) {
+        const normalizedText = String(text).trim();
+
+        if ((normalizedText.startsWith('"') && normalizedText.endsWith('"')) || (normalizedText.startsWith("'") && normalizedText.endsWith("'"))) {
+            return normalizedText.slice(1, -1);
+        }
+
+        return normalizedText;
     }
 
     /**
@@ -229,10 +356,31 @@ class RuleTemplate {
 
         const errors = [];
         const warnings = [];
-        const extractedVars = this.extractVariables();
+        const extractedVars = this._extractTemplateVariables();
+        const seenVariables = new Set();
+        const seenFilterErrors = new Set();
         
         for (const varInfo of extractedVars) {
             const varName = varInfo.name;
+
+            for (const filter of (varInfo.filterCalls || varInfo.filters || [])) {
+                const filterName = typeof filter === 'string' ? filter : filter?.name;
+                if (filterName && TemplateFilters[filterName]) {
+                    continue;
+                }
+
+                const errorMessage = `Unknown filter '${filterName || filter}' for variable '${varName}'`;
+                if (!seenFilterErrors.has(errorMessage)) {
+                    errors.push(errorMessage);
+                    seenFilterErrors.add(errorMessage);
+                }
+            }
+
+            if (seenVariables.has(varName)) {
+                continue;
+            }
+
+            seenVariables.add(varName);
             
             // Check if variable is provided
             if (!variables.hasOwnProperty(varName)) {
@@ -262,6 +410,23 @@ class RuleTemplate {
             }
         }
 
+        const canValidatePreparedRule = errors.length === 0
+            && Array.from(seenVariables).every(varName => {
+                const varData = variables[varName];
+                return varData
+                    && typeof varData === 'object'
+                    && Object.prototype.hasOwnProperty.call(varData, 'type')
+                    && Object.prototype.hasOwnProperty.call(varData, 'value');
+            });
+
+        if (canValidatePreparedRule) {
+            try {
+                RuleParser.toAst(this.prepare(variables));
+            } catch (error) {
+                errors.push(`Prepared rule is invalid: ${error.message}`);
+            }
+        }
+
         if (functionBlob && typeof functionBlob.validate === 'function') {
             for (const functionCall of this._extractFunctionCalls()) {
                 warnings.push(...functionBlob.validate(functionCall.name, functionCall.arguments));
@@ -305,6 +470,30 @@ class RuleTemplate {
         return functionCalls;
     }
 
+    _extractTemplateVariables() {
+        const variables = [];
+
+        const traverse = (node) => {
+            if (!node) return;
+
+            if (node.type === 'template_value') {
+                const variableInfo = this._extractVariableFromNode(node);
+                if (variableInfo) {
+                    variables.push(variableInfo);
+                }
+            }
+
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+
+        traverse(this.ast);
+        return variables;
+    }
+
     /**
      * Prepare the template by replacing variables with their values
      * Rebuilds from AST by iterating through children
@@ -407,12 +596,15 @@ class RuleTemplate {
         
         // Apply filters if present
         if (templateInfo.filters && templateInfo.filters.length > 0) {
-            for (const filterName of templateInfo.filters) {
-                if (!TemplateFilters[filterName]) {
-                    throw new Error(`Unknown filter '${filterName}'`);
+            for (const filter of (templateInfo.filterCalls || templateInfo.filters)) {
+                const filterName = typeof filter === 'string' ? filter : filter?.name;
+                const filterArgs = typeof filter === 'string' ? [] : (Array.isArray(filter?.args) ? filter.args : []);
+
+                if (!filterName || !TemplateFilters[filterName]) {
+                    throw new Error(`Unknown filter '${filterName || filter}'`);
                 }
-               
-                TemplateFilters[filterName](varData);
+
+                TemplateFilters[filterName](varData, ...filterArgs);
             }
         }
 
@@ -443,12 +635,12 @@ class RuleTemplate {
             return value ? 'true' : 'false';
         }
 
-        if (type === 'time period' || type === 'time period ago') {
-            let ret = `${value.from} TO ${value.to}`;
-            if(value.ago) {
-                ret += ` AGO ${value.ago[0]} ${value.ago[1]}`;
-            }
-            return ret;
+        if (type === 'time period') {
+            return `BETWEEN ${value.from} AND ${value.to}`;
+        }
+
+        if (type === 'time period ago') {
+            return `${value.ago[0]} ${value.ago[1]} AGO BETWEEN ${value.from} AND ${value.to}`;
         }
 
         if (type === 'object' || type === 'string array' || type === 'number array' || type === 'boolean array' || type === 'object array') {

package/src/RuleTemplate.production.ebnf.js

@@ -1 +1 @@
-module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value","WS+","unit"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]},{"name":"string_atom","bnf":[["string"]]},{"name":"boolean_atom","bnf":[["false"],["true"]]},{"name":"time_value_atom","bnf":[["number_tod"]]},{"name":"time_period_atom","bnf":[["time_value_atom","WS*","\"TO\"","WS*","time_value_atom"]]},{"name":"time_period_ago_atom","bnf":[["time_value_atom","WS*","\"TO\"","WS*","time_value_atom","WS+","AGO","WS+","number","WS+","unit"]]},{"name":"object_atom","bnf":[["json_object"]]},{"name":"json_value","bnf":[["string"],["number"],["false"],["true"],["null"],["json_array"],["json_object"]]},{"name":"json_member","bnf":[["string","NAME_SEPARATOR","json_value"]]},{"name":"%json_object[2][2]","bnf":[["VALUE_SEPARATOR","json_member"]],"fragment":true},{"name":"%json_object[2]","bnf":[["json_member","%json_object[2][2]*"]],"fragment":true},{"name":"json_object","bnf":[["BEGIN_OBJECT","%json_object[2]?","END_OBJECT"]]},{"name":"%json_array[2][2]","bnf":[["VALUE_SEPARATOR","json_value"]],"fragment":true},{"name":"%json_array[2]","bnf":[["json_value","%json_array[2][2]*"]],"fragment":true},{"name":"json_array","bnf":[["BEGIN_ARRAY","%json_array[2]?","END_ARRAY"]]},{"name":"%string_array[2][2]","bnf":[["VALUE_SEPARATOR","string"]],"fragment":true},{"name":"%string_array[2]","bnf":[["string","%string_array[2][2]*"]],"fragment":true},{"name":"string_array","bnf":[["BEGIN_ARRAY","%string_array[2]?","END_ARRAY"]]},{"name":"%number_array[2][2]","bnf":[["VALUE_SEPARATOR","number"]],"fragment":true},{"name":"%number_array[2]","bnf":[["number","%number_array[2][2]*"]],"fragment":true},{"name":"number_array","bnf":[["BEGIN_ARRAY","%number_array[2]?","END_ARRAY"]]},{"name":"%boolean_array[2][2]","bnf":[["VALUE_SEPARATOR","boolean_atom"]],"fragment":true},{"name":"%boolean_array[2]","bnf":[["boolean_atom","%boolean_array[2][2]*"]],"fragment":true},{"name":"boolean_array","bnf":[["BEGIN_ARRAY","%boolean_array[2]?","END_ARRAY"]]},{"name":"%object_array[2][2]","bnf":[["VALUE_SEPARATOR","json_object"]],"fragment":true},{"name":"%object_array[2]","bnf":[["json_object","%object_array[2][2]*"]],"fragment":true},{"name":"object_array","bnf":[["BEGIN_ARRAY","%object_array[2]?","END_ARRAY"]]}]
+module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"string_atom","bnf":[["string"]]},{"name":"boolean_atom","bnf":[["false"],["true"]]},{"name":"time_value_atom","bnf":[["number_tod"]]},{"name":"object_atom","bnf":[["json_object"]]},{"name":"json_value","bnf":[["string"],["number"],["false"],["true"],["null"],["json_array"],["json_object"]]},{"name":"json_member","bnf":[["string","NAME_SEPARATOR","json_value"]]},{"name":"%json_object[2][2]","bnf":[["VALUE_SEPARATOR","json_member"]],"fragment":true},{"name":"%json_object[2]","bnf":[["json_member","%json_object[2][2]*"]],"fragment":true},{"name":"json_object","bnf":[["BEGIN_OBJECT","%json_object[2]?","END_OBJECT"]]},{"name":"%json_array[2][2]","bnf":[["VALUE_SEPARATOR","json_value"]],"fragment":true},{"name":"%json_array[2]","bnf":[["json_value","%json_array[2][2]*"]],"fragment":true},{"name":"json_array","bnf":[["BEGIN_ARRAY","%json_array[2]?","END_ARRAY"]]},{"name":"%string_array[2][2]","bnf":[["VALUE_SEPARATOR","string"]],"fragment":true},{"name":"%string_array[2]","bnf":[["string","%string_array[2][2]*"]],"fragment":true},{"name":"string_array","bnf":[["BEGIN_ARRAY","%string_array[2]?","END_ARRAY"]]},{"name":"%number_array[2][2]","bnf":[["VALUE_SEPARATOR","number"]],"fragment":true},{"name":"%number_array[2]","bnf":[["number","%number_array[2][2]*"]],"fragment":true},{"name":"number_array","bnf":[["BEGIN_ARRAY","%number_array[2]?","END_ARRAY"]]},{"name":"%boolean_array[2][2]","bnf":[["VALUE_SEPARATOR","boolean_atom"]],"fragment":true},{"name":"%boolean_array[2]","bnf":[["boolean_atom","%boolean_array[2][2]*"]],"fragment":true},{"name":"boolean_array","bnf":[["BEGIN_ARRAY","%boolean_array[2]?","END_ARRAY"]]},{"name":"%object_array[2][2]","bnf":[["VALUE_SEPARATOR","json_object"]],"fragment":true},{"name":"%object_array[2]","bnf":[["json_object","%object_array[2][2]*"]],"fragment":true},{"name":"object_array","bnf":[["BEGIN_ARRAY","%object_array[2]?","END_ARRAY"]]}]