@react-querybuilder/core 8.10.0 → 8.11.0

package/dist/{convertQuery-BUgyz1GA.mjs → convertQuery-CqX3rPvj.mjs}

@@ -1,4 +1,4 @@
-import { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, lc } from "./isRuleGroup-CGe_rb2w.mjs";
+import { a as lc, n as isRuleGroupType, r as isRuleGroupTypeIC, t as isRuleGroup } from "./isRuleGroup-CYcfPgbg.mjs";
 import { produce } from "immer";
 
 //#region src/utils/convertQuery.ts
@@ -71,5 +71,5 @@ const convertToIC = (rg) => {
 };
 
 //#endregion
-export { convertFromIC, convertToIC };
-//# sourceMappingURL=convertQuery-BUgyz1GA.mjs.map
+export { convertToIC as n, convertFromIC as t };
+//# sourceMappingURL=convertQuery-CqX3rPvj.mjs.map

package/dist/{convertQuery-BUgyz1GA.mjs.map → convertQuery-CqX3rPvj.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"convertQuery-BUgyz1GA.mjs","names":["rules: (RuleGroupTypeIC | RuleType | string)[]"],"sources":["../src/utils/convertQuery.ts"],"sourcesContent":["import { produce } from 'immer';\nimport type {\n  RuleGroupArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n} from '../types';\nimport { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC } from './isRuleGroup';\nimport { lc } from './misc';\n\nconst combinatorLevels = ['or', 'xor', 'and'] as const;\n\nconst isSameString = (a: unknown, b: string) => lc(a) === b;\n\nconst generateRuleGroupICWithConsistentCombinators = (\n  rg: RuleGroupTypeIC,\n  baseCombinatorLevel: number = 0\n): RuleGroupTypeIC => {\n  const baseCombinator = combinatorLevels[baseCombinatorLevel];\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  if (!rg.rules.includes(baseCombinator as any)) {\n    // No instances of this combinator, so group based on the next\n    // combinator level if at least two levels remain\n    return baseCombinatorLevel < combinatorLevels.length - 2\n      ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1)\n      : rg;\n  }\n\n  return produce(rg, draft => {\n    let cursor = 0;\n\n    // Group all chains of combinators in the rule array that are not the base combinator\n    while (cursor < draft.rules.length - 2) {\n      if (isSameString(draft.rules[cursor + 1], baseCombinator)) {\n        cursor += 2;\n        continue;\n      }\n\n      const nextBaseCombinatorIndex = draft.rules.findIndex(\n        (r, i) => i > cursor && typeof r === 'string' && lc(r) === baseCombinator\n      );\n\n      if (nextBaseCombinatorIndex === -1) {\n        // No more instances of this combinator, so group all remaining rules and exit the loop\n        draft.rules.splice(\n          cursor,\n          draft.rules.length,\n          generateRuleGroupICWithConsistentCombinators(\n            // oxlint-disable-next-line typescript/no-explicit-any\n            { rules: draft.rules.slice(cursor) as any },\n            baseCombinatorLevel + 1\n          )\n        );\n        break;\n      } else {\n        // Group all rules between the current cursor and the next instance of the base combinator\n        draft.rules.splice(\n          cursor,\n          nextBaseCombinatorIndex - cursor,\n          generateRuleGroupICWithConsistentCombinators(\n            // oxlint-disable-next-line typescript/no-explicit-any\n            { rules: draft.rules.slice(cursor, nextBaseCombinatorIndex) as any },\n            baseCombinatorLevel + 1\n          )\n        );\n      }\n    }\n  });\n};\n\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.\n *\n * This function is idempotent: {@link RuleGroupType} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertFromIC = <RG extends RuleGroupType = RuleGroupType>(\n  rg: RuleGroupTypeAny\n): RG => {\n  if (isRuleGroupType(rg)) {\n    return rg as RG;\n  }\n  const processedRG = generateRuleGroupICWithConsistentCombinators(rg);\n  const rulesAsMixedList = processedRG.rules.map(r =>\n    typeof r === 'string' || !isRuleGroup(r) ? r : convertFromIC(r)\n  );\n  const combinator = rulesAsMixedList.length < 2 ? 'and' : (rulesAsMixedList[1] as string);\n  const rules = rulesAsMixedList.filter(r => typeof r !== 'string') as RuleGroupArray;\n  return { ...processedRG, combinator, rules } as RG;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.\n *\n * This function is idempotent: {@link RuleGroupTypeIC} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertToIC = <RGIC extends RuleGroupTypeIC = RuleGroupTypeIC>(\n  rg: RuleGroupTypeAny\n): RGIC => {\n  if (isRuleGroupTypeIC(rg)) {\n    return rg as RGIC;\n  }\n  const { combinator, ...queryWithoutCombinator } = rg;\n  const rules: (RuleGroupTypeIC | RuleType | string)[] = [];\n  const { length } = rg.rules;\n  for (const [idx, r] of rg.rules.entries()) {\n    if (isRuleGroup(r)) {\n      rules.push(convertToIC(r));\n    } else {\n      rules.push(r);\n    }\n    if (combinator && idx < length - 1) {\n      rules.push(combinator);\n    }\n  }\n  return { ...queryWithoutCombinator, rules } as RGIC;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit\n * operation, use {@link convertToIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupType): RuleGroupTypeIC;\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit\n * operation, use {@link convertFromIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupTypeIC): RuleGroupType;\nfunction convertQuery(query: RuleGroupType | RuleGroupTypeIC): RuleGroupType | RuleGroupTypeIC {\n  return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);\n}\n\nexport { convertQuery };\n"],"mappings":";;;;AAWA,MAAM,mBAAmB;CAAC;CAAM;CAAO;CAAM;AAE7C,MAAM,gBAAgB,GAAY,MAAc,GAAG,EAAE,KAAK;AAE1D,MAAM,gDACJ,IACA,sBAA8B,MACV;CACpB,MAAM,iBAAiB,iBAAiB;AAGxC,KAAI,CAAC,GAAG,MAAM,SAAS,eAAsB,CAG3C,QAAO,sBAAsB,iBAAiB,SAAS,IACnD,6CAA6C,IAAI,sBAAsB,EAAE,GACzE;AAGN,QAAO,QAAQ,KAAI,UAAS;EAC1B,IAAI,SAAS;AAGb,SAAO,SAAS,MAAM,MAAM,SAAS,GAAG;AACtC,OAAI,aAAa,MAAM,MAAM,SAAS,IAAI,eAAe,EAAE;AACzD,cAAU;AACV;;GAGF,MAAM,0BAA0B,MAAM,MAAM,WACzC,GAAG,MAAM,IAAI,UAAU,OAAO,MAAM,YAAY,GAAG,EAAE,KAAK,eAC5D;AAED,OAAI,4BAA4B,IAAI;AAElC,UAAM,MAAM,OACV,QACA,MAAM,MAAM,QACZ,6CAEE,EAAE,OAAO,MAAM,MAAM,MAAM,OAAO,EAAS,EAC3C,sBAAsB,EACvB,CACF;AACD;SAGA,OAAM,MAAM,OACV,QACA,0BAA0B,QAC1B,6CAEE,EAAE,OAAO,MAAM,MAAM,MAAM,QAAQ,wBAAwB,EAAS,EACpE,sBAAsB,EACvB,CACF;;GAGL;;;;;;;;;;AAWJ,MAAa,iBACX,OACO;AACP,KAAI,gBAAgB,GAAG,CACrB,QAAO;CAET,MAAM,cAAc,6CAA6C,GAAG;CACpE,MAAM,mBAAmB,YAAY,MAAM,KAAI,MAC7C,OAAO,MAAM,YAAY,CAAC,YAAY,EAAE,GAAG,IAAI,cAAc,EAAE,CAChE;CACD,MAAM,aAAa,iBAAiB,SAAS,IAAI,QAAS,iBAAiB;CAC3E,MAAM,QAAQ,iBAAiB,QAAO,MAAK,OAAO,MAAM,SAAS;AACjE,QAAO;EAAE,GAAG;EAAa;EAAY;EAAO;;;;;;;;;;AAW9C,MAAa,eACX,OACS;AACT,KAAI,kBAAkB,GAAG,CACvB,QAAO;CAET,MAAM,EAAE,WAAY,GAAG,2BAA2B;CAClD,MAAMA,QAAiD,EAAE;CACzD,MAAM,EAAE,WAAW,GAAG;AACtB,MAAK,MAAM,CAAC,KAAK,MAAM,GAAG,MAAM,SAAS,EAAE;AACzC,MAAI,YAAY,EAAE,CAChB,OAAM,KAAK,YAAY,EAAE,CAAC;MAE1B,OAAM,KAAK,EAAE;AAEf,MAAI,cAAc,MAAM,SAAS,EAC/B,OAAM,KAAK,WAAW;;AAG1B,QAAO;EAAE,GAAG;EAAwB;EAAO"}
+{"version":3,"file":"convertQuery-CqX3rPvj.mjs","names":["rules: (RuleGroupTypeIC | RuleType | string)[]"],"sources":["../src/utils/convertQuery.ts"],"sourcesContent":["import { produce } from 'immer';\nimport type {\n  RuleGroupArray,\n  RuleGroupType,\n  RuleGroupTypeAny,\n  RuleGroupTypeIC,\n  RuleType,\n} from '../types';\nimport { isRuleGroup, isRuleGroupType, isRuleGroupTypeIC } from './isRuleGroup';\nimport { lc } from './misc';\n\nconst combinatorLevels = ['or', 'xor', 'and'] as const;\n\nconst isSameString = (a: unknown, b: string) => lc(a) === b;\n\nconst generateRuleGroupICWithConsistentCombinators = (\n  rg: RuleGroupTypeIC,\n  baseCombinatorLevel: number = 0\n): RuleGroupTypeIC => {\n  const baseCombinator = combinatorLevels[baseCombinatorLevel];\n\n  // oxlint-disable-next-line typescript/no-explicit-any\n  if (!rg.rules.includes(baseCombinator as any)) {\n    // No instances of this combinator, so group based on the next\n    // combinator level if at least two levels remain\n    return baseCombinatorLevel < combinatorLevels.length - 2\n      ? generateRuleGroupICWithConsistentCombinators(rg, baseCombinatorLevel + 1)\n      : rg;\n  }\n\n  return produce(rg, draft => {\n    let cursor = 0;\n\n    // Group all chains of combinators in the rule array that are not the base combinator\n    while (cursor < draft.rules.length - 2) {\n      if (isSameString(draft.rules[cursor + 1], baseCombinator)) {\n        cursor += 2;\n        continue;\n      }\n\n      const nextBaseCombinatorIndex = draft.rules.findIndex(\n        (r, i) => i > cursor && typeof r === 'string' && lc(r) === baseCombinator\n      );\n\n      if (nextBaseCombinatorIndex === -1) {\n        // No more instances of this combinator, so group all remaining rules and exit the loop\n        draft.rules.splice(\n          cursor,\n          draft.rules.length,\n          generateRuleGroupICWithConsistentCombinators(\n            // oxlint-disable-next-line typescript/no-explicit-any\n            { rules: draft.rules.slice(cursor) as any },\n            baseCombinatorLevel + 1\n          )\n        );\n        break;\n      } else {\n        // Group all rules between the current cursor and the next instance of the base combinator\n        draft.rules.splice(\n          cursor,\n          nextBaseCombinatorIndex - cursor,\n          generateRuleGroupICWithConsistentCombinators(\n            // oxlint-disable-next-line typescript/no-explicit-any\n            { rules: draft.rules.slice(cursor, nextBaseCombinatorIndex) as any },\n            baseCombinatorLevel + 1\n          )\n        );\n      }\n    }\n  });\n};\n\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}.\n *\n * This function is idempotent: {@link RuleGroupType} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertFromIC = <RG extends RuleGroupType = RuleGroupType>(\n  rg: RuleGroupTypeAny\n): RG => {\n  if (isRuleGroupType(rg)) {\n    return rg as RG;\n  }\n  const processedRG = generateRuleGroupICWithConsistentCombinators(rg);\n  const rulesAsMixedList = processedRG.rules.map(r =>\n    typeof r === 'string' || !isRuleGroup(r) ? r : convertFromIC(r)\n  );\n  const combinator = rulesAsMixedList.length < 2 ? 'and' : (rulesAsMixedList[1] as string);\n  const rules = rulesAsMixedList.filter(r => typeof r !== 'string') as RuleGroupArray;\n  return { ...processedRG, combinator, rules } as RG;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}.\n *\n * This function is idempotent: {@link RuleGroupTypeIC} queries will be\n * returned as-is.\n *\n * @group Query Tools\n */\nexport const convertToIC = <RGIC extends RuleGroupTypeIC = RuleGroupTypeIC>(\n  rg: RuleGroupTypeAny\n): RGIC => {\n  if (isRuleGroupTypeIC(rg)) {\n    return rg as RGIC;\n  }\n  const { combinator, ...queryWithoutCombinator } = rg;\n  const rules: (RuleGroupTypeIC | RuleType | string)[] = [];\n  const { length } = rg.rules;\n  for (const [idx, r] of rg.rules.entries()) {\n    if (isRuleGroup(r)) {\n      rules.push(convertToIC(r));\n    } else {\n      rules.push(r);\n    }\n    if (combinator && idx < length - 1) {\n      rules.push(combinator);\n    }\n  }\n  return { ...queryWithoutCombinator, rules } as RGIC;\n};\n\n/**\n * Converts a {@link RuleGroupType} to {@link RuleGroupTypeIC}. For a more explicit\n * operation, use {@link convertToIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupType): RuleGroupTypeIC;\n/**\n * Converts a {@link RuleGroupTypeIC} to {@link RuleGroupType}. For a more explicit\n * operation, use {@link convertFromIC}.\n *\n * @group Query Tools\n */\nfunction convertQuery(query: RuleGroupTypeIC): RuleGroupType;\nfunction convertQuery(query: RuleGroupType | RuleGroupTypeIC): RuleGroupType | RuleGroupTypeIC {\n  return isRuleGroupTypeIC(query) ? convertFromIC(query) : convertToIC(query);\n}\n\nexport { convertQuery };\n"],"mappings":";;;;AAWA,MAAM,mBAAmB;CAAC;CAAM;CAAO;CAAM;AAE7C,MAAM,gBAAgB,GAAY,MAAc,GAAG,EAAE,KAAK;AAE1D,MAAM,gDACJ,IACA,sBAA8B,MACV;CACpB,MAAM,iBAAiB,iBAAiB;AAGxC,KAAI,CAAC,GAAG,MAAM,SAAS,eAAsB,CAG3C,QAAO,sBAAsB,iBAAiB,SAAS,IACnD,6CAA6C,IAAI,sBAAsB,EAAE,GACzE;AAGN,QAAO,QAAQ,KAAI,UAAS;EAC1B,IAAI,SAAS;AAGb,SAAO,SAAS,MAAM,MAAM,SAAS,GAAG;AACtC,OAAI,aAAa,MAAM,MAAM,SAAS,IAAI,eAAe,EAAE;AACzD,cAAU;AACV;;GAGF,MAAM,0BAA0B,MAAM,MAAM,WACzC,GAAG,MAAM,IAAI,UAAU,OAAO,MAAM,YAAY,GAAG,EAAE,KAAK,eAC5D;AAED,OAAI,4BAA4B,IAAI;AAElC,UAAM,MAAM,OACV,QACA,MAAM,MAAM,QACZ,6CAEE,EAAE,OAAO,MAAM,MAAM,MAAM,OAAO,EAAS,EAC3C,sBAAsB,EACvB,CACF;AACD;SAGA,OAAM,MAAM,OACV,QACA,0BAA0B,QAC1B,6CAEE,EAAE,OAAO,MAAM,MAAM,MAAM,QAAQ,wBAAwB,EAAS,EACpE,sBAAsB,EACvB,CACF;;GAGL;;;;;;;;;;AAWJ,MAAa,iBACX,OACO;AACP,KAAI,gBAAgB,GAAG,CACrB,QAAO;CAET,MAAM,cAAc,6CAA6C,GAAG;CACpE,MAAM,mBAAmB,YAAY,MAAM,KAAI,MAC7C,OAAO,MAAM,YAAY,CAAC,YAAY,EAAE,GAAG,IAAI,cAAc,EAAE,CAChE;CACD,MAAM,aAAa,iBAAiB,SAAS,IAAI,QAAS,iBAAiB;CAC3E,MAAM,QAAQ,iBAAiB,QAAO,MAAK,OAAO,MAAM,SAAS;AACjE,QAAO;EAAE,GAAG;EAAa;EAAY;EAAO;;;;;;;;;;AAW9C,MAAa,eACX,OACS;AACT,KAAI,kBAAkB,GAAG,CACvB,QAAO;CAET,MAAM,EAAE,WAAY,GAAG,2BAA2B;CAClD,MAAMA,QAAiD,EAAE;CACzD,MAAM,EAAE,WAAW,GAAG;AACtB,MAAK,MAAM,CAAC,KAAK,MAAM,GAAG,MAAM,SAAS,EAAE;AACzC,MAAI,YAAY,EAAE,CAChB,OAAM,KAAK,YAAY,EAAE,CAAC;MAE1B,OAAM,KAAK,EAAE;AAEf,MAAI,cAAc,MAAM,SAAS,EAC/B,OAAM,KAAK,WAAW;;AAG1B,QAAO;EAAE,GAAG;EAAwB;EAAO"}

package/dist/{export-Ccjfea21.d.mts → export-Dy4FckB-.d.ts}

@@ -1,4 +1,4 @@
-import { DefaultOperatorName, FlexibleOptionList, FullField, FullOperator, FullOptionList, InputType, ParseNumbersPropConfig, QueryValidator, RuleGroupTypeAny, RuleType, RuleValidator, ValidationMap, ValidationResult, ValueSource } from "./basic-BmpEwexQ.mjs";
+import { a as ValueSource, b as FullOptionList, c as RuleValidator, f as RuleGroupTypeAny, h as DefaultOperatorName, i as ParseNumbersPropConfig, l as ValidationMap, n as FullOperator, r as InputType, s as QueryValidator, t as FullField, u as ValidationResult, v as RuleType, y as FlexibleOptionList } from "./basic-Dd_M2f3M.js";
 import { RulesLogic } from "json-logic-js";
 import { Except } from "type-fest";
 
@@ -113,11 +113,11 @@ interface FormatQueryOptions {
   quoteValuesWith?: string;
   /**
   * Validator function for the entire query. Can be the same function passed
-  * as `validator` prop to {@link QueryBuilder}.
+  * as `validator` prop to {@link react-querybuilder!QueryBuilder QueryBuilder}.
   */
   validator?: QueryValidator;
   /**
-  * This can be the same {@link FullField} array passed to {@link QueryBuilder}, but
+  * This can be the same {@link FullField} array passed to {@link react-querybuilder!QueryBuilder QueryBuilder}, but
   * really all you need to provide is the `name` and `validator` for each field.
   *
   * The full field object from this array, where the field's identifying property
@@ -125,7 +125,7 @@ interface FormatQueryOptions {
   */
   fields?: FlexibleOptionList<FullField>;
   /**
-  * This can be the same `getOperators` function passed to {@link QueryBuilder}.
+  * This can be the same `getOperators` function passed to {@link react-querybuilder!QueryBuilder QueryBuilder}.
   *
   * The full operator object from this array, where the operator's identifying property
   * matches the rule's `operator`, will be passed to the rule processor.
@@ -449,5 +449,5 @@ type NLTranslationKey = "and" | "or" | "true" | "false" | `groupPrefix${ZeroOrMo
 */
 type NLTranslations = Partial<Record<NLTranslationKey, string>>;
 //#endregion
-export { ConstituentWordOrder, ExportFormat, ExportObjectFormats, ExportOperatorMap, FormatQueryOptions, GroupVariantCondition, NLTranslationKey, NLTranslations, ParameterizedNamedSQL, ParameterizedSQL, RQBJsonLogic, RuleGroupProcessor, RuleProcessor, SQLPreset, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions };
-//# sourceMappingURL=export-Ccjfea21.d.mts.map
+export { ValueProcessorOptions as _, FormatQueryOptions as a, NLTranslations as c, RQBJsonLogic as d, RuleGroupProcessor as f, ValueProcessorLegacy as g, ValueProcessorByRule as h, ExportOperatorMap as i, ParameterizedNamedSQL as l, SQLPreset as m, ExportFormat as n, GroupVariantCondition as o, RuleProcessor as p, ExportObjectFormats as r, NLTranslationKey as s, ConstituentWordOrder as t, ParameterizedSQL as u };
+//# sourceMappingURL=export-Dy4FckB-.d.ts.map

package/dist/{export-GUuxJ7zR.d.ts → export-t1V2N8pz.d.mts}

@@ -1,4 +1,4 @@
-import { DefaultOperatorName, FlexibleOptionList, FullField, FullOperator, FullOptionList, InputType, ParseNumbersPropConfig, QueryValidator, RuleGroupTypeAny, RuleType, RuleValidator, ValidationMap, ValidationResult, ValueSource } from "./basic-CDDA-KZa.js";
+import { a as ValueSource, b as FullOptionList, c as RuleValidator, f as RuleGroupTypeAny, h as DefaultOperatorName, i as ParseNumbersPropConfig, l as ValidationMap, n as FullOperator, r as InputType, s as QueryValidator, t as FullField, u as ValidationResult, v as RuleType, y as FlexibleOptionList } from "./basic-DEc65Kng.mjs";
 import { RulesLogic } from "json-logic-js";
 import { Except } from "type-fest";
 
@@ -113,11 +113,11 @@ interface FormatQueryOptions {
   quoteValuesWith?: string;
   /**
   * Validator function for the entire query. Can be the same function passed
-  * as `validator` prop to {@link QueryBuilder}.
+  * as `validator` prop to {@link react-querybuilder!QueryBuilder QueryBuilder}.
   */
   validator?: QueryValidator;
   /**
-  * This can be the same {@link FullField} array passed to {@link QueryBuilder}, but
+  * This can be the same {@link FullField} array passed to {@link react-querybuilder!QueryBuilder QueryBuilder}, but
   * really all you need to provide is the `name` and `validator` for each field.
   *
   * The full field object from this array, where the field's identifying property
@@ -125,7 +125,7 @@ interface FormatQueryOptions {
   */
   fields?: FlexibleOptionList<FullField>;
   /**
-  * This can be the same `getOperators` function passed to {@link QueryBuilder}.
+  * This can be the same `getOperators` function passed to {@link react-querybuilder!QueryBuilder QueryBuilder}.
   *
   * The full operator object from this array, where the operator's identifying property
   * matches the rule's `operator`, will be passed to the rule processor.
@@ -449,5 +449,5 @@ type NLTranslationKey = "and" | "or" | "true" | "false" | `groupPrefix${ZeroOrMo
 */
 type NLTranslations = Partial<Record<NLTranslationKey, string>>;
 //#endregion
-export { ConstituentWordOrder, ExportFormat, ExportObjectFormats, ExportOperatorMap, FormatQueryOptions, GroupVariantCondition, NLTranslationKey, NLTranslations, ParameterizedNamedSQL, ParameterizedSQL, RQBJsonLogic, RuleGroupProcessor, RuleProcessor, SQLPreset, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions };
-//# sourceMappingURL=export-GUuxJ7zR.d.ts.map
+export { ValueProcessorOptions as _, FormatQueryOptions as a, NLTranslations as c, RQBJsonLogic as d, RuleGroupProcessor as f, ValueProcessorLegacy as g, ValueProcessorByRule as h, ExportOperatorMap as i, ParameterizedNamedSQL as l, SQLPreset as m, ExportFormat as n, GroupVariantCondition as o, RuleProcessor as p, ExportObjectFormats as r, NLTranslationKey as s, ConstituentWordOrder as t, ParameterizedSQL as u };
+//# sourceMappingURL=export-t1V2N8pz.d.mts.map

package/dist/formatQuery.d.mts

@@ -1,5 +1,5 @@
-import { RuleGroupTypeAny, RuleType } from "./basic-BmpEwexQ.mjs";
-import { ConstituentWordOrder, ExportFormat, ExportObjectFormats, ExportOperatorMap, FormatQueryOptions, GroupVariantCondition, NLTranslationKey, NLTranslations, ParameterizedNamedSQL, ParameterizedSQL, RQBJsonLogic, RuleGroupProcessor, RuleProcessor, SQLPreset, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions } from "./export-Ccjfea21.mjs";
+import { f as RuleGroupTypeAny, v as RuleType } from "./basic-DEc65Kng.mjs";
+import { _ as ValueProcessorOptions, a as FormatQueryOptions, c as NLTranslations, d as RQBJsonLogic, f as RuleGroupProcessor, g as ValueProcessorLegacy, h as ValueProcessorByRule, i as ExportOperatorMap, l as ParameterizedNamedSQL, m as SQLPreset, n as ExportFormat, o as GroupVariantCondition, p as RuleProcessor, r as ExportObjectFormats, s as NLTranslationKey, t as ConstituentWordOrder, u as ParameterizedSQL } from "./export-t1V2N8pz.mjs";
 import { SetRequired } from "type-fest";
 import { Column, Operators, SQL, Table } from "drizzle-orm";
 import { WhereOptions } from "sequelize";

package/dist/formatQuery.d.ts

@@ -1,5 +1,5 @@
-import { RuleGroupTypeAny, RuleType } from "./basic-CDDA-KZa.js";
-import { ConstituentWordOrder, ExportFormat, ExportObjectFormats, ExportOperatorMap, FormatQueryOptions, GroupVariantCondition, NLTranslationKey, NLTranslations, ParameterizedNamedSQL, ParameterizedSQL, RQBJsonLogic, RuleGroupProcessor, RuleProcessor, SQLPreset, ValueProcessorByRule, ValueProcessorLegacy, ValueProcessorOptions } from "./export-GUuxJ7zR.js";
+import { f as RuleGroupTypeAny, v as RuleType } from "./basic-Dd_M2f3M.js";
+import { _ as ValueProcessorOptions, a as FormatQueryOptions, c as NLTranslations, d as RQBJsonLogic, f as RuleGroupProcessor, g as ValueProcessorLegacy, h as ValueProcessorByRule, i as ExportOperatorMap, l as ParameterizedNamedSQL, m as SQLPreset, n as ExportFormat, o as GroupVariantCondition, p as RuleProcessor, r as ExportObjectFormats, s as NLTranslationKey, t as ConstituentWordOrder, u as ParameterizedSQL } from "./export-Dy4FckB-.js";
 import { SetRequired } from "type-fest";
 import { Column, Operators, SQL, Table } from "drizzle-orm";
 import { WhereOptions } from "sequelize";

package/dist/formatQuery.mjs

@@ -1,9 +1,9 @@
-import { defaultPlaceholderFieldName, defaultPlaceholderOperatorName, getOption, toFlatOptionArray, toFullOptionList } from "./optGroupUtils-DrubUpx0.mjs";
-import { joinWith, splitBy, toArray, trimIfString } from "./arrayUtils-C9sO4qLO.mjs";
-import { isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, lc, nullOrUndefinedOrEmpty, numericRegex } from "./isRuleGroup-CGe_rb2w.mjs";
-import { parseNumber } from "./parseNumber-B_-sR6d5.mjs";
-import { transformQuery } from "./transformQuery-DHvtgDgZ.mjs";
-import { convertFromIC } from "./convertQuery-BUgyz1GA.mjs";
+import { d as defaultPlaceholderOperatorName, i as toFlatOptionArray, o as toFullOptionList, t as getOption, u as defaultPlaceholderFieldName } from "./optGroupUtils-VeZ3k7-1.mjs";
+import { i as trimIfString, n as splitBy, r as toArray, t as joinWith } from "./arrayUtils-A_OXU9W1.mjs";
+import { a as lc, i as isPojo, n as isRuleGroupType, o as nullOrUndefinedOrEmpty, r as isRuleGroupTypeIC, s as numericRegex, t as isRuleGroup } from "./isRuleGroup-CYcfPgbg.mjs";
+import { t as parseNumber } from "./parseNumber-CXdMVNFx.mjs";
+import { t as transformQuery } from "./transformQuery-DCCpjtyq.mjs";
+import { t as convertFromIC } from "./convertQuery-CqX3rPvj.mjs";
 import { produce } from "immer";
 
 //#region src/utils/isRuleOrGroupValid.ts

package/dist/{import-Dxevzw_-.d.mts → import-Cz8canKo.d.mts}

@@ -1,4 +1,4 @@
-import { FullField, OptionList, ValueSources } from "./basic-BmpEwexQ.mjs";
+import { o as ValueSources, t as FullField, x as OptionList } from "./basic-DEc65Kng.mjs";
 
 //#region src/types/import.d.ts
 
@@ -24,5 +24,5 @@ interface ParserCommonOptions {
   bigIntOnOverflow?: boolean;
 }
 //#endregion
-export { ParserCommonOptions };
-//# sourceMappingURL=import-Dxevzw_-.d.mts.map
+export { ParserCommonOptions as t };
+//# sourceMappingURL=import-Cz8canKo.d.mts.map

package/dist/{import-D-hm1phN.d.ts → import-DtS9Ocx5.d.ts}

@@ -1,4 +1,4 @@
-import { FullField, OptionList, ValueSources } from "./basic-CDDA-KZa.js";
+import { o as ValueSources, t as FullField, x as OptionList } from "./basic-Dd_M2f3M.js";
 
 //#region src/types/import.d.ts
 
@@ -24,5 +24,5 @@ interface ParserCommonOptions {
   bigIntOnOverflow?: boolean;
 }
 //#endregion
-export { ParserCommonOptions };
-//# sourceMappingURL=import-D-hm1phN.d.ts.map
+export { ParserCommonOptions as t };
+//# sourceMappingURL=import-DtS9Ocx5.d.ts.map

package/dist/{isRuleGroup-CGe_rb2w.mjs → isRuleGroup-CYcfPgbg.mjs}

@@ -36,5 +36,5 @@ const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "str
 const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
 
 //#endregion
-export { isPojo, isRuleGroup, isRuleGroupType, isRuleGroupTypeIC, lc, nullOrUndefinedOrEmpty, numericRegex$1 as numericRegex };
-//# sourceMappingURL=isRuleGroup-CGe_rb2w.mjs.map
+export { lc as a, isPojo as i, isRuleGroupType as n, nullOrUndefinedOrEmpty as o, isRuleGroupTypeIC as r, numericRegex$1 as s, isRuleGroup as t };
+//# sourceMappingURL=isRuleGroup-CYcfPgbg.mjs.map

package/dist/{isRuleGroup-CGe_rb2w.mjs.map → isRuleGroup-CYcfPgbg.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isRuleGroup-CGe_rb2w.mjs","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,iBAAuB,IAAI,OACtCC,aAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}
+{"version":3,"file":"isRuleGroup-CYcfPgbg.mjs","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,iBAAuB,IAAI,OACtCC,aAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}

package/dist/lexer-C53tqS2p.js

@@ -0,0 +1,406 @@
+const require_isRuleGroup = require('./isRuleGroup-DqAs2x4E.js');
+
+//#region ../../node_modules/@ts-jison/parser/lib/parser.js
+var require_parser = /* @__PURE__ */ require_isRuleGroup.__commonJS({ "../../node_modules/@ts-jison/parser/lib/parser.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var JisonParser = function() {
+		function JisonParser$1(yy, lexer) {
+			if (yy === void 0) yy = {};
+			this.yy = yy;
+			this.lexer = lexer;
+		}
+		JisonParser$1.prototype.trace = function(str) {};
+		JisonParser$1.prototype.parseError = function(str, hash) {
+			if (hash.recoverable) this.trace(str);
+			else {
+				var error = new Error(str);
+				error.hash = hash;
+				throw error;
+			}
+		};
+		JisonParser$1.prototype.parse = function(input, yy) {
+			if (yy === void 0) yy = typeof this.yy === "function" && typeof this.yy.constructor === "function" ? new this.yy(this, this.lexer) : Object.create(this.yy);
+			var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+			var args = lstack.slice.call(arguments, 1);
+			var lexer = Object.create(this.lexer);
+			var sharedState = { yy };
+			lexer.setInput(input, sharedState.yy);
+			sharedState.yy.lexer = lexer;
+			sharedState.yy.parser = this;
+			if (typeof lexer.yylloc == "undefined") lexer.yylloc = {};
+			var yyloc = lexer.yylloc;
+			lstack.push(yyloc);
+			var ranges = lexer.options && lexer.options.ranges;
+			if (typeof sharedState.yy.parseError === "function") this.parseError = sharedState.yy.parseError;
+			function popStack(n) {
+				stack.length = stack.length - 2 * n;
+				vstack.length = vstack.length - n;
+				lstack.length = lstack.length - n;
+			}
+			var lex = function() {
+				var token = lexer.lex() || EOF;
+				if (typeof token !== "number") token = self.symbols_[token] || token;
+				return token;
+			}, symbol, preErrorSymbol, state, action, r, yyval = {}, p, len, newState, expected;
+			while (true) {
+				state = stack[stack.length - 1];
+				if (this.defaultActions[state]) action = this.defaultActions[state];
+				else {
+					if (symbol === null || typeof symbol == "undefined") symbol = lex();
+					action = table[state] && table[state][symbol];
+				}
+				_handle_error: if (typeof action === "undefined" || !action.length || !action[0]) {
+					var error_rule_depth = null;
+					var errStr = "";
+					if (!recovering) {
+						error_rule_depth = locateNearestErrorRecoveryRule(state);
+						expected = [];
+						for (var _p in table[state]) {
+							p = Number(_p);
+							if (this.terminals_[p] && p > TERROR) expected.push("'" + this.terminals_[p] + "'");
+						}
+						if (lexer.showPosition) errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
+						else errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
+						this.parseError(errStr, {
+							text: lexer.match,
+							token: this.terminals_[symbol] || symbol,
+							line: lexer.yylineno,
+							loc: lexer.yylloc,
+							expected,
+							recoverable: error_rule_depth !== null
+						});
+					} else if (preErrorSymbol !== EOF) error_rule_depth = locateNearestErrorRecoveryRule(state);
+					if (recovering == 3) {
+						if (symbol === EOF || preErrorSymbol === EOF) throw new Error(errStr || "Parsing halted while starting to recover from another error.");
+						yyleng = lexer.yyleng;
+						yytext = lexer.yytext;
+						yylineno = lexer.yylineno;
+						yyloc = lexer.yylloc;
+						symbol = lex();
+					}
+					if (error_rule_depth === null) throw new Error(errStr || "Parsing halted. No suitable error recovery rule available.");
+					popStack(error_rule_depth || 0);
+					preErrorSymbol = symbol == TERROR ? null : symbol;
+					symbol = TERROR;
+					state = stack[stack.length - 1];
+					action = table[state] && table[state][TERROR];
+					recovering = 3;
+				}
+				if (action[0] instanceof Array && action.length > 1) throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
+				switch (action[0]) {
+					case 1:
+						stack.push(symbol);
+						vstack.push(lexer.yytext);
+						lstack.push(lexer.yylloc);
+						stack.push(action[1]);
+						symbol = null;
+						if (!preErrorSymbol) {
+							yyleng = lexer.yyleng;
+							yytext = lexer.yytext;
+							yylineno = lexer.yylineno;
+							yyloc = lexer.yylloc;
+							if (recovering > 0) recovering--;
+						} else {
+							symbol = preErrorSymbol;
+							preErrorSymbol = null;
+						}
+						break;
+					case 2:
+						len = this.productions_[action[1]][1];
+						yyval.$ = vstack[vstack.length - len];
+						yyval._$ = {
+							first_line: lstack[lstack.length - (len || 1)].first_line,
+							last_line: lstack[lstack.length - 1].last_line,
+							first_column: lstack[lstack.length - (len || 1)].first_column,
+							last_column: lstack[lstack.length - 1].last_column
+						};
+						if (ranges) yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
+						r = this.performAction.apply(yyval, [
+							yytext,
+							yyleng,
+							yylineno,
+							sharedState.yy,
+							action[1],
+							vstack,
+							lstack
+						].concat(args));
+						if (typeof r !== "undefined") return r;
+						if (len) {
+							stack = stack.slice(0, -1 * len * 2);
+							vstack = vstack.slice(0, -1 * len);
+							lstack = lstack.slice(0, -1 * len);
+						}
+						stack.push(this.productions_[action[1]][0]);
+						vstack.push(yyval.$);
+						lstack.push(yyval._$);
+						newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+						stack.push(newState);
+						break;
+					case 3: return true;
+				}
+			}
+			return true;
+			function locateNearestErrorRecoveryRule(state$1) {
+				var stack_probe = stack.length - 1;
+				var depth = 0;
+				for (;;) {
+					if (TERROR.toString() in table[state$1]) return depth;
+					if (state$1 === 0 || stack_probe < 2) return null;
+					stack_probe -= 2;
+					state$1 = stack[stack_probe];
+					++depth;
+				}
+			}
+		};
+		JisonParser$1.expandParseTable = function(k, v, o) {
+			var l = k.length;
+			for (o = o || {}; l--; o[k[l]] = v);
+			return o;
+		};
+		return JisonParser$1;
+	}();
+	exports.JisonParser = JisonParser;
+}) });
+
+//#endregion
+//#region ../../node_modules/@ts-jison/lexer/lib/lexer.js
+var require_lexer = /* @__PURE__ */ require_isRuleGroup.__commonJS({ "../../node_modules/@ts-jison/lexer/lib/lexer.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var JisonLexer = function() {
+		function JisonLexer$1(yy) {
+			if (yy === void 0) yy = {};
+			this.yy = yy;
+			this.EOF = 1;
+			this.options = {};
+			this.yyleng = 0;
+			this.yylloc = {
+				first_line: 1,
+				first_column: 0,
+				last_line: 1,
+				last_column: 0
+			};
+		}
+		JisonLexer$1.prototype.parseError = function(str, hash) {
+			if (this.yy.parser) this.yy.parser.parseError(str, hash);
+			else throw new Error(str);
+		};
+		JisonLexer$1.prototype.setInput = function(input, yy) {
+			this.yy = yy || this.yy || {};
+			this._input = input;
+			this._more = this._backtrack = this.done = false;
+			this.yylineno = this.yyleng = 0;
+			this.yytext = this.matched = this.match = "";
+			this.conditionStack = ["INITIAL"];
+			this.yylloc = {
+				first_line: 1,
+				first_column: 0,
+				last_line: 1,
+				last_column: 0
+			};
+			if (this.options.ranges) this.yylloc.range = [0, 0];
+			this.offset = 0;
+			return this;
+		};
+		JisonLexer$1.prototype.input = function() {
+			if (this._input.length === 0) {
+				this.done = true;
+				return "" + this.EOF;
+			}
+			var ch = this._input[0];
+			this.yytext += ch;
+			this.yyleng++;
+			this.offset++;
+			this.match += ch;
+			this.matched += ch;
+			if (ch.match(/(?:\r\n?|\n).*/g)) {
+				this.yylineno++;
+				this.yylloc.last_line++;
+			} else this.yylloc.last_column++;
+			if (this.options.ranges) this.yylloc.range[1]++;
+			this._input = this._input.slice(1);
+			return ch;
+		};
+		JisonLexer$1.prototype.unput = function(ch) {
+			var len = ch.length;
+			var lines = ch.split(/(?:\r\n?|\n)/g);
+			this._input = ch + this._input;
+			this.yytext = this.yytext.substr(0, this.yytext.length - len);
+			this.offset -= len;
+			var oldLines = this.match.split(/(?:\r\n?|\n)/g);
+			this.match = this.match.substr(0, this.match.length - 1);
+			this.matched = this.matched.substr(0, this.matched.length - 1);
+			if (lines.length - 1) this.yylineno -= lines.length - 1;
+			var r = this.yylloc.range;
+			this.yylloc = {
+				first_line: this.yylloc.first_line,
+				last_line: this.yylineno + 1,
+				first_column: this.yylloc.first_column,
+				last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
+			};
+			if (this.options.ranges) this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+			this.yyleng = this.yytext.length;
+			return this;
+		};
+		JisonLexer$1.prototype.more = function() {
+			this._more = true;
+			return this;
+		};
+		JisonLexer$1.prototype.reject = function() {
+			if (this.options.backtrack_lexer) this._backtrack = true;
+			else return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), {
+				text: "",
+				token: null,
+				line: this.yylineno
+			});
+			return this;
+		};
+		JisonLexer$1.prototype.less = function(n) {
+			this.unput(this.match.slice(n));
+		};
+		JisonLexer$1.prototype.pastInput = function() {
+			var past = this.matched.substr(0, this.matched.length - this.match.length);
+			return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
+		};
+		JisonLexer$1.prototype.upcomingInput = function() {
+			var next = this.match;
+			if (next.length < 20) next += this._input.substr(0, 20 - next.length);
+			return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
+		};
+		JisonLexer$1.prototype.showPosition = function() {
+			var pre = this.pastInput();
+			var c = new Array(pre.length + 1).join("-");
+			return pre + this.upcomingInput() + "\n" + c + "^";
+		};
+		JisonLexer$1.prototype.test_match = function(match, indexed_rule) {
+			var token, lines, backup;
+			if (this.options.backtrack_lexer) {
+				backup = {
+					yylineno: this.yylineno,
+					yylloc: {
+						first_line: this.yylloc.first_line,
+						last_line: this.yylloc.last_line,
+						first_column: this.yylloc.first_column,
+						last_column: this.yylloc.last_column
+					},
+					yytext: this.yytext,
+					match: this.match,
+					matches: this.matches,
+					matched: this.matched,
+					yyleng: this.yyleng,
+					offset: this.offset,
+					_more: this._more,
+					_input: this._input,
+					yy: this.yy,
+					conditionStack: this.conditionStack.slice(0),
+					done: this.done
+				};
+				if (this.options.ranges) backup.yylloc.range = this.yylloc.range.slice(0);
+			}
+			lines = match[0].match(/(?:\r\n?|\n).*/g);
+			if (lines) this.yylineno += lines.length;
+			this.yylloc = {
+				first_line: this.yylloc.last_line,
+				last_line: this.yylineno + 1,
+				first_column: this.yylloc.last_column,
+				last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
+			};
+			this.yytext += match[0];
+			this.match += match[0];
+			this.matches = match;
+			this.yyleng = this.yytext.length;
+			if (this.options.ranges) this.yylloc.range = [this.offset, this.offset += this.yyleng];
+			this._more = false;
+			this._backtrack = false;
+			this._input = this._input.slice(match[0].length);
+			this.matched += match[0];
+			token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
+			if (this.done && this._input) this.done = false;
+			if (token) return token;
+			else if (this._backtrack) {
+				for (var k in backup) this[k] = backup[k];
+				return false;
+			}
+			return false;
+		};
+		JisonLexer$1.prototype.next = function() {
+			if (this.done) return this.EOF;
+			if (!this._input) this.done = true;
+			var token, match = null, tempMatch, index;
+			if (!this._more) {
+				this.yytext = "";
+				this.match = "";
+			}
+			var rules = this._currentRules();
+			for (var i = 0; i < rules.length; i++) {
+				tempMatch = this._input.match(this.rules[rules[i]]);
+				if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+					match = tempMatch;
+					index = i;
+					if (this.options.backtrack_lexer) {
+						token = this.test_match(tempMatch, rules[i]);
+						if (token !== false) return token;
+						else if (this._backtrack) {
+							match = null;
+							continue;
+						} else return false;
+					} else if (!this.options.flex) break;
+				}
+			}
+			if (match) {
+				token = this.test_match(match, rules[index]);
+				if (token !== false) return token;
+				return false;
+			}
+			if (this._input === "") return this.EOF;
+			else return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
+				text: "",
+				token: null,
+				line: this.yylineno
+			});
+		};
+		JisonLexer$1.prototype.lex = function() {
+			var r = this.next();
+			if (r) return r;
+			else return this.lex();
+		};
+		JisonLexer$1.prototype.begin = function(condition) {
+			this.conditionStack.push(condition);
+		};
+		JisonLexer$1.prototype.popState = function() {
+			if (this.conditionStack.length - 1 > 0) return this.conditionStack.pop();
+			else return this.conditionStack[0];
+		};
+		JisonLexer$1.prototype._currentRules = function() {
+			if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+			else return this.conditions["INITIAL"].rules;
+		};
+		JisonLexer$1.prototype.topState = function(n) {
+			n = this.conditionStack.length - 1 - Math.abs(n || 0);
+			if (n >= 0) return this.conditionStack[n];
+			else return "INITIAL";
+		};
+		JisonLexer$1.prototype.pushState = function(condition) {
+			this.begin(condition);
+		};
+		JisonLexer$1.prototype.stateStackSize = function() {
+			return this.conditionStack.length;
+		};
+		return JisonLexer$1;
+	}();
+	exports.JisonLexer = JisonLexer;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'require_lexer', {
+  enumerable: true,
+  get: function () {
+    return require_lexer;
+  }
+});
+Object.defineProperty(exports, 'require_parser', {
+  enumerable: true,
+  get: function () {
+    return require_parser;
+  }
+});
+//# sourceMappingURL=lexer-C53tqS2p.js.map