wizard-ql 2.0.1 → 2.1.0

package/dist/errors.d.ts

@@ -14,15 +14,18 @@ export declare class ParseError extends Error {
     readonly startIndex: number | undefined;
     /** The end token index */
     readonly endIndex: number | undefined;
+    /** The tokens being parsed */
+    readonly tokens: Token[] | undefined;
     /**
      * Construct a Parsing Error
      * @param message    The error message
+     * @param tokens     The tokens being parsed
      * @param startToken The first token this error pertains to
      * @param startIndex The start token index
      * @param endToken   The last token this error pertains to
      * @param endIndex   The end token index
      */
-    constructor(message: string, startToken: Token | undefined, startIndex: number | undefined, endToken?: Token | undefined, endIndex?: number | undefined);
+    constructor(message: string, tokens: Token[] | undefined, startToken: Token | undefined, startIndex: number | undefined, endToken?: Token | undefined, endIndex?: number | undefined);
 }
 /**
  * A WizardQL string expression parsing constraint error
@@ -39,13 +42,16 @@ export declare class ConstraintError extends Error {
     readonly startIndex: number | undefined;
     /** The end token index */
     readonly endIndex: number | undefined;
+    /** The tokens being parsed */
+    readonly tokens: Token[] | undefined;
     /**
      * Construct a Constraint Error
      * @param message    The error message
+     * @param tokens     The tokens being parsed
      * @param startToken The first token this error pertains to
      * @param startIndex The start token index
      * @param endToken   The last token this error pertains to
      * @param endIndex   The end token index
      */
-    constructor(message: string, startToken: Token | undefined, startIndex: number | undefined, endToken?: Token | undefined, endIndex?: number | undefined);
+    constructor(message: string, tokens: Token[] | undefined, startToken: Token | undefined, startIndex: number | undefined, endToken?: Token | undefined, endIndex?: number | undefined);
 }

package/dist/index.js

@@ -1,4 +1,14 @@
 // src/spec.ts
+var QUOTES = ["'", '"', "`"];
+var BRACKETS = [
+  ["[", "]"],
+  ["{", "}"]
+];
+var PARENS = [
+  ["(", ")"]
+];
+var NEGATORS = ["!"];
+var ARRAY_DELIMITERS = [","];
 var OPERATION_ALIAS_DICTIONARY = {
   AND: "AND",
   "&&": "AND",
@@ -72,7 +82,6 @@ var COMPARISON_TYPE_DICTIONARY = {
 var TYPE_PRIORITY = ["boolean", "date", "number", "string"];
 // src/regex.ts
 var ESCAPE_REGEX = "(?<=(?<!\\\\)(?:\\\\\\\\)*)";
-var QUOTES = ["'", '"', "`"];
 var QUOTE_REGEX_STR = `${ESCAPE_REGEX}(?<quote>${QUOTES.map((q) => RegExp.escape(q)).join("|")})(?<quotecontent>.*?)${ESCAPE_REGEX}\\k<quote>`;
 
 // src/errors.ts
@@ -106,9 +115,11 @@ class ParseError extends Error {
   endToken;
   startIndex;
   endIndex;
-  constructor(message, startToken, startIndex, endToken = startToken, endIndex = startIndex) {
+  tokens;
+  constructor(message, tokens, startToken, startIndex, endToken = startToken, endIndex = startIndex) {
     const header = constructHeader(startToken, startIndex, endToken, endIndex);
     super(header + message);
+    this.tokens = tokens;
     this.rawMessage = message;
     this.startToken = startToken;
     this.endToken = endToken;
@@ -124,9 +135,11 @@ class ConstraintError extends Error {
   endToken;
   startIndex;
   endIndex;
-  constructor(message, startToken, startIndex, endToken = startToken, endIndex = startIndex) {
+  tokens;
+  constructor(message, tokens, startToken, startIndex, endToken = startToken, endIndex = startIndex) {
     const header = constructHeader(startToken, startIndex, endToken, endIndex);
     super(header + message);
+    this.tokens = tokens;
     this.rawMessage = message;
     this.startToken = startToken;
     this.endToken = endToken;
@@ -136,7 +149,7 @@ class ConstraintError extends Error {
 }
 
 // src/parse.ts
-var TOKEN_REGEX = new RegExp("(?<=(?<!\\\\)(?:\\\\\\\\)*)(?<quote>\\x27|\\x22|\\x60)(?<quotecontent>.*?)(?<=(?<!\\\\)(?:\\\\\\\\)*)\\k<quote>|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x41ND(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x26\\x26|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x26|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\^|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4fR(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\|\\||(?<=(?<!\\\\)(?:\\\\\\\\)*)\\||(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x56(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x47EQ(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3e\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d\\x3e|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4cEQ(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3c\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d\\x3c|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTEQUALS(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTEQUAL(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eEQ(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x49SNT(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x3d\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x3d|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x45QUALS(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x45QUAL(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x45Q(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x49S(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4cESS(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3c|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x47REATER(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3e|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4dORE(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTIN(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x3a|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x49N(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3a|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTMATCHES(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTMATCH(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x7e|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4dATCHES(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4dATCH(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x7e|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\(|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\[|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\]|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\{|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\}|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x2c|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21", "g");
+var TOKEN_REGEX = new RegExp("(?<=(?<!\\\\)(?:\\\\\\\\)*)(?<quote>\\x27|\\x22|\\x60)(?<quotecontent>.*?)(?<=(?<!\\\\)(?:\\\\\\\\)*)\\k<quote>|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x41ND(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x26\\x26|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x26|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\^|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4fR(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\|\\||(?<=(?<!\\\\)(?:\\\\\\\\)*)\\||(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x56(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x47EQ(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3e\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d\\x3e|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4cEQ(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3c\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d\\x3c|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTEQUALS(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTEQUAL(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eEQ(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x49SNT(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x3d\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x3d|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x45QUALS(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x45QUAL(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x45Q(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x49S(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d\\x3d|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3d|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4cESS(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3c|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x47REATER(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3e|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4dORE(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTIN(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x3a|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x49N(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x3a|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTMATCHES(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4eOTMATCH(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21\\x7e|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4dATCHES(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|^)\\x4dATCH(?=(?<=(?<!\\\\)(?:\\\\\\\\)*)\\s|$)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x7e|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\(|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\[|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\]|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\{|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\}|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x21|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\x2c", "g");
 var QUOTE_REGEX = new RegExp("(?<=(?<!\\\\)(?:\\\\\\\\)*)(?<quote>\\x27|\\x22|\\x60)(?<quotecontent>.*?)(?<=(?<!\\\\)(?:\\\\\\\\)*)\\k<quote>");
 var QUOTE_EDGE_REGEX = new RegExp(`^${"(?<=(?<!\\\\)(?:\\\\\\\\)*)(?<quote>\\x27|\\x22|\\x60)(?<quotecontent>.*?)(?<=(?<!\\\\)(?:\\\\\\\\)*)\\k<quote>"}$`);
 function pushSanitized(array, item, index) {
@@ -156,20 +169,27 @@ function _tokenize(expression, pattern) {
   let lastMatchEnd = null;
   for (const match of matches) {
     pushSanitized(tokens, expression.slice(lastMatchEnd ?? 0, match.index), lastMatchEnd === null ? 0 : lastMatchEnd);
-    if (["[", "{"].includes(match[0])) {
+    if (BRACKETS.some(([o]) => match[0] === o)) {
       const startToken = {
         content: match[0],
         index: match.index
       };
       tokens.push(startToken);
+      let subopenings = 0;
       let endToken;
       for (const submatch of matches) {
-        if (match[0] === "[" && submatch[0] === "]" || match[0] === "{" && submatch[0] === "}") {
-          endToken = {
-            content: submatch[0],
-            index: submatch.index
-          };
-          break;
+        if (match[0] === submatch[0] || match[0] === submatch[0])
+          ++subopenings;
+        if (BRACKETS.some(([o, c]) => match[0] === o && submatch[0] === c)) {
+          if (subopenings)
+            --subopenings;
+          else {
+            endToken = {
+              content: submatch[0],
+              index: submatch.index
+            };
+            break;
+          }
         }
       }
       const subtokens = endToken ? _tokenize(expression.slice(startToken.index + startToken.content.length, endToken.index), new RegExp(`${"(?<=(?<!\\\\)(?:\\\\\\\\)*)(?<quote>\\x27|\\x22|\\x60)(?<quotecontent>.*?)(?<=(?<!\\\\)(?:\\\\\\\\)*)\\k<quote>"}|${ESCAPE_REGEX},`, "g")) : _tokenize(expression.slice(startToken.index + startToken.content.length), TOKEN_REGEX);
@@ -200,6 +220,7 @@ function processToken(token) {
   const escaped = unquoted ?? token;
   const unescaped = escaped.replaceAll(new RegExp(`(?<!${ESCAPE_REGEX}\\\\)\\\\`, "g"), "");
   return {
+    raw: token,
     unquoted,
     escaped,
     unescaped
@@ -270,8 +291,8 @@ function complementExpression(expression) {
       break;
   }
 }
-function coerceType(value, fieldTypes, operatorTypes, dateInterpreter) {
-  const { unescaped } = processToken(value);
+function coerceType(processedToken, fieldTypes, operatorTypes, dateInterpreter) {
+  const { raw, unescaped } = processedToken;
   let operatorHits = 0;
   let fieldHits = 0;
   for (const type of TYPE_PRIORITY) {
@@ -285,13 +306,13 @@ function coerceType(value, fieldTypes, operatorTypes, dateInterpreter) {
       continue;
     switch (type) {
       case "boolean":
-        if (value === "true")
+        if (raw === "true")
           return true;
-        else if (value === "false")
+        else if (raw === "false")
           return false;
         break;
       case "number": {
-        const num = Number(value);
+        const num = Number(raw);
         if (isNaN(num))
           break;
         return num;
@@ -299,7 +320,7 @@ function coerceType(value, fieldTypes, operatorTypes, dateInterpreter) {
       case "string":
         return unescaped;
       case "date": {
-        const num = Number(value);
+        const num = Number(raw);
         const date = dateInterpreter(isNaN(num) ? unescaped : num);
         if (isNaN(+date))
           break;
@@ -319,46 +340,47 @@ function coerceType(value, fieldTypes, operatorTypes, dateInterpreter) {
 }
 function validateCondition(condition, constraints, valueIsImplicit, ctx) {
   let validated = false;
+  condition.field = processToken(condition.field).unescaped;
   const field = constraints?.caseInsensitive ? [...Object.keys(constraints.types ?? {}), ...Object.keys(constraints.restricted ?? {})].find((k) => k.toLowerCase() === condition.field.toLowerCase()) ?? condition.field : condition.field;
   const restriction = constraints?.restricted?.[field];
   const type = constraints?.types?.[field];
   if (constraints?.disallowUnvalidated && restriction === undefined && type === undefined)
-    throw new ConstraintError(`Unknown field "${condition.field}"`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+    throw new ConstraintError(`Unknown field "${condition.field}"`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
   const operationType = COMPARISON_TYPE_DICTIONARY[condition.operation];
   const types = type && (Array.isArray(type) ? type : [type]);
-  const values = Array.isArray(condition.value) ? condition.value : [condition.value];
+  const processedValues = (Array.isArray(condition.value) ? condition.value : [condition.value]).map((v) => processToken(v));
   if (restriction === true)
-    throw new ConstraintError(`Field "${condition.field}" is restricted`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+    throw new ConstraintError(`Field "${condition.field}" is restricted`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
   else if (Array.isArray(restriction)) {
     const [philosophy, checks] = restriction;
     if (philosophy === "deny") {
       for (const check of checks) {
         if (check instanceof RegExp) {
-          if (values.some((v) => check.test(v.toString()))) {
-            throw new ConstraintError(`Value for field "${condition.field}" violates prohibitive pattern constraint "${check.toString()}". Prohibited values/patterns: Allowed values/patterns: ${checks.join(", ")}`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+          if (processedValues.some(({ unescaped }) => check.test(unescaped))) {
+            throw new ConstraintError(`Value for field "${condition.field}" violates prohibitive pattern constraint "${check.toString()}". Prohibited values/patterns: Allowed values/patterns: ${checks.join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
           }
         } else {
-          if (values.includes(check)) {
-            throw new ConstraintError(`Forbidden value "${check}" for field "${condition.field}". Prohibited values/patterns: ${checks.join(", ")}`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+          if (processedValues.some(({ unescaped }) => unescaped === check)) {
+            throw new ConstraintError(`Forbidden value "${check}" for field "${condition.field}". Prohibited values/patterns: ${checks.join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
           }
         }
       }
     } else {
-      for (const value of values) {
-        if (!checks.some((c) => c instanceof RegExp && c.test(value.toString()) || c === value)) {
-          throw new ConstraintError(`Value for field "${condition.field}" does not meet any allowed value/pattern. Allowed values/patterns: ${checks.join(", ")}`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+      for (const { unescaped } of processedValues) {
+        if (!checks.some((c) => c instanceof RegExp ? c.test(unescaped) : c === unescaped)) {
+          throw new ConstraintError(`Value for field "${condition.field}" does not meet any allowed value/pattern. Allowed values/patterns: ${checks.join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
         }
       }
     }
     validated = true;
   }
   if (operationType === "array" && !Array.isArray(condition.value))
-    throw new ConstraintError(`Value "${condition.value.toString()}" is not permitted for "${condition.operation}" which expects an array`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+    throw new ConstraintError(`Value "${condition.value.toString()}" is not permitted for "${condition.operation}" which expects an array`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
   else if (operationType !== "array" && Array.isArray(condition.value))
-    throw new ConstraintError(`Value "${condition.value.toString()}" is not permitted for "${condition.operation}" which expects a non-array value`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+    throw new ConstraintError(`Value "${condition.value.toString()}" is not permitted for "${condition.operation}" which expects a non-array value`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
   const dateInterpreter = constraints?.dateInterpreter ?? ((v) => new Date(v));
-  for (let i = 0;i < values.length; ++i) {
-    const v = values[i];
+  for (let i = 0;i < processedValues.length; ++i) {
+    const v = processedValues[i];
     let opTypes;
     if (valueIsImplicit)
       opTypes = ["boolean"];
@@ -382,15 +404,16 @@ function validateCondition(condition, constraints, valueIsImplicit, ctx) {
     }
     try {
       const value = coerceType(v, types ?? opTypes, opTypes, dateInterpreter);
-      values[i] = value;
-      if (!Array.isArray(condition.value))
+      if (Array.isArray(condition.value))
+        condition.value[i] = value;
+      else
         condition.value = value;
     } catch (err) {
       switch (err.message) {
         case "operator":
-          throw new ConstraintError(`Value "${condition.value.toString()}" not allowed for operation "${condition.operation}" which only allows for "${operationType}" type`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+          throw new ConstraintError(`Value "${condition.value.toString()}" not allowed for operation "${condition.operation}" which only allows for "${operationType}" type`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
         case "field":
-          throw new ConstraintError(`Value "${condition.value.toString()}" includes a type not permitted for field "${condition.field}". Allowed types: ${(types ?? opTypes).join(", ")}`, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+          throw new ConstraintError(`Value "${condition.value.toString()}" includes a type not permitted for field "${condition.field}". Allowed types: ${(types ?? opTypes).join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
       }
     }
   }
@@ -413,15 +436,16 @@ function _parse(tokens, _offset, constraints) {
     if (inConjunction) {
       const prior = expressions.at(-1);
       if (!prior)
-        throw new ParseError("Unexpected: Expression list empty when parser is meant to append to an AND group", ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+        throw new ParseError("Unexpected: Expression list empty when parser is meant to append to an AND group", ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
       if (prior.type !== "group" || prior.operation !== "AND")
-        throw new ParseError("Unexpected: Last expression is not an AND group yet parser thinks it's appending to one", ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+        throw new ParseError("Unexpected: Last expression is not an AND group yet parser thinks it's appending to one", ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
       return prior.constituents;
     }
     return expressions;
   }
   function resolveCondition(ctx) {
     const baseCtx = {
+      tokens,
       startToken: field?.token ?? comparisonOperation?.token ?? value?.token,
       startIndex: field?.index ?? comparisonOperation?.index ?? value?.index,
       endToken: value?.token ?? comparisonOperation?.token ?? field?.token,
@@ -432,7 +456,7 @@ function _parse(tokens, _offset, constraints) {
     const group = getExpressionGroup(ctx);
     if (field && comparisonOperation && value) {
       if (!expectingExpression)
-        throw new ParseError("Unexpected expression resolution before junctive operator", ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
+        throw new ParseError("Unexpected expression resolution before junctive operator", ctx.tokens, ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
       group.push(validateCondition({
         type: "condition",
         field: field.content,
@@ -443,7 +467,7 @@ function _parse(tokens, _offset, constraints) {
       expectingExpression = false;
     } else if (field && !comparisonOperation && !value) {
       if (!expectingExpression)
-        throw new ParseError("Unexpected expression resolution before junctive operator", ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
+        throw new ParseError("Unexpected expression resolution before junctive operator", ctx.tokens, ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
       group.push(validateCondition({
         type: "condition",
         field: field.content,
@@ -453,30 +477,31 @@ function _parse(tokens, _offset, constraints) {
       inConjunction = false;
       expectingExpression = false;
     } else if (field || comparisonOperation || value !== undefined)
-      throw new ParseError("Failed to resolve condition; missing operand or operator", ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
+      throw new ParseError("Failed to resolve condition; missing operand or operator", ctx.tokens, ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
     field = undefined;
     comparisonOperation = undefined;
     value = undefined;
   }
   for (let t = 0;t < tokens.length; ++t) {
     const token = tokens[t];
-    if (token.content === ")")
-      throw new ParseError("Unexpected closing parenthesis", token, _offset + t);
-    if (["]", "}"].includes(token.content))
-      throw new ParseError("Unexpected closing bracket/brace", token, _offset + t);
-    if (token.content === "(") {
+    if (PARENS.some(([, c]) => token.content === c))
+      throw new ParseError("Unexpected closing parenthesis", tokens, token, _offset + t);
+    if (BRACKETS.some(([, c]) => token.content === c))
+      throw new ParseError("Unexpected closing bracket/brace", tokens, token, _offset + t);
+    const paren = PARENS.find(([o]) => token.content === o);
+    if (paren) {
       if (field || comparisonOperation || value)
-        throw new ParseError("Tried to open a group during an operation", token, _offset + t);
-      const closingIndex = getClosingIndex(tokens, t, "(", ")");
+        throw new ParseError("Tried to open a group during an operation", tokens, token, _offset + t);
+      const closingIndex = getClosingIndex(tokens, t, paren[0], paren[1]);
       if (closingIndex === -1)
-        throw new ParseError("Missing closing parenthesis for group", token, _offset + t);
+        throw new ParseError("Missing closing parenthesis for group", tokens, token, _offset + t);
       ++t;
       const subExpression = _parse(tokens.slice(t, closingIndex), _offset + t, constraints);
       if (subExpression) {
         if (subExpression.type === "group" && subExpression.operation === groupOperation)
           expressions.push(...subExpression.constituents);
         else {
-          const group = getExpressionGroup({ startToken: token, startIndex: _offset + t });
+          const group = getExpressionGroup({ tokens, startToken: token, startIndex: _offset + t });
           group.push(subExpression);
           inConjunction = false;
         }
@@ -487,6 +512,7 @@ function _parse(tokens, _offset, constraints) {
     const op = OPERATION_ALIAS_DICTIONARY[token.content];
     if (op && OPERATION_PURPOSE_DICTIONARY[op] === "junction") {
       resolveCondition({
+        tokens,
         startToken: field?.token ?? token,
         startIndex: field?.index ?? _offset + t,
         endToken: token,
@@ -494,16 +520,16 @@ function _parse(tokens, _offset, constraints) {
       });
       const prior = expressions.at(-1);
       if (!prior)
-        throw new ParseError("Unexpected junction operator with no preceding expression", token, _offset + t);
+        throw new ParseError("Unexpected junction operator with no preceding expression", tokens, token, _offset + t);
       expectingExpression = true;
       if (groupOperation && groupOperation !== op) {
         if (expressions.length < 2)
-          throw new ParseError("Unexpected junction operator with no preceding expression", token, _offset + t);
+          throw new ParseError("Unexpected junction operator with no preceding expression", tokens, token, _offset + t);
         switch (groupOperation) {
           case "AND": {
             const futureSubgroup = _parse(tokens.slice(t + 1), _offset + t, constraints);
             if (futureSubgroup === null)
-              throw new ParseError("Dangling junction operator", token, _offset + t);
+              throw new ParseError("Dangling junction operator", tokens, token, _offset + t);
             return {
               type: "group",
               operation: "OR",
@@ -540,19 +566,21 @@ function _parse(tokens, _offset, constraints) {
       }
       continue;
     }
-    if (token.content === "!") {
+    if (NEGATORS.includes(token.content)) {
       const nextToken = tokens[t + 1];
-      if (nextToken?.content === "(") {
+      const nextParen = PARENS.find(([o]) => nextToken?.content === o);
+      if (nextParen) {
         resolveCondition({
+          tokens,
           startToken: field?.token ?? token,
           startIndex: field?.index ?? _offset + t,
           endToken: value?.token ?? comparisonOperation?.token ?? field?.token,
           endIndex: value?.index ?? comparisonOperation?.index ?? field?.index
         });
         ++t;
-        const closingIndex = getClosingIndex(tokens, t, "(", ")");
+        const closingIndex = getClosingIndex(tokens, t, nextParen[0], nextParen[1]);
         if (closingIndex === -1)
-          throw new ParseError("Missing closing parenthesis for group", token, _offset + t);
+          throw new ParseError("Missing closing parenthesis for group", tokens, token, _offset + t);
         ++t;
         const futureSubExpression = _parse(tokens.slice(t, closingIndex), _offset + t, constraints);
         if (futureSubExpression) {
@@ -561,6 +589,7 @@ function _parse(tokens, _offset, constraints) {
             expressions.push(...futureSubExpression.constituents);
           else {
             const group = getExpressionGroup({
+              tokens,
               startToken: token,
               startIndex: _offset + t,
               endToken: tokens[closingIndex],
@@ -577,7 +606,7 @@ function _parse(tokens, _offset, constraints) {
     if (!comparisonOperation || op && OPERATION_PURPOSE_DICTIONARY[op] === "comparison") {
       if (op && OPERATION_PURPOSE_DICTIONARY[op] === "comparison") {
         if (comparisonOperation || !field)
-          throw new ParseError("Unexpected comparison operator", field?.token ?? token, field?.index ?? _offset + t, token, _offset + t);
+          throw new ParseError("Unexpected comparison operator", tokens, field?.token ?? token, field?.index ?? _offset + t, token, _offset + t);
         comparisonOperation = {
           content: op,
           token,
@@ -585,14 +614,15 @@ function _parse(tokens, _offset, constraints) {
         };
         continue;
       } else if (field)
-        throw new ParseError("Expected a comparison operator", field.token, field.index, token, _offset + t);
+        throw new ParseError("Expected a comparison operator", tokens, field.token, field.index, token, _offset + t);
     }
     if (!field) {
-      if (token.content === "!") {
+      if (NEGATORS.includes(token.content)) {
         const nextToken = tokens[t + 1];
         if (!nextToken)
-          throw new ParseError('Unexpected "!"', token, _offset + t);
+          throw new ParseError('Unexpected "!"', tokens, token, _offset + t);
         resolveCondition({
+          tokens,
           startToken: token,
           startIndex: _offset + t,
           endToken: nextToken,
@@ -600,7 +630,7 @@ function _parse(tokens, _offset, constraints) {
         });
         ++t;
         field = {
-          content: processToken(nextToken.content).unescaped,
+          content: nextToken.content,
           token,
           index: _offset + t
         };
@@ -612,6 +642,7 @@ function _parse(tokens, _offset, constraints) {
           implicit: true
         };
         resolveCondition({
+          tokens,
           startToken: field.token,
           startIndex: field.index,
           endToken: nextToken,
@@ -619,7 +650,7 @@ function _parse(tokens, _offset, constraints) {
         });
       } else {
         field = {
-          content: processToken(token.content).unescaped,
+          content: token.content,
           token,
           index: _offset + t
         };
@@ -627,17 +658,13 @@ function _parse(tokens, _offset, constraints) {
       continue;
     }
     if (!value) {
-      if (["[", "{"].includes(token.content)) {
+      const bracket = BRACKETS.find(([o]) => token.content === o);
+      if (bracket) {
         let resolveEntry = function(subtoken, subindex) {
           if (workingEntry) {
-            const {
-              unquoted: unquotedWorkingEntry
-            } = processToken(workingEntry);
             const subquotes = workingEntry.match(QUOTE_REGEX);
             if (subquotes && (subquotes.index !== 0 || subquotes[0].length !== workingEntry.length))
-              throw new ParseError("Quotes must surround entire values in arrays", firstEntryToken ?? subtoken, firstEntryTokenIndex ?? subindex, lastEntryToken ?? subtoken, lastEntryTokenIndex ?? subindex);
-            if (!unquotedWorkingEntry && (token.content === "[" && new RegExp(`${ESCAPE_REGEX}(?:\\[|\\])`).test(workingEntry) || token.content === "{" && new RegExp(`${ESCAPE_REGEX}(?:\\{|\\})`).test(workingEntry)))
-              throw new ParseError("Unescaped bracket in an array value", firstEntryToken ?? subtoken, firstEntryTokenIndex ?? subindex, lastEntryToken ?? subtoken, lastEntryTokenIndex ?? subindex);
+              throw new ParseError("Quotes must surround entire values in arrays", tokens, firstEntryToken ?? subtoken, firstEntryTokenIndex ?? subindex, lastEntryToken ?? subtoken, lastEntryTokenIndex ?? subindex);
             arr.push(workingEntry);
             workingEntry = "";
             firstEntryToken = undefined;
@@ -646,9 +673,9 @@ function _parse(tokens, _offset, constraints) {
             lastEntryTokenIndex = undefined;
           }
         };
-        const closingIndex = getClosingIndex(tokens, t, token.content, token.content === "[" ? "]" : "}");
+        const closingIndex = getClosingIndex(tokens, t, bracket[0], bracket[1]);
         if (closingIndex === -1)
-          throw new ParseError("Missing closing bracket/brace for array value", token, _offset + t);
+          throw new ParseError("Missing closing bracket/brace for array value", tokens, token, _offset + t);
         ++t;
         const arr = [];
         value = {
@@ -664,9 +691,9 @@ function _parse(tokens, _offset, constraints) {
         let lastEntryTokenIndex;
         for (let ct = 0;ct < arrayContents.length; ++ct) {
           const contentToken = arrayContents[ct];
-          if (contentToken.content === ",") {
+          if (ARRAY_DELIMITERS.includes(contentToken.content)) {
             if (!workingEntry)
-              throw new ParseError("Unexpected blank entry in array", contentToken, _offset + t + ct);
+              throw new ParseError("Unexpected blank entry in array", tokens, contentToken, _offset + t + ct);
             resolveEntry(contentToken, _offset + t + ct);
           } else {
             lastEntryToken = contentToken;
@@ -680,7 +707,7 @@ function _parse(tokens, _offset, constraints) {
         }
         resolveEntry(arrayContents.at(-1), _offset + t + arrayContents.length - 1);
         if (!arr.length) {
-          throw new ParseError("Empty array provided as value", token, _offset + t - 1, tokens[closingIndex], _offset + closingIndex);
+          throw new ParseError("Empty array provided as value", tokens, token, _offset + t - 1, tokens[closingIndex], _offset + closingIndex);
         }
         t = closingIndex;
       } else {
@@ -691,6 +718,7 @@ function _parse(tokens, _offset, constraints) {
         };
       }
       resolveCondition({
+        tokens,
         startToken: field.token,
         startIndex: field.index,
         endToken: value.token ?? comparisonOperation?.token ?? field.token,
@@ -699,23 +727,24 @@ function _parse(tokens, _offset, constraints) {
     }
   }
   resolveCondition({
+    tokens,
     startToken: field?.token,
     startIndex: field?.index,
     endToken: value?.token ?? comparisonOperation?.token ?? field?.token,
     endIndex: value?.index ?? comparisonOperation?.index ?? field?.index
   });
   if (inConjunction)
-    throw new ParseError("Dangling junction operator", tokens.at(-1), _offset + tokens.length - 1);
+    throw new ParseError("Dangling junction operator", tokens, tokens.at(-1), _offset + tokens.length - 1);
   if (groupOperation) {
     if (expressions.length === 1)
-      throw new ParseError("Dangling junction operator", tokens.at(-1), _offset + tokens.length - 1);
+      throw new ParseError("Dangling junction operator", tokens, tokens.at(-1), _offset + tokens.length - 1);
     return {
       type: "group",
       operation: groupOperation,
       constituents: expressions
     };
   } else if (expressions.length > 1)
-    throw new ParseError("Group possesses multiple conditions without disjunctive operators", tokens[0], _offset);
+    throw new ParseError("Group possesses multiple conditions without disjunctive operators", tokens, tokens[0], _offset);
   else
     return expressions[0] ?? null;
 }
@@ -815,6 +844,10 @@ function summarize(expressions) {
   return summary;
 }
 // src/stringify.ts
+var DEFAULT_BRACKET = BRACKETS[0];
+var DEFAULT_PAREN = PARENS[0];
+var DEFAULT_NEGATOR = NEGATORS[0];
+var DEFAULT_DELIMITER = ARRAY_DELIMITERS[0];
 var formats = {
   programmatic: {
     AND: "&",
@@ -883,16 +916,16 @@ function stringify(expression, opts = {}) {
             string += " ";
         }
         if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
-          string += "(";
+          string += DEFAULT_PAREN[0];
         string += stringify(constituent, opts);
         if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
-          string += ")";
+          string += DEFAULT_PAREN[1];
       }
       break;
     case "condition":
       if (condenseBooleans && ["EQUAL", "NOTEQUAL"].includes(expression.operation) && typeof expression.value === "boolean") {
         const negative = expression.operation === "EQUAL" && !expression.value || expression.operation === "NOTEQUAL" && expression.value;
-        string += `${negative ? "!" : ""}${expression.field}`;
+        string += `${negative ? DEFAULT_NEGATOR : ""}${expression.field}`;
       } else {
         string += expression.field;
         if (!compact || comparisonNotation === "linguistic")
@@ -901,8 +934,8 @@ function stringify(expression, opts = {}) {
         if (!compact || comparisonNotation === "linguistic")
           string += " ";
         if (Array.isArray(expression.value)) {
-          const join = expression.value.map(addQuotesIfNecessary).join(compact ? "," : ", ");
-          string += `[${join}]`;
+          const join = expression.value.map(addQuotesIfNecessary).join(compact ? DEFAULT_DELIMITER : DEFAULT_DELIMITER + " ");
+          string += `${DEFAULT_BRACKET[0]}${join}${DEFAULT_BRACKET[1]}`;
         } else
           string += addQuotesIfNecessary(expression.value);
       }
@@ -982,17 +1015,17 @@ function createDOMInput({ input, constraints, onUpdate, parseOnInitialize }) {
         element.toggleAttribute("data-quoted", true);
       if (!isNaN(Number(token.content)))
         element.toggleAttribute("data-number", true);
-      if (["(", ")", "[", "]", "{", "}"].includes(token.content)) {
-        if (inArray === "[" && token.content === "]" || inArray === "{" && token.content === "}")
+      if (PARENS.concat(BRACKETS).some((entry) => entry.includes(token.content))) {
+        if (inArray && BRACKETS.some(([o, c]) => inArray === o && token.content === c))
           inArray = undefined;
         if (!inArray)
           element.setAttribute("data-bracket", token.content);
-        if (!inArray && ["[", "{"].includes(token.content))
+        if (!inArray && BRACKETS.some(([o]) => o === token.content))
           inArray = token.content;
       }
-      if (inArray && token.content === ",")
+      if (inArray && ARRAY_DELIMITERS.includes(token.content))
         element.toggleAttribute("data-delimiter", true);
-      if (!inArray && token.content === "!")
+      if (!inArray && NEGATORS.includes(token.content))
         element.toggleAttribute("data-negation", true);
       if (!inArray && token.content in OPERATION_ALIAS_DICTIONARY) {
         element.setAttribute("data-operation", OPERATION_PURPOSE_DICTIONARY[OPERATION_ALIAS_DICTIONARY[token.content]]);

package/dist/parse.d.ts

@@ -17,7 +17,7 @@ export interface ExpressionConstraints<T extends TypeRecord, V extends boolean>
      * By default allow any value and restrict a collection of values by passing ['deny', VALUES[]]\
      * By default restrict any value and allow a collection of values by passing ['allow', VALUES[]]\
      * If the query value is of array type, it will check all entries of the array and ensure they're all allowed.\
-     * This check runs before type coercsion so the value checked will always be a string.
+     * This check runs before type coercion so the value checked will always be a string. However, quotes and escapes WILL be removed
      */
     restricted?: Partial<Record<keyof T | (string & {}), boolean | ['allow' | 'deny', Array<string | RegExp>]>>;
     /**

package/dist/spec.d.ts

@@ -1,3 +1,8 @@
+export declare const QUOTES: string[];
+export declare const BRACKETS: Array<[open: string, close: string]>;
+export declare const PARENS: Array<[open: string, close: string]>;
+export declare const NEGATORS: string[];
+export declare const ARRAY_DELIMITERS: string[];
 /** All available operation aliases (alias -> operation) */
 export declare const OPERATION_ALIAS_DICTIONARY: {
     readonly AND: "AND";

package/dist/stringify.d.ts

@@ -1,4 +1,4 @@
-import type { Expression } from './spec';
+import { type Expression } from './spec';
 export interface StringifyOptions {
     /**
      * The notation to use for junction operations

package/package.json

@@ -6,7 +6,7 @@
   },
   "homepage": "https://github.com/guidance-analytics/wizard-ql",
   "description": "WizardQL is a natural-language-like query language for constructing data queries for resources that meet conditions.",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/guidance-analytics/wizard-ql.git"