@witchcraft/expressit 0.0.2

package/dist/ast/builders/variable.js

@@ -0,0 +1,62 @@
+import { pos } from "./pos.js";
+import { token } from "./token.js";
+import { TOKEN_TYPE } from "../../types/ast.js";
+import { VariableNode } from "../classes/VariableNode.js";
+function variable(prefix, value, quote, position) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (typeof value === "string") {
+    value = token(TOKEN_TYPE.VALUE, value, position);
+  }
+  position = pos(value);
+  const node = {
+    value,
+    prefix
+  };
+  if (quote) {
+    node.quote = {};
+    const quoteLeftPos = (position == null ? void 0 : position.start) !== void 0 ? pos({ start: position.start }, { fill: true }) : void 0;
+    if (quote.left) {
+      if (quoteLeftPos)
+        quoteLeftPos.start -= 1;
+      node.quote.left = token(quote.type, quoteFromType(quote.type), quoteLeftPos);
+    } else {
+      node.quote.left = token(quote.type, void 0, quoteLeftPos);
+    }
+    const quoteRightPos = (position == null ? void 0 : position.end) !== void 0 ? pos({ end: position.end }, { fill: true }) : void 0;
+    if (quote.right) {
+      if (quoteRightPos)
+        quoteRightPos.end += 1;
+      node.quote.right = token(quote.type, quoteFromType(quote.type), quoteRightPos);
+    } else {
+      node.quote.right = token(quote.type, void 0, quoteRightPos);
+    }
+    if (quote.flags) {
+      const start = node.quote.right.end;
+      node.quote.flags = token(TOKEN_TYPE.VALUE, quote.flags, {
+        start,
+        end: start + ((_a = quote.flags) == null ? void 0 : _a.length)
+      });
+    }
+  }
+  node.start = ((_b = node.prefix) == null ? void 0 : _b.start) ?? ((_c = node.quote) == null ? void 0 : _c.left.start) ?? ((_d = node.value) == null ? void 0 : _d.start) ?? ((_e = node.quote) == null ? void 0 : _e.right.start);
+  node.end = ((_g = (_f = node.quote) == null ? void 0 : _f.flags) == null ? void 0 : _g.end) ?? ((_h = node.quote) == null ? void 0 : _h.right.end) ?? ((_i = node.value) == null ? void 0 : _i.end) ?? ((_j = node.quote) == null ? void 0 : _j.left.end);
+  const instance = new VariableNode(node);
+  return instance;
+}
+function quoteFromType(type) {
+  switch (type) {
+    case TOKEN_TYPE.BACKTICK:
+      return "`";
+    case TOKEN_TYPE.DOUBLEQUOTE:
+      return '"';
+    case TOKEN_TYPE.SINGLEQUOTE:
+      return "'";
+    case TOKEN_TYPE.REGEX:
+      return "/";
+    case void 0:
+      return "";
+  }
+}
+export {
+  variable
+};

package/dist/ast/classes/ArrayNode.d.ts

@@ -0,0 +1,18 @@
+import type { ConditionNode } from "./ConditionNode.js";
+import { Node } from "./Node.js";
+import type { VariableNode } from "./VariableNode.js";
+import { AST_TYPE, type NodeDelimiters, type TOKEN_TYPE } from "../../types/ast.js";
+export declare class ArrayNode<TValid extends boolean = boolean> extends Node<AST_TYPE.ARRAY> {
+    #private;
+    readonly values: VariableNode[];
+    readonly bracket: NodeDelimiters<TOKEN_TYPE.BRACKETL, TOKEN_TYPE.BRACKETR>;
+    get parent(): ConditionNode | undefined;
+    set parent(value: ConditionNode | undefined);
+    constructor({ values, bracket, start, end }: {
+        values: ArrayNode<TValid>["values"];
+        bracket: ArrayNode<TValid>["bracket"];
+        start: number;
+        end: number;
+    });
+}
+//# sourceMappingURL=ArrayNode.d.ts.map

package/dist/ast/classes/ArrayNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArrayNode.d.ts","sourceRoot":"","sources":["../../../src/ast/classes/ArrayNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,EAAE,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAGnF,qBAAa,SAAS,CACrB,MAAM,SAAS,OAAO,GAAG,OAAO,CAC/B,SAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;;IAC7B,QAAQ,CAAC,MAAM,EAAE,YAAY,EAAE,CAAA;IAE/B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,UAAU,CAAC,QAAQ,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAA;IAM1E,IAAI,MAAM,IAAI,aAAa,GAAG,SAAS,CAEtC;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,EAI1C;gBAEW,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QAC5C,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAA;QACnC,OAAO,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAA;QACrC,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,EAAE,MAAM,CAAA;KACX;CAWD"}

package/dist/ast/classes/ArrayNode.js

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _parent, _setParent;
+import { Node } from "./Node.js";
+import { ValidToken } from "./ValidToken.js";
+import { AST_TYPE } from "../../types/ast.js";
+class ArrayNode extends Node {
+  constructor({ values, bracket, start, end }) {
+    super(AST_TYPE.ARRAY, start, end);
+    __publicField(this, "values");
+    __publicField(this, "bracket");
+    __privateAdd(this, _parent, void 0);
+    __privateAdd(this, _setParent, false);
+    this.values = values;
+    this.bracket = bracket;
+    this.valid = this.values.every((val) => val.valid) && this.bracket.left instanceof ValidToken && this.bracket.right instanceof ValidToken;
+  }
+  get parent() {
+    return __privateGet(this, _parent);
+  }
+  set parent(value) {
+    if (__privateGet(this, _setParent)) {
+      throw new Error("parent property is readonly");
+    }
+    __privateSet(this, _parent, value);
+    __privateSet(this, _setParent, true);
+  }
+}
+_parent = new WeakMap();
+_setParent = new WeakMap();
+export {
+  ArrayNode
+};

package/dist/ast/classes/Condition.d.ts

@@ -0,0 +1,13 @@
+export declare class Condition<TOp extends string = string, TValue = any> {
+    readonly value: TValue;
+    readonly operator?: TOp;
+    readonly property: string[];
+    readonly negate: boolean;
+    constructor({ property, operator, value, negate }: {
+        property: Condition<TOp, TValue>["property"];
+        operator: Condition<TOp, TValue>["operator"];
+        value: Condition<TOp, TValue>["value"];
+        negate: Condition<TOp, TValue>["negate"];
+    });
+}
+//# sourceMappingURL=Condition.d.ts.map

package/dist/ast/classes/Condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Condition.d.ts","sourceRoot":"","sources":["../../../src/ast/classes/Condition.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAS,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,EAAE,MAAM,GAAG,GAAG;IAC/D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IAEtB,QAAQ,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAA;IAEvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAE3B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;gBAEZ,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;QAClD,QAAQ,EAAE,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;QAC5C,QAAQ,EAAE,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;QAC5C,KAAK,EAAE,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAA;QACtC,MAAM,EAAE,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAA;KACxC;CAMD"}

package/dist/ast/classes/Condition.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Condition {
+  constructor({ property, operator, value, negate }) {
+    __publicField(this, "value");
+    __publicField(this, "operator");
+    __publicField(this, "property");
+    __publicField(this, "negate");
+    this.value = value;
+    this.operator = operator;
+    this.property = property;
+    this.negate = negate;
+  }
+}
+export {
+  Condition
+};

package/dist/ast/classes/ConditionNode.d.ts

@@ -0,0 +1,73 @@
+import type { ArrayNode } from "./ArrayNode.js";
+import type { ErrorToken } from "./ErrorToken.js";
+import type { ExpressionNode } from "./ExpressionNode.js";
+import type { GroupNode } from "./GroupNode.js";
+import { Node } from "./Node.js";
+import { ValidToken } from "./ValidToken.js";
+import { VariableNode } from "./VariableNode.js";
+import { type AnyToken, AST_TYPE, type TOKEN_TYPE } from "../../types/ast.js";
+/**
+ * A condition is composed of a `variable`, @see Variable , and, if it's negated, a "not" `operator` token, @see ValidToken .
+ *
+ * The `value` property refers to the boolean value of the condition (not to the string value of the variable). See the `operator` property.
+ */
+export declare class ConditionNode<TValid extends boolean = boolean, TOperator extends ValidToken<TOKEN_TYPE.NOT> | undefined = ValidToken<TOKEN_TYPE.NOT> | undefined> extends Node<AST_TYPE.CONDITION> {
+    #private;
+    /**
+     * Contains a value node which could be a variable, an array node (if enabled), or a group.
+     *
+     * Might be an error in cases like:
+     * - just passing a negation operator
+     * - if condition property operators are used and you have an input like just `[SEP]`, `op[SEP]`, `prop[SEP]op[SEP]`, `[CUSTOM OP]`, or `prop[CUSTOM OP]` where the variable is missing.
+     */
+    readonly value: VariableNode<TValid> | ArrayNode<TValid> | GroupNode<TValid> | (TValid extends false ? ErrorToken<TOKEN_TYPE.VALUE> : never);
+    /**
+     * If the condition was negated, contains the "not" token, @see ValidToken , the condition was negated with.
+     */
+    readonly operator?: ValidToken<TOKEN_TYPE.NOT>;
+    /**
+     * If condition property operators are used, this will contain the property (as a variable), or an error token if it was missing (but some separator or operator was passed).
+     *
+     * While the property is a variable and can be a quoted variable, it cannot be a prefixed variable string.
+     *
+     * See the corresponding @see ParserOptions for more details.
+     */
+    readonly property?: VariableNode | (TValid extends false ? ErrorToken<TOKEN_TYPE.VALUE> : never);
+    /**
+     * If condition property operators are used, this will contain the operator.
+     *
+     * If a "short" form was used, this will contain an `OP_CUSTOM` type token, and the condition's `sep` will always be undefined.
+     *
+     * If a "long/expanded" form was used, this will contain a `VALUE` type token, and at least one of condition's `sep` tokens will be defined.
+     *
+     * See the corresponding @see ParserOptions for more details.
+     */
+    readonly propertyOperator?: AnyToken<TOKEN_TYPE.OP_CUSTOM | TOKEN_TYPE.VALUE>;
+    /**
+     * If "long/expanded" form condition property operators are used, this will contain the separators, otherwise it is undefined.
+     *
+     * If it's defined, either both side will be valid tokens, or only the left, while the right might be undefined or an error token.
+     *
+     * This is because given a string like `[SEP]val` which would produce an error like `[MISSING PROPERTY ERROR][SEP]var`, the separator is always interpreted as being the left one. And even if we have a situation like `op[SEP]var`, it is always interpreted by the parser as `prop[SEP]var`.
+     *
+     * Why might the right be undefined instead of an error token? This is because we don't need a separator between the operator and a group, `prop[SEP]op(group)`, but we do between a variable in cases like `prop[SEP]op"var"` which would produce an error token on the right side (we could parse this but it just looks inconsistent).
+     *
+     * See the corresponding @see ParserOptions for more details.
+     */
+    readonly sep?: {
+        left?: AnyToken<TOKEN_TYPE.OP_EXPANDED_SEP>;
+        right?: AnyToken<TOKEN_TYPE.OP_EXPANDED_SEP>;
+    };
+    get parent(): GroupNode | ExpressionNode | undefined;
+    set parent(value: GroupNode | ExpressionNode | undefined);
+    constructor({ property, propertyOperator, sep, value, start, end, operator }: {
+        operator?: TOperator;
+        property?: ConditionNode<TValid>["property"];
+        propertyOperator?: ConditionNode<TValid>["propertyOperator"];
+        sep?: ConditionNode<TValid>["sep"];
+        value: ConditionNode<TValid>["value"];
+        start: number;
+        end: number;
+    });
+}
+//# sourceMappingURL=ConditionNode.d.ts.map

package/dist/ast/classes/ConditionNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionNode.d.ts","sourceRoot":"","sources":["../../../src/ast/classes/ConditionNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,OAAO,EAAE,KAAK,QAAQ,EAAE,QAAQ,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAG7E;;;;GAIG;AACH,qBAAa,aAAa,CACzB,MAAM,SAAS,OAAO,GAAG,OAAO,EAChC,SAAS,SACR,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,SAAS,GACtC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,GAAG,SAAS,CACtC,SAAQ,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EACZ,YAAY,CAAC,MAAM,CAAC,GACpB,SAAS,CAAC,MAAM,CAAC,GACjB,SAAS,CAAC,MAAM,CAAC,GACjB,CAAC,MAAM,SAAS,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;IAE/D;;OAEG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;IAE9C;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,YAAY,GAAG,CAAC,MAAM,SAAS,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;IAEhG;;;;;;;;OAQG;IACH,QAAQ,CAAC,gBAAgB,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,SAAS,GAAG,UAAU,CAAC,KAAK,CAAC,CAAA;IAE7E;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE;QACd,IAAI,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,eAAe,CAAC,CAAA;QAC3C,KAAK,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,eAAe,CAAC,CAAA;KAC5C,CAAA;IAMD,IAAI,MAAM,IAAI,SAAS,GACvB,cAAc,GACd,SAAS,CAER;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,SAAS,GAC3B,cAAc,GACd,SAAS,EAKR;gBAEW,EAAE,QAAQ,EAAE,gBAAgB,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;QAC7E,QAAQ,CAAC,EAAE,SAAS,CAAA;QACpB,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;QAC5C,gBAAgB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAA;QAC5D,GAAG,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAA;QAClC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAA;QACrC,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,EAAE,MAAM,CAAA;KACX;CAoCD"}

package/dist/ast/classes/ConditionNode.js

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _parent, _setParent;
+import { Node } from "./Node.js";
+import { ValidToken } from "./ValidToken.js";
+import { VariableNode } from "./VariableNode.js";
+import { AST_TYPE } from "../../types/ast.js";
+class ConditionNode extends Node {
+  constructor({ property, propertyOperator, sep, value, start, end, operator }) {
+    var _a, _b;
+    super(AST_TYPE.CONDITION, start, end);
+    /**
+     * Contains a value node which could be a variable, an array node (if enabled), or a group.
+     *
+     * Might be an error in cases like:
+     * - just passing a negation operator
+     * - if condition property operators are used and you have an input like just `[SEP]`, `op[SEP]`, `prop[SEP]op[SEP]`, `[CUSTOM OP]`, or `prop[CUSTOM OP]` where the variable is missing.
+     */
+    __publicField(this, "value");
+    /**
+     * If the condition was negated, contains the "not" token, @see ValidToken , the condition was negated with.
+     */
+    __publicField(this, "operator");
+    /**
+     * If condition property operators are used, this will contain the property (as a variable), or an error token if it was missing (but some separator or operator was passed).
+     *
+     * While the property is a variable and can be a quoted variable, it cannot be a prefixed variable string.
+     *
+     * See the corresponding @see ParserOptions for more details.
+     */
+    __publicField(this, "property");
+    /**
+     * If condition property operators are used, this will contain the operator.
+     *
+     * If a "short" form was used, this will contain an `OP_CUSTOM` type token, and the condition's `sep` will always be undefined.
+     *
+     * If a "long/expanded" form was used, this will contain a `VALUE` type token, and at least one of condition's `sep` tokens will be defined.
+     *
+     * See the corresponding @see ParserOptions for more details.
+     */
+    __publicField(this, "propertyOperator");
+    /**
+     * If "long/expanded" form condition property operators are used, this will contain the separators, otherwise it is undefined.
+     *
+     * If it's defined, either both side will be valid tokens, or only the left, while the right might be undefined or an error token.
+     *
+     * This is because given a string like `[SEP]val` which would produce an error like `[MISSING PROPERTY ERROR][SEP]var`, the separator is always interpreted as being the left one. And even if we have a situation like `op[SEP]var`, it is always interpreted by the parser as `prop[SEP]var`.
+     *
+     * Why might the right be undefined instead of an error token? This is because we don't need a separator between the operator and a group, `prop[SEP]op(group)`, but we do between a variable in cases like `prop[SEP]op"var"` which would produce an error token on the right side (we could parse this but it just looks inconsistent).
+     *
+     * See the corresponding @see ParserOptions for more details.
+     */
+    __publicField(this, "sep");
+    __privateAdd(this, _parent, void 0);
+    __privateAdd(this, _setParent, false);
+    this.value = value;
+    this.operator = operator;
+    this.property = property;
+    this.propertyOperator = propertyOperator;
+    this.sep = sep;
+    this.operator = operator;
+    this.valid = (this.operator === void 0 || this.operator instanceof ValidToken) && this.value instanceof Node && this.value.valid && (this.property === void 0 && this.propertyOperator === void 0 && this.sep === void 0 || this.property instanceof VariableNode && (this.propertyOperator instanceof ValidToken || ((_a = this.sep) == null ? void 0 : _a.left) instanceof ValidToken && (this.sep.right === void 0 || ((_b = this.sep) == null ? void 0 : _b.right) instanceof ValidToken)));
+  }
+  get parent() {
+    return __privateGet(this, _parent);
+  }
+  set parent(value) {
+    if (__privateGet(this, _setParent)) {
+      throw new Error("parent property is readonly");
+    }
+    __privateSet(this, _parent, value);
+    __privateSet(this, _setParent, true);
+  }
+}
+_parent = new WeakMap();
+_setParent = new WeakMap();
+export {
+  ConditionNode
+};

package/dist/ast/classes/ErrorToken.d.ts

@@ -0,0 +1,27 @@
+import type { ConditionNode } from "./ConditionNode.js";
+import type { ExpressionNode } from "./ExpressionNode.js";
+import type { GroupNode } from "./GroupNode.js";
+import { Token } from "./Token.js";
+import type { VariableNode } from "./VariableNode.js";
+import type { TOKEN_TYPE } from "../../types/ast.js";
+/**
+ * The class for invalid recovery tokens.
+ *
+ * Unlike valid tokens, error tokens:
+ *
+ * - Have no value.
+ * - Contain an extra property, `expected` with an array of tokens *that would have fixed the issue* (NOT every possible token that could be there).
+ * - The start end positions will always be equal. An invalid token has no length.
+ */
+export declare class ErrorToken<TExpected extends TOKEN_TYPE = TOKEN_TYPE> extends Token<false, never, never, TExpected[]> {
+    #private;
+    readonly expected: TExpected[];
+    get parent(): VariableNode | GroupNode | ExpressionNode | ConditionNode;
+    set parent(value: VariableNode | GroupNode | ExpressionNode | ConditionNode);
+    constructor({ expected, start, end }: {
+        expected: TExpected[];
+        start: number;
+        end: number;
+    });
+}
+//# sourceMappingURL=ErrorToken.d.ts.map

package/dist/ast/classes/ErrorToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorToken.d.ts","sourceRoot":"","sources":["../../../src/ast/classes/ErrorToken.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;;;GAQG;AACH,qBAAa,UAAU,CACtB,SAAS,SAAS,UAAU,GAAG,UAAU,CACxC,SAAQ,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAA;IAI9B,IAAI,MAAM,IAAI,YAAY,GAC1B,SAAS,GACT,cAAc,GACd,aAAa,CAEZ;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,YAAY,GAC9B,SAAS,GACT,cAAc,GACd,aAAa,EAIZ;gBAEW,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QACrC,QAAQ,EAAE,SAAS,EAAE,CAAA;QACrB,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,EAAE,MAAM,CAAA;KACX;CAID"}

package/dist/ast/classes/ErrorToken.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _parent;
+import { Token } from "./Token.js";
+class ErrorToken extends Token {
+  constructor({ expected, start, end }) {
+    super(start, end);
+    __publicField(this, "expected");
+    __privateAdd(this, _parent, void 0);
+    this.expected = expected;
+  }
+  get parent() {
+    return __privateGet(this, _parent);
+  }
+  set parent(value) {
+    if (__privateGet(this, _parent)) {
+      throw new Error("parent property is readonly");
+    }
+    __privateSet(this, _parent, value);
+  }
+}
+_parent = new WeakMap();
+export {
+  ErrorToken
+};

package/dist/ast/classes/Expression.d.ts

@@ -0,0 +1,13 @@
+import type { Condition } from "./Condition.js";
+import type { TokenBooleanTypes } from "../../types/ast.js";
+export declare class Expression<TType extends string = string, TValue = any> {
+    readonly left: Expression<TType, TValue> | Condition<TType, TValue>;
+    readonly right: Expression<TType, TValue> | Condition<TType, TValue>;
+    readonly operator: TokenBooleanTypes;
+    constructor({ operator, left, right }: {
+        operator: Expression<TType, TValue>["operator"];
+        right: Expression<TType, TValue>["right"];
+        left: Expression<TType, TValue>["left"];
+    });
+}
+//# sourceMappingURL=Expression.d.ts.map

package/dist/ast/classes/Expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Expression.d.ts","sourceRoot":"","sources":["../../../src/ast/classes/Expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAG3D,qBAAa,UAAU,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM,EAAE,MAAM,GAAG,GAAG;IAClE,QAAQ,CAAC,IAAI,EACX,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,GACzB,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;IAE1B,QAAQ,CAAC,KAAK,EACZ,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,GACzB,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;IAE1B,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAA;gBAExB,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE;QACtC,QAAQ,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;QAC/C,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,OAAO,CAAC,CAAA;QACzC,IAAI,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,CAAA;KACvC;CAKD"}

package/dist/ast/classes/Expression.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Expression {
+  constructor({ operator, left, right }) {
+    __publicField(this, "left");
+    __publicField(this, "right");
+    __publicField(this, "operator");
+    this.operator = operator;
+    this.right = right;
+    this.left = left;
+  }
+}
+export {
+  Expression
+};

package/dist/ast/classes/ExpressionNode.d.ts

@@ -0,0 +1,21 @@
+import type { ConditionNode } from "./ConditionNode.js";
+import type { ErrorToken } from "./ErrorToken.js";
+import type { GroupNode } from "./GroupNode.js";
+import { Node } from "./Node.js";
+import { type AnyToken, AST_TYPE, type TOKEN_TYPE, type TokenBooleanTypes } from "../../types/ast.js";
+export declare class ExpressionNode<TValid extends boolean = boolean> extends Node<AST_TYPE.EXPRESSION> {
+    #private;
+    readonly operator: AnyToken<TokenBooleanTypes>;
+    readonly left: ExpressionNode<TValid> | ConditionNode<TValid> | GroupNode<TValid> | (TValid extends false ? ErrorToken<TOKEN_TYPE.VALUE> : never);
+    readonly right: ExpressionNode<TValid> | ConditionNode<TValid> | GroupNode<TValid> | (TValid extends false ? ErrorToken<TOKEN_TYPE.VALUE> : never);
+    get parent(): GroupNode | undefined;
+    set parent(value: GroupNode | undefined);
+    constructor({ operator, left, right, start, end }: {
+        operator: ExpressionNode<TValid>["operator"];
+        right: ExpressionNode<TValid>["right"];
+        left: ExpressionNode<TValid>["left"];
+        start: number;
+        end: number;
+    });
+}
+//# sourceMappingURL=ExpressionNode.d.ts.map

package/dist/ast/classes/ExpressionNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressionNode.d.ts","sourceRoot":"","sources":["../../../src/ast/classes/ExpressionNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGhC,OAAO,EAAE,KAAK,QAAQ,EAAE,QAAQ,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAGrG,qBAAa,cAAc,CAC1B,MAAM,SAAS,OAAO,GAAG,OAAO,CAEhC,SAAQ,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC;;IACjC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,iBAAiB,CAAC,CAAA;IAE9C,QAAQ,CAAC,IAAI,EACX,cAAc,CAAC,MAAM,CAAC,GACtB,aAAa,CAAC,MAAM,CAAC,GACrB,SAAS,CAAC,MAAM,CAAC,GACjB,CAAC,MAAM,SAAS,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;IAE/D,QAAQ,CAAC,KAAK,EACZ,cAAc,CAAC,MAAM,CAAC,GACtB,aAAa,CAAC,MAAM,CAAC,GACrB,SAAS,CAAC,MAAM,CAAC,GACjB,CAAC,MAAM,SAAS,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;IAM/D,IAAI,MAAM,IAAI,SAAS,GAAG,SAAS,CAElC;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,EAItC;gBAEW,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QAClD,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAA;QAC5C,KAAK,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAA;QACtC,IAAI,EAAE,cAAc,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAA;QACpC,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,EAAE,MAAM,CAAA;KACX;CAcD"}

package/dist/ast/classes/ExpressionNode.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _parent, _setParent;
+import { Node } from "./Node.js";
+import { ValidToken } from "./ValidToken.js";
+import { AST_TYPE } from "../../types/ast.js";
+class ExpressionNode extends Node {
+  constructor({ operator, left, right, start, end }) {
+    super(AST_TYPE.EXPRESSION, start, end);
+    __publicField(this, "operator");
+    __publicField(this, "left");
+    __publicField(this, "right");
+    __privateAdd(this, _parent, void 0);
+    __privateAdd(this, _setParent, false);
+    this.operator = operator;
+    this.right = right;
+    this.left = left;
+    this.valid = this.operator instanceof ValidToken && this.left instanceof Node && this.left.valid && this.right instanceof Node && this.right.valid;
+  }
+  get parent() {
+    return __privateGet(this, _parent);
+  }
+  set parent(value) {
+    if (__privateGet(this, _setParent)) {
+      throw new Error("parent property is readonly");
+    }
+    __privateSet(this, _parent, value);
+    __privateSet(this, _setParent, true);
+  }
+}
+_parent = new WeakMap();
+_setParent = new WeakMap();
+export {
+  ExpressionNode
+};

package/dist/ast/classes/GroupNode.d.ts

@@ -0,0 +1,64 @@
+import type { ConditionNode } from "./ConditionNode.js";
+import type { ErrorToken } from "./ErrorToken.js";
+import type { ExpressionNode } from "./ExpressionNode.js";
+import { Node } from "./Node.js";
+import { ValidToken } from "./ValidToken.js";
+import { AST_TYPE, type NodeDelimiters, type TOKEN_TYPE } from "../../types/ast.js";
+/**
+ * A node that symbolizes a parenthesized expression (might be negated), and if `prefixableGroups` is enabled, a prefixed expression @see ParserOptions .
+ *
+ * ```txt
+ * (a || b)
+ *  |----| ExpressionNode
+ * |------| GroupNode
+ *
+ * !(a || b)
+ * ^ prefix: "not" Token
+ *   |----| ExpressionNode
+ * |-------| GroupNode
+ * ```
+ *
+ * If `prefixableGroups` is enabled:
+ * ```txt
+ * prefix(a || b)
+ * |----| prefix: ConditionNode
+ *        |----| ExpressionNode
+ * |------------| GroupNode
+ *
+ * !prefix(a || b)
+ * |-----| prefix: ConditionNode
+ *         |----| ExpressionNode
+ * |-------------| GroupNode
+ *
+ * !(a || b)
+ * ^ prefix: STILL a "not" Token
+ * ```
+ */
+export declare class GroupNode<TValid extends boolean = boolean, TPrefixable extends boolean = true, TPrefix extends TPrefixable extends true ? ConditionNode<TValid> | ValidToken<TOKEN_TYPE.NOT> | undefined : ValidToken<TOKEN_TYPE.NOT> | undefined = TPrefixable extends true ? ConditionNode<TValid> | ValidToken<TOKEN_TYPE.NOT> | undefined : ValidToken<TOKEN_TYPE.NOT>> extends Node<AST_TYPE.GROUP> {
+    #private;
+    /**
+     * If the condition is negated this will contain a "not" **token**, @see ValidToken .
+     *
+     * If `prefixableGroups` is enabled and the group is prefixed by a **condition**, this will be an @see ConditionNode.
+     *
+     * **Careful:** `!(a)` here this would not be a **condition** since it's just a regular negation.
+     *
+     * See examples at @see GroupNode .
+     */
+    readonly prefix: TPrefix;
+    expression: ConditionNode<TValid> | GroupNode<TValid> | ExpressionNode<TValid> | (TValid extends false ? ErrorToken<TOKEN_TYPE.VALUE> : never);
+    /**
+     * The parenthesis tokens, @see ValidToken . These will always be defined (although not necessarily with valid tokens).
+     */
+    readonly paren: NodeDelimiters<TOKEN_TYPE.PARENL, TOKEN_TYPE.PARENR>;
+    get parent(): ExpressionNode | undefined;
+    set parent(value: ExpressionNode | undefined);
+    constructor({ prefix, expression, paren, start, end }: {
+        prefix: TPrefix;
+        expression: GroupNode<TValid>["expression"];
+        paren: GroupNode<TValid>["paren"];
+        start: number;
+        end: number;
+    });
+}
+//# sourceMappingURL=GroupNode.d.ts.map

package/dist/ast/classes/GroupNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupNode.d.ts","sourceRoot":"","sources":["../../../src/ast/classes/GroupNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,OAAO,EAAE,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAGnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,qBAAa,SAAS,CACrB,MAAM,SAAS,OAAO,GAAG,OAAO,EAChC,WAAW,SAAS,OAAO,GAAG,IAAI,EAClC,OAAO,SACN,WAAW,SAAS,IAAI,GACrB,aAAa,CAAC,MAAM,CAAC,GACvB,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,GAC1B,SAAS,GACP,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,GAC5B,SAAS,GACV,WAAW,SAAS,IAAI,GACrB,aAAa,CAAC,MAAM,CAAC,GACvB,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,GAC1B,SAAS,GACP,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAE9B,SAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;;IAC5B;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IAExB,UAAU,EACR,aAAa,CAAC,MAAM,CAAC,GACrB,SAAS,CAAC,MAAM,CAAC,GACjB,cAAc,CAAC,MAAM,CAAC,GACtB,CAAC,MAAM,SAAS,KAAK,GAAG,UAAU,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAA;IAE/D;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,CAAA;IAMpE,IAAI,MAAM,IAAI,cAAc,GAAG,SAAS,CAEvC;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,EAI3C;gBAEW,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE;QACtD,MAAM,EAAE,OAAO,CAAA;QACf,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAA;QAC3C,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAA;QACjC,KAAK,EAAE,MAAM,CAAA;QACb,GAAG,EAAE,MAAM,CAAA;KACX;CA0BD"}