wizard-ql 2.1.1 → 4.0.0

package/dist/index.js

@@ -1,87 +1,5 @@
 // src/spec.ts
-var BRACKETS = [
-  ["[", "]"],
-  ["{", "}"]
-];
-var PARENS = [
-  ["(", ")"]
-];
-var NEGATORS = ["!"];
-var ARRAY_DELIMITERS = [","];
-var OPERATION_ALIAS_DICTIONARY = {
-  AND: "AND",
-  "&&": "AND",
-  "&": "AND",
-  "^": "AND",
-  OR: "OR",
-  "||": "OR",
-  "|": "OR",
-  V: "OR",
-  GEQ: "GEQ",
-  ">=": "GEQ",
-  "=>": "GEQ",
-  LEQ: "LEQ",
-  "<=": "LEQ",
-  "=<": "LEQ",
-  NOTEQUALS: "NOTEQUAL",
-  NOTEQUAL: "NOTEQUAL",
-  NEQ: "NOTEQUAL",
-  ISNT: "NOTEQUAL",
-  "!==": "NOTEQUAL",
-  "!=": "NOTEQUAL",
-  EQUALS: "EQUAL",
-  EQUAL: "EQUAL",
-  EQ: "EQUAL",
-  IS: "EQUAL",
-  "==": "EQUAL",
-  "=": "EQUAL",
-  LESS: "LESS",
-  "<": "LESS",
-  GREATER: "GREATER",
-  ">": "GREATER",
-  MORE: "GREATER",
-  NOTIN: "NOTIN",
-  "!:": "NOTIN",
-  IN: "IN",
-  ":": "IN",
-  NOTMATCHES: "NOTMATCH",
-  NOTMATCH: "NOTMATCH",
-  "!~": "NOTMATCH",
-  MATCHES: "MATCH",
-  MATCH: "MATCH",
-  "~": "MATCH"
-};
-var ALIASES = Object.keys(OPERATION_ALIAS_DICTIONARY);
-var OPERATION_PURPOSE_DICTIONARY = {
-  AND: "junction",
-  OR: "junction",
-  EQUAL: "comparison",
-  NOTEQUAL: "comparison",
-  LESS: "comparison",
-  GREATER: "comparison",
-  GEQ: "comparison",
-  LEQ: "comparison",
-  IN: "comparison",
-  NOTIN: "comparison",
-  MATCH: "comparison",
-  NOTMATCH: "comparison"
-};
-var COMPARISON_TYPE_DICTIONARY = {
-  EQUAL: "primitive",
-  NOTEQUAL: "primitive",
-  GEQ: "numeric",
-  GREATER: "numeric",
-  LEQ: "numeric",
-  LESS: "numeric",
-  IN: "array",
-  NOTIN: "array",
-  MATCH: "string",
-  NOTMATCH: "string"
-};
 var TYPE_PRIORITY = ["boolean", "date", "number", "string"];
-// src/regex.ts
-var ESCAPE_REGEX = "(?<=(?<!\\\\)(?:\\\\\\\\)*)";
-
 // src/errors.ts
 function constructHeader(startToken, startIndex, endToken, endIndex) {
   let header = "Token #";
@@ -146,800 +64,1027 @@ 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|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\(|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\)|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\[|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\]|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\{|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\}|(?<=(?<!\\\\)(?:\\\\\\\\)*)\\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) {
-  let trimmed = item.trimEnd();
-  const pretrimLength = trimmed.length;
-  trimmed = trimmed.trimStart();
-  const lengthDiff = trimmed.length - pretrimLength;
-  if (trimmed) {
-    const token = { content: trimmed, index: index - lengthDiff };
-    array.push(token);
-    return token;
-  }
+// src/regex.ts
+var ESCAPE_REGEX = "(?<=(?<!\\\\)(?:\\\\\\\\)*)";
+var NO_ESCAPE_ERROR = new Error("Your JS runtime version does not include RegExp.escape(). Please update or use a polyfill");
+function createQuoteRegexString(quotes) {
+  if (!RegExp.escape)
+    throw NO_ESCAPE_ERROR;
+  return `${ESCAPE_REGEX}(?<quote>${quotes.map((q) => RegExp.escape(q)).join("|")})(?<quotecontent>.*?)${ESCAPE_REGEX}\\k<quote>`;
 }
-function _tokenize(expression, pattern) {
-  const tokens = [];
-  const matches = expression.toUpperCase().matchAll(pattern);
-  let lastMatchEnd = null;
-  for (const match of matches) {
-    pushSanitized(tokens, expression.slice(lastMatchEnd ?? 0, match.index), lastMatchEnd === null ? 0 : lastMatchEnd);
-    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])
-          ++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);
-      for (const subtoken of subtokens)
-        subtoken.index += match.index + 1;
-      tokens.push(...subtokens);
-      if (endToken) {
-        tokens.push(endToken);
-        lastMatchEnd = endToken.index + endToken.content.length;
-      } else {
-        lastMatchEnd = expression.length;
-        break;
-      }
-      continue;
-    } else {
-      pushSanitized(tokens, match.groups?.quotecontent !== undefined ? expression.slice(match.index, match.index + match[0].length) : match[0], match.index);
-    }
-    lastMatchEnd = match.index + match[0].length;
+function createArrayDelimitRegexString(quotes, delimiters) {
+  if (!RegExp.escape)
+    throw NO_ESCAPE_ERROR;
+  return `${createQuoteRegexString(quotes)}|${ESCAPE_REGEX}(?:${delimiters.map((d) => RegExp.escape(d)).join("|")})`;
+}
+function isAlpha(text) {
+  for (let c = 0;c < text.length; ++c) {
+    const char = text.charCodeAt(c);
+    const isUpper = char >= 65 && char <= 90;
+    const isLower = char >= 97 && char <= 122;
+    if (!isUpper && !isLower)
+      return false;
   }
-  pushSanitized(tokens, expression.slice(lastMatchEnd ?? 0), lastMatchEnd ?? 0);
-  return tokens;
+  return true;
 }
-function tokenize(expression) {
-  return _tokenize(expression, TOKEN_REGEX);
+function createTokenRegexString(keywords, quotes) {
+  if (!RegExp.escape)
+    throw NO_ESCAPE_ERROR;
+  const QUOTE_REGEX_STR = createQuoteRegexString(quotes);
+  const tokens = keywords.sort((a, b) => b.length - a.length).map((alias) => {
+    const escaped = RegExp.escape(alias);
+    return isAlpha(alias) ? `(?<=${ESCAPE_REGEX}\\s|^)${escaped}(?=${ESCAPE_REGEX}\\s|$)` : `${ESCAPE_REGEX}${escaped}`;
+  });
+  const full = `${QUOTE_REGEX_STR}|${tokens.join("|")}`;
+  return full;
 }
-function processToken(token) {
-  const unquoted = token.match(QUOTE_EDGE_REGEX)?.groups?.quotecontent;
-  const escaped = unquoted ?? token;
-  const unescaped = escaped.replaceAll(new RegExp(`(?<!${ESCAPE_REGEX}\\\\)\\\\`, "g"), "");
-  return {
-    raw: token,
-    unquoted,
-    escaped,
-    unescaped
+
+// src/parser.ts
+class WizardParser {
+  static DEFAULT_OPERATORS = {
+    AND: {
+      negationName: "OR",
+      type: "productjunction",
+      aliases: ["&&", "&", "^", "∧"],
+      negationAliases: ["||", "|", "V", "∨"]
+    },
+    EQUAL: {
+      negationName: "NOTEQUAL",
+      type: "primitive",
+      aliases: ["EQUALS", "EQ", "IS", "=", "=="],
+      negationAliases: ["NOTEQUALS", "NEQ", "ISNT", "!=", "!==", "≠"]
+    },
+    LESS: {
+      negationName: "GEQ",
+      type: "numeric",
+      aliases: ["<"],
+      negationAliases: [">=", "=>", "≥"],
+      exclusionary: true
+    },
+    GREATER: {
+      negationName: "LEQ",
+      type: "numeric",
+      aliases: [">", "MORE", "MORETHAN"],
+      negationAliases: ["<=", "=<", "≤"],
+      exclusionary: true
+    },
+    IN: {
+      negationName: "NOTIN",
+      type: "array",
+      aliases: [":", "∈"],
+      negationAliases: ["!:", "∉"]
+    },
+    MATCH: {
+      negationName: "NOTMATCH",
+      type: "string",
+      aliases: ["MATCHES", "~", "≅"],
+      negationAliases: ["NOTMATCHES", "!~", "≇"]
+    }
   };
-}
-function getClosingIndex(tokens, start, opening, closing) {
-  let openingCount = 1;
-  for (let index = start + 1;index < tokens.length; ++index) {
-    switch (tokens[index].content) {
-      case opening:
-        ++openingCount;
-        break;
-      case closing:
-        --openingCount;
-        break;
+  static DEFAULT_DIALECTS = {
+    programmatic: {
+      AND: "&",
+      OR: "|",
+      EQUAL: "=",
+      NOTEQUAL: "!=",
+      GEQ: ">=",
+      GREATER: ">",
+      LEQ: "<=",
+      LESS: "<",
+      IN: ":",
+      NOTIN: "!:",
+      MATCH: "~",
+      NOTMATCH: "!~"
+    },
+    linguistic: {
+      AND: "AND",
+      OR: "OR",
+      EQUAL: "EQUALS",
+      NOTEQUAL: "NOTEQUALS",
+      GEQ: "GEQ",
+      GREATER: "GREATER",
+      LEQ: "LEQ",
+      LESS: "LESS",
+      IN: "IN",
+      NOTIN: "NOTIN",
+      MATCH: "MATCHES",
+      NOTMATCH: "NOTMATCHES"
+    },
+    formal: {
+      AND: "∧",
+      OR: "∨",
+      EQUAL: "=",
+      NOTEQUAL: "≠",
+      GEQ: "≥",
+      GREATER: ">",
+      LEQ: "≤",
+      LESS: "<",
+      IN: "∈",
+      NOTIN: "∉",
+      MATCH: "≅",
+      NOTMATCH: "≇"
     }
-    if (openingCount === 0)
-      return index;
-  }
-  return -1;
-}
-function complementExpression(expression) {
-  switch (expression.type) {
-    case "group":
-      switch (expression.operation) {
-        case "AND":
-          expression.operation = "OR";
-          break;
-        case "OR":
-          expression.operation = "AND";
-          break;
-      }
-      expression.constituents.forEach(complementExpression);
-      break;
-    case "condition":
-      switch (expression.operation) {
-        case "EQUAL":
-          expression.operation = "NOTEQUAL";
-          break;
-        case "NOTEQUAL":
-          expression.operation = "EQUAL";
-          break;
-        case "GEQ":
-          expression.operation = "LESS";
-          break;
-        case "LESS":
-          expression.operation = "GEQ";
-          break;
-        case "LEQ":
-          expression.operation = "GREATER";
-          break;
-        case "GREATER":
-          expression.operation = "LEQ";
-          break;
-        case "IN":
-          expression.operation = "NOTIN";
-          break;
-        case "NOTIN":
-          expression.operation = "IN";
-          break;
-        case "MATCH":
-          expression.operation = "NOTMATCH";
-          break;
-        case "NOTMATCH":
-          expression.operation = "MATCH";
-          break;
+  };
+  static DEFAULT_QUOTES = ['"', "'", "`"];
+  static DEFAULT_NEGATORS = ["!"];
+  static DEFAULT_ARRAY_DELIMITERS = [","];
+  static DEFAULT_ARRAY_BRACKETS = [
+    ["[", "]"],
+    ["{", "}"]
+  ];
+  static DEFAULT_GROUP_BRACKETS = [
+    ["(", ")"]
+  ];
+  OPERATOR_DICTIONARY;
+  CONFIG;
+  TOKEN_REGEX;
+  QUOTE_REGEX;
+  QUOTE_EDGE_REGEX;
+  ARRAY_DELIMITER_REGEX;
+  FIELD_LIST;
+  constructor(config = {}) {
+    this.CONFIG = config;
+    if (!config.operators) {
+      config.operators = WizardParser.DEFAULT_OPERATORS;
+      if (config.implicitCondition === undefined) {
+        config.implicitCondition = {
+          operator: "EQUAL",
+          value: "true",
+          asType: "boolean"
+        };
       }
-      break;
-  }
-}
-function coerceType(processedToken, fieldTypes, operatorTypes, dateInterpreter) {
-  const { raw, unescaped } = processedToken;
-  let operatorHits = 0;
-  let fieldHits = 0;
-  for (const type of TYPE_PRIORITY) {
-    const operatorHit = operatorTypes.includes(type);
-    const fieldHit = fieldTypes.includes(type);
-    if (operatorHit)
-      ++operatorHits;
-    if (fieldHit)
-      ++fieldHits;
-    if (!operatorHit || !fieldHit)
-      continue;
-    switch (type) {
-      case "boolean":
-        if (raw === "true")
-          return true;
-        else if (raw === "false")
-          return false;
-        break;
-      case "number": {
-        const num = Number(raw);
-        if (isNaN(num))
-          break;
-        return num;
+      if (!config.dialects)
+        config.dialects = WizardParser.DEFAULT_DIALECTS;
+    }
+    const symbolPool = new Set;
+    config.symbols ??= {};
+    config.symbols.quotes ??= WizardParser.DEFAULT_QUOTES;
+    config.symbols.negators ??= WizardParser.DEFAULT_NEGATORS;
+    config.symbols.arrayDelimiters ??= WizardParser.DEFAULT_ARRAY_DELIMITERS;
+    config.symbols.arrayBrackets ??= WizardParser.DEFAULT_ARRAY_BRACKETS;
+    config.symbols.groupBrackets ??= WizardParser.DEFAULT_GROUP_BRACKETS;
+    for (const [opening, closing] of config.symbols.arrayBrackets) {
+      if (opening === closing)
+        throw Error(`Opening array bracket cannot be the same as closing array bracket ("${opening}")`);
+      if (symbolPool.has(opening))
+        throw Error(`Opening array bracket "${opening}" uses a symbol already defined elsewhere in the parser`);
+      if (symbolPool.has(closing))
+        throw Error(`Closing array bracket "${closing}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(opening);
+      symbolPool.add(closing);
+    }
+    for (const [opening, closing] of config.symbols.groupBrackets) {
+      if (opening === closing)
+        throw Error(`Opening group bracket cannot be the same as closing group bracket ("${opening}")`);
+      if (symbolPool.has(opening))
+        throw Error(`Opening group bracket "${opening}" uses a symbol already defined elsewhere in the parser`);
+      if (symbolPool.has(closing))
+        throw Error(`Closing group bracket "${closing}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(opening);
+      symbolPool.add(closing);
+    }
+    for (const quote of config.symbols.quotes) {
+      if (symbolPool.has(quote))
+        throw Error(`Quote "${quote}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(quote);
+    }
+    this.FIELD_LIST = new Map;
+    if (config.caseInsensitive) {
+      if (config.types) {
+        for (const key in config.types)
+          this.FIELD_LIST.set(key.toLowerCase(), key);
       }
-      case "string":
-        return unescaped;
-      case "date": {
-        const num = Number(raw);
-        const date = dateInterpreter(isNaN(num) ? unescaped : num);
-        if (isNaN(+date))
-          break;
-        return date;
+      if (config.restricted) {
+        for (const key in config.restricted)
+          this.FIELD_LIST.set(key.toLowerCase(), key);
       }
     }
-    if (operatorTypes.includes(type))
-      --operatorHits;
-    if (fieldTypes.includes(type))
-      --fieldHits;
-  }
-  if (!operatorHits)
-    throw new Error("operator");
-  if (!fieldHits)
-    throw new Error("field");
-  throw new Error("operator");
-}
-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?.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 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?.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 (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);
+    this.OPERATOR_DICTIONARY = {};
+    for (const operationName in config.operators) {
+      const operation = config.operators[operationName];
+      for (const symbol of symbolPool) {
+        if (operationName.includes(symbol))
+          throw Error(`Operator "${operationName}" contains symbol "${symbol}"`);
+        if (operation.aliases) {
+          for (const alias of operation.aliases) {
+            if (alias.includes(symbol))
+              throw Error(`Operator "${operationName}" alias "${alias}" contains symbol "${symbol}"`);
           }
-        } else {
-          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);
+        }
+        if (operation.negationName.includes(symbol))
+          throw Error(`Operator "${operation.negationName}" contains symbol "${symbol}"`);
+        if (operation.negationAliases) {
+          for (const alias of operation.negationAliases) {
+            if (alias.includes(symbol))
+              throw Error(`Operator "${operation.negationName}" alias "${alias}" contains symbol "${symbol}"`);
           }
         }
       }
-    } else {
-      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);
+      const opDef = {
+        name: operationName,
+        type: operation.type,
+        negation: operation.negationName,
+        exclusionary: operation.exclusionary ?? false
+      };
+      const negOpDef = {
+        name: operation.negationName,
+        type: operation.type === "sumjunction" ? "productjunction" : operation.type === "productjunction" ? "sumjunction" : operation.type,
+        negation: operationName,
+        exclusionary: !operation.exclusionary
+      };
+      if (operationName in this.OPERATOR_DICTIONARY)
+        throw Error(`Two operator definitions have been supplied with the same name "${operationName}"`);
+      this.OPERATOR_DICTIONARY[opDef.name] = opDef;
+      if (operation.negationName in this.OPERATOR_DICTIONARY)
+        throw Error(`An operator definition shares a negation name with another operator's definition "${operation.negationName}"`);
+      this.OPERATOR_DICTIONARY[negOpDef.name] = negOpDef;
+      if (operation.aliases) {
+        for (const alias of operation.aliases) {
+          if (alias in this.OPERATOR_DICTIONARY)
+            throw Error(`An operator definition has an alias that refers to another operator "${alias}"`);
+          this.OPERATOR_DICTIONARY[alias] = opDef;
         }
       }
+      if (operation.negationAliases) {
+        for (const alias of operation.negationAliases) {
+          if (alias in this.OPERATOR_DICTIONARY)
+            throw Error(`An operator definition has a negation alias that refers to another operator "${alias}"`);
+          this.OPERATOR_DICTIONARY[alias] = negOpDef;
+        }
+      }
+    }
+    for (const negator of config.symbols.negators) {
+      if (symbolPool.has(negator))
+        throw Error(`Negator "${negator}" uses a symbol already defined elsewhere in the parser`);
+      symbolPool.add(negator);
     }
-    validated = true;
+    this.TOKEN_REGEX = new RegExp(createTokenRegexString(Object.keys(this.OPERATOR_DICTIONARY).concat(config.symbols.groupBrackets.flat()).concat(config.symbols.arrayBrackets.flat()).concat(config.symbols.negators).concat(config.symbols.arrayDelimiters), config.symbols.quotes), "g");
+    const quoteRegexStr = createQuoteRegexString(config.symbols.quotes);
+    this.QUOTE_REGEX = new RegExp(quoteRegexStr);
+    this.QUOTE_EDGE_REGEX = new RegExp(`^${quoteRegexStr}$`);
+    this.ARRAY_DELIMITER_REGEX = new RegExp(createArrayDelimitRegexString(config.symbols.quotes, config.symbols.arrayDelimiters), "g");
+    Object.freeze(config);
   }
-  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?.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?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
-  const dateInterpreter = constraints?.dateInterpreter ?? ((v) => new Date(v));
-  for (let i = 0;i < processedValues.length; ++i) {
-    const v = processedValues[i];
-    let opTypes;
-    if (valueIsImplicit)
-      opTypes = ["boolean"];
-    else {
-      switch (operationType) {
-        case "primitive":
-        case "array":
-          opTypes = ["boolean", "number", "string"];
-          if (types?.includes("date"))
-            opTypes.push("date");
-          break;
-        case "numeric":
-          opTypes = ["number"];
-          if (types?.includes("date"))
-            opTypes.push("date");
-          break;
-        case "string":
-          opTypes = ["string"];
-          break;
-      }
+  static pushSanitized(array, item, index) {
+    let trimmed = item.trimEnd();
+    const pretrimLength = trimmed.length;
+    trimmed = trimmed.trimStart();
+    const lengthDiff = trimmed.length - pretrimLength;
+    if (trimmed) {
+      const token = { content: trimmed, index: index - lengthDiff };
+      array.push(token);
+      return token;
     }
-    try {
-      const value = coerceType(v, types ?? opTypes, opTypes, dateInterpreter);
-      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?.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?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+  }
+  interpretDate(v) {
+    if (this.CONFIG.dateInterpreter)
+      return this.CONFIG.dateInterpreter(v);
+    else
+      return new Date(v);
+  }
+  _tokenize(expression, pattern) {
+    const tokens = [];
+    const matches = expression.toUpperCase().matchAll(pattern);
+    let lastMatchEnd = null;
+    for (const match of matches) {
+      WizardParser.pushSanitized(tokens, expression.slice(lastMatchEnd ?? 0, match.index), lastMatchEnd === null ? 0 : lastMatchEnd);
+      if (this.CONFIG.symbols.arrayBrackets.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])
+            ++subopenings;
+          if (this.CONFIG.symbols.arrayBrackets.some(([o, c]) => match[0] === o && submatch[0] === c)) {
+            if (subopenings)
+              --subopenings;
+            else {
+              endToken = {
+                content: submatch[0],
+                index: submatch.index
+              };
+              break;
+            }
+          }
+        }
+        const subtokens = endToken ? this._tokenize(expression.slice(startToken.index + startToken.content.length, endToken.index), this.ARRAY_DELIMITER_REGEX) : this._tokenize(expression.slice(startToken.index + startToken.content.length), pattern);
+        for (const subtoken of subtokens)
+          subtoken.index += match.index + 1;
+        tokens.push(...subtokens);
+        if (endToken) {
+          tokens.push(endToken);
+          lastMatchEnd = endToken.index + endToken.content.length;
+        } else {
+          lastMatchEnd = expression.length;
+          break;
+        }
+        continue;
+      } else {
+        WizardParser.pushSanitized(tokens, match.groups?.quotecontent !== undefined ? expression.slice(match.index, match.index + match[0].length) : match[0], match.index);
       }
+      lastMatchEnd = match.index + match[0].length;
     }
+    WizardParser.pushSanitized(tokens, expression.slice(lastMatchEnd ?? 0), lastMatchEnd ?? 0);
+    return tokens;
   }
-  if (types)
-    validated = true;
-  const edit = condition;
-  edit.field = field;
-  edit.validated = validated;
-  return edit;
-}
-function _parse(tokens, _offset, constraints) {
-  let field;
-  let comparisonOperation;
-  let value;
-  let inConjunction = false;
-  let groupOperation;
-  let expectingExpression = true;
-  const expressions = [];
-  function getExpressionGroup(ctx) {
-    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?.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?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
-      return prior.constituents;
+  tokenize(expression) {
+    return this._tokenize(expression, this.TOKEN_REGEX);
+  }
+  static getClosingIndex(tokens, start, opening, closing) {
+    let openingCount = 1;
+    for (let index = start + 1;index < tokens.length; ++index) {
+      switch (tokens[index].content) {
+        case opening:
+          ++openingCount;
+          break;
+        case closing:
+          --openingCount;
+          break;
+      }
+      if (openingCount === 0)
+        return index;
     }
-    return expressions;
+    return -1;
   }
-  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,
-      endIndex: value?.index ?? comparisonOperation?.index ?? field?.index
+  processToken(token) {
+    const unquoted = token.match(this.QUOTE_EDGE_REGEX)?.groups?.quotecontent;
+    const escaped = unquoted ?? token;
+    const unescaped = escaped.replaceAll(new RegExp(`(?<!${ESCAPE_REGEX}\\\\)\\\\`, "g"), "");
+    return {
+      raw: token,
+      unquoted,
+      escaped,
+      unescaped
     };
-    if (!ctx)
-      ctx = baseCtx;
-    const group = getExpressionGroup(ctx);
-    if (field && comparisonOperation && value) {
-      if (!expectingExpression)
-        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,
-        operation: comparisonOperation.content,
-        value: value.content
-      }, constraints, value.implicit, baseCtx));
-      inConjunction = false;
-      expectingExpression = false;
-    } else if (field && !comparisonOperation && !value) {
-      if (!expectingExpression)
-        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,
-        operation: "EQUAL",
-        value: "true"
-      }, constraints, true, baseCtx));
-      inConjunction = false;
-      expectingExpression = false;
-    } else if (field || comparisonOperation || value !== undefined)
-      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 (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", tokens, token, _offset + t);
-      const closingIndex = getClosingIndex(tokens, t, paren[0], paren[1]);
-      if (closingIndex === -1)
-        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({ tokens, startToken: token, startIndex: _offset + t });
-          group.push(subExpression);
-          inConjunction = false;
+  complementExpression(expression) {
+    const inverse = this.OPERATOR_DICTIONARY[expression.operation].negation;
+    if (!inverse)
+      throw new Error(`Could not find inverse operation given operation name "${expression.operation}"`);
+    expression.operation = inverse;
+    if (expression.type === "group")
+      expression.constituents.forEach((e) => this.complementExpression(e));
+  }
+  coerceType(processedToken, fieldTypes, operatorTypes) {
+    const { raw, unescaped } = processedToken;
+    let operatorHits = 0;
+    let fieldHits = 0;
+    for (const type of TYPE_PRIORITY) {
+      const operatorHit = operatorTypes.includes(type);
+      const fieldHit = fieldTypes.includes(type);
+      if (operatorHit)
+        ++operatorHits;
+      if (fieldHit)
+        ++fieldHits;
+      if (!operatorHit || !fieldHit)
+        continue;
+      switch (type) {
+        case "boolean":
+          if (raw === "true")
+            return true;
+          else if (raw === "false")
+            return false;
+          break;
+        case "number": {
+          const num = Number(raw);
+          if (isNaN(num))
+            break;
+          return num;
+        }
+        case "string":
+          return unescaped;
+        case "date": {
+          const num = Number(raw);
+          const date = this.interpretDate(isNaN(num) ? unescaped : num);
+          if (isNaN(+date))
+            break;
+          return date;
         }
       }
-      t = closingIndex;
-      continue;
+      if (operatorTypes.includes(type))
+        --operatorHits;
+      if (fieldTypes.includes(type))
+        --fieldHits;
     }
-    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,
-        endIndex: _offset + t
-      });
-      const prior = expressions.at(-1);
-      if (!prior)
-        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", 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", tokens, token, _offset + t);
-            return {
-              type: "group",
-              operation: "OR",
-              constituents: [
-                {
-                  type: "group",
-                  operation: "AND",
-                  constituents: expressions
-                },
-                futureSubgroup
-              ]
-            };
+    if (!operatorHits)
+      throw new Error("operator");
+    if (!fieldHits)
+      throw new Error("field");
+    throw new Error("disagreement");
+  }
+  validateCondition(condition, valueIsImplicit, ctx) {
+    let validated = false;
+    condition.field = this.processToken(condition.field).unescaped;
+    const field = this.CONFIG.caseInsensitive ? this.FIELD_LIST.get(condition.field.toLowerCase()) ?? condition.field : condition.field;
+    const restriction = this.CONFIG.restricted?.[field];
+    const fieldType = this.CONFIG.types?.[field];
+    if (this.CONFIG.disallowUnvalidated && restriction === undefined && fieldType === undefined)
+      throw new ConstraintError(`Unknown field "${condition.field}"`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+    const fieldTypes = fieldType && (Array.isArray(fieldType) ? fieldType : [fieldType]);
+    const operationType = this.OPERATOR_DICTIONARY[condition.operation].type;
+    const processedValues = (Array.isArray(condition.value) ? condition.value : [condition.value]).map((v) => this.processToken(v));
+    if (restriction === true)
+      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 (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 (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 { 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);
           }
-          case "OR":
-            inConjunction = true;
-            if (prior.type === "group" && prior.operation === "AND")
-              continue;
-            expressions.splice(-1, 1);
-            expressions.push({
-              type: "group",
-              operation: "AND",
-              constituents: [
-                prior
-              ]
-            });
-            continue;
         }
       }
-      groupOperation = op;
-      if (expressions.length === 1 && expressions[0]?.type === "group" && expressions[0].operation === groupOperation) {
-        const exp = expressions[0];
-        expressions.splice(0, 1);
-        expressions.push(...exp.constituents);
+      validated = true;
+    }
+    if (operationType === "array" && !Array.isArray(condition.value))
+      throw new ConstraintError(`Value "${condition.value}" 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?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+    for (let i = 0;i < processedValues.length; ++i) {
+      const v = processedValues[i];
+      let opTypes;
+      if (valueIsImplicit) {
+        const implicitTypes = this.CONFIG.implicitCondition.asType;
+        opTypes = Array.isArray(implicitTypes) ? implicitTypes : [implicitTypes];
+      } else {
+        switch (operationType) {
+          case "primitive":
+          case "array":
+            opTypes = ["boolean", "number", "string"];
+            if (fieldTypes?.includes("date"))
+              opTypes.push("date");
+            break;
+          case "number":
+            opTypes = ["number"];
+            break;
+          case "date":
+            opTypes = ["date"];
+            break;
+          case "boolean":
+            opTypes = ["boolean"];
+            break;
+          case "numeric":
+            opTypes = ["number"];
+            if (fieldTypes?.includes("date"))
+              opTypes.push("date");
+            break;
+          case "string":
+            opTypes = ["string"];
+            break;
+        }
+      }
+      try {
+        const value = this.coerceType(v, fieldTypes ?? opTypes, opTypes);
+        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?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+          case "field":
+            throw new ConstraintError(`Value "${condition.value.toString()}" only has types not permitted for field "${condition.field}". Allowed types: ${(fieldTypes ?? opTypes).join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+          case "disagreement":
+            throw new ConstraintError(`Value "${condition.value.toString()}" using operation "${condition.operation}" cannot be coerced into a valid type for "${condition.field}". Allowed field types: ${(fieldTypes ?? ["ALL"]).join(", ")}; Allowed operator types: ${opTypes.join(", ")}`, ctx?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+        }
       }
-      continue;
     }
-    if (NEGATORS.includes(token.content)) {
-      const nextToken = tokens[t + 1];
-      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, nextParen[0], nextParen[1]);
+    if (fieldTypes)
+      validated = true;
+    const edit = condition;
+    edit.field = field;
+    edit.validated = validated;
+    return edit;
+  }
+  _parse(tokens, _offset) {
+    let field;
+    let comparisonOperation;
+    let value;
+    let inConjunction = false;
+    let activeGroupOperation;
+    let expectingExpression = true;
+    const expressions = [];
+    const getExpressionGroup = (ctx) => {
+      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?.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?.tokens, ctx?.startToken, ctx?.startIndex, ctx?.endToken, ctx?.endIndex);
+        return prior.constituents;
+      }
+      return expressions;
+    };
+    const 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,
+        endIndex: value?.index ?? comparisonOperation?.index ?? field?.index
+      };
+      if (!ctx)
+        ctx = baseCtx;
+      const group = getExpressionGroup(ctx);
+      if (field && comparisonOperation && value) {
+        if (!expectingExpression)
+          throw new ParseError("Unexpected expression resolution before junctive operator", ctx.tokens, ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
+        group.push(this.validateCondition({
+          type: "condition",
+          field: field.content,
+          operation: comparisonOperation.content,
+          value: value.content
+        }, value.implicit, baseCtx));
+        inConjunction = false;
+        expectingExpression = false;
+      } else if (field && !comparisonOperation && !value) {
+        if (!expectingExpression)
+          throw new ParseError("Unexpected expression resolution before junctive operator", ctx.tokens, ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
+        if (this.CONFIG.implicitCondition) {
+          group.push(this.validateCondition({
+            type: "condition",
+            field: field.content,
+            operation: this.CONFIG.implicitCondition.operator,
+            value: this.CONFIG.implicitCondition.value
+          }, true, baseCtx));
+          inConjunction = false;
+          expectingExpression = false;
+        } else
+          throw new ParseError("Failed to resolve condition; missing operand or operator (No implicit condition is configured)", ctx.tokens, ctx.startToken, ctx.startIndex, ctx.endToken, ctx.endIndex);
+      } else if (field || comparisonOperation || value !== undefined)
+        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 (this.CONFIG.symbols.groupBrackets.some(([, c]) => token.content === c))
+        throw new ParseError("Unexpected closing parenthesis", tokens, token, _offset + t);
+      if (this.CONFIG.symbols.arrayBrackets.some(([, c]) => token.content === c))
+        throw new ParseError("Unexpected closing bracket/brace", tokens, token, _offset + t);
+      const paren = this.CONFIG.symbols.groupBrackets.find(([o]) => token.content === o);
+      if (paren) {
+        if (field || comparisonOperation || value)
+          throw new ParseError("Tried to open a group during an operation", tokens, token, _offset + t);
+        const closingIndex = WizardParser.getClosingIndex(tokens, t, paren[0], paren[1]);
         if (closingIndex === -1)
           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) {
-          complementExpression(futureSubExpression);
-          if (futureSubExpression.type === "group" && futureSubExpression.operation === groupOperation)
-            expressions.push(...futureSubExpression.constituents);
+        const subExpression = this._parse(tokens.slice(t, closingIndex), _offset + t);
+        if (subExpression) {
+          if (subExpression.type === "group" && subExpression.operation === activeGroupOperation)
+            expressions.push(...subExpression.constituents);
           else {
-            const group = getExpressionGroup({
-              tokens,
-              startToken: token,
-              startIndex: _offset + t,
-              endToken: tokens[closingIndex],
-              endIndex: closingIndex
-            });
-            group.push(futureSubExpression);
+            const group = getExpressionGroup({ tokens, startToken: token, startIndex: _offset + t });
+            group.push(subExpression);
             inConjunction = false;
           }
         }
         t = closingIndex;
         continue;
       }
-    }
-    if (!comparisonOperation || op && OPERATION_PURPOSE_DICTIONARY[op] === "comparison") {
-      if (op && OPERATION_PURPOSE_DICTIONARY[op] === "comparison") {
-        if (comparisonOperation || !field)
-          throw new ParseError("Unexpected comparison operator", tokens, field?.token ?? token, field?.index ?? _offset + t, token, _offset + t);
-        comparisonOperation = {
-          content: op,
-          token,
-          index: _offset + t
-        };
-        continue;
-      } else if (field)
-        throw new ParseError("Expected a comparison operator", tokens, field.token, field.index, token, _offset + t);
-    }
-    if (!field) {
-      if (NEGATORS.includes(token.content)) {
-        const nextToken = tokens[t + 1];
-        if (!nextToken)
-          throw new ParseError('Unexpected "!"', tokens, token, _offset + t);
+      const op = this.OPERATOR_DICTIONARY[token.content];
+      if (op?.type === "sumjunction" || op?.type === "productjunction") {
         resolveCondition({
           tokens,
-          startToken: token,
-          startIndex: _offset + t,
-          endToken: nextToken,
-          endIndex: _offset + t + 1
+          startToken: field?.token ?? token,
+          startIndex: field?.index ?? _offset + t,
+          endToken: token,
+          endIndex: _offset + t
         });
-        ++t;
-        field = {
-          content: nextToken.content,
-          token,
-          index: _offset + t
-        };
-        comparisonOperation = {
-          content: "EQUAL"
-        };
-        value = {
-          content: "false",
-          implicit: true
-        };
+        const prior = expressions.at(-1);
+        if (!prior)
+          throw new ParseError("Unexpected junction operator with no preceding expression", tokens, token, _offset + t);
+        expectingExpression = true;
+        if (activeGroupOperation && activeGroupOperation !== op.name) {
+          if (expressions.length < 2)
+            throw new ParseError("Unexpected junction operator with no preceding expression", tokens, token, _offset + t);
+          const activeGroupOperationType = this.OPERATOR_DICTIONARY[activeGroupOperation].type;
+          if (activeGroupOperationType === op.type)
+            throw new ParseError("Mixed two junction operators of the same precedence level. Unclear how to separate without grouping", tokens, token, _offset + t);
+          switch (op.type) {
+            case "productjunction": {
+              inConjunction = true;
+              if (prior.type === "group" && this.OPERATOR_DICTIONARY[prior.operation].type === "productjunction")
+                continue;
+              expressions.splice(-1, 1);
+              expressions.push({
+                type: "group",
+                operation: op.name,
+                constituents: [
+                  prior
+                ]
+              });
+              continue;
+            }
+            case "sumjunction": {
+              const futureSubgroup = this._parse(tokens.slice(t + 1), _offset + t);
+              if (futureSubgroup === null)
+                throw new ParseError("Dangling junction operator", tokens, token, _offset + t);
+              return {
+                type: "group",
+                operation: op.name,
+                constituents: [
+                  {
+                    type: "group",
+                    operation: activeGroupOperation,
+                    constituents: expressions
+                  },
+                  futureSubgroup
+                ]
+              };
+            }
+          }
+        }
+        activeGroupOperation = op.name;
+        if (expressions.length === 1 && expressions[0]?.type === "group" && expressions[0].operation === activeGroupOperation) {
+          const exp = expressions[0];
+          expressions.splice(0, 1);
+          expressions.push(...exp.constituents);
+        }
+        continue;
+      }
+      if (this.CONFIG.symbols.negators.includes(token.content)) {
+        const nextToken = tokens[t + 1];
+        const nextParen = this.CONFIG.symbols.groupBrackets.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 = WizardParser.getClosingIndex(tokens, t, nextParen[0], nextParen[1]);
+          if (closingIndex === -1)
+            throw new ParseError("Missing closing parenthesis for group", tokens, token, _offset + t);
+          ++t;
+          const futureSubExpression = this._parse(tokens.slice(t, closingIndex), _offset + t);
+          if (futureSubExpression) {
+            this.complementExpression(futureSubExpression);
+            if (futureSubExpression.type === "group" && futureSubExpression.operation === activeGroupOperation)
+              expressions.push(...futureSubExpression.constituents);
+            else {
+              const group = getExpressionGroup({
+                tokens,
+                startToken: token,
+                startIndex: _offset + t,
+                endToken: tokens[closingIndex],
+                endIndex: closingIndex
+              });
+              group.push(futureSubExpression);
+              inConjunction = false;
+            }
+          }
+          t = closingIndex;
+          continue;
+        }
+      }
+      if (!comparisonOperation || op) {
+        if (op) {
+          if (comparisonOperation || !field)
+            throw new ParseError("Unexpected comparison operator", tokens, field?.token ?? token, field?.index ?? _offset + t, token, _offset + t);
+          comparisonOperation = {
+            content: op.name,
+            token,
+            index: _offset + t
+          };
+          continue;
+        } else if (field)
+          throw new ParseError("Expected a comparison operator", tokens, field.token, field.index, token, _offset + t);
+      }
+      if (!field) {
+        if (this.CONFIG.symbols.negators.includes(token.content)) {
+          if (!this.CONFIG.implicitCondition)
+            throw new ParseError("Could not attempt a negative implicit condition as one is not defined in the config", tokens, token, _offset + t);
+          const nextToken = tokens[t + 1];
+          if (!nextToken)
+            throw new ParseError('Unexpected "!"', tokens, token, _offset + t);
+          resolveCondition({
+            tokens,
+            startToken: token,
+            startIndex: _offset + t,
+            endToken: nextToken,
+            endIndex: _offset + t + 1
+          });
+          ++t;
+          field = {
+            content: nextToken.content,
+            token,
+            index: _offset + t
+          };
+          comparisonOperation = {
+            content: this.OPERATOR_DICTIONARY[this.CONFIG.implicitCondition.operator].negation
+          };
+          value = {
+            content: this.CONFIG.implicitCondition.value,
+            implicit: true
+          };
+          resolveCondition({
+            tokens,
+            startToken: field.token,
+            startIndex: field.index,
+            endToken: nextToken,
+            endIndex: _offset + t
+          });
+        } else {
+          field = {
+            content: token.content,
+            token,
+            index: _offset + t
+          };
+        }
+        continue;
+      }
+      if (!value) {
+        const bracket = this.CONFIG.symbols.arrayBrackets.find(([o]) => token.content === o);
+        if (bracket) {
+          const closingIndex = WizardParser.getClosingIndex(tokens, t, bracket[0], bracket[1]);
+          if (closingIndex === -1)
+            throw new ParseError("Missing closing bracket/brace for array value", tokens, token, _offset + t);
+          ++t;
+          const arr = [];
+          value = {
+            content: arr,
+            token: tokens[closingIndex],
+            index: closingIndex
+          };
+          const arrayContents = tokens.slice(t, closingIndex);
+          let workingEntry = "";
+          let firstEntryToken;
+          let firstEntryTokenIndex;
+          let lastEntryToken;
+          let lastEntryTokenIndex;
+          const resolveEntry = (subtoken, subindex) => {
+            if (workingEntry) {
+              const subquotes = workingEntry.match(this.QUOTE_REGEX);
+              if (subquotes && (subquotes.index !== 0 || subquotes[0].length !== workingEntry.length))
+                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;
+              firstEntryTokenIndex = undefined;
+              lastEntryToken = undefined;
+              lastEntryTokenIndex = undefined;
+            }
+          };
+          for (let ct = 0;ct < arrayContents.length; ++ct) {
+            const contentToken = arrayContents[ct];
+            if (this.CONFIG.symbols.arrayDelimiters.includes(contentToken.content)) {
+              if (!workingEntry)
+                throw new ParseError("Unexpected blank entry in array", tokens, contentToken, _offset + t + ct);
+              resolveEntry(contentToken, _offset + t + ct);
+            } else {
+              lastEntryToken = contentToken;
+              lastEntryTokenIndex = _offset + t + ct;
+              if (!firstEntryToken)
+                firstEntryToken = lastEntryToken;
+              if (!firstEntryTokenIndex)
+                firstEntryTokenIndex = lastEntryTokenIndex;
+              workingEntry += contentToken.content;
+            }
+          }
+          resolveEntry(arrayContents.at(-1), _offset + t + arrayContents.length - 1);
+          if (!arr.length) {
+            throw new ParseError("Empty array provided as value", tokens, token, _offset + t - 1, tokens[closingIndex], _offset + closingIndex);
+          }
+          t = closingIndex;
+        } else {
+          value = {
+            content: token.content,
+            token,
+            index: _offset + t
+          };
+        }
         resolveCondition({
           tokens,
           startToken: field.token,
           startIndex: field.index,
-          endToken: nextToken,
-          endIndex: _offset + t
+          endToken: value.token ?? comparisonOperation?.token ?? field.token,
+          endIndex: value.index ?? comparisonOperation?.index ?? field.index
         });
-      } else {
-        field = {
-          content: token.content,
-          token,
-          index: _offset + t
-        };
       }
-      continue;
     }
-    if (!value) {
-      const bracket = BRACKETS.find(([o]) => token.content === o);
-      if (bracket) {
-        let resolveEntry = function(subtoken, subindex) {
-          if (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", tokens, firstEntryToken ?? subtoken, firstEntryTokenIndex ?? subindex, lastEntryToken ?? subtoken, lastEntryTokenIndex ?? subindex);
-            arr.push(workingEntry);
-            workingEntry = "";
-            firstEntryToken = undefined;
-            firstEntryTokenIndex = undefined;
-            lastEntryToken = undefined;
-            lastEntryTokenIndex = undefined;
-          }
-        };
-        const closingIndex = getClosingIndex(tokens, t, bracket[0], bracket[1]);
-        if (closingIndex === -1)
-          throw new ParseError("Missing closing bracket/brace for array value", tokens, token, _offset + t);
-        ++t;
-        const arr = [];
-        value = {
-          content: arr,
-          token: tokens[closingIndex],
-          index: closingIndex
-        };
-        const arrayContents = tokens.slice(t, closingIndex);
-        let workingEntry = "";
-        let firstEntryToken;
-        let firstEntryTokenIndex;
-        let lastEntryToken;
-        let lastEntryTokenIndex;
-        for (let ct = 0;ct < arrayContents.length; ++ct) {
-          const contentToken = arrayContents[ct];
-          if (ARRAY_DELIMITERS.includes(contentToken.content)) {
-            if (!workingEntry)
-              throw new ParseError("Unexpected blank entry in array", tokens, contentToken, _offset + t + ct);
-            resolveEntry(contentToken, _offset + t + ct);
-          } else {
-            lastEntryToken = contentToken;
-            lastEntryTokenIndex = _offset + t + ct;
-            if (!firstEntryToken)
-              firstEntryToken = lastEntryToken;
-            if (!firstEntryTokenIndex)
-              firstEntryTokenIndex = lastEntryTokenIndex;
-            workingEntry += contentToken.content;
+    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, tokens.at(-1), _offset + tokens.length - 1);
+    if (activeGroupOperation) {
+      if (expressions.length === 1)
+        throw new ParseError("Dangling junction operator", tokens, tokens.at(-1), _offset + tokens.length - 1);
+      return {
+        type: "group",
+        operation: activeGroupOperation,
+        constituents: expressions
+      };
+    } else if (expressions.length > 1)
+      throw new ParseError("Group possesses multiple conditions without disjunctive operators", tokens, tokens[0], _offset);
+    else
+      return expressions[0] ?? null;
+  }
+  parse(expression) {
+    let tokens;
+    if (Array.isArray(expression)) {
+      tokens = [];
+      let type;
+      for (let t = 0;t < expression.length; ++t) {
+        const token = expression[t];
+        if (!type)
+          type = typeof token;
+        if (typeof token !== type)
+          console.warn("WizardQL: parse was called with a mixed array of string tokens and token objects");
+        tokens.push(typeof token === "string" ? { content: token, index: type === "string" ? t : -1 } : token);
+      }
+    } else
+      tokens = this.tokenize(expression);
+    return this._parse(tokens, 0);
+  }
+  addQuotesIfNecessary(value) {
+    if (value instanceof Date) {
+      return this.CONFIG.dateSerializer ? this.CONFIG.dateSerializer(value) : value.toISOString();
+    }
+    if (typeof value !== "string")
+      return value.toString();
+    const QUOTE = this.CONFIG.symbols.quotes[0];
+    if (value === "true")
+      return `${QUOTE}true${QUOTE}`;
+    if (value === "false")
+      return `${QUOTE}false${QUOTE}`;
+    if (!isNaN(Number(value)))
+      return `${QUOTE}${value}${QUOTE}`;
+    const escaped = value.replaceAll("\\", "\\\\");
+    if (new RegExp(this.TOKEN_REGEX, "gi").test(escaped))
+      return `${QUOTE}${escaped.replaceAll(QUOTE, `\\${QUOTE}`)}${QUOTE}`;
+    return escaped;
+  }
+  stringify(expression, opts) {
+    const {
+      dialect,
+      alwaysParenthesize = false,
+      compact = false,
+      condenseImplicit = false
+    } = typeof opts === "string" ? { dialect: opts } : opts;
+    if (!this.CONFIG.dialects)
+      throw new Error("No dialect dictionaries are defined in the config");
+    if (!(dialect in this.CONFIG.dialects))
+      throw new Error(`Dialect '${dialect}' is not defined in the config`);
+    let string = "";
+    switch (expression.type) {
+      case "group":
+        for (const constituent of expression.constituents) {
+          if (string.length) {
+            const transformed = this.CONFIG.dialects[dialect][expression.operation];
+            const alpha = isAlpha(transformed);
+            if (!compact || alpha)
+              string += " ";
+            string += transformed;
+            if (!compact || alpha)
+              string += " ";
           }
+          if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
+            string += this.CONFIG.symbols.groupBrackets[0][0];
+          string += this.stringify(constituent, opts);
+          if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
+            string += this.CONFIG.symbols.groupBrackets[0][1];
         }
-        resolveEntry(arrayContents.at(-1), _offset + t + arrayContents.length - 1);
-        if (!arr.length) {
-          throw new ParseError("Empty array provided as value", tokens, token, _offset + t - 1, tokens[closingIndex], _offset + closingIndex);
-        }
-        t = closingIndex;
-      } else {
-        value = {
-          content: token.content,
-          token,
-          index: _offset + t
+        break;
+      case "condition": {
+        const resolveNonImplicit = () => {
+          const transformed = this.CONFIG.dialects[dialect][expression.operation];
+          const alpha = isAlpha(transformed);
+          string += expression.field.toString();
+          if (!compact || alpha)
+            string += " ";
+          string += transformed;
+          if (!compact || alpha)
+            string += " ";
+          if (Array.isArray(expression.value)) {
+            const join = expression.value.map((v) => this.addQuotesIfNecessary(v)).join(compact ? this.CONFIG.symbols.arrayDelimiters[0] : this.CONFIG.symbols.arrayDelimiters[0] + " ");
+            string += `${this.CONFIG.symbols.arrayBrackets[0][0]}${join}${this.CONFIG.symbols.arrayBrackets[0][1]}`;
+          } else
+            string += this.addQuotesIfNecessary(expression.value);
         };
+        if (condenseImplicit && this.CONFIG.implicitCondition) {
+          const implicitOperator = this.OPERATOR_DICTIONARY[this.CONFIG.implicitCondition.operator];
+          let isNegation = expression.operation === implicitOperator.negation;
+          if (expression.operation === implicitOperator.name || isNegation) {
+            const fieldType = this.CONFIG.types?.[expression.field];
+            const fieldTypes = fieldType && (Array.isArray(fieldType) ? fieldType : [fieldType]);
+            const opTypes = Array.isArray(this.CONFIG.implicitCondition.asType) ? this.CONFIG.implicitCondition.asType : [this.CONFIG.implicitCondition.asType];
+            const processed = this.processToken(this.CONFIG.implicitCondition.value);
+            let coerced;
+            try {
+              coerced = this.coerceType(processed, fieldTypes ?? opTypes, opTypes);
+            } catch {
+              resolveNonImplicit();
+              break;
+            }
+            const bothBoolean = typeof coerced === "boolean" && typeof expression.value === "boolean";
+            if (coerced.valueOf() === expression.value || bothBoolean) {
+              if (bothBoolean && coerced !== expression.value)
+                isNegation = !isNegation;
+              string += `${isNegation ? this.CONFIG.symbols.negators[0] : ""}${expression.field.toString()}`;
+            } else
+              resolveNonImplicit();
+          } else
+            resolveNonImplicit();
+        } else
+          resolveNonImplicit();
+        break;
       }
-      resolveCondition({
-        tokens,
-        startToken: field.token,
-        startIndex: field.index,
-        endToken: value.token ?? comparisonOperation?.token ?? field.token,
-        endIndex: value.index ?? comparisonOperation?.index ?? field.index
-      });
     }
+    return string;
   }
-  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, tokens.at(-1), _offset + tokens.length - 1);
-  if (groupOperation) {
-    if (expressions.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, tokens[0], _offset);
-  else
-    return expressions[0] ?? null;
-}
-function parse(expression, constraints) {
-  let tokens;
-  if (Array.isArray(expression)) {
-    tokens = [];
-    let type;
-    for (let t = 0;t < expression.length; ++t) {
-      const token = expression[t];
-      if (!type)
-        type = typeof token;
-      if (typeof token !== type)
-        console.warn("WizardQL: parse was called with a mixed array of string tokens and token objects");
-      tokens.push(typeof token === "string" ? { content: token, index: type === "string" ? t : -1 } : token);
+  static getOrPutArrayInMap(map, key) {
+    const existingEntry = map.get(key);
+    if (existingEntry)
+      return existingEntry;
+    else {
+      const arr = [];
+      map.set(key, arr);
+      return arr;
     }
-  } else
-    tokens = tokenize(expression);
-  return _parse(tokens, 0, constraints);
-}
-// src/execute.ts
-function executeAsKnex(query, expression) {
-  switch (expression.type) {
-    case "group": {
-      let firstHappened = false;
-      for (const constituent of expression.constituents) {
-        query[firstHappened ? expression.operation === "AND" ? "andWhere" : "orWhere" : "where"]((clause) => executeAsKnex(clause, constituent));
-        firstHappened = true;
+  }
+  summarize(expressions) {
+    const array = Array.isArray(expressions) ? expressions : [expressions];
+    const summary = new Map;
+    for (const expression of array) {
+      if (expression.type === "group") {
+        const constituents = this.summarize(expression.constituents);
+        for (const [field, values] of constituents.entries()) {
+          const collection = WizardParser.getOrPutArrayInMap(summary, field);
+          collection.push(...values);
+        }
+      } else {
+        const collection = WizardParser.getOrPutArrayInMap(summary, expression.field);
+        collection.push({
+          operation: expression.operation,
+          value: expression.value,
+          exclusionary: this.OPERATOR_DICTIONARY[expression.operation].exclusionary
+        });
       }
-      break;
     }
-    case "condition":
-      switch (expression.operation) {
-        case "EQUAL":
-          query.where(expression.field, "=", expression.value);
-          break;
-        case "NOTEQUAL":
-          query.where(expression.field, "!=", expression.value);
-          break;
-        case "GEQ":
-          query.where(expression.field, ">=", expression.value);
-          break;
-        case "LEQ":
-          query.where(expression.field, "<=", expression.value);
-          break;
-        case "GREATER":
-          query.where(expression.field, ">", expression.value);
-          break;
-        case "LESS":
-          query.where(expression.field, "<", expression.value);
-          break;
-        case "IN":
-          query.whereIn(expression.field, expression.value);
-          break;
-        case "NOTIN":
-          query.whereNotIn(expression.field, expression.value);
-          break;
-        case "MATCH":
-          query.whereRaw("?? ~* ?", [expression.field, expression.value]);
-          break;
-        case "NOTMATCH":
-          query.whereRaw("?? !~* ?", [expression.field, expression.value]);
-          break;
-      }
-  }
-}
-// src/summarize.ts
-function getOrPutArrayInMap(map, key) {
-  const existingEntry = map.get(key);
-  if (existingEntry)
-    return existingEntry;
-  else {
-    const arr = [];
-    map.set(key, arr);
-    return arr;
+    return summary;
   }
-}
-function summarize(expressions) {
-  const array = Array.isArray(expressions) ? expressions : [expressions];
-  const summary = new Map;
-  for (const expression of array) {
-    if (expression.type === "group") {
-      const constituents = summarize(expression.constituents);
-      for (const [field, values] of constituents.entries()) {
-        const collection = getOrPutArrayInMap(summary, field);
-        collection.push(...values);
+  getPartType(segment, activeArrayOpeningBracket) {
+    if (segment.match(this.QUOTE_EDGE_REGEX))
+      return "quoted";
+    if (!isNaN(Number(segment)))
+      return "number";
+    for (const [opening, closing] of this.CONFIG.symbols.arrayBrackets) {
+      if (!activeArrayOpeningBracket && segment === opening)
+        return "openingarraybracket";
+      else if (activeArrayOpeningBracket === opening && segment === closing)
+        return "closingarraybracket";
+    }
+    if (!activeArrayOpeningBracket) {
+      for (const [opening, closing] of this.CONFIG.symbols.groupBrackets) {
+        if (segment === opening)
+          return "openinggroupbracket";
+        else if (segment === closing)
+          return "closinggroupbracket";
       }
-    } else {
-      const collection = getOrPutArrayInMap(summary, expression.field);
-      collection.push({
-        operation: expression.operation,
-        value: expression.value,
-        exclusionary: ["NOTEQUAL", "LESS", "GREATER", "NOTIN"].includes(expression.operation)
-      });
     }
+    if (activeArrayOpeningBracket && this.CONFIG.symbols.arrayDelimiters.includes(segment))
+      return "arraydelimiter";
+    if (!activeArrayOpeningBracket && this.CONFIG.symbols.negators.includes(segment))
+      return "negator";
+    if (!activeArrayOpeningBracket && segment in this.OPERATOR_DICTIONARY) {
+      const type = this.OPERATOR_DICTIONARY[segment].type;
+      if (type === "sumjunction" || type === "productjunction")
+        return "junctionoperator";
+      else
+        return "conditionoperator";
+    }
+    return "literal";
   }
-  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: "&",
-    OR: "|",
-    EQUAL: "=",
-    NOTEQUAL: "!=",
-    GEQ: ">=",
-    GREATER: ">",
-    LEQ: "<=",
-    LESS: "<",
-    IN: ":",
-    NOTIN: "!:",
-    MATCH: "~",
-    NOTMATCH: "!~"
-  },
-  linguistic: {
-    AND: "AND",
-    OR: "OR",
-    EQUAL: "EQUALS",
-    NOTEQUAL: "NOTEQUALS",
-    GEQ: "GEQ",
-    GREATER: "GREATER",
-    LEQ: "LEQ",
-    LESS: "LESS",
-    IN: "IN",
-    NOTIN: "NOTIN",
-    MATCH: "MATCHES",
-    NOTMATCH: "NOTMATCHES"
-  },
-  formal: {
-    AND: "^",
-    OR: "V"
+  resolveOperatorAlias(alias) {
+    return this.OPERATOR_DICTIONARY[alias]?.name;
   }
-};
-function addQuotesIfNecessary(value) {
-  if (typeof value !== "string")
-    return value.toString();
-  if (value === "true")
-    return '"true"';
-  if (value === "false")
-    return '"false"';
-  if (!isNaN(Number(value)))
-    return `"${value}"`;
-  const escaped = value.replaceAll("\\", "\\\\");
-  if (new RegExp(TOKEN_REGEX, "gi").test(escaped))
-    return `"${escaped.replaceAll('"', "\\\"")}"`;
-  return escaped;
-}
-function stringify(expression, opts = {}) {
-  const {
-    junctionNotation = "programmatic",
-    comparisonNotation = "programmatic",
-    alwaysParenthesize = false,
-    compact = false,
-    condenseBooleans = false
-  } = opts;
-  let string = "";
-  switch (expression.type) {
-    case "group":
-      for (const constituent of expression.constituents) {
-        if (string.length) {
-          if (!compact || junctionNotation === "linguistic")
-            string += " ";
-          string += formats[junctionNotation][expression.operation];
-          if (!compact || junctionNotation === "linguistic")
-            string += " ";
-        }
-        if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
-          string += DEFAULT_PAREN[0];
-        string += stringify(constituent, opts);
-        if (alwaysParenthesize && constituent.type === "group" || expression.operation === "AND" && constituent.operation === "OR")
-          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 ? DEFAULT_NEGATOR : ""}${expression.field}`;
-      } else {
-        string += expression.field;
-        if (!compact || comparisonNotation === "linguistic")
-          string += " ";
-        string += formats[comparisonNotation][expression.operation];
-        if (!compact || comparisonNotation === "linguistic")
-          string += " ";
-        if (Array.isArray(expression.value)) {
-          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);
-      }
-      break;
-  }
-  return string;
 }
 // src/dominput.ts
 function getCursorIndex(element) {
@@ -973,7 +1118,8 @@ function setCursor(element, index) {
       accumulated += length;
   }
 }
-function createDOMInput({ input, constraints, onUpdate, parseOnInitialize }) {
+function createDOMInput({ input, config, onUpdate, parseOnInitialize }) {
+  const parser = new WizardParser(config);
   const history = [];
   let historyIndex = -1;
   let savedCursor;
@@ -982,13 +1128,13 @@ function createDOMInput({ input, constraints, onUpdate, parseOnInitialize }) {
     const text = input.textContent.replaceAll(`
 `, "");
     const endPadding = input.textContent?.match(/\s*$/)?.[0].length ?? 0;
-    const newTokens = tokenize(text);
+    const newTokens = parser.tokenize(text);
     const lastToken = newTokens.at(-1);
-    if (lastToken && lastToken.content in OPERATION_ALIAS_DICTIONARY && focused && (!endPadding && lastToken.content.match(/^[A-Za-z]+?$/)))
+    if (lastToken && parser.resolveOperatorAlias(lastToken.content) && focused && (!endPadding && lastToken.content.match(/^[A-Za-z]+?$/)))
       return;
     const absoluteIndex = focused ? getCursorIndex(input) : 0;
     observer.disconnect();
-    let inArray;
+    let activeArrayOpeningBracket;
     let offset = 0;
     for (let t = 0;t < newTokens.length; ++t) {
       const token = newTokens[t];
@@ -1009,24 +1155,37 @@ function createDOMInput({ input, constraints, onUpdate, parseOnInitialize }) {
       const element = document.createElement("span");
       element.textContent = token.content;
       element.toggleAttribute("data-node", true);
-      if (token.content.match(QUOTE_EDGE_REGEX))
-        element.toggleAttribute("data-quoted", true);
-      if (!isNaN(Number(token.content)))
-        element.toggleAttribute("data-number", true);
-      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)
+      const partType = parser.getPartType(token.content, activeArrayOpeningBracket);
+      token.partType = partType;
+      switch (partType) {
+        case "quoted":
+          element.toggleAttribute("data-quoted", true);
+          break;
+        case "number":
+          element.toggleAttribute("data-number", true);
+          break;
+        case "openingarraybracket":
+          activeArrayOpeningBracket = token.content;
+        case "openinggroupbracket":
           element.setAttribute("data-bracket", token.content);
-        if (!inArray && BRACKETS.some(([o]) => o === token.content))
-          inArray = token.content;
-      }
-      if (inArray && ARRAY_DELIMITERS.includes(token.content))
-        element.toggleAttribute("data-delimiter", true);
-      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]]);
+          break;
+        case "closingarraybracket":
+          activeArrayOpeningBracket = undefined;
+        case "closinggroupbracket":
+          element.setAttribute("data-bracket", token.content);
+          break;
+        case "arraydelimiter":
+          element.toggleAttribute("data-delimiter", true);
+          break;
+        case "negator":
+          element.toggleAttribute("data-negator", true);
+          break;
+        case "junctionoperator":
+          element.setAttribute("data-operator", "junction");
+          break;
+        case "conditionoperator":
+          element.setAttribute("data-operator", "condition");
+          break;
       }
       const existing = input.childNodes.item(t + offset);
       if (existing)
@@ -1059,7 +1218,7 @@ function createDOMInput({ input, constraints, onUpdate, parseOnInitialize }) {
     }
     let result;
     try {
-      result = parse(newTokens, constraints);
+      result = parser.parse(newTokens);
       input.removeAttribute("data-error-message");
       input.removeAttribute("data-error-start");
       input.removeAttribute("data-error-end");
@@ -1118,16 +1277,9 @@ function createDOMInput({ input, constraints, onUpdate, parseOnInitialize }) {
   };
 }
 export {
-  tokenize,
-  summarize,
-  stringify,
-  parse,
-  executeAsKnex,
   createDOMInput,
-  QUOTE_EDGE_REGEX,
+  WizardParser,
+  TYPE_PRIORITY,
   ParseError,
-  OPERATION_PURPOSE_DICTIONARY,
-  OPERATION_ALIAS_DICTIONARY,
-  ConstraintError,
-  COMPARISON_TYPE_DICTIONARY
+  ConstraintError
 };