@witchcraft/expressit 0.0.2

package/dist/utils/getCursorInfo.js

@@ -0,0 +1,86 @@
+import { isArray, unreachable } from "@alanscodelog/utils";
+import { extractTokens } from "./extractTokens.js";
+import { ValidToken } from "../ast/classes/ValidToken.js";
+import { ErrorToken } from "../ast/classes/ErrorToken.js";
+function getCursorInfo(input, ast, index) {
+  const tokens = isArray(ast) ? ast : extractTokens(ast);
+  if (input.length < index || index < 0) {
+    throw new Error(`Index ${index} out of bounds. Input length is ${input.length}.`);
+  }
+  const info = {
+    index,
+    at: void 0,
+    prev: void 0,
+    next: void 0,
+    valid: {
+      prev: void 0,
+      next: void 0
+    },
+    whitespace: {
+      prev: false,
+      next: false
+    }
+  };
+  for (const token of tokens) {
+    if (token.end <= index) {
+      if (token instanceof ValidToken) {
+        info.prev = token;
+        info.valid.prev = token;
+      } else if (token.end !== index) {
+        info.prev = token;
+      }
+    }
+    if (token.start < index && token.end > index) {
+      if (token instanceof ErrorToken) {
+        unreachable();
+      } else {
+        info.at = token;
+      }
+    }
+    if (token.start >= index) {
+      info.next || (info.next = token);
+      if (token instanceof ValidToken && !info.valid.next) {
+        info.valid.next = token;
+        break;
+      }
+    }
+  }
+  setWhitespaceBetween(input, index, "prev", info);
+  setWhitespaceBetween(input, index, "next", info);
+  return info;
+}
+function setWhitespaceBetween(input, index, side, info) {
+  const oppositePos = side === "next" ? "start" : "end";
+  const pos = side === "next" ? "end" : "start";
+  const limit = side === "next" ? input.length : 0;
+  if (info.at) {
+    if (info.valid[side]) {
+      const nextTokStart = info.valid[side][oppositePos];
+      if (info.at[pos] !== nextTokStart)
+        info.whitespace[side] = true;
+      else
+        return;
+    } else {
+      if (info.at[pos] !== limit)
+        info.whitespace[side] = true;
+      else
+        return;
+    }
+  } else {
+    if (info.valid[side]) {
+      const nextTokStart = info.valid[side][oppositePos];
+      if (index !== nextTokStart)
+        info.whitespace[side] = true;
+      else
+        return;
+    } else {
+      if (index !== limit)
+        info.whitespace[side] = true;
+      else
+        return;
+    }
+  }
+}
+export {
+  getCursorInfo
+};

package/dist/utils/getOppositeDelimiter.d.ts

@@ -0,0 +1,6 @@
+import { type AnyToken, type TokenDelimiterTypes } from "../types/ast.js";
+/**
+ * Given a delimiter token, returns it's opposite pair, or undefined if the type passed was not a delimiter token (so you can pass any type without checking).
+ */
+export declare function getOppositeDelimiter(token: AnyToken): AnyToken<TokenDelimiterTypes> | undefined;
+//# sourceMappingURL=getOppositeDelimiter.d.ts.map

package/dist/utils/getOppositeDelimiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOppositeDelimiter.d.ts","sourceRoot":"","sources":["../../src/utils/getOppositeDelimiter.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAErF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAsB/F"}

package/dist/utils/getOppositeDelimiter.js

@@ -0,0 +1,35 @@
+import { unreachable } from "@alanscodelog/utils";
+import { isBracket } from "./isBracket.js";
+import { isDelimiter } from "./isDelimiter.js";
+import { isParen } from "./isParen.js";
+import { isQuote } from "./isQuote.js";
+import { TOKEN_TYPE } from "../types/ast.js";
+function getOppositeDelimiter(token) {
+  if (!isDelimiter(token))
+    throw new Error("Token is not a delimiter type.");
+  if (isParen(token)) {
+    const paren = token.parent.paren;
+    const opposite = paren.left === token ? "right" : "left";
+    return paren[opposite];
+  } else if (isBracket(token)) {
+    const bracket = token.parent.bracket;
+    const opposite = bracket.left === token ? "right" : "left";
+    return bracket[opposite];
+  } else if (isQuote(token)) {
+    const quotes = token.parent.quote;
+    if (quotes === void 0)
+      unreachable();
+    const opposite = quotes.left === token ? "right" : "left";
+    return quotes[opposite];
+  } else if (token.type === TOKEN_TYPE.OP_EXPANDED_SEP) {
+    const sep = token.parent.sep;
+    if (sep === void 0)
+      unreachable();
+    const opposite = sep.left === token ? "right" : "left";
+    return sep[opposite];
+  }
+  unreachable();
+}
+export {
+  getOppositeDelimiter
+};

package/dist/utils/getSurroundingErrors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Mostly for internal use by @see autosuggest.
+ *
+ * Returns all error tokens immediately before/after cursor (since there might be multiple error tokens one after the other).
+ *
+ * The errors are sorted by closeness to the given cursor (inside @see CursorInfo), with quote errors having priority, then paren errors, then any other errors. They can be sorted by closeness because although two errors might follow each other, their positions might be different because of whitespace, but they can still be fixed from any cursor position between their ends.
+ *
+ * For example:
+ * ```
+ * a a"
+ *  ^ operator missing at 1
+ *   ^ doublequote missing at 2
+ * if the cursor is at 1 (`a| a"`):
+ * errors = [operator, doublequote]
+ * if the cursor is at 2 (`a |a"`):
+ * errors = [doublequote, operator]
+ *
+ * either insertion would fix the issue for either position would fix the issue, albeit with different results
+ * ```
+ */
+import { ErrorToken } from "../ast/classes/ErrorToken.js";
+import { type AnyToken } from "../types/ast.js";
+import type { CursorInfo } from "../types/autocomplete.js";
+export declare function getSurroundingErrors(tokens: AnyToken[], token: CursorInfo): ErrorToken[];
+//# sourceMappingURL=getSurroundingErrors.d.ts.map

package/dist/utils/getSurroundingErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSurroundingErrors.d.ts","sourceRoot":"","sources":["../../src/utils/getSurroundingErrors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AACzD,OAAO,EAAE,KAAK,QAAQ,EAAc,MAAM,iBAAiB,CAAA;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAG1D,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,UAAU,GAAG,UAAU,EAAE,CA8BxF"}

package/dist/utils/getSurroundingErrors.js

@@ -0,0 +1,37 @@
+import { ErrorToken } from "../ast/classes/ErrorToken.js";
+import { TOKEN_TYPE } from "../types/ast.js";
+function getSurroundingErrors(tokens, token) {
+  if (token.at) {
+    return [];
+  }
+  const i = tokens.indexOf(token.next ?? token.prev);
+  let iNext = tokens[i] === token.next ? i : i + 1;
+  let iPrev = tokens[i] === token.next ? i - 1 : i;
+  const errors = [];
+  while (tokens[iNext] instanceof ErrorToken) {
+    errors.push(tokens[iNext]);
+    iNext++;
+  }
+  while (tokens[iPrev] instanceof ErrorToken) {
+    errors.push(tokens[iPrev]);
+    iPrev--;
+  }
+  return errors.sort((a, b) => {
+    const aIsQuote = [TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE].includes(a.expected[0]);
+    const bIsQuote = [TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.BACKTICK, TOKEN_TYPE.SINGLEQUOTE].includes(b.expected[0]);
+    const aIsParen = [TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL].includes(a.expected[0]);
+    const bIsParen = [TOKEN_TYPE.PARENR, TOKEN_TYPE.PARENL].includes(b.expected[0]);
+    const aCloseness = Math.abs(i - tokens.indexOf(a));
+    const bCloseness = Math.abs(i - tokens.indexOf(b));
+    const closenessComparison = aCloseness - bCloseness;
+    if (aIsQuote === bIsQuote) {
+      if (aIsParen !== bIsParen) {
+        return aIsParen ? -1 : 1;
+      }
+    }
+    return closenessComparison;
+  });
+}
+export {
+  getSurroundingErrors
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,10 @@
+export { extractTokens } from "./extractTokens.js";
+export { getCursorInfo } from "./getCursorInfo.js";
+export { getOppositeDelimiter } from "./getOppositeDelimiter.js";
+export { getSurroundingErrors } from "./getSurroundingErrors.js";
+export { isBracket } from "./isBracket.js";
+export { isDelimiter } from "./isDelimiter.js";
+export { isParen } from "./isParen.js";
+export { isQuote } from "./isQuote.js";
+export { prettyAst } from "./prettyAst.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,20 @@
+import { extractTokens } from "./extractTokens.js";
+import { getCursorInfo } from "./getCursorInfo.js";
+import { getOppositeDelimiter } from "./getOppositeDelimiter.js";
+import { getSurroundingErrors } from "./getSurroundingErrors.js";
+import { isBracket } from "./isBracket.js";
+import { isDelimiter } from "./isDelimiter.js";
+import { isParen } from "./isParen.js";
+import { isQuote } from "./isQuote.js";
+import { prettyAst } from "./prettyAst.js";
+export {
+  extractTokens,
+  getCursorInfo,
+  getOppositeDelimiter,
+  getSurroundingErrors,
+  isBracket,
+  isDelimiter,
+  isParen,
+  isQuote,
+  prettyAst
+};

package/dist/utils/isBracket.d.ts

@@ -0,0 +1,3 @@
+import { type AnyToken, type TokenBracketTypes } from "../types/ast.js";
+export declare function isBracket(token?: AnyToken): token is AnyToken<TokenBracketTypes>;
+//# sourceMappingURL=isBracket.d.ts.map

package/dist/utils/isBracket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBracket.d.ts","sourceRoot":"","sources":["../../src/utils/isBracket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAGnF,wBAAgB,SAAS,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,iBAAiB,CAAC,CAEhF"}

package/dist/utils/isBracket.js

@@ -0,0 +1,7 @@
+import { TOKEN_TYPE } from "../types/ast.js";
+function isBracket(token) {
+  return [TOKEN_TYPE.BRACKETL, TOKEN_TYPE.BRACKETR].includes(token == null ? void 0 : token.type);
+}
+export {
+  isBracket
+};

package/dist/utils/isDelimiter.d.ts

@@ -0,0 +1,6 @@
+import { type AnyToken, type TokenDelimiterTypes } from "../types/ast.js";
+/**
+ * Returns whether token is a delimiter type (including if it's an expanded operator separator).
+ */
+export declare function isDelimiter(token?: AnyToken): token is AnyToken<TokenDelimiterTypes>;
+//# sourceMappingURL=isDelimiter.d.ts.map

package/dist/utils/isDelimiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDelimiter.d.ts","sourceRoot":"","sources":["../../src/utils/isDelimiter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAErF;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,mBAAmB,CAAC,CAYpF"}

package/dist/utils/isDelimiter.js

@@ -0,0 +1,17 @@
+import { TOKEN_TYPE } from "../types/ast.js";
+function isDelimiter(token) {
+  return [
+    TOKEN_TYPE.BACKTICK,
+    TOKEN_TYPE.DOUBLEQUOTE,
+    TOKEN_TYPE.SINGLEQUOTE,
+    TOKEN_TYPE.PARENL,
+    TOKEN_TYPE.PARENR,
+    TOKEN_TYPE.BRACKETL,
+    TOKEN_TYPE.BRACKETR,
+    TOKEN_TYPE.OP_EXPANDED_SEP,
+    TOKEN_TYPE.REGEX
+  ].includes(token == null ? void 0 : token.type);
+}
+export {
+  isDelimiter
+};

package/dist/utils/isParen.d.ts

@@ -0,0 +1,3 @@
+import { type AnyToken, type TokenParenTypes } from "../types/ast.js";
+export declare function isParen(token?: AnyToken): token is AnyToken<TokenParenTypes>;
+//# sourceMappingURL=isParen.d.ts.map

package/dist/utils/isParen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isParen.d.ts","sourceRoot":"","sources":["../../src/utils/isParen.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAGjF,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,eAAe,CAAC,CAE5E"}

package/dist/utils/isParen.js

@@ -0,0 +1,7 @@
+import { TOKEN_TYPE } from "../types/ast.js";
+function isParen(token) {
+  return [TOKEN_TYPE.PARENL, TOKEN_TYPE.PARENR].includes(token == null ? void 0 : token.type);
+}
+export {
+  isParen
+};

package/dist/utils/isQuote.d.ts

@@ -0,0 +1,4 @@
+import { type AnyToken, type TokenQuoteTypes } from "../types/ast.js";
+/** Returns if the token is a quote token. This includes regex delimiters. */
+export declare function isQuote(token?: AnyToken): token is AnyToken<TokenQuoteTypes>;
+//# sourceMappingURL=isQuote.d.ts.map

package/dist/utils/isQuote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isQuote.d.ts","sourceRoot":"","sources":["../../src/utils/isQuote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAEjF,6EAA6E;AAC7E,wBAAgB,OAAO,CAAC,KAAK,CAAC,EAAE,QAAQ,GAAG,KAAK,IAAI,QAAQ,CAAC,eAAe,CAAC,CAE5E"}

package/dist/utils/isQuote.js

@@ -0,0 +1,7 @@
+import { TOKEN_TYPE } from "../types/ast.js";
+function isQuote(token) {
+  return [TOKEN_TYPE.BACKTICK, TOKEN_TYPE.DOUBLEQUOTE, TOKEN_TYPE.SINGLEQUOTE, TOKEN_TYPE.REGEX].includes(token == null ? void 0 : token.type);
+}
+export {
+  isQuote
+};

package/dist/utils/prettyAst.d.ts

@@ -0,0 +1,35 @@
+import { ArrayNode, GroupNode, VariableNode } from "../ast/classes/index.js";
+import { type AnyToken, type ParserResults } from "../types/ast.js";
+type Colors = {
+    /** Color used to highlight the actual text content of the token nodes. */
+    values: string;
+    /** Color used to highlight the extra information some nodes contain in their headers for a quick overview (e.g. which operator for expression nodes, if a condition/group value is true, how long an array value is etc). */
+    info: string;
+    position: string;
+    /** Color used to highlight the hints in parens that indicate how the node is being used (e.g. a variable node might be a property, or alone as a variable, etc) */
+    hint: string;
+    error: string;
+    /** Color used to reset highlights. */
+    reset: string;
+};
+/**
+ * Returns a more compressed, color coded, string representation of the ast for debugging.
+ *
+ * There are options to change which symbols are used for tree and if the variables are surrounded by quotes (default false).
+ *
+ * Colors can changed by passing ansi codes (or whatever you want\*) to the third parameter. Or you can pass false instead of an object to disable them. Default colors are:
+ * ```ts
+ * {
+ * 	values: // yellow,
+ * 	position: // green,
+ * 	info: // cyan,
+ * 	hint: // blue,
+ * 	error: // red,
+ * 	reset: // ansi reset code
+ * }
+ * ```
+ * \* For example, you could pass html tags to show this in the browser instead (this is how the demo works). This is why the reset color is exposed. For example, a color might be `<span class="error">` and reset can be `</span>`.
+ */
+export declare function prettyAst(ast: ParserResults | AnyToken | VariableNode | ArrayNode | GroupNode, { indent, children, last, branch, quote }?: Partial<Record<"indent" | "children" | "last" | "branch" | "quote", string>>, colors?: Partial<Colors> | false): string;
+export {};
+//# sourceMappingURL=prettyAst.d.ts.map

package/dist/utils/prettyAst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettyAst.d.ts","sourceRoot":"","sources":["../../src/utils/prettyAst.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAA6C,SAAS,EAAc,YAAY,EAAE,MAAM,yBAAyB,CAAA;AACnI,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAc,MAAM,iBAAiB,CAAA;AAG/E,KAAK,MAAM,GAAG;IACb,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAA;IACd,6NAA6N;IAC7N,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,mKAAmK;IACnK,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,sCAAsC;IACtC,KAAK,EAAE,MAAM,CAAA;CACb,CAAA;AAoBD;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAgB,SAAS,CACxB,GAAG,EAAE,aAAa,GAAG,QAAQ,GAAG,YAAY,GAAG,SAAS,GAAG,SAAS,EACpE,EAAE,MAAc,EAAE,QAAe,EAAE,IAAW,EAAE,MAAY,EAAE,KAAU,EAAE,GAAE,OAAO,CAAC,MAAM,CAAC,QAAQ,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,EAAE,MAAM,CAAC,CAAM,EAC7J,MAAM,GAAE,OAAO,CAAC,MAAM,CAAC,GAAG,KAAU,GAClC,MAAM,CAyFR"}

package/dist/utils/prettyAst.js

@@ -0,0 +1,112 @@
+import { colors, isBlank, unreachable } 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 { TOKEN_TYPE } from "../types/ast.js";
+const defaultColors = {
+  values: colors.yellow,
+  info: colors.cyan,
+  position: colors.green,
+  hint: colors.blue,
+  error: colors.red,
+  reset: colors.reset
+};
+const disableColors = Object.fromEntries(Object.keys(defaultColors).map((key) => [key, ""]));
+const toRows = (rows, opts) => {
+  rows = rows.filter((child) => child !== "");
+  return [
+    ...rows.slice(0, rows.length - 1).map((child) => `${opts.indent}${opts.children}${child}`),
+    `${opts.indent}${opts.last}${rows[rows.length - 1]}`
+  ];
+};
+function prettyAst(ast, { indent = "   ", children = "├╴", last = "└╴", branch = "│", quote = "" } = {}, colors2 = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const opts = { indent, children, last, branch, quote };
+  const c = colors2 ? { ...defaultColors, ...colors2 } : disableColors;
+  const pos = `${c.position}(${ast.start}, ${ast.end})${c.reset}`;
+  const _ = indent;
+  const __ = arguments[3] ?? "";
+  let extra = arguments[4] ?? "";
+  if (!isBlank(extra))
+    extra = ` ${c.hint}${extra}${c.reset}`;
+  const ___ = __ + _ + branch;
+  const __L = __ + _ + indent[0];
+  const prettyAst_ = prettyAst;
+  if (ast instanceof ValidToken) {
+    const value = `${ast.value}`;
+    return `TOKEN ${pos} ${c.values}${quote}${value}${quote}${c.reset}${extra}`;
+  }
+  if (ast instanceof ErrorToken) {
+    const value = `[${ast.expected.join(", ")}]`;
+    return `ERROR ${pos} ${c.error}${value}${c.reset}${extra}`;
+  }
+  if (ast instanceof ConditionNode) {
+    const header = `${c.info}${ast.operator === void 0}${c.reset}`;
+    const not = ast.operator ? prettyAst_(ast.operator, opts, c, ___, `(negation)`) : "";
+    const property = ast.property ? prettyAst_(ast.property, opts, c, ___, `(property)`) : "";
+    const sepL = ((_a = ast.sep) == null ? void 0 : _a.left) ? prettyAst_(ast.sep.left, opts, c, ___, `(separator)`) : "";
+    const op = ast.propertyOperator ? prettyAst_(ast.propertyOperator, opts, c, ___, `(property operator)`) : "";
+    const sepR = ((_b = ast.sep) == null ? void 0 : _b.right) ? prettyAst_(ast.sep.right, opts, c, ___, `(separator)`) : "";
+    const isRegex = ast.value instanceof VariableNode && ((_c = ast.value.quote) == null ? void 0 : _c.left.type) === TOKEN_TYPE.REGEX;
+    const isArray = ast.value instanceof ArrayNode;
+    const variable = prettyAst_(ast.value, opts, c, __L, `(${property ? "value" : "variable/alone"}${isRegex ? " - regex" : isArray ? "- array" : ""})`);
+    return [
+      `CONDITION ${pos} ${header}${extra}`,
+      ...toRows([not, property, sepL, op, sepR, variable], opts)
+    ].join(`
+${__}`);
+  }
+  if (ast instanceof VariableNode) {
+    const prefix = ast.prefix ? prettyAst_(ast.prefix, opts, c, ___, `(value prefix)`) : "";
+    const left = ((_d = ast.quote) == null ? void 0 : _d.left) ? prettyAst_(ast.quote.left, opts, c, ___, "") : "";
+    const value = prettyAst_(ast.value, opts, c, !ast.quote ? __L : !((_e = ast.quote) == null ? void 0 : _e.right) ? __L : ___, "");
+    const right = ((_f = ast.quote) == null ? void 0 : _f.right) ? prettyAst_(ast.quote.right, opts, c, !((_g = ast.quote) == null ? void 0 : _g.flags) ? __L : ___, "") : "";
+    const flags = ((_h = ast.quote) == null ? void 0 : _h.flags) ? prettyAst_(ast.quote.flags, opts, c, __L, "(flags)") : "";
+    return [
+      `VARIABLE ${pos}${extra}`,
+      ...toRows([prefix, left, value, right, flags], opts)
+    ].join(`
+${__}`);
+  }
+  if (ast instanceof GroupNode) {
+    const header = `${c.info}${ast.prefix === void 0 || ast.prefix.operator === void 0}${c.reset}`;
+    const prefix = ast.prefix ? prettyAst_(ast.prefix, opts, c, ___, `(group prefix)`) : "";
+    const expression = prettyAst_(ast.expression, opts, c, __L, "");
+    return [
+      `GROUP ${pos}${!extra.includes("value") ? ` ${header}` : ""}${extra}`,
+      ...toRows([prefix, expression], opts)
+    ].join(`
+${__}`);
+  }
+  if (ast instanceof ArrayNode) {
+    const bracketL = ast.bracket.left ? prettyAst_(ast.bracket.left, opts, c, ast.values.length === 0 && !ast.bracket.right ? __L : ___, "") : "";
+    const values = ast.values.length > 0 ? ast.values.map(
+      (node, i) => prettyAst_(node, opts, c, !ast.bracket.right && i === ast.values.length - 1 ? __L : ___, "")
+    ) : [];
+    const bracketR = ast.bracket.right ? prettyAst_(ast.bracket.right, opts, c, __L, "") : "";
+    return [
+      `ARRAY ${pos} ${c.info}[${ast.values.length}]${c.reset}${extra}`,
+      ...toRows([bracketL, ...values, bracketR], opts)
+    ].join(`
+${__}`);
+  }
+  if (ast instanceof ExpressionNode) {
+    const left = prettyAst_(ast.left, opts, c, ___, "");
+    const operator = prettyAst_(ast.operator, opts, c, ___, `(boolean operator)`);
+    const right = prettyAst_(ast.right, opts, c, __L, "");
+    const header = ast.operator instanceof ErrorToken ? `${c.info}[${ast.operator.expected.join(",")}]${c.reset}` : `${c.info}"${ast.operator.value}"${c.reset}`;
+    return [
+      `EXPRESSION ${pos} ${header}${extra}`,
+      ...toRows([left, operator, right], opts)
+    ].join(`
+${__}`);
+  }
+  unreachable();
+}
+export {
+  prettyAst
+};

package/package.json

@@ -0,0 +1,152 @@
+{
+	"name": "@witchcraft/expressit",
+	"description": "A blazing fast, customizable, error-tolerant expression parser that creates safe to eval expressions + a few other goodies like autocomplete.",
+	"version": "0.0.2",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./ast": {
+			"types": "./dist/ast/index.d.ts",
+			"import": "./dist/ast/index.js"
+		},
+		"./grammar": {
+			"types": "./dist/grammar/index.d.ts",
+			"import": "./dist/grammar/index.js"
+		},
+		"./helpers": {
+			"types": "./dist/helpers/index.d.ts",
+			"import": "./dist/helpers/index.js"
+		},
+		"./methods": {
+			"types": "./dist/methods/index.d.ts",
+			"import": "./dist/methods/index.js"
+		},
+		"./types": {
+			"types": "./dist/types/index.d.ts",
+			"import": "./dist/types/index.js"
+		},
+		"./utils": {
+			"types": "./dist/utils/index.d.ts",
+			"import": "./dist/utils/index.js"
+		},
+		"./examples": {
+			"types": "./dist/examples/index.d.ts",
+			"import": "./dist/examples/index.js"
+		},
+		"./*": {
+			"types": "./dist/*",
+			"import": "./dist/*"
+		}
+	},
+	"scripts": {
+		"debug": "ts-node -r tsconfig-paths/register -T --esm",
+		"build": "vite build",
+		"build:dev": "vite build --mode development",
+		"build:watch": "vite build --watch --mode production",
+		"build:types": "tsc --emitDeclarationOnly -p tsconfig.types.json && npm run build:types:fix",
+		"build:types:fix": "tsc-alias -p tsconfig.types.json --debug",
+		"lint:eslint": "eslint \"{src,tests,bin}/**/*.{cjs,js,ts}\" \"*.{cjs,js,ts}\" --max-warnings=0 --report-unused-disable-directives",
+		"lint:types": "tsc --noEmit --pretty",
+		"lint:commits": "commitlint --from $(git rev-list --max-parents=0 HEAD) --to HEAD --verbose",
+		"lint:imports": "madge --circular --extensions ts ./src",
+		"lint": "npm run lint:types && npm run lint:eslint",
+		"coverage": "vitest --coverage",
+		"coverage:dev": "vitest --watch --coverage",
+		"test": "npm run lint:types && vitest run",
+		"test:watch": "vitest --watch",
+		"test:inspect-errors": "cross-env INSPECT_ERRORS=true npm run test",
+		"doc": "typedoc --options typedoc.config.cjs",
+		"doc:watch": "onchange -i \"src/**/*.ts\" \"typedoc.config.cjs\" -- npm run doc",
+		"doc:serve": "http-server docs --port=5001",
+		"doc:dev": "concurrently \"npm run doc:watch\" \"npm run doc:serve\"",
+		"doc:check-invalid": "typedoc --options typedoc.config.cjs --listInvalidSymbolLinks",
+		"demo:dev": "cd demo && concurrently \"vite\" \"npm run build:watch\"",
+		"demo:build": "cd demo && npm run build",
+		"actions:debug": "act -r -v -j build",
+		"gen:exports": "indexit update -o '${path}.js' -i **/*.d.ts",
+		"prepare": "husky install && npm run build"
+	},
+	"dependencies": {
+		"@alanscodelog/utils": "^4.0.0-beta.11",
+		"chevrotain": "^11.0.3"
+	},
+	"devDependencies": {
+		"@alanscodelog/commitlint-config": "^2.0.0",
+		"@alanscodelog/eslint-config": "^4.0.3",
+		"@alanscodelog/semantic-release-config": "^3.0.0",
+		"@alanscodelog/tsconfigs": "^3.2.0",
+		"@knodes/typedoc-plugin-pages": "^0.23.4",
+		"@types/node": "^20.4.1",
+		"@typescript-eslint/eslint-plugin": "^6.7.4",
+		"@typescript-eslint/parser": "^6.7.4",
+		"@vitest/coverage-c8": "^0.33.0",
+		"commitlint": "^17.6.6",
+		"concurrently": "^8.2.0",
+		"cross-env": "^7.0.3",
+		"eslint": "^8.44.0",
+		"eslint-import-resolver-typescript": "^3.5.5",
+		"eslint-plugin-import": "^2.27.5",
+		"eslint-plugin-jsdoc": "^46.4.3",
+		"eslint-plugin-simple-import-sort": "^10.0.0",
+		"fast-glob": "^3.3.1",
+		"http-server": "^14.1.1",
+		"husky": "^8.0.3",
+		"indexit": "2.1.0-beta.3",
+		"madge": "^6.1.0",
+		"onchange": "^7.1.0",
+		"semantic-release": "^22.0.5",
+		"ts-node": "^10.9.1",
+		"tsc-alias": "^1.8.7",
+		"typedoc": "~0.23.1",
+		"typescript": "~5.0.0",
+		"vite": "^4.4.2",
+		"vite-plugin-externalize-deps": "^0.7.0",
+		"vite-tsconfig-paths": "^4.2.0",
+		"vitest": "^0.34.6"
+	},
+	"author": "Alan <alanscodelog@gmail.com>",
+	"repository": "https://github.com/witchcraftjs/expressit",
+	"keywords": [
+		"boolean",
+		"parser",
+		"query",
+		"evaluator",
+		"expression",
+		"condition",
+		"search"
+	],
+	"license": "MIT",
+	"files": [
+		"src",
+		"dist"
+	],
+	"release": {
+		"extends": [
+			"@alanscodelog/semantic-release-config"
+		]
+	},
+	"commitlint": {
+		"extends": [
+			"@alanscodelog"
+		]
+	},
+	"browserslist": "defaults and supports es6-module,maintained node versions",
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"@comments": {
+		"scripts": {
+			"test": "Runs `lint:types` before (so that flags can be passed to the test command) so that we can test type assertions. See expect_type function in @alanscodelog/utils.",
+			"lint:commits": "Lints all unpushed commits in the active branch.",
+			"prepare": "Needed so that if we pull the package from git it will get built and installed properly.",
+			"actions:debug": "For debugging github build action locally with nektos/act. Requires act and docker. Note: Cache will never work locally because of https://github.com/nektos/act/issues/285"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}