{"version":3,"file":"utils-ChLG90DP.mjs","names":["numericRegex"],"sources":["../src/defaults.ts","../src/utils/arrayUtils.ts","../src/utils/parseNumber.ts","../src/utils/optGroupUtils.ts","../src/utils/getParseNumberMethod.ts","../src/utils/formatQuery/utils.ts"],"sourcesContent":["import type {\n  BaseTranslationsFull,\n  Classnames,\n  DefaultCombinatorName,\n  DefaultCombinatorNameExtended,\n  DefaultOperatorName,\n  MatchMode,\n  Path,\n  QueryBuilderFlags,\n  StringUnionToFullOptionArray,\n} from './types';\n\n// DO NOT ALTER OR REMOVE REGION NAMES. Some of them are used\n// to generate code snippets in the documentation.\n\n/**\n * @group Defaults\n */\nexport const defaultPlaceholderName = '~';\n/**\n * @group Defaults\n */\nexport const defaultPlaceholderLabel = '------';\n/**\n * Default `name` for placeholder option in the `fields` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderFieldName: typeof defaultPlaceholderName = defaultPlaceholderName;\n/**\n * Default `label` for placeholder option in the `fields` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderFieldLabel: typeof defaultPlaceholderLabel = defaultPlaceholderLabel;\n/**\n * Default `label` for placeholder option group in the `fields` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderFieldGroupLabel: typeof defaultPlaceholderLabel =\n  defaultPlaceholderLabel;\n/**\n * Default `name` for placeholder option in the `operators` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderOperatorName: typeof defaultPlaceholderName = defaultPlaceholderName;\n/**\n * Default `label` for placeholder option in the `operators` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderOperatorLabel: typeof defaultPlaceholderLabel =\n  defaultPlaceholderLabel;\n/**\n * Default `label` for placeholder option group in the `operators` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderOperatorGroupLabel: typeof defaultPlaceholderLabel =\n  defaultPlaceholderLabel;\n/**\n * Default `name` for placeholder option in the `values` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderValueName: typeof defaultPlaceholderName = defaultPlaceholderName;\n/**\n * Default `label` for placeholder option in the `values` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderValueLabel: typeof defaultPlaceholderLabel = defaultPlaceholderLabel;\n/**\n * Default `label` for placeholder option group in the `values` array.\n *\n * @group Defaults\n */\nexport const defaultPlaceholderValueGroupLabel: typeof defaultPlaceholderLabel =\n  defaultPlaceholderLabel;\n\n/**\n * Default configuration of translatable strings.\n *\n * @group Defaults\n */\n// #region docs-translations\nexport const defaultTranslations: BaseTranslationsFull = {\n  fields: {\n    title: 'Field',\n    placeholderName: defaultPlaceholderFieldName,\n    placeholderLabel: defaultPlaceholderFieldLabel,\n    placeholderGroupLabel: defaultPlaceholderFieldGroupLabel,\n  } as const,\n  operators: {\n    title: 'Operator',\n    placeholderName: defaultPlaceholderOperatorName,\n    placeholderLabel: defaultPlaceholderOperatorLabel,\n    placeholderGroupLabel: defaultPlaceholderOperatorGroupLabel,\n  } as const,\n  values: {\n    title: 'Values',\n    placeholderName: defaultPlaceholderValueName,\n    placeholderLabel: defaultPlaceholderValueLabel,\n    placeholderGroupLabel: defaultPlaceholderValueGroupLabel,\n  } as const,\n  matchMode: { title: 'Match mode' } as const,\n  matchThreshold: { title: 'Match threshold' } as const,\n  value: { title: 'Value' } as const,\n  removeRule: { label: '⨯', title: 'Remove rule' } as const,\n  removeGroup: { label: '⨯', title: 'Remove group' } as const,\n  addRule: { label: '+ Rule', title: 'Add rule' } as const,\n  addGroup: { label: '+ Group', title: 'Add group' } as const,\n  combinators: { title: 'Combinator' } as const,\n  notToggle: { label: 'Not', title: 'Invert this group' } as const,\n  cloneRule: { label: '⧉', title: 'Clone rule' } as const,\n  cloneRuleGroup: { label: '⧉', title: 'Clone group' } as const,\n  shiftActionUp: { label: '˄', title: 'Shift up' } as const,\n  shiftActionDown: { label: '˅', title: 'Shift down' } as const,\n  dragHandle: { label: '⁞⁞', title: 'Drag handle' } as const,\n  lockRule: { label: '🔓', title: 'Lock rule' } as const,\n  lockGroup: { label: '🔓', title: 'Lock group' } as const,\n  lockRuleDisabled: { label: '🔒', title: 'Unlock rule' } as const,\n  lockGroupDisabled: { label: '🔒', title: 'Unlock group' } as const,\n  muteRule: { label: '🔊', title: 'Mute rule' } as const,\n  muteGroup: { label: '🔊', title: 'Mute group' } as const,\n  unmuteRule: { label: '🔇', title: 'Unmute rule' } as const,\n  unmuteGroup: { label: '🔇', title: 'Unmute group' } as const,\n  valueSourceSelector: { title: 'Value source' } as const,\n} satisfies BaseTranslationsFull;\n// #endregion\n\n/**\n * Default character used to `.join` and `.split` arrays.\n *\n * @group Defaults\n */\nexport const defaultJoinChar = ',';\n\nexport type DefaultOperators = StringUnionToFullOptionArray<DefaultOperatorName>;\n\nexport const defaultOperatorLabelMap: Record<DefaultOperatorName, string> = {\n  '=': '=',\n  '!=': '!=',\n  '<': '<',\n  '>': '>',\n  '<=': '<=',\n  '>=': '>=',\n  contains: 'contains',\n  beginsWith: 'begins with',\n  endsWith: 'ends with',\n  doesNotContain: 'does not contain',\n  doesNotBeginWith: 'does not begin with',\n  doesNotEndWith: 'does not end with',\n  null: 'is null',\n  notNull: 'is not null',\n  in: 'in',\n  notIn: 'not in',\n  between: 'between',\n  notBetween: 'not between',\n};\n\nexport const defaultCombinatorLabelMap: Record<DefaultCombinatorNameExtended, string> = {\n  and: 'AND',\n  or: 'OR',\n  xor: 'XOR',\n};\n\n/**\n * Default operator list.\n *\n * @group Defaults\n */\n// #region docs-operators\nexport const defaultOperators: DefaultOperators = [\n  { name: '=', value: '=', label: '=' },\n  { name: '!=', value: '!=', label: '!=' },\n  { name: '<', value: '<', label: '<' },\n  { name: '>', value: '>', label: '>' },\n  { name: '<=', value: '<=', label: '<=' },\n  { name: '>=', value: '>=', label: '>=' },\n  { name: 'contains', value: 'contains', label: 'contains' },\n  { name: 'beginsWith', value: 'beginsWith', label: 'begins with' },\n  { name: 'endsWith', value: 'endsWith', label: 'ends with' },\n  { name: 'doesNotContain', value: 'doesNotContain', label: 'does not contain' },\n  { name: 'doesNotBeginWith', value: 'doesNotBeginWith', label: 'does not begin with' },\n  { name: 'doesNotEndWith', value: 'doesNotEndWith', label: 'does not end with' },\n  { name: 'null', value: 'null', label: 'is null' },\n  { name: 'notNull', value: 'notNull', label: 'is not null' },\n  { name: 'in', value: 'in', label: 'in' },\n  { name: 'notIn', value: 'notIn', label: 'not in' },\n  { name: 'between', value: 'between', label: 'between' },\n  { name: 'notBetween', value: 'notBetween', label: 'not between' },\n];\n// #endregion\n\n/**\n * Map of default operators to their respective opposite/negating operators.\n *\n * @group Defaults\n */\nexport const defaultOperatorNegationMap: Record<DefaultOperatorName, DefaultOperatorName> = {\n  '=': '!=',\n  '!=': '=',\n  '<': '>=',\n  '<=': '>',\n  '>': '<=',\n  '>=': '<',\n  beginsWith: 'doesNotBeginWith',\n  doesNotBeginWith: 'beginsWith',\n  endsWith: 'doesNotEndWith',\n  doesNotEndWith: 'endsWith',\n  contains: 'doesNotContain',\n  doesNotContain: 'contains',\n  between: 'notBetween',\n  notBetween: 'between',\n  in: 'notIn',\n  notIn: 'in',\n  notNull: 'null',\n  null: 'notNull',\n} satisfies Record<DefaultOperatorName, DefaultOperatorName>;\n\nexport type DefaultCombinators = StringUnionToFullOptionArray<DefaultCombinatorName>;\n\n/**\n * Default combinator list.\n *\n * @group Defaults\n */\n// #region docs-combinators\nexport const defaultCombinators: DefaultCombinators = [\n  { name: 'and', value: 'and', label: 'AND' } as const,\n  { name: 'or', value: 'or', label: 'OR' } as const,\n];\n// #endregion\n\nexport type DefaultCombinatorsExtended =\n  StringUnionToFullOptionArray<DefaultCombinatorNameExtended>;\n\n/**\n * Default combinator list, with `XOR` added.\n *\n * @group Defaults\n */\nexport const defaultCombinatorsExtended: DefaultCombinatorsExtended = [\n  ...defaultCombinators,\n  { name: 'xor', value: 'xor', label: 'XOR' } as const,\n];\n\nexport type DefaultMatchModes = StringUnionToFullOptionArray<MatchMode>;\n\n/**\n * Default match modes.\n *\n * @group Defaults\n */\n// #region docs-matchmodes\nexport const defaultMatchModes: DefaultMatchModes = [\n  { name: 'all', value: 'all', label: 'all' },\n  { name: 'some', value: 'some', label: 'some' },\n  { name: 'none', value: 'none', label: 'none' },\n  { name: 'atLeast', value: 'atLeast', label: 'at least' },\n  { name: 'atMost', value: 'atMost', label: 'at most' },\n  { name: 'exactly', value: 'exactly', label: 'exactly' },\n];\n// #endregion\n\n/**\n * Standard classnames applied to each component.\n *\n * @group Defaults\n */\n// #region docs-standardclassnames\nexport const standardClassnames = {\n  queryBuilder: 'queryBuilder',\n  ruleGroup: 'ruleGroup',\n  header: 'ruleGroup-header',\n  body: 'ruleGroup-body',\n  combinators: 'ruleGroup-combinators',\n  addRule: 'ruleGroup-addRule',\n  addGroup: 'ruleGroup-addGroup',\n  cloneRule: 'rule-cloneRule',\n  cloneGroup: 'ruleGroup-cloneGroup',\n  removeGroup: 'ruleGroup-remove',\n  notToggle: 'ruleGroup-notToggle',\n  rule: 'rule',\n  fields: 'rule-fields',\n  matchMode: 'rule-matchMode',\n  matchThreshold: 'rule-matchThreshold',\n  operators: 'rule-operators',\n  value: 'rule-value',\n  removeRule: 'rule-remove',\n  betweenRules: 'betweenRules',\n  valid: 'queryBuilder-valid',\n  invalid: 'queryBuilder-invalid',\n  shiftActions: 'shiftActions',\n  dndDragging: 'dndDragging',\n  dndOver: 'dndOver',\n  dndCopy: 'dndCopy',\n  dndGroup: 'dndGroup',\n  dndDropNotAllowed: 'dndDropNotAllowed',\n  dndPreviewPosition: 'dndPreviewPosition',\n  dndHidden: 'dndHidden',\n  dragHandle: 'queryBuilder-dragHandle',\n  disabled: 'queryBuilder-disabled',\n  muted: 'queryBuilder-muted',\n  lockRule: 'rule-lock',\n  lockGroup: 'ruleGroup-lock',\n  muteRule: 'rule-mute',\n  muteGroup: 'ruleGroup-mute',\n  valueSource: 'rule-valueSource',\n  valueListItem: 'rule-value-list-item',\n  branches: 'queryBuilder-branches',\n  justified: 'queryBuilder-justified',\n  hasSubQuery: 'rule-hasSubQuery',\n  loading: 'queryBuilder-loading',\n} as const;\n// #endregion\n\n/**\n * Default classnames for each component.\n *\n * @group Defaults\n */\nexport const defaultControlClassnames: Classnames = {\n  queryBuilder: '',\n  ruleGroup: '',\n  header: '',\n  body: '',\n  combinators: '',\n  addRule: '',\n  addGroup: '',\n  cloneRule: '',\n  cloneGroup: '',\n  removeGroup: '',\n  notToggle: '',\n  rule: '',\n  fields: '',\n  matchMode: '',\n  matchThreshold: '',\n  operators: '',\n  value: '',\n  removeRule: '',\n  shiftActions: '',\n  dragHandle: '',\n  lockRule: '',\n  lockGroup: '',\n  muteRule: '',\n  muteGroup: '',\n  muted: '',\n  valueSource: '',\n  actionElement: '',\n  valueSelector: '',\n  betweenRules: '',\n  valid: '',\n  invalid: '',\n  dndDragging: '',\n  dndOver: '',\n  dndGroup: '',\n  dndCopy: '',\n  dndDropNotAllowed: '',\n  dndPreviewPosition: '',\n  dndHidden: '',\n  disabled: '',\n  valueListItem: '',\n  branches: '',\n  hasSubQuery: '',\n  loading: '',\n} satisfies Classnames;\n\n/**\n * Default reason codes for a group being invalid.\n *\n * @group Defaults\n */\nexport const groupInvalidReasons = {\n  empty: 'empty',\n  invalidCombinator: 'invalid combinator',\n  invalidIndependentCombinators: 'invalid independent combinators',\n} as const;\n\n/**\n * Component identifiers for testing.\n *\n * @group Defaults\n */\nexport const TestID = {\n  rule: 'rule',\n  ruleGroup: 'rule-group',\n  inlineCombinator: 'inline-combinator',\n  addGroup: 'add-group',\n  removeGroup: 'remove-group',\n  cloneGroup: 'clone-group',\n  cloneRule: 'clone-rule',\n  addRule: 'add-rule',\n  removeRule: 'remove-rule',\n  combinators: 'combinators',\n  fields: 'fields',\n  operators: 'operators',\n  valueEditor: 'value-editor',\n  notToggle: 'not-toggle',\n  shiftActions: 'shift-actions',\n  dragHandle: 'drag-handle',\n  lockRule: 'lock-rule',\n  lockGroup: 'lock-group',\n  muteRule: 'mute-rule',\n  muteGroup: 'mute-group',\n  valueSourceSelector: 'value-source-selector',\n  matchModeEditor: 'match-mode-editor',\n} as const;\n\nexport const LogType = {\n  parentPathDisabled: 'action aborted: parent path disabled',\n  pathDisabled: 'action aborted: path is disabled',\n  queryUpdate: 'query updated',\n  onAddRuleFalse: 'onAddRule callback returned false',\n  onAddGroupFalse: 'onAddGroup callback returned false',\n  onGroupRuleFalse: 'onGroupRule callback returned false',\n  onGroupGroupFalse: 'onGroupGroup callback returned false',\n  onMoveRuleFalse: 'onMoveRule callback returned false',\n  onMoveGroupFalse: 'onMoveGroup callback returned false',\n  onRemoveFalse: 'onRemove callback returned false',\n  add: 'rule or group added',\n  remove: 'rule or group removed',\n  update: 'rule or group updated',\n  move: 'rule or group moved',\n  group: 'rule or group grouped with another',\n} as const;\n\n/**\n * The {@link Path} of the root group.\n *\n * @group Defaults\n */\nexport const rootPath: Path = [] satisfies Path;\n\n/**\n * Default values for all `boolean`\n * {@link react-querybuilder!QueryBuilder QueryBuilder} options.\n *\n * @group Defaults\n */\nexport const queryBuilderFlagDefaults: Required<QueryBuilderFlags> = {\n  addRuleToNewGroups: false,\n  autoSelectField: true,\n  autoSelectOperator: true,\n  autoSelectValue: false,\n  debugMode: false,\n  enableDragAndDrop: false,\n  enableMountQueryChange: true,\n  listsAsArrays: false,\n  resetOnFieldChange: true,\n  resetOnOperatorChange: false,\n  showCloneButtons: false,\n  showCombinatorsBetweenRules: false,\n  showLockButtons: false,\n  showMuteButtons: false,\n  showNotToggle: false,\n  showShiftActions: false,\n  suppressStandardClassnames: false,\n};\n","import { defaultJoinChar } from '../defaults';\n\n/**\n * Splits a string by a given character (see {@link defaultJoinChar}). Escaped characters\n * (characters preceded by a backslash) will not apply to the split, and the backslash will\n * be removed in the array element. Inverse of {@link joinWith}.\n *\n * @example\n * splitBy('this\\\\,\\\\,that,,the other,,,\\\\,')\n * // or\n * splitBy('this\\\\,\\\\,that,,the other,,,\\\\,', ',')\n * // would return\n * ['this,,that', '', 'the other', '', '', ',']\n */\nexport const splitBy = (str?: string, splitChar: string = defaultJoinChar): string[] =>\n  typeof str === 'string'\n    ? str\n        .split(`\\\\${splitChar}`)\n        .map(c => c.split(splitChar))\n        .reduce((prev, curr, idx) => {\n          if (idx === 0) {\n            return curr;\n          }\n          return [...prev.slice(0, -1), `${prev.at(-1)}${splitChar}${curr[0]}`, ...curr.slice(1)];\n        }, [])\n    : [];\n\n/**\n * Joins an array of strings using the given character (see {@link defaultJoinChar}). When\n * the given character appears in an array element, a backslash will be added just before it\n * to distinguish it from the join character. Effectively the inverse of {@link splitBy}.\n *\n * TIP: The join character can actually be a string of any length. Only the first character\n * will be searched for in the array elements and preceded by a backslash.\n *\n * @example\n * joinWith(['this,,that', '', 'the other', '', '', ','], ', ')\n * // would return\n * 'this\\\\,\\\\,that, , the other, , , \\\\,'\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const joinWith = (strArr: any[], joinChar: string = defaultJoinChar): string =>\n  strArr.map(str => `${str ?? ''}`.replaceAll(joinChar[0], `\\\\${joinChar[0]}`)).join(joinChar);\n\n/**\n * Trims the value if it is a string. Otherwise returns the value as is.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const trimIfString = (val: any): any => (typeof val === 'string' ? val.trim() : val);\n\n/**\n * Splits a string by comma then trims each element. Arrays are returned as is except\n * any string elements are trimmed.\n */\nexport const toArray = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  a: any,\n  { retainEmptyStrings }: { retainEmptyStrings?: boolean } = {}\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any[] =>\n  Array.isArray(a)\n    ? a.map(v => trimIfString(v))\n    : typeof a === 'string'\n      ? splitBy(a, defaultJoinChar)\n          .filter(retainEmptyStrings ? () => true : s => !/^\\s*$/.test(s))\n          .map(s => s.trim())\n      : typeof a === 'number'\n        ? [a]\n        : [];\n\n/**\n * Determines if an array is free of `null`/`undefined`.\n */\nexport const nullFreeArray = <T>(arr: T[]): arr is Exclude<T, null>[] =>\n  arr.every(el => el === false || (el ?? false) !== false);\n","import { numericQuantity } from 'numeric-quantity';\nimport type { ParseNumberMethod } from '../types';\n\n/**\n * Options object for {@link parseNumber}.\n */\nexport interface ParseNumberOptions {\n  parseNumbers?: ParseNumberMethod;\n  /**\n   * Generates a `bigint` value if the string represents a valid integer\n   * outside the safe boundaries of the `number` type.\n   */\n  bigIntOnOverflow?: boolean;\n}\n\n/**\n * Converts a string to a number. Uses native `parseFloat` if `parseNumbers` is \"native\",\n * otherwise uses [`numeric-quantity`](https://jakeboone02.github.io/numeric-quantity/).\n * If that returns `NaN`, the string is returned unchanged. Numeric values are returned\n * as-is regardless of the `parseNumbers` option.\n */\nexport const parseNumber = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  val: any,\n  { parseNumbers, bigIntOnOverflow }: ParseNumberOptions = {}\n  // oxlint-disable-next-line typescript/no-explicit-any\n): any => {\n  if (!parseNumbers || typeof val === 'bigint' || typeof val === 'number') {\n    return val;\n  }\n\n  if (parseNumbers === 'native') {\n    return Number.parseFloat(val);\n  }\n\n  const valAsNum: number | bigint =\n    // TODO: Should these options be configurable?\n    numericQuantity(val, {\n      allowTrailingInvalid: parseNumbers === 'enhanced',\n      bigIntOnOverflow,\n      romanNumerals: false,\n      round: false,\n    });\n\n  return typeof valAsNum === 'bigint' || !Number.isNaN(valAsNum) ? valAsNum : val;\n};\n","import type { RequireAtLeastOne } from 'type-fest';\nimport { defaultPlaceholderLabel, defaultPlaceholderName } from '../defaults';\nimport type {\n  BaseOption,\n  BaseOptionMap,\n  FlexibleOption,\n  FlexibleOptionGroup,\n  FlexibleOptionList,\n  FlexibleOptionListProp,\n  FullOption,\n  FullOptionList,\n  FullOptionMap,\n  FullOptionRecord,\n  GetOptionIdentifierType,\n  Option,\n  OptionGroup,\n  Placeholder,\n  ToFullOption,\n  ValueOption,\n  WithUnknownIndex,\n} from '../types';\nimport { isPojo } from './misc';\nimport { objectKeys } from './objectUtils';\n\nconst isOptionWithName = (opt: BaseOption): opt is Option =>\n  isPojo(opt) && 'name' in opt && typeof opt.name === 'string';\nconst isOptionWithValue = (opt: BaseOption): opt is ValueOption =>\n  isPojo(opt) && 'value' in opt && typeof opt.value === 'string';\n\n/**\n * Converts an {@link Option} or {@link ValueOption} (i.e., {@link BaseOption})\n * into a {@link FullOption}. Full options are left unchanged.\n *\n * @group Option Lists\n */\nexport function toFullOption<Opt extends BaseOption>(\n  opt: Opt | string,\n  baseProperties?: Record<string, unknown>,\n  labelMap?: Record<string, unknown>\n): ToFullOption<Opt> {\n  if (typeof opt === 'string') {\n    return {\n      ...baseProperties,\n      name: opt,\n      value: opt,\n      label: labelMap?.[opt] ?? opt,\n    } as ToFullOption<Opt>;\n  }\n\n  const idObj: { name?: string; value?: string } = {};\n  let needsUpdating = !!baseProperties;\n\n  if (isOptionWithName(opt) && !isOptionWithValue(opt)) {\n    idObj.value = opt.name;\n    needsUpdating = true;\n  } else if (!isOptionWithName(opt) && isOptionWithValue(opt)) {\n    idObj.name = opt.value;\n    needsUpdating = true;\n  }\n\n  if (needsUpdating) {\n    return Object.assign({}, baseProperties, opt, idObj) as ToFullOption<Opt>;\n  }\n\n  return opt as ToFullOption<Opt>;\n}\n\n/**\n * Converts an {@link OptionList} or {@link FlexibleOptionList} into a {@link FullOptionList}.\n * Lists of full options are left unchanged.\n *\n * @group Option Lists\n */\nexport function toFullOptionList<Opt extends BaseOption>(\n  optList: unknown[],\n  baseProperties?: Record<string, unknown>,\n  labelMap?: Record<string, unknown>\n): FullOptionList<Opt> {\n  if (!Array.isArray(optList)) {\n    return [] as unknown as FullOptionList<Opt>;\n  }\n\n  const list = optList as FlexibleOptionList<Opt>;\n\n  if (isFlexibleOptionGroupArray(list)) {\n    return list.map(optGroup => ({\n      ...optGroup,\n      options: optGroup.options.map(opt => toFullOption(opt, baseProperties, labelMap)),\n    })) as unknown as FullOptionList<Opt>;\n  }\n\n  return (list as Opt[]).map(opt =>\n    toFullOption(opt, baseProperties, labelMap)\n  ) as FullOptionList<Opt>;\n}\n\n/**\n * Converts a {@link FlexibleOptionList} into a {@link FullOptionList}.\n * Lists of full options are left unchanged.\n *\n * @group Option Lists\n */\nexport function toFullOptionMap<OptMap extends BaseOptionMap>(\n  optMap: OptMap,\n  baseProperties?: Record<string, unknown>\n): OptMap extends BaseOptionMap<infer V, infer K> ? Partial<Record<K, ToFullOption<V>>> : never {\n  type FullOptMapType =\n    OptMap extends BaseOptionMap<infer VT, infer KT>\n      ? Partial<Record<KT, ToFullOption<VT>>>\n      : never;\n\n  return Object.fromEntries(\n    (Object.entries(optMap) as [string, FlexibleOption][]).map(([k, v]) => [\n      k,\n      toFullOption(v, baseProperties),\n    ])\n  ) as FullOptMapType;\n}\n\n/**\n * @deprecated Renamed to {@link uniqByIdentifier}.\n *\n * @group Option Lists\n */\nexport const uniqByName = <\n  T extends { name: string; value?: string } | { name?: string; value: string },\n>(\n  originalArray: T[]\n): T[] => uniqByIdentifier(originalArray);\n\n/**\n * Generates a new array of objects with duplicates removed based\n * on the identifying property (`value` or `name`)\n *\n * @group Option Lists\n */\nexport const uniqByIdentifier = <\n  T extends RequireAtLeastOne<{ name: string; value: string }, 'name' | 'value'>,\n>(\n  originalArray: T[]\n): T[] => {\n  const names = new Set<string>();\n  const newArray: T[] = [];\n  for (const el of originalArray) {\n    if (!names.has((el.value ?? el.name)!)) {\n      names.add((el.value ?? el.name)!);\n      newArray.push(el);\n    }\n  }\n  return originalArray.length === newArray.length ? originalArray : newArray;\n};\n\n/**\n * Determines if an {@link OptionList} is an {@link OptionGroup} array.\n *\n * @group Option Lists\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isOptionGroupArray = (arr: any): arr is OptionGroup<BaseOption>[] =>\n  Array.isArray(arr) &&\n  arr.length > 0 &&\n  isPojo(arr[0]) &&\n  'options' in arr[0] &&\n  Array.isArray(arr[0].options);\n\n/**\n * Determines if an array is a flat array of {@link FlexibleOption}.\n *\n * @group Option Lists\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isFlexibleOptionArray = (arr: any): arr is FlexibleOption[] => {\n  let isFOA = false;\n  if (Array.isArray(arr)) {\n    for (const o of arr) {\n      if (isOptionWithName(o) || isOptionWithValue(o)) {\n        isFOA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOA;\n};\n\n/**\n * Determines if an array is a flat array of {@link FullOption}.\n *\n * @group Option Lists\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isFullOptionArray = (arr: any): arr is FullOption[] => {\n  let isFOA = false;\n  if (Array.isArray(arr)) {\n    for (const o of arr) {\n      if (isOptionWithName(o) && isOptionWithValue(o)) {\n        isFOA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOA;\n};\n\n/**\n * Determines if a {@link FlexibleOptionList} is a {@link FlexibleOptionGroup} array.\n *\n * @group Option Lists\n */\nexport const isFlexibleOptionGroupArray = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  arr: any,\n  { allowEmpty = false }: { allowEmpty?: boolean } = {}\n): arr is FlexibleOptionGroup[] => {\n  let isFOGA = false;\n  if (Array.isArray(arr)) {\n    for (const og of arr) {\n      if (\n        isPojo(og) &&\n        'options' in og &&\n        (isFlexibleOptionArray(og.options) ||\n          (allowEmpty && Array.isArray(og.options) && og.options.length === 0))\n      ) {\n        isFOGA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOGA;\n};\n\n/**\n * Determines if a {@link FlexibleOptionList} is a {@link OptionGroup} array of {@link FullOption}.\n *\n * @group Option Lists\n */\nexport const isFullOptionGroupArray = (\n  // oxlint-disable-next-line typescript/no-explicit-any\n  arr: any,\n  { allowEmpty = false }: { allowEmpty?: boolean } = {}\n): arr is OptionGroup<FullOption>[] => {\n  let isFOGA = false;\n  if (Array.isArray(arr)) {\n    for (const og of arr) {\n      if (\n        isPojo(og) &&\n        'options' in og &&\n        (isFullOptionArray(og.options) ||\n          (allowEmpty && Array.isArray(og.options) && og.options.length === 0))\n      ) {\n        isFOGA = true;\n      } else {\n        return false;\n      }\n    }\n  }\n  return isFOGA;\n};\n\n/**\n * Gets the option from an {@link OptionList} with the given `name`. Handles\n * {@link Option} arrays as well as {@link OptionGroup} arrays.\n *\n * @group Option Lists\n */\nexport function getOption<OptType extends FullOption>(\n  arr: FullOptionList<OptType>,\n  name: string\n): OptType | undefined;\nexport function getOption<OptType extends ValueOption>(\n  arr: FlexibleOptionList<OptType>,\n  name: string\n): OptType | undefined;\nexport function getOption<OptType extends Option>(\n  arr: FlexibleOptionList<OptType>,\n  name: string\n): OptType | undefined;\nexport function getOption<OptType extends BaseOption>(\n  arr: FlexibleOptionList<OptType>,\n  name: string\n): OptType | undefined {\n  const options = isFlexibleOptionGroupArray(arr, { allowEmpty: true })\n    ? arr.flatMap(og => og.options)\n    : arr;\n  return options.find(op => op.value === name || op.name === name) as OptType | undefined;\n}\n\n/**\n * Gets the first option from an {@link OptionList}.\n *\n * @group Option Lists\n */\nexport function getFirstOption<Opt extends FullOption>(\n  arr?: OptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null;\nexport function getFirstOption<Opt extends ValueOption>(\n  arr?: OptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null;\nexport function getFirstOption<Opt extends Option>(\n  arr?: OptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null;\nexport function getFirstOption<Opt extends BaseOption>(\n  arr?: FlexibleOptionGroup<Opt>[] | Opt[]\n): GetOptionIdentifierType<Opt> | null {\n  if (!Array.isArray(arr) || arr.length === 0) {\n    return null;\n  } else if (isFlexibleOptionGroupArray(arr, { allowEmpty: true })) {\n    for (const og of arr) {\n      if (og.options.length > 0) {\n        return (og.options[0].value ?? og.options[0].name) as GetOptionIdentifierType<Opt>;\n      }\n    }\n    // v8 ignore next\n    return null;\n  }\n\n  return (arr[0].value ?? arr[0].name) as GetOptionIdentifierType<Opt>;\n}\n\n/**\n * Flattens {@link FlexibleOptionGroup} arrays into {@link BaseOption} arrays.\n * If the array is already flat, it is returned as is.\n *\n * @group Option Lists\n */\nexport const toFlatOptionArray = <T extends FullOption>(arr: FullOptionList<T>) =>\n  uniqByIdentifier(isOptionGroupArray(arr) ? arr.flatMap(og => og.options) : arr) as T[];\n\n/**\n * Generates a new {@link OptionGroup} array with duplicates\n * removed based on the identifying property (`value` or `name`).\n *\n * @group Option Lists\n */\nexport const uniqOptGroups = <T extends BaseOption>(\n  originalArray: FlexibleOptionGroup<T>[]\n): OptionGroup<ToFullOption<T>>[] => {\n  type K = T extends BaseOption<infer KT> ? KT : never;\n  const labels = new Set<string>();\n  const names = new Set<K>();\n  const newArray: OptionGroup<ToFullOption<T>>[] = [];\n  for (const el of originalArray) {\n    if (!labels.has(el.label)) {\n      labels.add(el.label);\n      const optionsForThisGroup: WithUnknownIndex<ToFullOption<T>>[] = [];\n      for (const opt of el.options) {\n        if (!names.has((opt.value ?? opt.name) as K)) {\n          names.add((opt.value ?? opt.name) as K);\n          optionsForThisGroup.push(toFullOption(opt) as WithUnknownIndex<ToFullOption<T>>);\n        }\n      }\n      newArray.push({ ...el, options: optionsForThisGroup });\n    }\n  }\n  return newArray;\n};\n\n/**\n * Generates a new {@link Option} or {@link OptionGroup} array with duplicates\n * removed based on the identifier property (`value` or `name`).\n *\n * @group Option Lists\n */\nexport const uniqOptList = <T extends BaseOption>(\n  originalArray: FlexibleOptionList<T>\n): WithUnknownIndex<BaseOption & FullOption>[] | OptionGroup<ToFullOption<T>>[] => {\n  if (isFlexibleOptionGroupArray(originalArray)) {\n    return uniqOptGroups(originalArray) as OptionGroup<ToFullOption<T>>[];\n  }\n  return uniqByIdentifier((originalArray as BaseOption[]).map(o => toFullOption(o)));\n};\n\nexport interface PreparedOptionList<O extends FullOption> {\n  defaultOption: FullOption;\n  optionList: FullOptionList<O>;\n  optionsMap: Partial<FullOptionRecord<FullOption>>;\n}\n\nexport interface PrepareOptionListParams<O extends FullOption> {\n  placeholder?: Placeholder;\n  optionList?: FlexibleOptionListProp<O> | BaseOptionMap<O>;\n  baseOption?: Record<string, unknown>;\n  labelMap?: Record<string, string>;\n  autoSelectOption?: boolean;\n}\n\nexport const prepareOptionList = <O extends FullOption>(\n  props: PrepareOptionListParams<O>\n): PreparedOptionList<O> => {\n  type OptionIdentifier = GetOptionIdentifierType<O>;\n\n  // v8 ignore next\n  const {\n    optionList: optionListPropOriginal,\n    baseOption = {},\n    labelMap = {},\n    placeholder: {\n      placeholderName = defaultPlaceholderName,\n      placeholderLabel = defaultPlaceholderLabel,\n      placeholderGroupLabel = defaultPlaceholderLabel,\n    } = {},\n    autoSelectOption = true,\n  } = props;\n\n  const defaultOption = {\n    id: placeholderName,\n    name: placeholderName,\n    value: placeholderName,\n    label: placeholderLabel,\n  } as FullOption;\n\n  const optionsProp = optionListPropOriginal ?? ([defaultOption] as FlexibleOptionList<O>);\n\n  let optionList: FullOptionList<O>;\n  const opts = (\n    Array.isArray(optionsProp)\n      ? toFullOptionList(optionsProp, baseOption, labelMap)\n      : (objectKeys(toFullOptionMap(optionsProp, baseOption)) as unknown as OptionIdentifier[])\n          // oxlint-disable-next-line no-map-spread\n          .map<FullOption<OptionIdentifier>>(opt => ({\n            ...optionsProp[opt]!,\n            name: opt,\n            value: opt,\n          }))\n          // oxlint-disable-next-line no-array-sort\n          .sort((a, b) => a.label.localeCompare(b.label))\n  ) as FullOptionList<O>;\n  if (isFlexibleOptionGroupArray(opts)) {\n    optionList = autoSelectOption\n      ? (uniqOptGroups(opts) as FullOptionList<O>)\n      : (uniqOptGroups([\n          {\n            label: placeholderGroupLabel,\n            options: [defaultOption],\n          },\n          ...opts,\n        ]) as FullOptionList<O>);\n  } else {\n    optionList = autoSelectOption\n      ? (uniqByIdentifier(opts as O[]) as FullOptionList<O>)\n      : (uniqByIdentifier([defaultOption, ...(opts as O[])]) as FullOptionList<O>);\n  }\n\n  let optionsMap: Partial<FullOptionRecord<FullOption>> = {};\n  if (!Array.isArray(optionsProp)) {\n    const op = toFullOptionMap(optionsProp, baseOption) as FullOptionMap<\n      FullOption,\n      OptionIdentifier\n    >;\n    optionsMap = autoSelectOption ? op : { ...op, [placeholderName]: defaultOption };\n  } else {\n    if (isFlexibleOptionGroupArray(optionList)) {\n      for (const og of optionList as OptionGroup<ToFullOption<O>>[]) {\n        for (const opt of og.options) {\n          optionsMap[\n            (opt.value ??\n              /* v8 ignore start -- @preserve */ opt.name) /* v8 ignore stop -- @preserve */ as OptionIdentifier\n          ] = toFullOption(opt, baseOption) as FullOption;\n        }\n      }\n    } else {\n      for (const opt of optionList as ToFullOption<O>[]) {\n        optionsMap[\n          (opt.value ??\n            /* v8 ignore start -- @preserve */ opt.name) /* v8 ignore stop -- @preserve */ as OptionIdentifier\n        ] = toFullOption(opt, baseOption) as FullOption;\n      }\n    }\n  }\n\n  return { defaultOption, optionList, optionsMap };\n};\n","import type { InputType, ParseNumberMethod, ParseNumbersPropConfig } from '../types';\n\nexport const getParseNumberMethod = ({\n  parseNumbers,\n  inputType,\n}: {\n  parseNumbers?: ParseNumbersPropConfig;\n  inputType?: InputType | null;\n}): ParseNumberMethod => {\n  if (typeof parseNumbers === 'string') {\n    const [method, level] = parseNumbers.split('-') as\n      | [ParseNumberMethod, 'limited']\n      | [ParseNumberMethod];\n    if (level === 'limited') {\n      return inputType === 'number' ? method : false;\n    }\n\n    return method;\n  }\n\n  return parseNumbers ? 'strict' : false;\n};\n","import type { SetRequired } from 'type-fest';\nimport type {\n  ConstituentWordOrder,\n  DefaultCombinatorName,\n  FormatQueryOptions,\n  FullField,\n  GroupVariantCondition,\n  MatchMode,\n  NLTranslationKey,\n  NLTranslations,\n  OptionList,\n  RuleGroupTypeAny,\n  RuleType,\n  ValueProcessorByRule,\n  ValueProcessorLegacy,\n  ValueProcessorOptions,\n} from '../../types';\nimport { joinWith, splitBy, toArray } from '../arrayUtils';\nimport { getParseNumberMethod } from '../getParseNumberMethod';\nimport { isRuleGroup } from '../isRuleGroup';\nimport { isPojo, lc, numericRegex } from '../misc';\nimport { getOption } from '../optGroupUtils';\nimport { parseNumber } from '../parseNumber';\n\n/**\n * Maps a {@link DefaultOperatorName} to a SQL operator.\n *\n * @group Export\n */\nexport const mapSQLOperator = (rqbOperator: string): string => {\n  switch (lc(rqbOperator)) {\n    case 'null':\n      return 'is null';\n    case 'notnull':\n      return 'is not null';\n    case 'notin':\n      return 'not in';\n    case 'notbetween':\n      return 'not between';\n    case 'contains':\n    case 'beginswith':\n    case 'endswith':\n      return 'like';\n    case 'doesnotcontain':\n    case 'doesnotbeginwith':\n    case 'doesnotendwith':\n      return 'not like';\n    default:\n      return rqbOperator;\n  }\n};\n\n/**\n * Maps a (lowercase) {@link DefaultOperatorName} to a MongoDB operator.\n *\n * @group Export\n */\nexport const mongoOperators = {\n  '=': '$eq',\n  '!=': '$ne',\n  '<': '$lt',\n  '<=': '$lte',\n  '>': '$gt',\n  '>=': '$gte',\n  in: '$in',\n  notin: '$nin',\n  notIn: '$nin', // only here for backwards compatibility\n};\n\n/**\n * Maps a (lowercase) {@link DefaultOperatorName} to a Prisma ORM operator.\n *\n * @group Export\n */\nexport const prismaOperators = {\n  '=': 'equals',\n  '!=': 'not',\n  '<': 'lt',\n  '<=': 'lte',\n  '>': 'gt',\n  '>=': 'gte',\n  in: 'in',\n  notin: 'notIn',\n};\n\n/**\n * Maps a {@link DefaultCombinatorName} to a CEL combinator.\n *\n * @group Export\n */\nexport const celCombinatorMap: {\n  and: '&&';\n  or: '||';\n} = {\n  and: '&&',\n  or: '||',\n} satisfies Record<DefaultCombinatorName, '&&' | '||'>;\n\n/**\n * Register these operators with `jsonLogic` before applying the result\n * of `formatQuery(query, 'jsonlogic')`.\n *\n * @example\n * ```\n * for (const [op, func] of Object.entries(jsonLogicAdditionalOperators)) {\n *   jsonLogic.add_operation(op, func);\n * }\n * jsonLogic.apply({ \"startsWith\": [{ \"var\": \"firstName\" }, \"Stev\"] }, data);\n * ```\n *\n * @group Export\n */\nexport const jsonLogicAdditionalOperators: Record<\n  'startsWith' | 'endsWith',\n  (a: string, b: string) => boolean\n> = {\n  startsWith: (a: string, b: string) => typeof a === 'string' && a.startsWith(b),\n  endsWith: (a: string, b: string) => typeof a === 'string' && a.endsWith(b),\n};\n\n/**\n * Returns a new query object with all `string`-type `value` properties converted\n * to `number` where appropriate.\n *\n * Used by {@link formatQuery} for the `json*` formats when `parseNumbers` is `true`.\n *\n * @group Export\n */\nexport const numerifyValues = (\n  rg: RuleGroupTypeAny,\n  options: SetRequired<FormatQueryOptions, 'fields'>\n): RuleGroupTypeAny => ({\n  ...rg,\n  // @ts-expect-error TS doesn't keep track of odd/even indexes here\n  rules: rg.rules.map(r => {\n    if (typeof r === 'string') {\n      return r;\n    }\n\n    if (isRuleGroup(r)) {\n      return numerifyValues(r, options);\n    }\n\n    const fieldData = getOption(options.fields as OptionList<FullField>, r.field);\n    const parseNumbers = getParseNumberMethod({\n      parseNumbers: options.parseNumbers,\n      inputType: fieldData?.inputType,\n    });\n\n    if (Array.isArray(r.value)) {\n      return { ...r, value: r.value.map(v => parseNumber(v, { parseNumbers })) };\n    }\n\n    const valAsArray = toArray(r.value, { retainEmptyStrings: true }).map(v =>\n      parseNumber(v, { parseNumbers })\n    );\n    if (valAsArray.every(v => typeof v === 'number')) {\n      // v8 ignore else\n      if (valAsArray.length > 1) {\n        return { ...r, value: valAsArray };\n      } else if (valAsArray.length === 1) {\n        return { ...r, value: valAsArray[0] };\n      }\n    }\n\n    return r;\n  }),\n});\n\n/**\n * Determines whether a value is _anything_ except an empty `string` or `NaN`.\n *\n * @group Export\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isValidValue = (value: any): boolean =>\n  (typeof value === 'string' && value.length > 0) ||\n  (typeof value === 'number' && !Number.isNaN(value)) ||\n  (typeof value !== 'string' && typeof value !== 'number');\n\n/**\n * Determines whether {@link formatQuery} should render the given value as a number.\n * As long as `parseNumbers` is `true`, `number` and `bigint` values will return `true` and\n * `string` values will return `true` if they test positive against {@link numericRegex}.\n *\n * @group Export\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const shouldRenderAsNumber = (value: any, parseNumbers?: boolean): boolean =>\n  !!parseNumbers &&\n  (typeof value === 'number' ||\n    typeof value === 'bigint' ||\n    (typeof value === 'string' && numericRegex.test(value)));\n\n/**\n * Used by {@link formatQuery} to determine whether the given value processor is a\n * \"legacy\" value processor by counting the number of arguments. Legacy value\n * processors take 3 arguments (not counting any arguments with default values), while\n * rule-based value processors take no more than 2 arguments.\n *\n * @group Export\n */\nexport const isValueProcessorLegacy = (\n  valueProcessor: ValueProcessorLegacy | ValueProcessorByRule\n): valueProcessor is ValueProcessorLegacy => valueProcessor.length >= 3;\n\n/**\n * Converts the `quoteFieldNamesWith` option into an array of two strings.\n * If the option is a string, the array elements are both that string.\n *\n * @default\n * ['', '']\n *\n * @group Export\n */\nexport const getQuoteFieldNamesWithArray = (\n  // v8 ignore next\n  quoteFieldNamesWith: null | string | [string, string] = ['', '']\n): [string, string] =>\n  Array.isArray(quoteFieldNamesWith)\n    ? quoteFieldNamesWith\n    : typeof quoteFieldNamesWith === 'string'\n      ? [quoteFieldNamesWith, quoteFieldNamesWith]\n      : (quoteFieldNamesWith ?? ['', '']);\n\n/**\n * Given a field name and relevant {@link ValueProcessorOptions}, returns the field name\n * wrapped in the configured quote character(s).\n *\n * @group Export\n */\nexport const getQuotedFieldName = (\n  fieldName: string,\n  { quoteFieldNamesWith, fieldIdentifierSeparator }: ValueProcessorOptions\n): string => {\n  const [qPre, qPost] = getQuoteFieldNamesWithArray(quoteFieldNamesWith);\n  return typeof fieldIdentifierSeparator === 'string' && fieldIdentifierSeparator.length > 0\n    ? joinWith(\n        splitBy(fieldName, fieldIdentifierSeparator).map(part => `${qPre}${part}${qPost}`),\n        fieldIdentifierSeparator\n      )\n    : `${qPre}${fieldName}${qPost}`;\n};\n\nconst defaultWordOrder = ['S', 'V', 'O'];\n\n/**\n * Given a [Constituent word order](https://en.wikipedia.org/wiki/Word_order#Constituent_word_orders)\n * like \"svo\" or \"sov\", returns a permutation of `[\"S\", \"V\", \"O\"]` based on the first occurrence of\n * each letter in the input string (case insensitive). This widens the valid input from abbreviations\n * like \"svo\" to more expressive strings like \"subject-verb-object\" or \"sub ver obj\". Any missing\n * letters are appended in the default order \"SVO\" (e.g., \"object\" would yield `[\"O\", \"S\", \"V\"]`).\n *\n * @group Export\n */\nexport const normalizeConstituentWordOrder = (input: string): ConstituentWordOrder => {\n  const result: string[] = [];\n  const letterSet = new Set(defaultWordOrder);\n\n  for (const char of input.toUpperCase()) {\n    if (letterSet.has(char)) {\n      result.push(char);\n      letterSet.delete(char);\n      if (letterSet.size === 0) break;\n    }\n  }\n\n  // Add any missing letters in default order\n  for (const letter of defaultWordOrder) {\n    if (letterSet.has(letter)) {\n      result.push(letter);\n    }\n  }\n\n  return result as ConstituentWordOrder;\n};\n\n/**\n * Default translations used by {@link formatQuery} for \"natural_language\" format.\n *\n * @group Export\n */\n// The ones commented below are unnecessary for the default implementation,\n// but they can be overridden for customized implementations.\nexport const defaultNLTranslations: NLTranslations = {\n  // and: 'and',\n  // or: 'or',\n  // true: 'true',\n  // false: 'false',\n  groupPrefix: '',\n  // groupPrefix_not: '',\n  groupPrefix_not_xor: 'either zero or more than one of',\n  groupPrefix_xor: 'exactly one of',\n  groupSuffix: 'is true',\n  groupSuffix_not: 'is not true',\n  // groupSuffix_not_xor: 'is true',\n  // groupSuffix_xor: 'is true',\n};\n\n/**\n * Note: This function assumes `conditions.length > 0`\n */\nconst translationMatchFilter = (\n  key: NLTranslationKey,\n  keyToTest: string,\n  conditions: GroupVariantCondition[]\n) =>\n  // The translation matches the base key\n  keyToTest.startsWith(key) &&\n  // The translation specifies all conditions\n  conditions.every(\n    c =>\n      // This translation specifies _this_ condition\n      keyToTest.includes(`_${c}`) &&\n      // This translation specifies the same _total number_ of conditions\n      keyToTest.match(/_/g)?.length === conditions.length\n  );\n\n/**\n * Used by {@link formatQuery} to get a translation based on certain conditions\n * for the \"natural_language\" format.\n *\n * @group Export\n */\nexport const getNLTranslataion = (\n  key: NLTranslationKey,\n  translations: NLTranslations,\n  conditions: GroupVariantCondition[] = []\n): string =>\n  conditions.length === 0\n    ? (translations[key] ??\n      defaultNLTranslations[key] ??\n      /* v8 ignore start -- @preserve */ '') /* v8 ignore stop -- @preserve */\n    : (Object.entries(translations).find(([keyToTest]) =>\n        translationMatchFilter(key, keyToTest, conditions)\n      )?.[1] ??\n      Object.entries(defaultNLTranslations).find(([keyToTest]) =>\n        translationMatchFilter(key, keyToTest, conditions)\n      )?.[1] ??\n      defaultNLTranslations[key] ??\n      /* v8 ignore next -- @preserve */ '');\n\ntype ProcessedMatchMode =\n  | { mode: 'all'; threshold?: number | null | undefined }\n  | { mode: 'none'; threshold?: number | null | undefined }\n  | { mode: 'some'; threshold?: number | null | undefined }\n  | { mode: 'atleast'; threshold: number }\n  | { mode: 'atmost'; threshold: number }\n  | { mode: 'exactly'; threshold: number };\n\n/**\n * Transforms\n * - `match: { mode: \"atLeast\", threshold: 1 }` to `match: { mode: \"some\" }`\n * - `match: { mode: \"atMost\", threshold: 0 }` to `match: { mode: \"none\" }`.\n *\n * Returns:\n * - Processed `{ mode, threshold }` object for valid subqueries\n * - `null` if match mode is not applicable for the rule\n * - `false` if match mode is valid, but either\n *   1. `threshold` is required and invalid, or\n *   2. `value` is not a valid rule group.\n */\nexport const processMatchMode = (rule: RuleType): null | false | ProcessedMatchMode => {\n  const { mode, threshold } = rule.match ?? {};\n\n  if (!mode) return null;\n\n  if (!isRuleGroup(rule.value)) return false;\n\n  const matchModeLC = lc(mode) as Lowercase<MatchMode>;\n\n  const matchModeCoerced =\n    matchModeLC === 'atleast' && threshold === 1\n      ? 'some'\n      : matchModeLC === 'atmost' && threshold === 0\n        ? 'none'\n        : matchModeLC;\n\n  if (\n    (matchModeCoerced === 'atleast' ||\n      matchModeCoerced === 'atmost' ||\n      matchModeCoerced === 'exactly') &&\n    (typeof threshold !== 'number' || threshold < 0)\n  ) {\n    return false;\n  }\n\n  return { mode: matchModeCoerced, threshold: threshold! };\n};\n\n/**\n * \"Replacer\" method for JSON.stringify's second argument. Converts `bigint` values to\n * objects with a `$bigint` property having a value of a string representation of\n * the actual `bigint`-type value.\n *\n * Inverse of {@link bigIntJsonParseReviver}.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json\n */\nexport const bigIntJsonStringifyReplacer = (_key: string, value: unknown): unknown =>\n  typeof value === 'bigint' ? { $bigint: value.toString() } : value;\n\n/**\n * \"Reviver\" method for JSON.parse's second argument. Converts objects having a single\n * `$bigint: string` property to an actual `bigint` value.\n *\n * Inverse of {@link bigIntJsonStringifyReplacer}.\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#use_within_json\n */\nexport const bigIntJsonParseReviver = (_key: string, value: unknown): unknown =>\n  isPojo(value) && Object.keys(value).length === 1 && typeof value.$bigint === 'string'\n    ? BigInt(value.$bigint)\n    : value;\n"],"mappings":"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"}