@witchcraft/expressit 0.0.2

package/dist/package.json.js

@@ -0,0 +1,193 @@
+const name = "@witchcraft/expressit";
+const description = "A blazing fast, customizable, error-tolerant expression parser that creates safe to eval expressions + a few other goodies like autocomplete.";
+const version = "0.0.2";
+const types = "./dist/index.d.ts";
+const type = "module";
+const 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/*"
+  }
+};
+const 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"
+};
+const dependencies = {
+  "@alanscodelog/utils": "^4.0.0-beta.11",
+  chevrotain: "^11.0.3"
+};
+const 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"
+};
+const author = "Alan <alanscodelog@gmail.com>";
+const repository = "https://github.com/witchcraftjs/expressit";
+const keywords = [
+  "boolean",
+  "parser",
+  "query",
+  "evaluator",
+  "expression",
+  "condition",
+  "search"
+];
+const license = "MIT";
+const files = [
+  "src",
+  "dist"
+];
+const release = {
+  "extends": [
+    "@alanscodelog/semantic-release-config"
+  ]
+};
+const commitlint = {
+  "extends": [
+    "@alanscodelog"
+  ]
+};
+const browserslist = "defaults and supports es6-module,maintained node versions";
+const engines = {
+  node: ">=18.0.0"
+};
+const publishConfig = {
+  access: "public"
+};
+const pkg = {
+  name,
+  description,
+  version,
+  types,
+  type,
+  exports,
+  scripts,
+  dependencies,
+  devDependencies,
+  author,
+  repository,
+  keywords,
+  license,
+  files,
+  release,
+  commitlint,
+  browserslist,
+  engines,
+  "@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
+};
+export {
+  author,
+  browserslist,
+  commitlint,
+  pkg as default,
+  dependencies,
+  description,
+  devDependencies,
+  engines,
+  exports,
+  files,
+  keywords,
+  license,
+  name,
+  publishConfig,
+  release,
+  repository,
+  scripts,
+  type,
+  types,
+  version
+};

package/dist/parser.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The parser's methods are often long and have a lot of documentation per method, so it's methods have been split into mixins. They can be found in the `./methods` folder.
+ *
+ * Writing from within any of these methods is like writing a method from here except:
+ * - `this` calls are wrapped in `(this as any as Parser<T>)`
+ * - private method/property access requires `// @ts-expect-error`.
+ * - recursion with hidden parameters requires re-typing this (see evaluate/validate for examples) since otherwise if we only retyped the function it would become unbound from `this`.
+ *
+ * Docs work like normal (on methods). From the outside, users of the library cannot even tell the class is composed of mixins.
+ */
+import type { Mixin } from "@alanscodelog/utils";
+import { createTokens } from "./grammar/createTokens.js";
+import { ParserBase } from "./grammar/ParserBase.js";
+import { AutocompleteMixin } from "./methods/autocomplete.js";
+import { AutoreplaceMixin } from "./methods/autoreplace.js";
+import { Autosuggest } from "./methods/autosuggest.js";
+import { EvaluateMixin } from "./methods/evaluate.js";
+import { GetBestIndexesMixin } from "./methods/getBestIndex.js";
+import { GetIndexMixin } from "./methods/getIndexes.js";
+import { NormalizeMixin, ValidateMixin } from "./methods/index.js";
+import type { ParserResults } from "./types/ast.js";
+import type { FullParserOptions, ParserOptions } from "./types/parser.js";
+/**
+ * Creates the main parser class which handles all functionality (evaluation, validation, etc).
+ */
+export declare class Parser<T extends {} = {}> {
+    options: FullParserOptions<T>;
+    private readonly rawOptions;
+    parser: ParserBase<T>;
+    private readonly lexer;
+    private readonly tokens;
+    info: ReturnType<typeof createTokens>["info"];
+    constructor(options?: ParserOptions<T>);
+    /**
+     * Parses a string.
+     */
+    parse(input: string): ParserResults;
+    private evaluationOptionsChecked;
+    _checkEvaluationOptions(): void;
+    private validationOptionsChecked;
+    _checkValidationOptions(): void;
+    /**
+     * Generates a railroad diagram for debugging. Does not 100% represent how things are actually handled internally.
+     *
+     * Not exposed because it uses the raw chevrotain tokens.
+     *
+     * **Note: It is not 100% accurate. Some special cases are parsed one way but handled internally differently.**
+     */
+    private _generateRailRoadDiagram;
+    /**
+     * For debugging.
+     * Not exposed because it returns the raw chevrotain tokens.
+     */
+    private _lex;
+}
+export interface Parser<T extends {} = {}> extends Mixin<AutocompleteMixin<T> | AutoreplaceMixin | Autosuggest<T> | EvaluateMixin<T> | ValidateMixin<T> | NormalizeMixin<T> | GetIndexMixin<T> | GetBestIndexesMixin>, AutocompleteMixin<T>, AutoreplaceMixin, Autosuggest<T>, EvaluateMixin<T>, ValidateMixin<T>, NormalizeMixin<T>, GetIndexMixin<T>, GetBestIndexesMixin {
+}
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAKhD,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAKpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAGzE;;GAEG;AACH,qBAAa,MAAM,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE;IACpC,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAA;IAE7B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;IAE7C,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;IAErB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAO;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;IAElE,IAAI,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAA;gBAEjC,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;IAYtC;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa;IA8CnC,OAAO,CAAC,wBAAwB,CAAiB;IAGjD,uBAAuB,IAAI,IAAI;IAO/B,OAAO,CAAC,wBAAwB,CAAiB;IAGjD,uBAAuB,IAAI,IAAI;IAO/B;;;;;;OAMG;IACH,OAAO,CAAC,wBAAwB;IAMhC;;;OAGG;IACH,OAAO,CAAC,IAAI;CAGZ;AAED,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,KAAK,CACrD,iBAAiB,CAAC,CAAC,CAAC,GACpB,gBAAgB,GAChB,WAAW,CAAC,CAAC,CAAC,GACd,aAAa,CAAC,CAAC,CAAC,GAChB,aAAa,CAAC,CAAC,CAAC,GAChB,cAAc,CAAC,CAAC,CAAC,GACjB,aAAa,CAAC,CAAC,CAAC,GAChB,mBAAmB,CACrB,EACA,iBAAiB,CAAC,CAAC,CAAC,EACpB,gBAAgB,EAChB,WAAW,CAAC,CAAC,CAAC,EACd,aAAa,CAAC,CAAC,CAAC,EAChB,aAAa,CAAG,CAAC,CAAE,EACnB,cAAc,CAAC,CAAC,CAAC,EACjB,aAAa,CAAC,CAAC,CAAC,EAChB,mBAAmB;CAClB"}

package/dist/parser.js

@@ -0,0 +1,136 @@
+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;
+};
+import { mixin, isWhitespace } from "@alanscodelog/utils";
+import { createSyntaxDiagramsCode } from "chevrotain";
+import { token } from "./ast/handlers.js";
+import { createTokens } from "./grammar/createTokens.js";
+import { ParserBase } from "./grammar/ParserBase.js";
+import { BooleanParserLibraryError } from "./helpers/errors.js";
+import { checkParserOpts } from "./helpers/parser/checkParserOpts.js";
+import { getUnclosedRightParenCount } from "./helpers/parser/getUnclosedRightParenCount.js";
+import { ERROR_CODES } from "./types/errors.js";
+import { parseParserOptions } from "./helpers/parser/parseParserOptions.js";
+import { seal } from "./helpers/parser/seal.js";
+import { AutocompleteMixin } from "./methods/autocomplete.js";
+import { AutoreplaceMixin } from "./methods/autoreplace.js";
+import { Autosuggest } from "./methods/autosuggest.js";
+import { EvaluateMixin } from "./methods/evaluate.js";
+import { GetBestIndexesMixin } from "./methods/getBestIndex.js";
+import { GetIndexMixin } from "./methods/getIndexes.js";
+import { NormalizeMixin } from "./methods/normalize.js";
+import { ValidateMixin } from "./methods/validate.js";
+class Parser {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "rawOptions");
+    __publicField(this, "parser");
+    __publicField(this, "lexer");
+    __publicField(this, "tokens");
+    __publicField(this, "info");
+    // needed for evaluate and validate so they are only checked on demand
+    __publicField(this, "evaluationOptionsChecked", false);
+    __publicField(this, "validationOptionsChecked", false);
+    this.rawOptions = options ?? {};
+    const opts = parseParserOptions(this.rawOptions);
+    checkParserOpts(opts);
+    this.options = opts;
+    const { lexer, tokens, info } = createTokens(opts);
+    this.lexer = lexer;
+    this.tokens = tokens;
+    this.info = info;
+    this.parser = new ParserBase(opts, this.tokens, this.info);
+  }
+  /**
+   * Parses a string.
+   */
+  parse(input) {
+    var _a;
+    if (isWhitespace(input)) {
+      return token.value(void 0, { start: 0, end: 0 });
+    }
+    let lexed = this._lex(input);
+    const shift = getUnclosedRightParenCount(lexed.tokens, this.tokens);
+    if (shift) {
+      input = "(".repeat(shift) + input;
+      lexed = this._lex(input);
+    }
+    this.parser.shift = shift;
+    this.parser.input = lexed.tokens;
+    this.parser.rawInput = input;
+    try {
+      if (lexed.errors.length > 0)
+        throw new Error("Unexpected Lexer Errors");
+      this.parser.input = lexed.tokens;
+      const res = this.parser.main();
+      if (res === void 0) {
+        throw new Error("throw");
+      }
+      if (!((_a = arguments[1]) == null ? void 0 : _a.unsealed))
+        seal(res);
+      return res;
+    } catch (error) {
+      if (error.message === "throw")
+        error = void 0;
+      const err = new BooleanParserLibraryError(ERROR_CODES.PARSER_ERROR, {
+        input,
+        options: this.rawOptions,
+        "parsed options": this.options,
+        error,
+        "lexed tokens": lexed.tokens,
+        "lexer errors": lexed.errors,
+        "parser errors": this.parser.errors
+      });
+      throw err;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  _checkEvaluationOptions() {
+    if (!this.evaluationOptionsChecked) {
+      checkParserOpts(this.options, true);
+      this.evaluationOptionsChecked = true;
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  _checkValidationOptions() {
+    if (!this.validationOptionsChecked) {
+      checkParserOpts(this.options, false, true);
+      this.validationOptionsChecked = true;
+    }
+  }
+  /**
+   * Generates a railroad diagram for debugging. Does not 100% represent how things are actually handled internally.
+   *
+   * Not exposed because it uses the raw chevrotain tokens.
+   *
+   * **Note: It is not 100% accurate. Some special cases are parsed one way but handled internally differently.**
+   */
+  _generateRailRoadDiagram() {
+    const serialized = this.parser.getSerializedGastProductions();
+    const html = createSyntaxDiagramsCode(serialized);
+    return html;
+  }
+  /**
+   * For debugging.
+   * Not exposed because it returns the raw chevrotain tokens.
+   */
+  _lex(input) {
+    return this.lexer.tokenize(input);
+  }
+}
+mixin(Parser, [
+  AutocompleteMixin,
+  AutoreplaceMixin,
+  Autosuggest,
+  EvaluateMixin,
+  ValidateMixin,
+  NormalizeMixin,
+  GetIndexMixin,
+  GetBestIndexesMixin
+]);
+export {
+  Parser
+};

package/dist/types/ast.d.ts

@@ -0,0 +1,70 @@
+import type { AnyFunction } from "@alanscodelog/utils";
+import type { ArrayNode } from "../ast/classes/ArrayNode.js";
+import type { ConditionNode } from "../ast/classes/ConditionNode.js";
+import type { ErrorToken } from "../ast/classes/ErrorToken.js";
+import type { ExpressionNode } from "../ast/classes/ExpressionNode.js";
+import type { GroupNode } from "../ast/classes/GroupNode.js";
+import type { ValidToken } from "../ast/classes/ValidToken.js";
+import type { VariableNode } from "../ast/classes/VariableNode.js";
+export type AddParameters<T extends AnyFunction, TExtra extends any[] = [boolean]> = (...args: [...Parameters<T>, ...TExtra]) => ReturnType<T>;
+export declare enum TOKEN_TYPE {
+    VALUE = "VALUE",
+    AND = "AND",
+    OR = "OR",
+    NOT = "NOT",
+    BACKTICK = "BACKTICK",
+    SINGLEQUOTE = "SINGLEQUOTE",
+    DOUBLEQUOTE = "DOUBLEQUOTE",
+    PARENL = "PARENL",
+    PARENR = "PARENR",
+    BRACKETL = "BRACKETL",
+    BRACKETR = "BRACKETR",
+    OP_EXPANDED_SEP = "OP_EXPANDED",
+    OP_CUSTOM = "OP_CUSTOM",
+    REGEX = "REGEX"
+}
+/**
+ * @internal
+ * Note if the negation operator, `!`, is used as a propertyOperator, this will return the wrong type.
+ */
+export type ExtractTokenType<T extends string> = T extends "`" ? TOKEN_TYPE.BACKTICK : T extends `'` ? TOKEN_TYPE.SINGLEQUOTE : T extends `"` ? TOKEN_TYPE.DOUBLEQUOTE : T extends `/` ? TOKEN_TYPE.REGEX : T extends `(` ? TOKEN_TYPE.PARENL : T extends `)` ? TOKEN_TYPE.PARENR : T extends `[` ? TOKEN_TYPE.BRACKETL : T extends `]` ? TOKEN_TYPE.BRACKETR : T extends `and` ? TOKEN_TYPE.AND : T extends `&&` ? TOKEN_TYPE.AND : T extends `&` ? TOKEN_TYPE.AND : T extends `or` ? TOKEN_TYPE.OR : T extends `||` ? TOKEN_TYPE.OR : T extends `|` ? TOKEN_TYPE.OR : T extends `not` ? TOKEN_TYPE.NOT : T extends `!` ? TOKEN_TYPE.NOT : TOKEN_TYPE.VALUE;
+export type TokenParenTypes = TOKEN_TYPE.PARENL | TOKEN_TYPE.PARENR;
+export type TokenBracketTypes = TOKEN_TYPE.BRACKETL | TOKEN_TYPE.BRACKETR;
+export type TokenDelimiterTypes = TokenParenTypes | TokenQuoteTypes | TokenBracketTypes | TOKEN_TYPE.OP_EXPANDED_SEP;
+export type TokenQuoteTypes = TOKEN_TYPE.BACKTICK | TOKEN_TYPE.SINGLEQUOTE | TOKEN_TYPE.DOUBLEQUOTE | TOKEN_TYPE.REGEX;
+export type TokenBooleanTypes = TOKEN_TYPE.AND | TOKEN_TYPE.OR;
+export type TokenOperatorTypes = TokenBooleanTypes | TOKEN_TYPE.NOT;
+export type TokenPropertyOperatorTypes = TOKEN_TYPE.OP_CUSTOM | TOKEN_TYPE.OP_EXPANDED_SEP;
+export type EmptyObj = Record<any, never>;
+export type FirstConstructorParam<T extends new (...args: any) => any> = ConstructorParameters<T>["0"];
+export type Position = {
+    start: number;
+    end: number;
+};
+export declare enum AST_TYPE {
+    EXPRESSION = "EXPRESSION",
+    GROUP = "GROUP",
+    ARRAY = "ARRAY",
+    CONDITION = "CONDITION",
+    VARIABLE = "VARIABLE"
+}
+/**
+ * For more easily typing tokens that might or might not be valid.
+ *
+ * Using @see Token does not work well in certain situations and is also more complex because it has so many generics.
+ */
+export type AnyToken<TType extends TOKEN_TYPE = TOKEN_TYPE> = ValidToken<TType> | ErrorToken<TType>;
+export type ParserResults = ExpressionNode | ConditionNode | GroupNode | ErrorToken<TOKEN_TYPE.VALUE>;
+export type Nodes = ExpressionNode | ConditionNode | GroupNode | VariableNode | ArrayNode;
+/**
+ * Contains any delimiter tokens some AST nodes ( @see GroupNode and @see VariableNode ) can have.
+ *
+ * These are usually not important for evaluating an expression but are useful for syntax highlighting.
+ */
+export type NodeDelimiters<TLEFT extends TOKEN_TYPE, TRIGHT extends TOKEN_TYPE = TLEFT> = {
+    left: AnyToken<TLEFT>;
+    right: AnyToken<TRIGHT>;
+    /** Only exists if regexes are enabled and this is a regex value. */
+    flags?: ValidToken<TOKEN_TYPE.VALUE>;
+};
+//# sourceMappingURL=ast.d.ts.map

package/dist/types/ast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/types/ast.ts"],"names":[],"mappings":"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"}

package/dist/types/ast.js

@@ -0,0 +1,29 @@
+var TOKEN_TYPE = /* @__PURE__ */ ((TOKEN_TYPE2) => {
+  TOKEN_TYPE2["VALUE"] = "VALUE";
+  TOKEN_TYPE2["AND"] = "AND";
+  TOKEN_TYPE2["OR"] = "OR";
+  TOKEN_TYPE2["NOT"] = "NOT";
+  TOKEN_TYPE2["BACKTICK"] = "BACKTICK";
+  TOKEN_TYPE2["SINGLEQUOTE"] = "SINGLEQUOTE";
+  TOKEN_TYPE2["DOUBLEQUOTE"] = "DOUBLEQUOTE";
+  TOKEN_TYPE2["PARENL"] = "PARENL";
+  TOKEN_TYPE2["PARENR"] = "PARENR";
+  TOKEN_TYPE2["BRACKETL"] = "BRACKETL";
+  TOKEN_TYPE2["BRACKETR"] = "BRACKETR";
+  TOKEN_TYPE2["OP_EXPANDED_SEP"] = "OP_EXPANDED";
+  TOKEN_TYPE2["OP_CUSTOM"] = "OP_CUSTOM";
+  TOKEN_TYPE2["REGEX"] = "REGEX";
+  return TOKEN_TYPE2;
+})(TOKEN_TYPE || {});
+var AST_TYPE = /* @__PURE__ */ ((AST_TYPE2) => {
+  AST_TYPE2["EXPRESSION"] = "EXPRESSION";
+  AST_TYPE2["GROUP"] = "GROUP";
+  AST_TYPE2["ARRAY"] = "ARRAY";
+  AST_TYPE2["CONDITION"] = "CONDITION";
+  AST_TYPE2["VARIABLE"] = "VARIABLE";
+  return AST_TYPE2;
+})(AST_TYPE || {});
+export {
+  AST_TYPE,
+  TOKEN_TYPE
+};

package/dist/types/autocomplete.d.ts

@@ -0,0 +1,143 @@
+import type { AnyToken, Position } from "./ast.js";
+import type { ValidToken } from "../ast/classes/ValidToken.js";
+/**
+ * Contains information regarding the tokens around a cursor position. Mostly for internally use by @see autosuggest.
+ *
+ * Notes:
+ *
+ * - There are no whitespace tokens because whitespace is not tokenized. `prev`, `at`, `next` properties that contain tokens are set looking only at the list of tokens extracted from the ast by @see extractTokens. This is why there is an extra `whitespace` property to tell us whether there is whitespace (i.e. a hole) between the cursor and the next/prev **valid** tokens or if it can't find any, the start/end of the input.
+ * - If next/prev are invalid tokens, note that there are cases where more invalid tokens might follow them. To get them we can use @see getSurroundingErrors or we can just find their index in the tokens list and go forward/backward as needed:
+ * ```ts
+ * let i =  tokens.findIndex(t => t === info.next)
+ * while (tokens[i] instanceof ErrorToken) {...}
+ * ```
+ *
+ * Examples:
+ *
+ * ```js
+ * aaaa| bbbb // tokens: ["aaaa", TokenError(operator), "bbbb"]
+ *     ^
+ * {
+ * 	index: 4, // cursor position
+ * 	at: undefined, // it's not inside a token
+ * 	prev: "aaaa",
+ * 	next: TokenError, // operator is missing to the right
+ * 	// closest valid tokens to either side
+ * 	valid: {
+ * 		prev: "aaaa",
+ * 		next: "bbbb",
+ * 	},
+ * 	// whether there is whitespace between the cursor and the next/prev valid tokens or start/end of input
+ * 	whitespace: {
+ * 		prev: false,
+ * 		next: true,
+ * 	}
+ * }
+ * ```
+ * ```js
+ * aaaa || bb|bb && cccc
+ *           ^
+ * {
+ * 	index: 10,
+ * 	at: "bbbb", // it's inside a token
+ * 	prev: "||",
+ * 	next: "&&",
+ * 	valid: {
+ * 		prev: "||",
+ * 		next: "&&",
+ * 	},
+ * 	whitespace: {
+ * 		prev: true,
+ * 		next: true,
+ * 	}
+ * }
+ * ```
+ */
+export type CursorInfo = {
+    index: number;
+    /**
+     * The token the cursor is inside of. By "inside", we mean the ends of the token are before/after the cursor respectively (e.g. `a|a`, but NOT `|aa` or `aa|`). This token, if defined, is always a valid token, since error tokens have no length.
+     *
+     * Note though that there are cases where one might be inside a variable but not inside a token because quotes are their own tokens (e.g. `"|var"` or `"var|"`).
+     */
+    at?: ValidToken;
+    /** The first token, valid or invalid, that starts at or after the index position. */
+    next?: AnyToken;
+    /** The first token (going backwards), valid or invalid, that ends at or before the index position. */
+    prev?: AnyToken;
+    /** Closest valid tokens. */
+    valid: {
+        /** Closest prev valid token. */
+        next?: ValidToken;
+        /** Closest next valid token. */
+        prev?: ValidToken;
+    };
+    /** Whether there is whitespace between the cursor and the next/prev valid tokens or start/end of the input. */
+    whitespace: {
+        /** Whether there is whitespace between the cursor and the next valid token or the end of the input. */
+        next: boolean;
+        /** Whether there is whitespace between the cursor and the prev valid token or the start of the input. */
+        prev: boolean;
+    };
+};
+export declare enum SUGGESTION_TYPE {
+    VARIABLE = "VARIABLE",
+    ARRAY_VALUE = "ARRAY_VALUE",
+    VALUE = "VALUE",
+    PREFIX = "PREFIX",
+    BOOLEAN_WORD_OP = "BOOLEAN_WORD_OP",
+    BOOLEAN_SYMBOL_OP = "BOOLEAN_SYMBOL_OP",
+    BACKTICK = "BACKTICK",
+    DOUBLEQUOTE = "DOUBLEQUOTE",
+    SINGLEQUOTE = "SINGLEQUOTE",
+    PARENL = "PARENL",
+    PARENR = "PARENR",
+    PROPERTY = "PROPERTY",
+    EXPANDED_PROPERTY_OPERATOR = "EXPANDED_PROPERTY_OPERATOR",
+    CUSTOM_PROPERTY_OPERATOR = "CUSTOM_PROPERTY_OPERATOR",
+    PROPERTY_SEP = "PROPERTY_SEP",
+    BRAKCETR = "BRAKCETR",
+    REGEX = "REGEX",
+    REGEX_FLAGS = "REGEX_FLAGS"
+}
+/**
+ * A suggestion entry that describes a type of suggestion.
+ */
+export type Suggestion = {
+    type: SUGGESTION_TYPE;
+    /** The range the suggestion should replace / be inserted at. */
+    range: Position;
+    /** @see CursorInfo */
+    cursorInfo: CursorInfo;
+    /** Tells us any additional requirements for inserting the suggestion. */
+    requires: {
+        /**
+         * Whether the suggestions requires inserting whitespace before/after to keep the intent of the expression consistent. For example, an unquoted variable needs a space between it and a non-symbol operator.
+         *
+         * In the case of variables this requirement can be ignored though if you insert a quoted value.
+         */
+        whitespace: {
+            after: boolean;
+            before: boolean;
+        };
+        /**
+         * If prefixableGroups is enabled, a suggestion can be a prefix suggestion and this tells us whether `()` needs to be inserted at the end in the case it does not already exist.
+         *
+         * For example, a user might choose to insert a prefix in this situation `a && |` and we want the result to be `a && prefix()` because without the `()` the prefix will probably be an invalid variable name on insertion.
+         *
+         * The opposite happens with an existing prefix where the user might want to replace it. `a && existing|(...)`. We want the result to be `a && replacement(...)` not `a && replacement()(...)`.
+         */
+        group: boolean;
+        /** If `prefixableValues` is enabled and a value is prefixed, contains the prefix it was prefixed with. Note that the prefix is included in the range. This way you can choose to suggest/replace just the prefix, just the value or both. */
+        prefix: string | false;
+    };
+    /**
+     * Whether the suggestion was created because there was an error token there and it would fix it.
+     */
+    isError: boolean;
+};
+export type Completion = {
+    suggestion: Suggestion;
+    value: string;
+};
+//# sourceMappingURL=autocomplete.d.ts.map

package/dist/types/autocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.d.ts","sourceRoot":"","sources":["../../src/types/autocomplete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAElD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAA;AAG9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,EAAE,CAAC,EAAE,UAAU,CAAA;IACf,qFAAqF;IACrF,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,sGAAsG;IACtG,IAAI,CAAC,EAAE,QAAQ,CAAA;IACf,4BAA4B;IAC5B,KAAK,EAAE;QACN,gCAAgC;QAChC,IAAI,CAAC,EAAE,UAAU,CAAA;QACjB,gCAAgC;QAChC,IAAI,CAAC,EAAE,UAAU,CAAA;KACjB,CAAA;IACD,+GAA+G;IAC/G,UAAU,EAAE;QACX,uGAAuG;QACvG,IAAI,EAAE,OAAO,CAAA;QACb,yGAAyG;QACzG,IAAI,EAAE,OAAO,CAAA;KACb,CAAA;CACD,CAAA;AAED,oBAAY,eAAe;IAE1B,QAAQ,aAAa;IACrB,WAAW,gBAAgB;IAC3B,KAAK,UAAU;IACf,MAAM,WAAW;IACjB,eAAe,oBAAoB;IACnC,iBAAiB,sBAAsB;IACvC,QAAQ,aAAa;IACrB,WAAW,gBAAgB;IAC3B,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,QAAQ,aAAa;IACrB,0BAA0B,+BAA+B;IACzD,wBAAwB,6BAA6B;IACrD,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,WAAW,gBAAgB;CAG3B;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACxB,IAAI,EAAE,eAAe,CAAA;IACrB,gEAAgE;IAChE,KAAK,EAAE,QAAQ,CAAA;IACf,sBAAsB;IACtB,UAAU,EAAE,UAAU,CAAA;IACtB,yEAAyE;IACzE,QAAQ,EAAE;QACT;;;;WAIG;QACH,UAAU,EAAE;YACX,KAAK,EAAE,OAAO,CAAA;YACd,MAAM,EAAE,OAAO,CAAA;SACf,CAAA;QACD;;;;;;WAMG;QACH,KAAK,EAAE,OAAO,CAAA;QACd,6OAA6O;QAC7O,MAAM,EAAE,MAAM,GAAG,KAAK,CAAA;KACtB,CAAA;IACD;;OAEG;IACH,OAAO,EAAE,OAAO,CAAA;CAChB,CAAA;AAGD,MAAM,MAAM,UAAU,GAAG;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,KAAK,EAAE,MAAM,CAAA;CACb,CAAA"}