{"version":3,"file":"selective.min.mjs","sources":["../../src/tools/create-result.ts","../../src/tools/is.ts","../../src/tools/errors.ts","../../src/tools/value-nullish.ts","../../src/potential/function.ts","../../src/tools/resolve-key.ts","../../src/tools/resolve-polar-key.ts","../../src/potential/key-list.ts","../../src/potential/object.ts","../../src/potential/single-key.ts","../../src/potential/value.ts","../../src/tools/create-resolver.ts","../../src/resolvers/bool-based.ts","../../src/resolvers/value-based.ts"],"sourcesContent":["import type { KeyList, Resolved } from '../types/resolver-types';\n\nexport function createResult<K extends string, V>(keys: KeyList<K>, value: V): Resolved<K, V> {\n  const entries = keys.map<readonly [K, V]>((key) => {\n    return [key, value];\n  });\n  return Object.fromEntries(entries) as Resolved<K, V>;\n}\n\n/**\n * @deprecated\n */\n// eslint-disable-next-line @typescript-eslint/unified-signatures\nexport function deprecatedCreateResult<K extends string, V>(keys: KeyList<K>, value: V, input: undefined | Resolved<K, V>): Resolved<K, V>;\n\nexport function deprecatedCreateResult<K extends string, V>(keys: KeyList<K>, value: V): Resolved<K, V>;\nexport function deprecatedCreateResult<K extends string, V>(keys: KeyList<K>, value: V, input?: Resolved<K, V>): Resolved<K, V> {\n  const result = createResult(keys, value);\n  return { ...input, ...result };\n}\n\nexport function createResultGetValue<K extends string, V>(keys: KeyList<K>, getValue: (key: K) => V): Resolved<K, V> {\n  const entries = keys.map<readonly [K, V]>((key) => {\n    const value = getValue(key);\n    return [key, value];\n  });\n  return Object.fromEntries(entries) as Resolved<K, V>;\n}\n","/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */\nimport type { TypeCheckFunction } from '../types/private-types';\n\ninterface IsArrayFunction extends TypeCheckFunction<unknown[]>, TypeCheckFunction<readonly unknown[]> {\n  <T extends readonly unknown[]>(value: unknown): value is T;\n  <T extends unknown[]>(value: unknown): value is T;\n  <T>(value: unknown): value is (readonly T[] | T[]);\n}\n\ninterface ExtendedArrayConstructor extends ArrayConstructor {\n  isArray: IsArrayFunction;\n}\n\nexport const { isArray } = Array as ExtendedArrayConstructor;\n\nexport function is(value: unknown, type: 'object'): value is object | null;\nexport function is<T extends object | null | unknown[] | readonly unknown[]>(value: unknown, type: 'object'): value is T;\nexport function is(value: unknown, type: 'function'): value is CallableFunction;\nexport function is<T extends CallableFunction>(value: unknown, type: 'function'): value is T;\nexport function is(value: unknown, type: 'string'): value is string;\nexport function is(value: unknown, type: string): boolean {\n  return typeof value === type;\n}\n","import { is } from './is';\n\nexport function errorInvalidKey(key: unknown): Error {\n  return new Error(`\"${key}\" is not a valid key`);\n}\n\nexport function errorInvalidValue(value: unknown): Error {\n  const formattedValue = is(value, 'string') ? `\"${value}\"` : value;\n  return new Error(`${formattedValue} is not a valid value`);\n}\n","import type { Nullish, TypeCheckFunction, Void } from '../types/private-types';\nimport { errorInvalidValue } from './errors';\n\ntype ValueOrNullishResult<V extends boolean, T> = [isValid: V, value: T];\ntype IsValidResult<V> = ValueOrNullishResult<true, V>;\ntype IsNullishResult = ValueOrNullishResult<false, Nullish>;\n\nexport function validateValue<V>(value: unknown, isValidValue: TypeCheckFunction<V>): IsValidResult<V> | IsNullishResult | Void {\n\n  // return \"valid\" result if value is valid\n  if (isValidValue(value)) return [true, value];\n\n  // return \"nullish\" result if value is nullish\n  if (value == null) return [false, value];\n\n  // return nothing (undefined) if value is invalid\n  // return;\n\n}\n\nexport function validateValueOrThrow<V>(value: unknown, isValidValue: TypeCheckFunction<V>): IsValidResult<V> | IsNullishResult {\n\n  // resolve if value is valid or nullish\n  const resolved = validateValue(value, isValidValue);\n\n  // throw if not resolved\n  if (!resolved) throw errorInvalidValue(value);\n\n  // return resolved value\n  return resolved;\n\n}\n","import { createResultGetValue } from '../tools/create-result';\nimport { is } from '../tools/is';\nimport { validateValueOrThrow } from '../tools/value-nullish';\nimport type { FunctionOption } from '../types/input-types';\nimport type { TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, PotentialResolver } from '../types/resolver-types';\n\nexport function createFunctionResolver<K extends string, V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n): PotentialResolver<K, V>;\n\nexport function createFunctionResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D>;\n\nexport function createFunctionResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D> {\n\n  // return function resolver\n  return (input) => {\n\n    // exit if input is not a function\n    if (!is<FunctionOption<K, V>>(input, 'function')) return;\n\n    const getValue = (key: K) => {\n\n      // get value from input\n      const value = input(key);\n\n      // get data from value if it's valid or nullish\n      const [isValid, validatedValue] = validateValueOrThrow(value, isValidValue);\n\n      // return value if it's valid\n      if (isValid) return validatedValue;\n\n      // return default value if value is nullish\n      return defaultValue;\n\n    };\n\n    // return result\n    return createResultGetValue(\n      keys,\n      getValue,\n    );\n\n  };\n\n}\n","import type { AllowNullish, KeyResolved } from '../types/private-types';\nimport type { KeyList, SpecialKeys } from '../types/resolver-types';\n\nexport function resolveKey<K extends string>(key: string, keys: KeyList<K>, special: AllowNullish<Partial<SpecialKeys<string, K>>>): KeyResolved<K> | undefined {\n  if (keys.includes(key as never)) return [[key as K], false];\n  if (!special) return;\n  const specialResolved = special[key];\n  if (!specialResolved) return;\n  return [specialResolved, true];\n}\n","import type { AllowNullish, NegativeKeyPrefix, PolarKeyResolved, PositiveKeyPrefix } from '../types/private-types';\nimport type { KeyList, SpecialKeys } from '../types/resolver-types';\nimport { is } from './is';\nimport { resolveKey } from './resolve-key';\n\nconst polarityPrefixes = ['!', '+', '-'] as ReadonlyArray<PositiveKeyPrefix | NegativeKeyPrefix>;\n\nexport function resolvePolarKey<K extends string, S extends string>(key: unknown, keys: KeyList<K>, special?: AllowNullish<SpecialKeys<S, K>>): PolarKeyResolved<K> | undefined {\n\n  // throw if item is not a string\n  if (!is(key, 'string')) return;\n\n  // try to resolve positive key\n  const resolved = resolveKey(key, keys, special);\n\n  // return positive key result if resolved\n  if (resolved) {\n    const [resolvedKeys] = resolved;\n    return [resolvedKeys, true];\n  }\n\n  // get first character to test for key polarity\n  const sign = key.charAt(0);\n\n  // fail if first character in not a polarity prefix\n  if (!polarityPrefixes.includes(sign as never)) return;\n\n  // get key without polarity\n  const absoluteKey = key.slice(1) as K;\n\n  // try to resolve key\n  const absoluteResolved = resolveKey(absoluteKey, keys, special);\n\n  // fail if it can't be resolved\n  if (!absoluteResolved) return;\n\n  // return key result with polarity\n  const [resolvedKeys] = absoluteResolved;\n  return [resolvedKeys, sign === '+'];\n\n}\n","import { createResult } from '../tools/create-result';\nimport { errorInvalidKey } from '../tools/errors';\nimport { isArray } from '../tools/is';\nimport { resolvePolarKey } from '../tools/resolve-polar-key';\nimport type { AllowNullish, Nullish, PolarKeyResolved } from '../types/private-types';\nimport type { KeyList, PotentialResolver, Resolved, SpecialKeys } from '../types/resolver-types';\n\nfunction resolveKeyOrThrow<K extends string, S extends string>(key: unknown, keys: KeyList<K>, special?: AllowNullish<SpecialKeys<S, K>>): PolarKeyResolved<K> {\n\n  // try to resolve key\n  const resolvedKey = resolvePolarKey(key, keys, special);\n\n  // throw if it can't be resolved\n  if (!resolvedKey) throw errorInvalidKey(key);\n\n  // return resolved key\n  return resolvedKey;\n\n}\n\nexport function createKeyListResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyListResolver<K extends string>(\n  keys: KeyList<K>,\n  special?: Nullish,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyListResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyListResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean> {\n\n  // return array resolver\n  return (input) => {\n\n    // exit if value is not an array\n    if (!isArray(input)) return;\n\n    // resolve to false if input array is empty\n    if (input.length === 0) return createResult(\n      keys,\n      false,\n    );\n\n    // get first key independently from the rest\n    const [first, ...rest] = input;\n\n    // resolve first key\n    const [firstKeys, firstPolarity] = resolveKeyOrThrow(first, keys, special);\n\n    // create result based on first key\n    const base = createResult(\n      keys,\n      !firstPolarity,\n    );\n\n    const override = createResult(\n      firstKeys,\n      firstPolarity,\n    );\n\n    const baseResult = { ...base, ...override };\n\n    // extend base result according to the rest of the items\n    return rest.reduce<Resolved<K, boolean>>((output, key) => {\n\n      // resolve key\n      const [resolvedKeys, resolvedPolarity] = resolveKeyOrThrow(key, keys, special);\n\n      // return updated result\n      const override = createResult(resolvedKeys, resolvedPolarity);\n      return { ...output, ...override };\n\n    }, baseResult);\n\n  };\n\n}\n","/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */\nimport { createResult } from '../tools/create-result';\nimport { errorInvalidKey } from '../tools/errors';\nimport { is, isArray } from '../tools/is';\nimport { resolveKey } from '../tools/resolve-key';\nimport { validateValueOrThrow } from '../tools/value-nullish';\nimport type { AllowNullish, Nullish, TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, PotentialResolver, Resolved, SpecialKeys } from '../types/resolver-types';\n\ntype ObjectProcessed<K extends string, V, D> = [override: V | D, keys: Array<Resolved<K, V>>, special: Array<Resolved<K, V>>];\n\nfunction processInput<K extends string, S extends string, V, D = V>(\n  input: object,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: string,\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): ObjectProcessed<K, V, D> {\n\n  // get input object keys\n  const objectKeys = Object.keys(input);\n\n  // return array containing processed data\n  return objectKeys.reduce<ObjectProcessed<K, V, D>>((output, key) => {\n\n    // get object key value\n    const value = input[key as never];\n\n    // get data from value if it's valid or nullish\n    const [isValid, validatedValue] = validateValueOrThrow(value, isValidValue);\n\n    // return output without changes if value is nullish\n    if (!isValid) return output;\n\n    // destructure output array\n    const [override, keysData, specialData] = output;\n\n    // set override value if key equals override key\n    if (key === overrideKey) return [validatedValue, keysData, specialData];\n\n    const keyResolved__ = resolveKey(key, keys, special);\n\n    if (!keyResolved__) throw errorInvalidKey(key);\n\n    const [keyResolved, isSpecial] = keyResolved__;\n    const item = createResult(keyResolved, validatedValue);\n\n    if (isSpecial) {\n      const newSpecialData = [...specialData, item];\n      return [override, keysData, newSpecialData];\n    }\n\n    const newKeysData = [...keysData, item];\n    return [override, newKeysData, specialData];\n\n    // // try to resolve key as regular key\n    // const keyResolved = resolveKey(key, keys);\n\n    // // extend regular key data if regular key resolved\n    // if (keyResolved) {\n    //   const item = createResult(keyResolved, validatedValue);\n    //   const newKeysData = [...keysData, item];\n    //   return [override, newKeysData, specialData];\n    // }\n\n    // // throw if special is not defined at this point\n    // if (!special) throw errorInvalidKey(key);\n\n    // // try to resolve key as special key\n    // const specialResolved = special[key as S] as K[] | undefined;\n\n    // // throw if key can't be resolved as special key\n    // if (!specialResolved) throw errorInvalidKey(key);\n\n    // // extend special key data if special key resolved\n    // const item = createResult(specialResolved, validatedValue);\n    // const newSpecialData = [...specialData, item];\n    // return [override, keysData, newSpecialData];\n\n  }, [defaultValue, [], []]);\n\n}\n\nfunction extendResolved<K extends string, V>(output: Resolved<K, V>, extension: Resolved<K, V>): Resolved<K, V> {\n  return { ...output, ...extension };\n}\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, V | D>;\n\nexport function createObjectResolver<K extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): PotentialResolver<K, V | D>;\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, V>;\n\nexport function createObjectResolver<K extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special?: Nullish,\n): PotentialResolver<K, V>;\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, V | D>;\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, V | D> {\n\n  // return object resolver\n  return (input) => {\n\n    // exit if it's not an object\n    if (!input || !is(input, 'object') || isArray(input)) return;\n\n    // process input object\n    const [overrideValue, keysData, specialData] = processInput(\n      input,\n      isValidValue,\n      defaultValue,\n      overrideKey,\n      keys,\n      special,\n    );\n\n    // return result create from processed input object\n    return keysData.reduce(\n      extendResolved,\n      specialData.reduce(\n        extendResolved,\n        createResult(keys, overrideValue),\n      ),\n    );\n\n  };\n\n}\n","import { createResult } from '../tools/create-result';\nimport { resolvePolarKey } from '../tools/resolve-polar-key';\nimport type { AllowNullish, Nullish } from '../types/private-types';\nimport type { KeyList, PotentialResolver, SpecialKeys } from '../types/resolver-types';\n\nexport function createKeyResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyResolver<K extends string>(\n  keys: KeyList<K>,\n  special?: Nullish,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean> {\n\n  // return string resolver\n  return (input) => {\n\n    // try to resolve value as key or special key\n    const resolvedInput = resolvePolarKey(input, keys, special);\n\n    // exit if it can't be resolved\n    if (!resolvedInput) return;\n\n    // get data from resolved input\n    const [resolvedKeys, polarity] = resolvedInput;\n\n    // create base result\n    const base = createResult(\n      keys,\n      !polarity,\n    );\n\n    // create override result\n    const override = createResult(\n      resolvedKeys,\n      polarity,\n    );\n\n    // return result\n    return { ...base, ...override };\n\n  };\n\n}\n","import { createResult } from '../tools/create-result';\nimport { validateValue } from '../tools/value-nullish';\nimport type { TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, PotentialResolver } from '../types/resolver-types';\n\nexport function createValueResolver<K extends string, V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n): PotentialResolver<K, V>;\n\nexport function createValueResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D>;\n\nexport function createValueResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D> {\n\n  // return value resolver\n  return (input) => {\n\n    // check if value is valid or nullish\n    const validated = validateValue(input, isValidValue);\n\n    // exit if value is not valid nor nullish\n    if (!validated) return;\n\n    // get data from resolved value\n    const [isValid, validatedValue] = validated;\n\n    // return result using value if it's valid\n    if (isValid) return createResult(\n      keys,\n      validatedValue,\n    );\n\n    // return result using default value\n    return createResult(\n      keys,\n      defaultValue,\n    );\n\n  };\n\n}\n","import type { PotentialResolver, Resolver } from '../types/resolver-types';\nimport { errorInvalidValue } from './errors';\n\nexport function createResolver<K extends string, V, I = unknown>(...resolvers: Array<PotentialResolver<K, V>>): Resolver<K, V, I>;\nexport function createResolver<K extends string, V, I = unknown>(...resolvers: Array<PotentialResolver<K, V>>): Resolver<K, V, I> {\n\n  // return resolver\n  return (input) => {\n\n    // iterate through resolvers\n    for (const resolve of resolvers) {\n\n      // execute resolver\n      const result = resolve(input);\n\n      // return result if it's resolved\n      if (result) return result;\n    }\n\n    // throw Error if input can't be resolved\n    throw errorInvalidValue(input);\n\n  };\n\n}\n","import { createFunctionResolver } from '../potential/function';\nimport { createKeyListResolver } from '../potential/key-list';\nimport { createObjectResolver } from '../potential/object';\nimport { createKeyResolver } from '../potential/single-key';\nimport { createValueResolver } from '../potential/value';\nimport { createResolver } from '../tools/create-resolver';\nimport type { BoolBasedSelectiveOption } from '../types/input-types';\nimport type { AllowNullish, Nullish, TypeCheckFunction } from '../types/private-types';\nimport type { BoolBasedResolver, KeyList, SpecialKeys } from '../types/resolver-types';\n\nfunction wrapValueValidator<V>(isValidValue: AllowNullish<TypeCheckFunction<V>>): TypeCheckFunction<V | boolean> {\n  const isBoolean: TypeCheckFunction<boolean> = (value) => {\n    return value === true || value === false;\n  };\n  if (!isValidValue) return isBoolean;\n  const isValueOrBool: TypeCheckFunction<V | boolean> = (value) => {\n    return isValidValue(value) || isBoolean(value);\n  };\n  return isValueOrBool;\n}\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, V | boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, V | boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, O extends string, D>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, O extends string, D>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V | boolean,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, V | boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V | boolean,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, V | boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: boolean,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: boolean,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: AllowNullish<TypeCheckFunction<V>>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): BoolBasedResolver<K, S, V | boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: AllowNullish<TypeCheckFunction<V>>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): BoolBasedResolver<K, S, V | boolean, O, D> {\n\n  // create boolean value validator\n  const isValueOrBool = wrapValueValidator(isValidValue);\n\n  // create potential resolvers\n  const resolveValue = createValueResolver(keys, isValueOrBool, defaultValue);\n  const resolveFunction = createFunctionResolver(keys, isValueOrBool, defaultValue);\n  const resolveSingleKey = createKeyResolver(keys, special);\n  const resolveKeyList = createKeyListResolver(keys, special);\n  const resolveObject = createObjectResolver(keys, isValueOrBool, defaultValue, overrideKey, special);\n\n  // return compiled resolver\n  return createResolver<K, boolean | V | D, BoolBasedSelectiveOption<K, S, boolean | V, O>>(\n    resolveValue,\n    resolveFunction,\n    resolveSingleKey,\n    resolveKeyList,\n    resolveObject,\n  );\n\n}\n","import { createFunctionResolver } from '../potential/function';\nimport { createObjectResolver } from '../potential/object';\nimport { createValueResolver } from '../potential/value';\nimport { createResolver } from '../tools/create-resolver';\nimport type { ValueBasedSelectiveOption } from '../types/input-types';\nimport type { AllowNullish, Nullish, TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, SpecialKeys, ValueBasedResolver } from '../types/resolver-types';\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): ValueBasedResolver<K, S | O, V, D>;\n\nexport function createValueBasedResolver<K extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): ValueBasedResolver<K, O, V, D>;\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): ValueBasedResolver<K, S | O, V>;\n\nexport function createValueBasedResolver<K extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special?: Nullish,\n): ValueBasedResolver<K, O, V>;\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): ValueBasedResolver<K, S | O, V>;\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): ValueBasedResolver<K, S | O, V, D> {\n\n  // create potential resolvers\n  const resolveValue = createValueResolver(keys, isValidValue, defaultValue);\n  const resolveFunction = createFunctionResolver(keys, isValidValue, defaultValue);\n  const resolveObject = createObjectResolver(keys, isValidValue, defaultValue, overrideKey, special);\n\n  // return compiled resolver\n  return createResolver<K, V | D, ValueBasedSelectiveOption<K, O | S, V>>(\n    resolveValue,\n    resolveFunction,\n    resolveObject,\n  );\n\n}\n"],"names":["createResult","keys","value","entries","map","key","Object","fromEntries","deprecatedCreateResult","input","result","assign","isArray","Array","is","type","errorInvalidKey","Error","errorInvalidValue","formattedValue","validateValue","isValidValue","validateValueOrThrow","resolved","createFunctionResolver","defaultValue","getValue","createResultGetValue","_validateValueOrThrow2","_maybeArrayLike","_slicedToArray","isValid","validatedValue","resolveKey","special","includes","specialResolved","polarityPrefixes","resolvePolarKey","sign","charAt","absoluteResolved","slice","resolveKeyOrThrow","resolvedKey","createKeyListResolver","length","_input","_toArray","first","rest","_resolveKeyOrThrow2","firstKeys","firstPolarity","base","override","baseResult","reduce","output","_resolveKeyOrThrow4","extendResolved","extension","createObjectResolver","overrideKey","_processInput","_output","keysData","specialData","keyResolved__","_keyResolved__","keyResolved","isSpecial","item","concat","_toConsumableArray","processInput","_processInput2","overrideValue","createKeyResolver","resolvedInput","_resolvedInput","resolvedKeys","polarity","createValueResolver","validated","_validated","createResolver","_len","arguments","resolvers","_key","_i","_resolvers","resolve","createBoolBasedResolver","isValueOrBool","isBoolean","wrapValueValidator","createValueBasedResolver"],"mappings":"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"}