@witchcraft/expressit 0.0.2

package/dist/methods/evaluate.d.ts

@@ -0,0 +1,11 @@
+import { Condition } from "../ast/classes/Condition.js";
+import { Expression } from "../ast/classes/Expression.js";
+export declare class EvaluateMixin<T extends {}> {
+    /**
+     * Evaluates a {@link Parser.normalize normalized} ast.
+     *
+     * How the ast is evaluated for different operators can be controlled by the {@link ParserOptions.valueComparer valueComparer} option.
+     */
+    evaluate(ast: Expression<any, any> | Condition<any, any>, context: Record<string, any>): boolean;
+}
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/methods/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/methods/evaluate.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAKzD,qBAAa,aAAa,CAAC,CAAC,SAAS,EAAE;IACtC;;;;OAIG;IACH,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO;CAsBhG"}

package/dist/methods/evaluate.js

@@ -0,0 +1,30 @@
+import { get, unreachable } from "@alanscodelog/utils";
+import { Condition } from "../ast/classes/Condition.js";
+import { Expression } from "../ast/classes/Expression.js";
+import { TOKEN_TYPE } from "../types/ast.js";
+class EvaluateMixin {
+  /**
+   * Evaluates a {@link Parser.normalize normalized} ast.
+   *
+   * How the ast is evaluated for different operators can be controlled by the {@link ParserOptions.valueComparer valueComparer} option.
+   */
+  evaluate(ast, context) {
+    this._checkEvaluationOptions();
+    const opts = this.options;
+    const self_ = this;
+    if (ast instanceof Condition) {
+      const contextValue = get(context, ast.property);
+      const res = opts.valueComparer({ property: ast.property, value: ast.value, operator: ast.operator }, contextValue, context);
+      return ast.negate ? !res : res;
+    }
+    if (ast instanceof Expression) {
+      const left = self_.evaluate(ast.left, context);
+      const right = self_.evaluate(ast.right, context);
+      return ast.operator === TOKEN_TYPE.AND ? left && right : left || right;
+    }
+    return unreachable();
+  }
+}
+export {
+  EvaluateMixin
+};

package/dist/methods/getBestIndex.d.ts

@@ -0,0 +1,19 @@
+export declare class GetBestIndexesMixin {
+    /**
+     * Given the set of indexes returned by {@link getBestIndex}, the set of existing indexes in a database, and the index to sort by\*, will return a list of the best/shortest sets of indexes.
+     *
+     * For example, given the query `a && b && c`, `getBestIndex` will return `[Set(a), Set(b)]`.
+     *
+     * Suppose we have indexes on all the variables and that the user wants to sort by `c`, this function will return [`Set(c)`].
+     *
+     * Suppose instead we have indexes only on `a` and `b` and that the user wants to sort by `c`, this function will return [`Set(a), Set(b)`]. Either can be picked by some other criteria (e.g. size of the indexes). Sort should then be done in memory.
+     *
+     * And then finally, if we have no existing indexes on any of the variables, the function will return `[]`.
+     *
+     * Note: This is a simple algorithm and is not designed to take into account instances where entries are indexed by two or more properties as their keys (i.e. multicolumn indexes).
+     *
+     * \* If the sort index is not in the list of existing indexes it is not taken into account.
+     */
+    getBestIndexes(indexes: Set<string>[], existing: Set<string> | Map<string, number>, sortIndex?: string): Set<string>[];
+}
+//# sourceMappingURL=getBestIndex.d.ts.map

package/dist/methods/getBestIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBestIndex.d.ts","sourceRoot":"","sources":["../../src/methods/getBestIndex.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAmB;IAC/B;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAE,MAAW,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE;CAmC1H"}

package/dist/methods/getBestIndex.js

@@ -0,0 +1,53 @@
+class GetBestIndexesMixin {
+  /**
+   * Given the set of indexes returned by {@link getBestIndex}, the set of existing indexes in a database, and the index to sort by\*, will return a list of the best/shortest sets of indexes.
+   *
+   * For example, given the query `a && b && c`, `getBestIndex` will return `[Set(a), Set(b)]`.
+   *
+   * Suppose we have indexes on all the variables and that the user wants to sort by `c`, this function will return [`Set(c)`].
+   *
+   * Suppose instead we have indexes only on `a` and `b` and that the user wants to sort by `c`, this function will return [`Set(a), Set(b)`]. Either can be picked by some other criteria (e.g. size of the indexes). Sort should then be done in memory.
+   *
+   * And then finally, if we have no existing indexes on any of the variables, the function will return `[]`.
+   *
+   * Note: This is a simple algorithm and is not designed to take into account instances where entries are indexed by two or more properties as their keys (i.e. multicolumn indexes).
+   *
+   * \* If the sort index is not in the list of existing indexes it is not taken into account.
+   */
+  getBestIndexes(indexes, existing, sortIndex = "") {
+    indexes = indexes.filter((set) => {
+      for (const key of set) {
+        if (!existing.has(key))
+          return false;
+      }
+      return true;
+    });
+    let finalIndexes = indexes;
+    if (existing.has(sortIndex)) {
+      const indexesWithSortIndex = indexes.filter((set) => set.has(sortIndex));
+      if (indexesWithSortIndex.length > 0)
+        finalIndexes = indexesWithSortIndex;
+    }
+    let smallest = Infinity;
+    if (existing instanceof Map) {
+      const scores = /* @__PURE__ */ new Map();
+      for (const set of finalIndexes) {
+        let score = 0;
+        for (const key of set) {
+          score += existing.get(key) ?? 0;
+        }
+        scores.set(set, score);
+        smallest = score < smallest ? score : smallest;
+      }
+      return indexes.filter((set) => smallest === Infinity || scores.get(set) === smallest);
+    } else {
+      for (const set of finalIndexes) {
+        smallest = set.size < smallest ? set.size : smallest;
+      }
+      return indexes.filter((set) => smallest === Infinity || set.size === smallest);
+    }
+  }
+}
+export {
+  GetBestIndexesMixin
+};

package/dist/methods/getIndexes.d.ts

@@ -0,0 +1,17 @@
+import { Condition } from "../ast/classes/Condition.js";
+import { Expression } from "../ast/classes/Expression.js";
+export declare class GetIndexMixin<T> {
+    /**
+     * Returns a list of the different sets of keys that need to be indexed to run a normalized query on a database and hit an existing index.
+     *
+     * For example, the expression `a || b` requires both `a` AND `b` be indexed to use an index. The function would return `[Set(a, b)]`.
+     *
+     * On the otherhand, the expression `a && b` only requires `a` OR `b` to be indexed (`[Set(a), Set(b)]`) If at least one is indexed, the rest of the filtering can be done in memory. There is no need to in memory filter the entire database.
+     *
+     * Now take a more complicated query like `(a && b) || (a && c)`. This only requires `a` be indexed, or both `b` AND `c`. (`[Set(a)], [Set(b), Set(c)]`).
+     *
+     * Queries like `(a || b) && (a || c)` would require all the variables to be indexed `[Set(a), Set(b), Set(c)]`.
+     */
+    getIndexes(ast: Condition | Expression): Set<string>[];
+}
+//# sourceMappingURL=getIndexes.d.ts.map

package/dist/methods/getIndexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getIndexes.d.ts","sourceRoot":"","sources":["../../src/methods/getIndexes.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAIzD,qBAAa,aAAa,CAAC,CAAC;IAC3B;;;;;;;;;;OAUG;IACH,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE;CAqEtD"}

package/dist/methods/getIndexes.js

@@ -0,0 +1,97 @@
+import { unreachable } from "@alanscodelog/utils";
+import { Condition } from "../ast/classes/Condition.js";
+import { Expression } from "../ast/classes/Expression.js";
+import { TOKEN_TYPE } from "../types/ast.js";
+class GetIndexMixin {
+  /**
+   * Returns a list of the different sets of keys that need to be indexed to run a normalized query on a database and hit an existing index.
+   *
+   * For example, the expression `a || b` requires both `a` AND `b` be indexed to use an index. The function would return `[Set(a, b)]`.
+   *
+   * On the otherhand, the expression `a && b` only requires `a` OR `b` to be indexed (`[Set(a), Set(b)]`) If at least one is indexed, the rest of the filtering can be done in memory. There is no need to in memory filter the entire database.
+   *
+   * Now take a more complicated query like `(a && b) || (a && c)`. This only requires `a` be indexed, or both `b` AND `c`. (`[Set(a)], [Set(b), Set(c)]`).
+   *
+   * Queries like `(a || b) && (a || c)` would require all the variables to be indexed `[Set(a), Set(b), Set(c)]`.
+   */
+  getIndexes(ast) {
+    const self_ = this;
+    if (ast instanceof Condition) {
+      return [new Set(ast.property.join("."))];
+    }
+    if (ast instanceof Expression) {
+      const left = self_.getIndexes(ast.left);
+      const right = self_.getIndexes(ast.right);
+      if (ast.operator === TOKEN_TYPE.AND) {
+        const sets = [];
+        const allKeys = /* @__PURE__ */ new Set();
+        for (const leftSet of left) {
+          const exists = sets.find((set) => isEqualSet(set, leftSet));
+          if (exists)
+            continue;
+          sets.push(leftSet);
+          for (const key of leftSet) {
+            allKeys.add(key);
+          }
+        }
+        for (const rightSet of right) {
+          const exists = sets.find((set) => isEqualSet(set, rightSet));
+          if (exists)
+            continue;
+          sets.push(rightSet);
+          for (const key of rightSet) {
+            allKeys.add(key);
+          }
+        }
+        const commonKeys = /* @__PURE__ */ new Set();
+        outerCheck:
+          for (const key of allKeys) {
+            for (const set of sets) {
+              if (!set.has(key))
+                continue outerCheck;
+            }
+            commonKeys.add(key);
+          }
+        if (commonKeys.size > 0) {
+          return [commonKeys, allKeys];
+        } else {
+          return sets;
+        }
+      }
+      if (ast.operator === TOKEN_TYPE.OR) {
+        for (const rightSet of right) {
+          for (const leftSet of left) {
+            if (isEqualSet(leftSet, rightSet)) {
+              return [rightSet];
+            }
+          }
+        }
+        const res = /* @__PURE__ */ new Set();
+        for (const leftSet of left) {
+          for (const key of leftSet) {
+            res.add(key);
+          }
+        }
+        for (const rightSet of right) {
+          for (const key of rightSet) {
+            res.add(key);
+          }
+        }
+        return [res];
+      }
+    }
+    return unreachable();
+  }
+}
+function isEqualSet(setA, setB) {
+  if (setA.size !== setB.size)
+    return false;
+  for (const key of setA) {
+    if (!setB.has(key))
+      return false;
+  }
+  return true;
+}
+export {
+  GetIndexMixin
+};

package/dist/methods/index.d.ts

@@ -0,0 +1,9 @@
+export { AutocompleteMixin } from "./autocomplete.js";
+export { AutoreplaceMixin } from "./autoreplace.js";
+export { Autosuggest } from "./autosuggest.js";
+export { EvaluateMixin } from "./evaluate.js";
+export { GetBestIndexesMixin } from "./getBestIndex.js";
+export { GetIndexMixin } from "./getIndexes.js";
+export { NormalizeMixin } from "./normalize.js";
+export { ValidateMixin } from "./validate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/methods/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/methods/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA"}

package/dist/methods/index.js

@@ -0,0 +1,18 @@
+import { AutocompleteMixin } from "./autocomplete.js";
+import { AutoreplaceMixin } from "./autoreplace.js";
+import { Autosuggest } from "./autosuggest.js";
+import { EvaluateMixin } from "./evaluate.js";
+import { GetBestIndexesMixin } from "./getBestIndex.js";
+import { GetIndexMixin } from "./getIndexes.js";
+import { NormalizeMixin } from "./normalize.js";
+import { ValidateMixin } from "./validate.js";
+export {
+  AutocompleteMixin,
+  AutoreplaceMixin,
+  Autosuggest,
+  EvaluateMixin,
+  GetBestIndexesMixin,
+  GetIndexMixin,
+  NormalizeMixin,
+  ValidateMixin
+};

package/dist/methods/normalize.d.ts

@@ -0,0 +1,12 @@
+import { Condition } from "../ast/classes/Condition.js";
+import { Expression } from "../ast/classes/Expression.js";
+import { type ParserResults } from "../types/ast.js";
+export declare class NormalizeMixin<T extends {}> {
+    /**
+     * Normalizes the ast by applying {@link GroupNode GroupNodes} and converting {@link ConditionNode ConditionNodes} to {@link NormalizedConditionNode NormalizedConditionNodes}.
+     *
+     * To do this, a
+     */
+    normalize<TType extends string, TValue>(ast: ParserResults): Condition<TType, TValue> | Expression<TType, TValue>;
+}
+//# sourceMappingURL=normalize.d.ts.map

package/dist/methods/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/methods/normalize.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAGvD,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAQzD,OAAO,EAAE,KAAK,aAAa,EAAsC,MAAM,iBAAiB,CAAA;AASxF,qBAAa,cAAc,CAAC,CAAC,SAAS,EAAE;IACvC;;;;OAIG;IACH,SAAS,CAAC,KAAK,SAAS,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,aAAa,GAAG,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC;CA4GjH"}

package/dist/methods/normalize.js

@@ -0,0 +1,99 @@
+import { unreachable } from "@alanscodelog/utils";
+import { ArrayNode } from "../ast/classes/ArrayNode.js";
+import { Condition } from "../ast/classes/Condition.js";
+import { ConditionNode } from "../ast/classes/ConditionNode.js";
+import { ErrorToken } from "../ast/classes/ErrorToken.js";
+import { Expression } from "../ast/classes/Expression.js";
+import { ExpressionNode } from "../ast/classes/ExpressionNode.js";
+import { GroupNode } from "../ast/classes/GroupNode.js";
+import { ValidToken } from "../ast/classes/ValidToken.js";
+import { VariableNode } from "../ast/classes/VariableNode.js";
+import { applyBoolean } from "../helpers/general/applyBoolean.js";
+import { applyPrefix } from "../helpers/general/applyPrefix.js";
+import { TOKEN_TYPE } from "../types/ast.js";
+const OPPOSITE = {
+  [TOKEN_TYPE.AND]: TOKEN_TYPE.OR,
+  [TOKEN_TYPE.OR]: TOKEN_TYPE.AND
+};
+class NormalizeMixin {
+  /**
+   * Normalizes the ast by applying {@link GroupNode GroupNodes} and converting {@link ConditionNode ConditionNodes} to {@link NormalizedConditionNode NormalizedConditionNodes}.
+   *
+   * To do this, a
+   */
+  normalize(ast) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    this._checkEvaluationOptions();
+    const opts = this.options;
+    if (ast instanceof ErrorToken || !ast.valid) {
+      throw new Error("AST node must be valid.");
+    }
+    const prefix = arguments[1];
+    const groupValue = arguments[2];
+    let operator = arguments[3];
+    const self_ = this;
+    if (ast instanceof ConditionNode) {
+      if (!(ast.value instanceof GroupNode)) {
+        const isValue = ast.value instanceof ArrayNode || ((_b = (_a = ast.value) == null ? void 0 : _a.quote) == null ? void 0 : _b.left.type) === TOKEN_TYPE.REGEX;
+        let name = ast.property ? unescape(ast.property.value.value) : isValue ? void 0 : unescape((_c = ast.value) == null ? void 0 : _c.value.value);
+        const isNested = operator !== void 0;
+        if (prefix !== void 0 && !isNested) {
+          name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix;
+        }
+        let value;
+        if (isNested) {
+          value = name ?? true;
+          name = prefix;
+        } else {
+          value = ast.value instanceof ArrayNode ? ast.value.values.map((val) => unescape(val.value.value)) : ((_e = (_d = ast.value) == null ? void 0 : _d.quote) == null ? void 0 : _e.left.type) === TOKEN_TYPE.REGEX ? ast.value.value.value : ast.property && ast.value instanceof VariableNode ? unescape(ast.value.value.value) : true;
+        }
+        const propertyKeys = name ? opts.keyParser(name) : [];
+        const boolValue = applyBoolean(groupValue, ast.operator === void 0);
+        const valuePrefix = ast.value instanceof VariableNode && ast.value.prefix ? unescape(ast.value.prefix.value) : void 0;
+        operator ?? (operator = (_f = ast.propertyOperator) == null ? void 0 : _f.value);
+        const isRegex = ((_h = (_g = ast.value) == null ? void 0 : _g.quote) == null ? void 0 : _h.left.type) === TOKEN_TYPE.REGEX;
+        const isQuoted = ((_i = ast.value) == null ? void 0 : _i.quote) !== void 0;
+        const isExpanded = ast.sep !== void 0;
+        const regexFlags = (_l = (_k = (_j = ast.value) == null ? void 0 : _j.quote) == null ? void 0 : _k.flags) == null ? void 0 : _l.value;
+        const query = {
+          value,
+          operator,
+          prefix: valuePrefix,
+          regexFlags,
+          property: propertyKeys,
+          isRegex,
+          isQuoted,
+          isExpanded,
+          isNegated: !boolValue,
+          condition: ast
+        };
+        const res = opts.conditionNormalizer(query);
+        return new Condition({ property: propertyKeys, ...res });
+      } else {
+        let name = unescape(ast.property.value.value);
+        if (prefix !== void 0) {
+          name = applyPrefix(prefix, name, opts.prefixApplier);
+        }
+        const boolValue = applyBoolean(groupValue, ast.operator === void 0);
+        const operator2 = (_m = ast.propertyOperator) == null ? void 0 : _m.value;
+        return self_.normalize(ast.value, name, boolValue, operator2);
+      }
+    }
+    if (ast instanceof GroupNode) {
+      const _prefix = ast.prefix instanceof ConditionNode && ast.prefix.value instanceof VariableNode ? unescape(ast.prefix.value.value.value) : void 0;
+      const _groupValue = ast.prefix instanceof ConditionNode ? ast.prefix.operator === void 0 : !(ast.prefix instanceof ValidToken);
+      const applied = applyPrefix(prefix, _prefix ?? "", opts.prefixApplier);
+      return self_.normalize(ast.expression, applied, applyBoolean(groupValue, _groupValue), operator);
+    }
+    if (ast instanceof ExpressionNode) {
+      const left = self_.normalize(ast.left, prefix, groupValue, operator);
+      const right = self_.normalize(ast.right, prefix, groupValue, operator);
+      const type = groupValue === false ? OPPOSITE[ast.operator.type] : ast.operator.type;
+      return new Expression({ operator: type, left, right });
+    }
+    return unreachable();
+  }
+}
+export {
+  NormalizeMixin
+};

package/dist/methods/validate.d.ts

@@ -0,0 +1,11 @@
+import { type ParserResults, type Position } from "../types/ast.js";
+export declare class ValidateMixin<T extends {}> {
+    /**
+     * Allows pre-validating ASTs for syntax highlighting purposes.
+     * Works similar to evaluate. Internally it will use the prefixApplier, keyParser, and valueValidator (instead of comparer).
+     *
+     * The context does not need to be passed. If it's not passed, the function will not attempt to get the values (so it will not error) and the contextValue param of the valueValidator will be undefined.
+     */
+    validate(ast: ParserResults, context?: Record<string, any>): (Position & T)[];
+}
+//# sourceMappingURL=validate.d.ts.map

package/dist/methods/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/methods/validate.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAc,MAAM,iBAAiB,CAAA;AAI/E,qBAAa,aAAa,CAAC,CAAC,SAAS,EAAE;IACtC;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,QAAQ,GAAG,CAAC,CAAC,EAAE;CAqH7E"}

package/dist/methods/validate.js

@@ -0,0 +1,111 @@
+import { get, isArray } from "@alanscodelog/utils";
+import { ArrayNode } from "../ast/classes/ArrayNode.js";
+import { ConditionNode } from "../ast/classes/ConditionNode.js";
+import { ErrorToken } from "../ast/classes/ErrorToken.js";
+import { ExpressionNode } from "../ast/classes/ExpressionNode.js";
+import { GroupNode } from "../ast/classes/GroupNode.js";
+import { ValidToken } from "../ast/classes/ValidToken.js";
+import { VariableNode } from "../ast/classes/VariableNode.js";
+import { applyBoolean } from "../helpers/general/applyBoolean.js";
+import { applyPrefix } from "../helpers/general/applyPrefix.js";
+import { TOKEN_TYPE } from "../types/ast.js";
+class ValidateMixin {
+  /**
+   * Allows pre-validating ASTs for syntax highlighting purposes.
+   * Works similar to evaluate. Internally it will use the prefixApplier, keyParser, and valueValidator (instead of comparer).
+   *
+   * The context does not need to be passed. If it's not passed, the function will not attempt to get the values (so it will not error) and the contextValue param of the valueValidator will be undefined.
+   */
+  validate(ast, context) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const self = this;
+    self._checkValidationOptions();
+    const opts = self.options;
+    if (ast instanceof ErrorToken || !ast.valid) {
+      throw new Error("AST node must be valid.");
+    }
+    const prefix = arguments[2];
+    const groupValue = arguments[3];
+    const results = arguments[4] ?? [];
+    const prefixes = arguments[5] ?? [];
+    let operator = arguments[6];
+    const self_ = this;
+    if (ast instanceof ConditionNode) {
+      if (!(ast.value instanceof GroupNode)) {
+        const isValue = ast.value instanceof ArrayNode || ((_b = (_a = ast.value) == null ? void 0 : _a.quote) == null ? void 0 : _b.left.type) === TOKEN_TYPE.REGEX;
+        const nameNode = ast.property ? ast.property : isValue ? void 0 : ast.value;
+        let name = nameNode ? unescape(nameNode.value.value) : void 0;
+        const isNested = operator !== void 0;
+        if (prefix !== void 0 && !isNested) {
+          name = name ? applyPrefix(prefix, name, opts.prefixApplier) : prefix;
+        }
+        let value;
+        let propertyNodes = [];
+        if (isNested) {
+          value = name;
+          name = prefix;
+          propertyNodes = [...prefixes];
+        } else {
+          propertyNodes = [...prefixes, ...nameNode ? [nameNode] : []];
+          value = ast.value instanceof ArrayNode ? ast.value.values : ((_d = (_c = ast.value) == null ? void 0 : _c.quote) == null ? void 0 : _d.left.type) === TOKEN_TYPE.REGEX ? ast.value : ast.property && ast.value instanceof VariableNode ? ast.value : true;
+        }
+        const propertyKeys = name ? opts.keyParser(name) : [];
+        const contextValue = context !== void 0 ? get(context, propertyKeys) : void 0;
+        const boolValue = applyBoolean(groupValue, ast.operator === void 0);
+        const valuePrefix = ast.value instanceof VariableNode && ast.value.prefix ? ast.value.prefix : void 0;
+        operator ?? (operator = ast.propertyOperator);
+        const isRegex = ((_f = (_e = ast.value) == null ? void 0 : _e.quote) == null ? void 0 : _f.left.type) === TOKEN_TYPE.REGEX;
+        const isQuoted = ((_g = ast.value) == null ? void 0 : _g.quote) !== void 0;
+        const isExpanded = ast.sep !== void 0;
+        const regexFlags = (_i = (_h = ast.value) == null ? void 0 : _h.quote) == null ? void 0 : _i.flags;
+        const query = {
+          value,
+          operator,
+          prefix: valuePrefix,
+          prefixes,
+          property: propertyNodes,
+          propertyKeys,
+          propertyName: name,
+          regexFlags,
+          isRegex,
+          isNegated: !boolValue,
+          isQuoted,
+          isExpanded,
+          condition: ast
+        };
+        const res = opts.valueValidator(contextValue, query, context);
+        if (res && !isArray(res))
+          throw new Error("The valueValidator must return an array or nothing/undefined");
+        if (res) {
+          for (const entry of res)
+            results.push(entry);
+        }
+      } else {
+        let name = unescape(ast.property.value.value);
+        if (prefix !== void 0) {
+          name = applyPrefix(prefix, name, opts.prefixApplier);
+        }
+        const boolValue = applyBoolean(groupValue, ast.operator === void 0);
+        if (ast.property)
+          prefixes.push(ast.property);
+        const operator2 = ast.propertyOperator;
+        self_.validate(ast.value, context, name, boolValue, results, prefixes, operator2);
+      }
+    }
+    if (ast instanceof GroupNode) {
+      const _prefix = ast.prefix instanceof ConditionNode && ast.prefix.value instanceof VariableNode ? ast.prefix.value : void 0;
+      if (_prefix)
+        prefixes.push(_prefix);
+      const _groupValue = ast.prefix instanceof ConditionNode ? ast.prefix.operator === void 0 : !(ast.prefix instanceof ValidToken);
+      self_.validate(ast.expression, context, applyPrefix(prefix, (_prefix == null ? void 0 : _prefix.value.value) ?? "", opts.prefixApplier), applyBoolean(groupValue, _groupValue), results, prefixes, operator);
+    }
+    if (ast instanceof ExpressionNode) {
+      self_.validate(ast.left, context, prefix, groupValue, results, [...prefixes], operator);
+      self_.validate(ast.right, context, prefix, groupValue, results, [...prefixes], operator);
+    }
+    return results;
+  }
+}
+export {
+  ValidateMixin
+};

package/dist/package.js

@@ -0,0 +1,7 @@
+import pkg from "./package.json.js";
+const version = pkg.version;
+const repository = pkg.repository;
+export {
+  repository,
+  version
+};