{"version":3,"file":"chunks/15.edd8a55c8e0db2216fdd.js","mappings":"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","sources":["webpack://@iqx-web/libs/../../node_modules/@automapper/core/index.js"],"sourcesContent":["function normalizeNamingConventions(namingConventions) {\n  if ('source' in namingConventions && 'destination' in namingConventions) {\n    return [namingConventions.source, namingConventions.destination];\n  }\n\n  return [namingConventions, namingConventions];\n}\n\nconst STRATEGY = Symbol.for('__strategy__');\nconst MAPPINGS = Symbol.for('__mappings__');\nconst METADATA_MAP = Symbol.for('__metadata_map__');\nconst METADATA_OBJECT_MAP = Symbol.for('__metadata_object_map__');\nconst ERROR_HANDLER = Symbol.for('__error_handler__');\nconst NAMING_CONVENTIONS = Symbol.for('__naming_conventions__');\nconst RECURSIVE_DEPTH = Symbol.for('__recursive_depth__');\nconst RECURSIVE_COUNT = Symbol.for('__recursive_count__');\nconst PROFILE_CONFIGURATION_CONTEXT = Symbol.for('__profile_configuration_context__');\nconst CUSTOM_NODE_INSPECT = Symbol.for('nodejs.util.inspect.custom');\nfunction getErrorHandler(mapper) {\n  return mapper[ERROR_HANDLER];\n}\nfunction getMappings(mapper) {\n  return mapper[MAPPINGS];\n}\nfunction getMetadataMap(mapper) {\n  return mapper[METADATA_MAP];\n}\nfunction getMetadataObjectMap(mapper) {\n  return mapper[METADATA_OBJECT_MAP];\n}\nfunction getNamingConventions(mapper) {\n  const namingConventions = mapper[NAMING_CONVENTIONS];\n  if (!namingConventions) return undefined;\n  return normalizeNamingConventions(namingConventions);\n}\nfunction getRecursiveDepth(mapper) {\n  return mapper[RECURSIVE_DEPTH];\n}\nfunction getRecursiveCount(mapper) {\n  return mapper[RECURSIVE_COUNT];\n}\nfunction getStrategy(mapper) {\n  return mapper[STRATEGY];\n}\nfunction getProfileConfigurationContext(mapper) {\n  return mapper[PROFILE_CONFIGURATION_CONTEXT];\n}\n\n/**\r\n * Depends on implementation of strategy.createMapping\r\n */\nfunction assertUnmappedProperties(destinationObject, destinationMetadata, configuredKeys, sourceIdentifier, destinationIdentifier, errorHandler) {\n  var _a, _b;\n\n  const unmappedKeys = Object.keys(destinationMetadata).reduce((result, key) => {\n    var _a;\n\n    const isOnDestination = (key in destinationObject);\n    const isAlreadyConfigured = configuredKeys.some(configuredKey => configuredKey === key);\n    const isWritable = ((_a = Object.getOwnPropertyDescriptor(destinationMetadata, key)) === null || _a === void 0 ? void 0 : _a.writable) === true;\n\n    if (!isAlreadyConfigured && !isOnDestination && isWritable && destinationObject[key] === undefined) {\n      result.push(key);\n    }\n\n    return result;\n  }, []);\n\n  if (unmappedKeys.length) {\n    const parentInfo = `${(_a = sourceIdentifier['name']) !== null && _a !== void 0 ? _a : sourceIdentifier} -> ${(_b = destinationIdentifier['name']) !== null && _b !== void 0 ? _b : destinationIdentifier}`;\n    errorHandler.handle(`\nUnmapped properties for ${parentInfo}:\n-------------------\n${unmappedKeys.join(',\\n')}\n`);\n  }\n}\n\nfunction get(object, path = []) {\n  if (!path.length) {\n    return;\n  }\n\n  let index;\n  const length = path.length;\n\n  for (index = 0; index < length && object != null; index++) {\n    object = object[path[index]];\n  }\n\n  return index && index == length ? object : undefined;\n}\n\nfunction getMapping(mapper, source, destination, allowNull = false) {\n  var _a; // turn string into symbol for identifier\n\n\n  const sourceIdentifier = typeof source === 'string' ? Symbol.for(source) : source;\n  const destinationIdentifier = typeof destination === 'string' ? Symbol.for(destination) : destination;\n  const mapping = (_a = getMappings(mapper).get(sourceIdentifier)) === null || _a === void 0 ? void 0 : _a.get(destinationIdentifier);\n\n  if (mapping == null && !allowNull) {\n    const errorHandler = getErrorHandler(mapper);\n    const errorMessage = `Mapping is not found for ${String(source)} and ${String(destination)}`;\n    errorHandler.handle(errorMessage);\n    throw new Error(errorMessage);\n  }\n\n  return mapping;\n}\n\n/**\r\n * Check if value is a Date constructor\r\n *\r\n * @param {Function} value\r\n */\nfunction isDateConstructor(value) {\n  return Object.getPrototypeOf(value) === Date || value === Date;\n}\n\nfunction isEmpty(value) {\n  if (Array.isArray(value)) {\n    return !value.length;\n  }\n\n  if (typeof value !== 'object' && typeof value !== 'function') {\n    return !value;\n  }\n\n  return !Object.keys(value).length;\n}\n\nfunction isPrimitiveArrayEqual(a, b) {\n  if (a.length !== b.length) return false;\n  return a.every((itemA, index) => b[index] === itemA);\n}\n\n/**\r\n * Check if value is a String/Number/Boolean/Array constructor\r\n *\r\n * @param {Function} value\r\n */\nfunction isPrimitiveConstructor(value) {\n  // constructor/function passed in is undefined/null, we fall back to primitive\n  if (value == null) return true;\n  const proto = Object.getPrototypeOf(value);\n  return proto === String || proto === Number || proto === Boolean || value === String || value === Number || value === Boolean;\n}\n\nfunction set(object, path, value) {\n  const {\n    decomposedPath,\n    base\n  } = decomposePath(path);\n\n  if (base === undefined) {\n    return object;\n  } // assign an empty object in order to spread object\n\n\n  assignEmpty(object, base); // Determine if there is still layers to traverse\n\n  value = decomposedPath.length <= 1 ? value : set(object[base], decomposedPath.slice(1), value);\n  return Object.assign(object, {\n    [base]: value\n  });\n}\nfunction setMutate(object, path, value) {\n  const {\n    decomposedPath,\n    base\n  } = decomposePath(path);\n\n  if (base === undefined) {\n    return;\n  } // assign an empty object in order to spread object\n\n\n  assignEmpty(object, base); // Determine if there is still layers to traverse\n\n  if (decomposedPath.length <= 1) {\n    object[base] = value;\n  } else {\n    setMutate(object[base], decomposedPath.slice(1), value);\n  }\n}\n\nfunction decomposePath(path) {\n  if (path.length < 1) {\n    return {\n      base: '',\n      decomposedPath: []\n    };\n  }\n\n  const decomposedPath = path;\n  const base = path[0];\n  return {\n    base,\n    decomposedPath\n  };\n}\n\nfunction assignEmpty(obj, base) {\n  if (!obj.hasOwnProperty(base)) {\n    obj[base] = {};\n  }\n}\n\nfunction mapMember(transformationMapFn, sourceObject, destinationObject, destinationMemberPath, extraArgs, mapper, sourceMemberIdentifier, destinationMemberIdentifier) {\n  let value;\n  const transformationType = transformationMapFn[0\n  /* MapFnClassId.type */\n  ];\n  const mapFn = transformationMapFn[1\n  /* MapFnClassId.fn */\n  ];\n  const shouldRunImplicitMap = !(isPrimitiveConstructor(sourceMemberIdentifier) || isPrimitiveConstructor(destinationMemberIdentifier) || isDateConstructor(sourceMemberIdentifier) || isDateConstructor(destinationMemberIdentifier));\n\n  switch (transformationType) {\n    case 1\n    /* TransformationType.MapFrom */\n    :\n      value = mapFn(sourceObject);\n      break;\n\n    case 3\n    /* TransformationType.FromValue */\n    :\n      value = mapFn();\n      break;\n\n    case 4\n    /* TransformationType.MapWith */\n    :\n      value = mapFn(sourceObject, mapper);\n      break;\n\n    case 5\n    /* TransformationType.ConvertUsing */\n    :\n      value = mapFn(sourceObject);\n      break;\n\n    case 2\n    /* TransformationType.Condition */\n    :\n    case 7\n    /* TransformationType.NullSubstitution */\n    :\n    case 8\n    /* TransformationType.UndefinedSubstitution */\n    :\n      value = mapFn(sourceObject, destinationMemberPath);\n\n      if (shouldRunImplicitMap && value != null) {\n        value = Array.isArray(value) ? mapper.mapArray(value, sourceMemberIdentifier, destinationMemberIdentifier) : mapper.map(value, sourceMemberIdentifier, destinationMemberIdentifier);\n      }\n\n      break;\n\n    case 9\n    /* TransformationType.MapWithArguments */\n    :\n      value = mapFn(sourceObject, extraArgs || {});\n      break;\n\n    case 10\n    /* TransformationType.MapDefer */\n    :\n      value = mapMember(mapFn(sourceObject), sourceObject, destinationObject, destinationMemberPath, extraArgs, mapper, sourceMemberIdentifier, destinationMemberIdentifier);\n      break;\n  }\n\n  return value;\n}\n\nfunction setMemberReturnFn(destinationMemberPath, destination) {\n  return value => {\n    if (destination) {\n      destination = set(destination, destinationMemberPath, value);\n    }\n  };\n}\n\nfunction mapReturn(mapping, sourceObject, options, isMapArray = false) {\n  return map({\n    mapping,\n    sourceObject,\n    options,\n    setMemberFn: setMemberReturnFn,\n    isMapArray\n  });\n}\n\nfunction setMemberMutateFn(destinationObj) {\n  return destinationMember => value => {\n    if (value !== undefined) {\n      setMutate(destinationObj, destinationMember, value);\n    }\n  };\n}\n\nfunction getMemberMutateFn(destinationObj) {\n  return memberPath => get(destinationObj, memberPath);\n}\n\nfunction mapMutate(mapping, sourceObject, destinationObj, options, isMapArray = false) {\n  map({\n    sourceObject,\n    mapping,\n    setMemberFn: setMemberMutateFn(destinationObj),\n    getMemberFn: getMemberMutateFn(destinationObj),\n    options,\n    isMapArray\n  });\n}\nfunction map({\n  mapping,\n  sourceObject,\n  options,\n  setMemberFn,\n  getMemberFn,\n  isMapArray = false\n}) {\n  // destructure mapping\n  const [[sourceIdentifier, destinationIdentifier], [, destinationWithMetadata], propsToMap, mapper, destinationConstructor,, [mappingBeforeCallback, mappingAfterCallback] = []] = mapping; // deconstruct MapOptions\n\n  const {\n    beforeMap: mapBeforeCallback,\n    afterMap: mapAfterCallback,\n    destinationConstructor: mapDestinationConstructor = destinationConstructor,\n    extraArgs\n  } = options !== null && options !== void 0 ? options : {};\n  const errorHandler = getErrorHandler(mapper);\n  const metadataMap = getMetadataMap(mapper);\n  const destination = mapDestinationConstructor(sourceObject, destinationIdentifier); // initialize an array of keys that have already been configured\n\n  const configuredKeys = [];\n\n  if (!isMapArray) {\n    const beforeMap = mapBeforeCallback !== null && mapBeforeCallback !== void 0 ? mapBeforeCallback : mappingBeforeCallback;\n\n    if (beforeMap) {\n      beforeMap(sourceObject, destination);\n    }\n  } // map\n\n\n  for (let i = 0, length = propsToMap.length; i < length; i++) {\n    // destructure mapping property\n    const [destinationMemberPath, [, [transformationMapFn, [transformationPreConditionPredicate, transformationPreConditionDefaultValue = undefined] = []]], [destinationMemberIdentifier, sourceMemberIdentifier] = []] = propsToMap[i];\n    let hasSameIdentifier = !isPrimitiveConstructor(destinationMemberIdentifier) && !isDateConstructor(destinationMemberIdentifier) && !isPrimitiveConstructor(sourceMemberIdentifier) && !isDateConstructor(sourceMemberIdentifier) && sourceMemberIdentifier === destinationMemberIdentifier;\n\n    if (hasSameIdentifier) {\n      // at this point, we have a same identifier that aren't primitive or date\n      // we then check if there is a mapping created for this identifier\n      hasSameIdentifier = !getMapping(mapper, sourceMemberIdentifier, destinationMemberIdentifier, true);\n    } // Setup a shortcut function to set destinationMemberPath on destination with value as argument\n\n\n    const setMember = valFn => {\n      var _a, _b;\n\n      try {\n        return setMemberFn(destinationMemberPath, destination)(valFn());\n      } catch (originalError) {\n        const errorMessage = `\nError at \"${destinationMemberPath}\" on ${((_b = (_a = destinationIdentifier['prototype']) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) || destinationIdentifier} (${JSON.stringify(destination)})\n---------------------------------------------------------------------\nOriginal error: ${originalError}`;\n        errorHandler.handle(errorMessage);\n        throw new Error(errorMessage);\n      }\n    }; // This destination key is being configured. Push to configuredKeys array\n\n\n    configuredKeys.push(destinationMemberPath[0]); // Pre Condition check\n\n    if (transformationPreConditionPredicate && !transformationPreConditionPredicate(sourceObject)) {\n      setMember(() => transformationPreConditionDefaultValue);\n      continue;\n    } // Start with all the mapInitialize\n\n\n    if (transformationMapFn[0\n    /* MapFnClassId.type */\n    ] === 6\n    /* TransformationType.MapInitialize */\n    ) {\n      // check if metadata as destinationMemberPath is null\n      const destinationMetadata = metadataMap.get(destinationIdentifier);\n      const hasNullMetadata = destinationMetadata && destinationMetadata.find(metadata => isPrimitiveArrayEqual(metadata[0\n      /* MetadataClassId.propertyKeys */\n      ], destinationMemberPath)) === null;\n      const mapInitializedValue = transformationMapFn[1\n      /* MapFnClassId.fn */\n      ](sourceObject);\n      const isTypedConverted = transformationMapFn[2\n      /* MapFnClassId.isConverted */\n      ]; // if null/undefined\n      // if isDate, isFile\n      // if metadata is null, treat as-is\n      // if has same identifier that are not primitives or Date\n      // if the initialized value was converted with typeConverter\n\n      if (mapInitializedValue == null || mapInitializedValue instanceof Date || Object.prototype.toString.call(mapInitializedValue).slice(8, -1) === 'File' || hasNullMetadata || hasSameIdentifier || isTypedConverted) {\n        setMember(() => mapInitializedValue);\n        continue;\n      } // if isArray\n\n\n      if (Array.isArray(mapInitializedValue)) {\n        const [first] = mapInitializedValue; // if first item is a primitive\n\n        if (typeof first !== 'object' || first instanceof Date || Object.prototype.toString.call(first).slice(8, -1) === 'File') {\n          setMember(() => mapInitializedValue.slice());\n          continue;\n        } // if first is empty\n\n\n        if (isEmpty(first)) {\n          setMember(() => []);\n          continue;\n        }\n\n        setMember(() => mapInitializedValue.map(each => mapReturn(getMapping(mapper, sourceMemberIdentifier, destinationMemberIdentifier), each, {\n          extraArgs\n        })));\n        continue;\n      }\n\n      if (typeof mapInitializedValue === 'object') {\n        const nestedMapping = getMapping(mapper, sourceMemberIdentifier, destinationMemberIdentifier); // nested mutate\n\n        if (getMemberFn) {\n          const memberValue = getMemberFn(destinationMemberPath);\n\n          if (memberValue !== undefined) {\n            map({\n              sourceObject: mapInitializedValue,\n              mapping: nestedMapping,\n              options: {\n                extraArgs\n              },\n              setMemberFn: setMemberMutateFn(memberValue),\n              getMemberFn: getMemberMutateFn(memberValue)\n            });\n          }\n\n          continue;\n        }\n\n        setMember(() => map({\n          mapping: nestedMapping,\n          sourceObject: mapInitializedValue,\n          options: {\n            extraArgs\n          },\n          setMemberFn: setMemberReturnFn\n        }));\n        continue;\n      } // if is primitive\n\n\n      setMember(() => mapInitializedValue);\n      continue;\n    }\n\n    setMember(() => mapMember(transformationMapFn, sourceObject, destination, destinationMemberPath, extraArgs === null || extraArgs === void 0 ? void 0 : extraArgs(mapping, destination), mapper, sourceMemberIdentifier, destinationMemberIdentifier));\n  }\n\n  if (!isMapArray) {\n    const afterMap = mapAfterCallback !== null && mapAfterCallback !== void 0 ? mapAfterCallback : mappingAfterCallback;\n\n    if (afterMap) {\n      afterMap(sourceObject, destination);\n    }\n  } // Check unmapped properties\n\n\n  assertUnmappedProperties(destination, destinationWithMetadata, configuredKeys, sourceIdentifier, destinationIdentifier, errorHandler);\n  return destination;\n}\n\nclass AutoMapperLogger {\n  static configure(customLogger = {}) {\n    if (this.configured) return;\n    this.configured = true;\n    Object.entries(customLogger).forEach(([logLevel, logImpl]) => {\n      if (logImpl !== undefined) {\n        this[logLevel] = logImpl;\n      }\n    });\n  }\n\n  static log(message) {\n    console.log.bind(console, this.AUTOMAPPER_PREFIX, message);\n  }\n\n  static warn(warning) {\n    console.warn.bind(console, this.AUTOMAPPER_PREFIX, warning);\n  }\n\n  static error(error) {\n    console.error.bind(console, this.AUTOMAPPER_PREFIX, error);\n  }\n\n  static info(info) {\n    console.info.bind(console, this.AUTOMAPPER_PREFIX, info);\n  }\n\n}\nAutoMapperLogger.AUTOMAPPER_PREFIX = '[AutoMapper]: ';\nAutoMapperLogger.configured = false;\n\n/**\r\n * Creates and returns a Mapper {} as a Proxy. The following methods are available to use with a Mapper:\r\n *  ```\r\n *  - Mapper#map(Array)(Async), Mapper#mutate(Array)(Async)\r\n *  - createMap()\r\n *  - addProfile()\r\n *  - getMapping()\r\n *  - getMappings()\r\n *  ```\r\n * @param {CreateMapperOptions} options\r\n */\n\nfunction createMapper({\n  strategyInitializer,\n  errorHandler,\n  namingConventions\n}) {\n  let strategy; // this mapper is responsible for all mappings\n\n  let mappings; // this mapper is responsible for all metadata\n\n  let metadataMap;\n  let metadataObjectMap; // this mapper is responsible for recursive depths and counts\n\n  let recursiveDepth;\n  let recursiveCount; // this mapper is tracking some context about the MappingProfile\n\n  let profileConfigurationContext;\n\n  function getOptions(sourceIdentifier, destinationIdentifierOrOptions, options) {\n    if (destinationIdentifierOrOptions && options) {\n      return {\n        destinationIdentifier: destinationIdentifierOrOptions,\n        mapOptions: options\n      };\n    }\n\n    let destinationIdentifier = sourceIdentifier;\n\n    if (destinationIdentifierOrOptions && !options) {\n      const typeofDestinationOrOptions = typeof destinationIdentifierOrOptions;\n\n      if (typeofDestinationOrOptions === 'string' || typeofDestinationOrOptions === 'function') {\n        destinationIdentifier = destinationIdentifierOrOptions;\n      } else {\n        options = destinationIdentifierOrOptions;\n      }\n    }\n\n    return {\n      destinationIdentifier,\n      mapOptions: options\n    };\n  } // return the Proxy\n\n\n  return new Proxy({\n    [CUSTOM_NODE_INSPECT]() {\n      return `\nMapper {} is an empty Object as a Proxy. The following methods are available to use with a Mapper:\n- Mapper#map(Array)(Async), Mapper#mutate(Array)(Async)\n- createMap()\n- addProfile()\n- getMapping()\n- getMappings()\n        `;\n    }\n\n  }, {\n    get(target, p, receiver) {\n      if (p === STRATEGY) {\n        if (!strategy) {\n          strategy = strategyInitializer(receiver);\n        }\n\n        return strategy;\n      }\n\n      if (p === PROFILE_CONFIGURATION_CONTEXT) {\n        if (!profileConfigurationContext) {\n          profileConfigurationContext = new Set();\n        }\n\n        return profileConfigurationContext;\n      }\n\n      if (p === MAPPINGS) {\n        if (!mappings) {\n          mappings = new Map();\n        }\n\n        return mappings;\n      }\n\n      if (p === METADATA_MAP) {\n        if (!metadataMap) {\n          metadataMap = new Map();\n        }\n\n        return metadataMap;\n      }\n\n      if (p === METADATA_OBJECT_MAP) {\n        if (!metadataObjectMap) {\n          metadataObjectMap = new Map();\n        }\n\n        return metadataObjectMap;\n      }\n\n      if (p === ERROR_HANDLER) {\n        if (!errorHandler) {\n          errorHandler = {\n            handle: AutoMapperLogger.error ? AutoMapperLogger.error.bind(AutoMapperLogger) : // eslint-disable-next-line @typescript-eslint/no-empty-function\n            () => {}\n          };\n        }\n\n        return errorHandler;\n      }\n\n      if (p === NAMING_CONVENTIONS) {\n        return namingConventions;\n      }\n\n      if (p === RECURSIVE_DEPTH) {\n        if (!recursiveDepth) {\n          recursiveDepth = new Map();\n        }\n\n        return recursiveDepth;\n      }\n\n      if (p === RECURSIVE_COUNT) {\n        if (!recursiveCount) {\n          recursiveCount = new Map();\n        }\n\n        return recursiveCount;\n      }\n\n      if (p === 'dispose') {\n        return () => {\n          mappings === null || mappings === void 0 ? void 0 : mappings.clear(); // TODO: why can metadata not be clear?\n          // metadata?.clear();\n\n          metadataObjectMap === null || metadataObjectMap === void 0 ? void 0 : metadataObjectMap.clear();\n          recursiveDepth === null || recursiveDepth === void 0 ? void 0 : recursiveDepth.clear();\n          recursiveCount === null || recursiveCount === void 0 ? void 0 : recursiveCount.clear();\n          profileConfigurationContext === null || profileConfigurationContext === void 0 ? void 0 : profileConfigurationContext.clear();\n        };\n      }\n\n      if (p === 'map') {\n        return (sourceObject, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          if (sourceObject == null) return sourceObject;\n          const {\n            destinationIdentifier,\n            mapOptions\n          } = getOptions(sourceIdentifier, destinationIdentifierOrOptions, options);\n          const mapping = getMapping(receiver, sourceIdentifier, destinationIdentifier);\n          sourceObject = strategy.preMap(sourceObject, mapping);\n          const destination = mapReturn(mapping, sourceObject, mapOptions || {});\n          return strategy.postMap(sourceObject, // seal destination so that consumers cannot add properties to it\n          // or change the property descriptors. but they can still modify it\n          // the ideal behavior is seal but the consumers might need to add/modify the object after map finishes\n          destination, mapping);\n        };\n      }\n\n      if (p === 'mapAsync') {\n        return (sourceObject, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          const result = receiver['map'](sourceObject, sourceIdentifier, destinationIdentifierOrOptions, options);\n          return new Promise(res => {\n            setTimeout(res, 0, result);\n          });\n        };\n      }\n\n      if (p === 'mapArray') {\n        return (sourceArray, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          if (!sourceArray.length) return [];\n          const {\n            destinationIdentifier,\n            mapOptions\n          } = getOptions(sourceIdentifier, destinationIdentifierOrOptions, options);\n          const mapping = getMapping(receiver, sourceIdentifier, destinationIdentifier);\n          const {\n            beforeMap,\n            afterMap,\n            extraArgs\n          } = mapOptions || {};\n\n          if (beforeMap) {\n            beforeMap(sourceArray, []);\n          }\n\n          const destinationArray = [];\n\n          for (let i = 0, length = sourceArray.length; i < length; i++) {\n            let sourceObject = sourceArray[i];\n            sourceObject = strategy.preMap(sourceObject, mapping);\n            const destination = mapReturn(mapping, sourceObject, {\n              extraArgs: extraArgs\n            }, true);\n            destinationArray.push(strategy.postMap(sourceObject, // seal destination so that consumers cannot add properties to it\n            // or change the property descriptors. but they can still modify it\n            // the ideal behavior is seal but the consumers might need to add/modify the object after map finishes\n            destination, mapping));\n          }\n\n          if (afterMap) {\n            afterMap(sourceArray, destinationArray);\n          }\n\n          return destinationArray;\n        };\n      }\n\n      if (p === 'mapArrayAsync') {\n        return (sourceArray, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          const result = receiver['mapArray'](sourceArray, sourceIdentifier, destinationIdentifierOrOptions, options);\n          return new Promise(res => {\n            setTimeout(res, 0, result);\n          });\n        };\n      }\n\n      if (p === 'mutate') {\n        return (sourceObject, destinationObject, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          if (sourceObject == null) return;\n          const {\n            destinationIdentifier,\n            mapOptions\n          } = getOptions(sourceIdentifier, destinationIdentifierOrOptions, options);\n          const mapping = getMapping(receiver, sourceIdentifier, destinationIdentifier);\n          sourceObject = strategy.preMap(sourceObject, mapping);\n          mapMutate(mapping, sourceObject, destinationObject, mapOptions || {});\n          strategy.postMap(sourceObject, destinationObject, mapping);\n        };\n      }\n\n      if (p === 'mutateAsync') {\n        return (sourceObject, destinationObject, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          return new Promise(res => {\n            receiver['mutate'](sourceObject, destinationObject, sourceIdentifier, destinationIdentifierOrOptions, options);\n            setTimeout(res);\n          });\n        };\n      }\n\n      if (p === 'mutateArray') {\n        return (sourceArray, destinationArray, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          if (!sourceArray.length) return;\n          const {\n            destinationIdentifier,\n            mapOptions\n          } = getOptions(sourceIdentifier, destinationIdentifierOrOptions, options);\n          const mapping = getMapping(receiver, sourceIdentifier, destinationIdentifier);\n          const {\n            beforeMap,\n            afterMap,\n            extraArgs\n          } = mapOptions || {};\n\n          if (beforeMap) {\n            beforeMap(sourceArray, destinationArray);\n          }\n\n          for (let i = 0, length = sourceArray.length; i < length; i++) {\n            let sourceObject = sourceArray[i];\n            sourceObject = strategy.preMap(sourceObject, mapping);\n            mapMutate(mapping, sourceObject, destinationArray[i] || {}, {\n              extraArgs: extraArgs\n            }, true);\n            strategy.postMap(sourceObject, destinationArray[i], mapping);\n          }\n\n          if (afterMap) {\n            afterMap(sourceArray, destinationArray);\n          }\n        };\n      }\n\n      if (p === 'mutateArrayAsync') {\n        return (sourceArray, destinationArray, sourceIdentifier, destinationIdentifierOrOptions, options) => {\n          return new Promise(res => {\n            receiver['mutateArray'](sourceArray, destinationArray, sourceIdentifier, destinationIdentifierOrOptions, options);\n            setTimeout(res);\n          });\n        };\n      }\n\n      return Reflect.get(target, p, receiver);\n    }\n\n  });\n}\n\nconst RECURSIVE_DATA = Symbol('__recursive_data__');\nfunction getRecursiveValue(recursiveMap, parent, member) {\n  const parentValue = recursiveMap.get(parent);\n  return parentValue ? arrayMapGet(parentValue, member) : undefined;\n}\nfunction setRecursiveValue(recursiveMap, parent, member, value) {\n  if (!recursiveMap.has(parent)) {\n    recursiveMap.set(parent, arrayMapSet(new Map(), member, value));\n    return;\n  }\n\n  const parentValue = recursiveMap.get(parent);\n  if (arrayMapHas(parentValue, member)) return;\n  arrayMapSet(parentValue, member, value);\n}\n\nfunction arrayMapSet(root, path, value) {\n  let map = root;\n\n  for (const item of path) {\n    let nextMap = map.get(item);\n\n    if (!nextMap) {\n      // Create next map if none exists\n      nextMap = new Map();\n      map.set(item, nextMap);\n    }\n\n    map = nextMap;\n  } // Reached end of path.  Set the data symbol to the given value\n\n\n  map.set(RECURSIVE_DATA, value);\n  return root;\n}\n\nfunction arrayMapHas(root, path) {\n  let map = root;\n\n  for (const item of path) {\n    const nextMap = map.get(item);\n\n    if (nextMap) {\n      map = nextMap;\n    } else {\n      return false;\n    }\n  }\n\n  return map.has(RECURSIVE_DATA);\n}\n\nfunction arrayMapGet(root, path) {\n  let map = root;\n\n  for (const item of path) {\n    map = map.get(item);\n    if (!map) return undefined;\n  }\n\n  return map.get(RECURSIVE_DATA);\n}\n\nfunction defaultApplyMetadata(strategy) {\n  const mapper = strategy.mapper;\n  const metadataMap = getMetadataMap(mapper);\n  const metadataObjectMap = getMetadataObjectMap(mapper);\n  const recursiveCountMap = getRecursiveCount(mapper);\n  const recursiveDepthMap = getRecursiveDepth(mapper);\n\n  function applyMetadata(model, as, root = true, selfReference = false) {\n    var _a; // get the metadata of the model\n\n\n    const metadata = metadataMap.get(model); // instantiate a model\n\n    const instance = {}; // if metadata is empty, return the instance early\n\n    if (isEmpty(metadata) || !metadata) {\n      return instance;\n    } // walking the metadata\n\n\n    for (let i = 0, length = metadata.length; i < length; i++) {\n      // destructure the metadata\n      const key = metadata[i][0\n      /* MetadataClassId.propertyKeys */\n      ];\n      const metaFn = metadata[i][1\n      /* MetadataClassId.metaFn */\n      ];\n      const isArray = metadata[i][2\n      /* MetadataClassId.isArray */\n      ];\n      /**\r\n       * in V8, AutoMapper does not instantiate a new model on applying metadata anymore.\r\n       * Hence, isGetterOnly seems to be obsolete.\r\n       */\n\n      const isGetterOnly = metadata[i][3\n      /* MetadataClassId.isGetterOnly */\n      ]; // skip getter if is applying metadata to a destination (because we will be setting data\n      // on the destination. Getter only cannot be set\n\n      if (isGetterOnly && as === 1\n      /* MetadataObjectMapClassId.asDestination */\n      ) {\n        continue;\n      } // call the meta fn to get the metaResult of the current key\n\n\n      const metaResult = metaFn(); // if the metadata is an Array, then assign an empty array\n\n      if (isArray) {\n        setMutate(instance, key, []);\n        continue;\n      } // if is String, Number, Boolean\n      // null meta means this has any type or an arbitrary object, treat as primitives\n\n\n      if (isPrimitiveConstructor(metaResult) || metaResult === null) {\n        setMutate(instance, key, undefined);\n        continue;\n      } // if is Date, assign a new Date value if valueAtKey is defined, otherwise, undefined\n\n\n      if (isDateConstructor(metaResult)) {\n        setMutate(instance, key, new Date());\n        continue;\n      } // get depth and count of the current key on the current model\n      // Eg: Foo {bar: Bar}, model here is Foo and key is bar\n\n\n      const depth = getRecursiveValue(recursiveDepthMap, model, key);\n      const count = getRecursiveValue(recursiveCountMap, model, key) || 0; // if no depth, just instantiate with new keyword without recursive\n\n      if (depth === 0) {\n        setMutate(instance, key, {});\n        continue;\n      } // if depth equals count, meaning instantiate has run enough loop.\n      // reset the count then assign with new keyword\n\n\n      if (depth === count) {\n        if (root || !selfReference) {\n          setRecursiveValue(recursiveCountMap, model, key, 0);\n        }\n\n        setMutate(instance, key, {});\n        continue;\n      } // increment the count and recursively call instantiate\n\n\n      setRecursiveValue(recursiveCountMap, model, key, count + 1);\n      const childMetadataObjectMap = metadataObjectMap.get(metaResult);\n      const childMetadata = (childMetadataObjectMap === null || childMetadataObjectMap === void 0 ? void 0 : childMetadataObjectMap[as]) || applyMetadata(metaResult, as, false, metaResult === model);\n      setMutate(instance, key, childMetadata);\n    } // after all, resetAllCount on the current model\n\n\n    if (root || !selfReference) {\n      (_a = recursiveCountMap.get(model)) === null || _a === void 0 ? void 0 : _a.clear();\n    }\n\n    return instance;\n  }\n\n  return applyMetadata;\n}\n\nconst defaultStrategyInitializerOptions = {\n  applyMetadata: defaultApplyMetadata,\n\n  preMap(source) {\n    return source;\n  },\n\n  postMap(_, destination) {\n    return destination;\n  }\n\n};\n\nfunction isDefined(value, strict = false) {\n  return strict ? value !== undefined : value != null;\n}\n\nfunction storeMetadata(mapper, model, metadataList) {\n  if (!isDefined(metadataList)) return;\n  const metadataMap = getMetadataMap(mapper);\n  if (metadataMap.has(model)) return;\n\n  for (const [propertyKey, {\n    isGetterOnly,\n    type,\n    depth,\n    isArray\n  }] of metadataList) {\n    metadataMap.set(model, [...(metadataMap.get(model) || []), [[propertyKey], type, isArray, isGetterOnly]]);\n\n    if (depth != null) {\n      setRecursiveValue(getRecursiveDepth(mapper), model, [propertyKey], depth);\n    }\n  }\n}\n\nfunction mapInitialize(sourcePath) {\n  return [6\n  /* TransformationType.MapInitialize */\n  , source => get(source, sourcePath)];\n}\n\nfunction getPath(path, [sourceNamingConvention, destinationNamingConvention]) {\n  const keyParts = path.map(s => s.split(destinationNamingConvention.splittingExpression).filter(Boolean)).filter(p => p.length > 0);\n  return !keyParts.length ? path : keyParts.map(p => sourceNamingConvention.transformPropertyName(p));\n}\nfunction getFlatteningPaths(src, srcPath, namingConventions) {\n  const [sourceNamingConvention] = namingConventions;\n  const splitSourcePaths = [].concat(...srcPath.map(s => s.split(sourceNamingConvention.splittingExpression).filter(Boolean)));\n  const [first, ...paths] = splitSourcePaths.slice(0, splitSourcePaths.length - 1);\n  let trueFirstPartOfSource = first;\n  let stopIndex = 0;\n  let found = hasProperty(src, trueFirstPartOfSource);\n\n  if (!found) {\n    for (let i = 0, len = paths.length; i < len; i++) {\n      trueFirstPartOfSource = sourceNamingConvention.transformPropertyName([trueFirstPartOfSource, paths[i]]);\n\n      if (hasProperty(src, trueFirstPartOfSource)) {\n        stopIndex = i + 1;\n        found = true;\n        break;\n      }\n    }\n  }\n\n  if (!found) {\n    return srcPath;\n  }\n\n  const restPaths = splitSourcePaths.slice(stopIndex + 1, splitSourcePaths.length + 1);\n  const transformedRestPaths = sourceNamingConvention.transformPropertyName(restPaths);\n\n  if (restPaths.length > 1 && !hasProperty(src[trueFirstPartOfSource], transformedRestPaths) && hasProperty(src[trueFirstPartOfSource], sourceNamingConvention.transformPropertyName([restPaths[0]]))) {\n    // still has more flattening to do: eg: bookAuthorName -> ['Author', 'Name']\n    // transformedRestPaths (authorName) does not exist on source\n    // first of rest paths (author) does exist on source\n    return [trueFirstPartOfSource, ...getFlatteningPaths(src[trueFirstPartOfSource], getPath([transformedRestPaths], namingConventions), namingConventions)];\n  }\n\n  return [trueFirstPartOfSource, sourceNamingConvention.transformPropertyName(splitSourcePaths.slice(stopIndex + 1, splitSourcePaths.length + 1))];\n}\n\nfunction hasProperty(obj, property) {\n  return Object.prototype.hasOwnProperty.call(obj, property);\n}\n\nfunction isSamePath(target, value) {\n  if (target.length !== value.length) {\n    return false;\n  }\n\n  for (let i = 0, targetLen = target.length; i < targetLen; i++) {\n    if (target[i] !== value[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction uniquePaths(paths) {\n  const result = [];\n\n  for (let i = 0, pathsLen = paths.length; i < pathsLen; i++) {\n    const value = paths[i];\n\n    if (!result.some(item => isSamePath(item, value))) {\n      result.push(value);\n    }\n  }\n\n  return result;\n}\n\nconst EXCLUDE_KEYS = ['constructor', '__defineGetter__', '__defineSetter__', 'hasOwnProperty', '__lookupGetter__', '__lookupSetter__', 'isPrototypeOf', 'propertyIsEnumerable', 'toString', 'valueOf', '__proto__', 'toLocaleString'];\nfunction getPathRecursive(node, prefix = [], previous = []) {\n  const result = previous;\n  let hasChildPaths = false;\n  const keys = Array.from(new Set([...Object.getOwnPropertyNames(node)].filter(key => !EXCLUDE_KEYS.includes(key))));\n\n  for (let i = 0, len = keys.length; i < len; i++) {\n    const key = keys[i];\n    const path = [...prefix, key];\n    const child = node[key];\n\n    if (typeof child === 'function') {\n      continue;\n    }\n\n    result.push(path);\n\n    if (typeof child === 'object') {\n      const queue = Array.isArray(child) ? child : [child];\n\n      for (const childNode of queue) {\n        const childPaths = getPathRecursive(childNode, path);\n\n        if (childPaths) {\n          hasChildPaths = true;\n          result.push(...childPaths);\n        }\n      }\n    }\n  }\n\n  if (hasChildPaths) {\n    return uniquePaths(result);\n  }\n\n  return result;\n}\n\nfunction createInitialMapping(mapper, source, destination, configurations = []) {\n  const strategy = getStrategy(mapper);\n  const applyMetadataFn = strategy.applyMetadata.bind(strategy);\n  const destinationConstructor = strategy.destinationConstructor.bind(strategy);\n  const metadataObjectMap = getMetadataObjectMap(mapper);\n  const sourceMetadataObjectMap = metadataObjectMap.get(source);\n  const destinationMetadataObjectMap = metadataObjectMap.get(destination);\n  const destinationObject = (destinationMetadataObjectMap === null || destinationMetadataObjectMap === void 0 ? void 0 : destinationMetadataObjectMap[1\n  /* MetadataObjectMapClassId.asDestination */\n  ]) || applyMetadataFn(destination, 1\n  /* MetadataObjectMapClassId.asDestination */\n  );\n\n  if (destinationMetadataObjectMap) {\n    destinationMetadataObjectMap[1\n    /* MetadataObjectMapClassId.asDestination */\n    ] = destinationObject;\n  } else {\n    metadataObjectMap.set(destination, [undefined, destinationObject]);\n  }\n\n  const sourceObject = (sourceMetadataObjectMap === null || sourceMetadataObjectMap === void 0 ? void 0 : sourceMetadataObjectMap[0\n  /* MetadataObjectMapClassId.asSource */\n  ]) || applyMetadataFn(source, 0\n  /* MetadataObjectMapClassId.asSource */\n  );\n\n  if (sourceMetadataObjectMap) {\n    sourceMetadataObjectMap[0\n    /* MetadataObjectMapClassId.asSource */\n    ] = sourceObject;\n  } else {\n    metadataObjectMap.set(source, [sourceObject]);\n  }\n\n  const mapping = [[source, destination], [sourceObject, destinationObject], [], mapper, destinationConstructor]; // try to inherit naming conventions from mapper\n\n  mapping[7\n  /* MappingClassId.namingConventions */\n  ] = getNamingConventions(mapper); // run configuration fn on mapping\n\n  for (let i = 0, length = configurations.length; i < length; i++) {\n    configurations[i](mapping);\n  }\n\n  const destinationPaths = getPathRecursive(destinationObject);\n  const mappingProperties = mapping[2\n  /* MappingClassId.properties */\n  ];\n  const hasCustomMappingProperties = mappingProperties.length > 0;\n  const namingConventions = mapping[7\n  /* MappingClassId.namingConventions */\n  ];\n  const metadataMap = getMetadataMap(mapper);\n  const destinationMetadata = metadataMap.get(destination) || [];\n  const sourceMetadata = metadataMap.get(source) || [];\n\n  for (let i = 0, length = destinationPaths.length; i < length; i++) {\n    const destinationPath = destinationPaths[i]; // is a forMember (custom mapping configuration) already exists\n    // for this destination path, skip it\n\n    if (hasCustomMappingProperties && mappingProperties.some(property => isPrimitiveArrayEqual(property[0\n    /* MappingPropertiesClassId.path */\n    ], destinationPath))) {\n      continue;\n    }\n\n    const metadataAtDestination = destinationMetadata.find(metadata => isPrimitiveArrayEqual(metadata[0\n    /* MetadataClassId.propertyKeys */\n    ], destinationPath)); // try getting the sourcePath that is associated with this destinationPath\n\n    /**\r\n     * with naming conventions: fooBar -> [foo, bar]\r\n     * without naming conventions: fooBar -> fooBar\r\n     */\n\n    let sourcePath = destinationPath;\n\n    if (namingConventions) {\n      sourcePath = getFlatteningPaths(sourceObject, getPath(destinationPath, namingConventions), namingConventions);\n    } // sourcePath is not in sourceObject. No AutoMap available\n\n\n    if (!(sourcePath[0] in sourceObject)) {\n      continue;\n    }\n\n    const metadataAtSource = sourceMetadata.find(metadata => isPrimitiveArrayEqual(metadata[0\n    /* MetadataClassId.propertyKeys */\n    ], sourcePath));\n    let nestedMappingPair = undefined;\n    if (!metadataAtSource && !metadataAtDestination) continue;\n\n    if (metadataAtSource && metadataAtDestination) {\n      nestedMappingPair = [metadataAtDestination[1\n      /* MetadataClassId.metaFn */\n      ](), metadataAtSource[1\n      /* MetadataClassId.metaFn */\n      ]()];\n    }\n\n    const transformation = [mapInitialize(sourcePath)];\n\n    if (nestedMappingPair) {\n      let typeConverter;\n      const isSourceArray = metadataAtSource[2\n      /* MetadataClassId.isArray */\n      ];\n      const isDestinationArray = metadataAtDestination[2\n      /* MetadataClassId.isArray */\n      ];\n      const mappingTypeConverters = mapping[5\n      /* MappingClassId.typeConverters */\n      ];\n\n      if (mappingTypeConverters) {\n        const [sourceConverters, arraySourceConverters] = mappingTypeConverters.get(nestedMappingPair[1\n        /* NestedMappingPairClassId.source */\n        ]) || [];\n        const [destinationConverter, arrayDestinationConverter] = (isSourceArray ? arraySourceConverters === null || arraySourceConverters === void 0 ? void 0 : arraySourceConverters.get(nestedMappingPair[0\n        /* NestedMappingPairClassId.destination */\n        ]) : sourceConverters === null || sourceConverters === void 0 ? void 0 : sourceConverters.get(nestedMappingPair[0\n        /* NestedMappingPairClassId.destination */\n        ])) || [];\n        typeConverter = isDestinationArray ? arrayDestinationConverter : destinationConverter;\n      }\n\n      if (typeConverter) {\n        const originalMapInitializeFn = transformation[0\n        /* MappingTransformationClassId.memberMapFn */\n        ][1\n        /* MapFnClassId.fn */\n        ];\n\n        transformation[0\n        /* MappingTransformationClassId.memberMapFn */\n        ][1\n        /* MapFnClassId.fn */\n        ] = srcObj => typeConverter(originalMapInitializeFn(srcObj));\n\n        transformation[0\n        /* MappingTransformationClassId.memberMapFn */\n        ][2\n        /* MapFnClassId.isConverted */\n        ] = true;\n      }\n    }\n\n    mappingProperties.unshift([destinationPath, [destinationPath, transformation], nestedMappingPair]);\n  }\n\n  return mapping;\n}\n\nfunction createMap(mapper, source, ...mappingConfigFnsOrIdentifier) {\n  var _a; // turn string into symbol for identifier\n\n\n  const sourceIdentifier = typeof source === 'string' ? Symbol.for(source) : source;\n  let destinationIdentifier = sourceIdentifier;\n  const [destination, ...mappingConfigFns] = mappingConfigFnsOrIdentifier || [];\n\n  if (destination) {\n    if (typeof destination === 'string') {\n      destinationIdentifier = Symbol.for(destination);\n    } else if (typeof destination === 'function' && destination.prototype !== undefined) {\n      destinationIdentifier = destination;\n    } else {\n      (mappingConfigFns || []).push(destination);\n    }\n  }\n\n  const mappings = getMappings(mapper);\n  let mapping = (_a = mappings.get(sourceIdentifier)) === null || _a === void 0 ? void 0 : _a.get(destinationIdentifier);\n\n  if (mapping) {\n    getErrorHandler(mapper).handle(`Mapping for source ${String(source)} and destination ${String(destination)} already exists`);\n    return mapping;\n  } // get the strategy from Mapper to retrieve the metadata\n\n\n  const strategy = getStrategy(mapper);\n  const strategyMetadataMap = strategy.retrieveMetadata(sourceIdentifier, destinationIdentifier);\n  strategyMetadataMap.forEach((metadataList, identifier) => {\n    storeMetadata(mapper, identifier, metadataList);\n  }); // after all the mapping configurations are consolidated,\n  // initialize the mapping\n\n  mapping = createInitialMapping(mapper, sourceIdentifier, destinationIdentifier, (mappingConfigFns || []).concat(...getProfileConfigurationContext(mapper).values()).filter(configFn => configFn != undefined)); // store the mapping\n\n  if (!mappings.has(sourceIdentifier)) {\n    mappings.set(sourceIdentifier, new Map([[destinationIdentifier, mapping]]));\n  } else {\n    mappings.get(sourceIdentifier).set(destinationIdentifier, mapping);\n  } // return the mapping\n\n\n  return mapping;\n}\n\nfunction addProfile(mapper, profile, ...mappingConfigurations) {\n  mappingConfigurations.forEach(mappingConfiguration => {\n    getProfileConfigurationContext(mapper).add(mappingConfiguration);\n  });\n  profile.apply({\n    profileName: profile.name\n  }, [mapper]);\n  getProfileConfigurationContext(mapper).clear();\n}\n\nconst PROXY_TARGET = () => undefined;\n\nconst PROXY_OBJECT = createProxy(PROXY_TARGET);\n/**\r\n * For a given JS function selector, return a list of all members that were selected.\r\n *\r\n * @returns `null` if the given `fnSelector` doesn't match with anything.\r\n */\n\nfunction getMembers(fnSelector) {\n  const resultProxy = fnSelector(PROXY_OBJECT);\n\n  if (typeof resultProxy !== 'function') {\n    return null;\n  }\n\n  const members = resultProxy();\n\n  if (members.length === 0 || members.some(m => typeof m !== 'string')) {\n    return null;\n  }\n\n  return members;\n}\n/**\r\n * Get a dot-separated string of the properties selected by a given `fn` selector\r\n * function.\r\n *\r\n * @example\r\n * ```js\r\n * getMemberPath(s => s.foo.bar) === 'foo.bar'\r\n * getMemberPath(s => s['foo']) === 'foo'\r\n * getMemberPath(s => s.foo['']) === 'foo.'\r\n * // invalid usage\r\n * getMemberPath(s => s) === ''\r\n * ```\r\n */\n\nfunction getMemberPath(fn) {\n  const members = getMembers(fn);\n  return members ? members : [];\n}\n/**\r\n * @returns {Proxy} A proxy that's wrap on the target object and track of\r\n * the path of accessed nested properties\r\n */\n\nfunction createProxy(target, path = []) {\n  const realTraps = {\n    get(_, p) {\n      const childPath = path.slice();\n      childPath.push(p);\n      return createProxy(PROXY_TARGET, childPath);\n    },\n\n    apply() {\n      return path;\n    }\n\n  };\n  return new Proxy(target, realTraps);\n}\n\nfunction forMember(selector, ...fns) {\n  let [preCondOrMapMemberFn, mapMemberFn] = fns;\n  const memberPath = getMemberPath(selector); // reassign mapMemberFn and preCond\n\n  if (mapMemberFn == null) {\n    mapMemberFn = preCondOrMapMemberFn;\n    preCondOrMapMemberFn = undefined;\n  }\n\n  const mappingProperty = [memberPath, [mapMemberFn, preCondOrMapMemberFn]];\n  return mapping => {\n    // TODO: consolidate this logic with the one in createInitialMapping\n    const [sourceIdentifier, destinationIdentifier] = mapping[0\n    /* MappingClassId.identifiers */\n    ];\n    const mapper = mapping[3\n    /* MappingClassId.mapper */\n    ];\n    const namingConventions = mapping[7\n    /* MappingClassId.namingConventions */\n    ];\n    const [sourceObject] = mapping[1\n    /* MappingClassId.identifierMetadata */\n    ];\n    const metadataMap = getMetadataMap(mapper);\n    const destinationMetadata = metadataMap.get(destinationIdentifier) || [];\n    const sourceMetadata = metadataMap.get(sourceIdentifier) || [];\n    let nestedMappingPair = undefined;\n    const metadataAtMember = destinationMetadata.find(metadata => isPrimitiveArrayEqual(metadata[0\n    /* MetadataClassId.propertyKeys */\n    ], memberPath));\n    let sourcePath = memberPath;\n\n    if (namingConventions) {\n      sourcePath = getFlatteningPaths(sourceObject, getPath(memberPath, namingConventions), namingConventions);\n    } // sourcePath is not in sourceObject. No AutoMap available\n\n\n    if (!(sourcePath[0] in sourceObject)) {\n      mapping[2\n      /* MappingClassId.properties */\n      ].push([memberPath, mappingProperty, nestedMappingPair]);\n      return;\n    }\n\n    const metadataAtSource = sourceMetadata.find(metadata => isPrimitiveArrayEqual(metadata[0\n    /* MetadataClassId.propertyKeys */\n    ], sourcePath));\n\n    if (metadataAtSource && metadataAtMember) {\n      nestedMappingPair = [metadataAtMember[1\n      /* MetadataClassId.metaFn */\n      ](), metadataAtSource[1\n      /* MetadataClassId.metaFn */\n      ]()];\n    }\n\n    mapping[2\n    /* MappingClassId.properties */\n    ].push([memberPath, mappingProperty, nestedMappingPair]);\n  };\n}\n\nfunction forSelf(sourceOrMapping, selector) {\n  let selfMapping = Array.isArray(sourceOrMapping) ? sourceOrMapping : undefined;\n  return mapping => {\n    if (selfMapping == null) {\n      const [, destinationIdentifier] = mapping[0\n      /* MappingClassId.identifiers */\n      ];\n      const mapper = mapping[3\n      /* MappingClassId.mapper */\n      ];\n      const strategy = getStrategy(mapper); // turn string into symbol for identifier\n\n      const sourceIdentifier = typeof sourceOrMapping === 'string' ? Symbol.for(sourceOrMapping) : sourceOrMapping;\n      const strategyMetadataMap = strategy.retrieveMetadata(sourceIdentifier);\n      strategyMetadataMap.forEach((metadataList, identifier) => {\n        storeMetadata(mapper, identifier, metadataList);\n      });\n      selfMapping = createInitialMapping(mapper, sourceIdentifier, destinationIdentifier);\n    }\n\n    const selfMapProperties = selfMapping[2\n    /* MappingClassId.properties */\n    ];\n\n    for (let i = 0, length = selfMapProperties.length; i < length; i++) {\n      const mapProperty = selfMapProperties[i];\n\n      if (mapping[2\n      /* MappingClassId.properties */\n      ].some(property => isPrimitiveArrayEqual(property[0\n      /* MappingPropertiesClassId.path */\n      ], mapProperty[0\n      /* MappingPropertiesClassId.path */\n      ]))) {\n        continue;\n      }\n\n      const transformation = mapProperty[1\n      /* MappingPropertiesClassId.mappingProperty */\n      ][1\n      /* MappingPropertyClassId.transformation */\n      ];\n\n      transformation[0\n      /* MappingTransformationClassId.memberMapFn */\n      ][1\n      /* MapFnClassId.fn */\n      ] = sourceObj => get(selector(sourceObj), mapProperty[0\n      /* MappingPropertiesClassId.path */\n      ]);\n\n      mapping[2\n      /* MappingClassId.properties */\n      ].push([mapProperty[0\n      /* MappingPropertiesClassId.path */\n      ], [mapProperty[0\n      /* MappingPropertiesClassId.path */\n      ], transformation], mapProperty[2\n      /* MappingPropertiesClassId.nestedMappingPair */\n      ]]);\n    }\n  };\n}\n\nfunction toSelector(input) {\n  if ('convert' in input) return input.convert.bind(input);\n  return input;\n}\n\nfunction typeConverter(source, destination, converterOrValueSelector) {\n  return mapping => {\n    const isSourceArray = Array.isArray(source);\n    const isDestinationArray = Array.isArray(destination);\n    const sourceIdentifier = isSourceArray ? source[0] : source;\n    const destinationIdentifier = isDestinationArray ? destination[0] : destination;\n    const selector = toSelector(converterOrValueSelector);\n    const typeConverters = mapping[5\n    /* MappingClassId.typeConverters */\n    ] || (mapping[5\n    /* MappingClassId.typeConverters */\n    ] = new Map());\n    let sourceConverters;\n    const [sourceTypeConverters, arraySourceTypeConverters] = typeConverters.get(sourceIdentifier) || [];\n\n    if (sourceTypeConverters || arraySourceTypeConverters) {\n      sourceConverters = isSourceArray ? arraySourceTypeConverters : sourceTypeConverters;\n      const [destinationConverter, arrayDestinationConverter] = sourceConverters.get(destinationIdentifier) || [];\n      sourceConverters.set(destinationIdentifier, isDestinationArray ? [destinationConverter, selector] : [selector, arrayDestinationConverter]);\n      return;\n    }\n\n    sourceConverters = new Map([[destinationIdentifier, isDestinationArray ? [undefined, selector] : [selector, undefined]]]);\n    typeConverters.set(sourceIdentifier, isSourceArray ? [new Map(), sourceConverters] : [sourceConverters, new Map()]);\n  };\n}\n\nconst constructUsing = destinationConstructor => {\n  return mapping => {\n    mapping[4\n    /* MappingClassId.destinationConstructor */\n    ] = destinationConstructor;\n  };\n};\n\nfunction beforeMap(cb) {\n  return mapping => {\n    if (mapping[6\n    /* MappingClassId.callbacks */\n    ] == null) {\n      mapping[6\n      /* MappingClassId.callbacks */\n      ] = [];\n    }\n\n    mapping[6\n    /* MappingClassId.callbacks */\n    ][0\n    /* MappingCallbacksClassId.beforeMap */\n    ] = cb;\n  };\n}\n\nfunction afterMap(cb) {\n  return mapping => {\n    if (mapping[6\n    /* MappingClassId.callbacks */\n    ] == null) {\n      mapping[6\n      /* MappingClassId.callbacks */\n      ] = [];\n    }\n\n    mapping[6\n    /* MappingClassId.callbacks */\n    ][1\n    /* MappingCallbacksClassId.afterMap */\n    ] = cb;\n  };\n}\n\nfunction extend(sourceOrMapping, destination) {\n  return mapping => {\n    let mappingToExtend;\n\n    if (Array.isArray(sourceOrMapping)) {\n      mappingToExtend = sourceOrMapping;\n    } else {\n      const mapper = mapping[3\n      /* MappingClassId.mapper */\n      ];\n      mappingToExtend = getMapping(mapper, sourceOrMapping, destination);\n    }\n\n    const propsToExtend = mappingToExtend[2\n    /* MappingClassId.properties */\n    ];\n\n    for (let i = 0, length = propsToExtend.length; i < length; i++) {\n      const [propToExtendKey, propToExtendMappingProp, propToExtendNestedMapping] = propsToExtend[i];\n      const existProp = mapping[2\n      /* MappingClassId.properties */\n      ].find(([pKey]) => isSamePath(pKey, propToExtendKey));\n      if (existProp) continue;\n      mapping[2\n      /* MappingClassId.properties */\n      ].push([propToExtendKey, propToExtendMappingProp, propToExtendNestedMapping]);\n    }\n  };\n}\n\nconst namingConventions = namingConventionsInput => {\n  return mapping => {\n    mapping[7\n    /* MappingClassId.namingConventions */\n    ] = normalizeNamingConventions(namingConventionsInput);\n  };\n};\n\nfunction isResolver(fn) {\n  return 'resolve' in fn;\n}\n\nfunction mapFrom(from) {\n  if (isResolver(from)) {\n    return [1\n    /* TransformationType.MapFrom */\n    , from.resolve.bind(from)];\n  }\n\n  return [1\n  /* TransformationType.MapFrom */\n  , from];\n}\n\nfunction mapWith(withDestination, withSource, withSourceValue) {\n  return [4\n  /* TransformationType.MapWith */\n  , (source, mapper) => {\n    const sourceValue = withSourceValue(source);\n\n    if (Array.isArray(sourceValue)) {\n      return mapper.mapArray(sourceValue, withSource, withDestination);\n    }\n\n    return mapper.map(sourceValue, withSource, withDestination);\n  }];\n}\n\nfunction convertUsing(converter, selector) {\n  return [5\n  /* TransformationType.ConvertUsing */\n  , source => converter.convert(selector(source))];\n}\n\nfunction ignore() {\n  return [0\n  /* TransformationType.Ignore */\n  ];\n}\n\nfunction nullSubstitution(substitution) {\n  return [7\n  /* TransformationType.NullSubstitution */\n  , (source, sourceMemberPath) => {\n    const sourceValue = get(source, sourceMemberPath);\n    return sourceValue === null ? substitution : sourceValue;\n  }];\n}\n\nfunction preCondition(predicate, defaultValue) {\n  return [predicate, defaultValue];\n}\n\nfunction condition(predicate, defaultValue) {\n  return [2\n  /* TransformationType.Condition */\n  , (source, sourceMemberPaths) => {\n    if (predicate(source)) {\n      return get(source, sourceMemberPaths);\n    }\n\n    return defaultValue;\n  }];\n}\n\nfunction fromValue(rawValue) {\n  return [3\n  /* TransformationType.FromValue */\n  , () => rawValue];\n}\n\nfunction mapWithArguments(withArgumentsResolver) {\n  if (isResolver(withArgumentsResolver)) {\n    return [9\n    /* TransformationType.MapWithArguments */\n    , withArgumentsResolver.resolve.bind(withArgumentsResolver)];\n  }\n\n  return [9\n  /* TransformationType.MapWithArguments */\n  , withArgumentsResolver];\n}\n\nfunction mapDefer(defer) {\n  return [10\n  /* TransformationType.MapDefer */\n  , defer];\n}\n\nfunction undefinedSubstitution(substitution) {\n  return [8\n  /* TransformationType.UndefinedSubstitution */\n  , (source, sourceMemberPath) => {\n    const sourceValue = get(source, sourceMemberPath);\n    return sourceValue === undefined ? substitution : sourceValue;\n  }];\n}\n\n/**\r\n * CamelCaseNamingConvention\r\n *\r\n * @example thisIsCamelCase\r\n */\nclass CamelCaseNamingConvention {\n  constructor() {\n    this.separatorCharacter = '';\n    this.splittingExpression = /(^[a-z]+(?=$|[A-Z]{1}[a-z0-9]+)|[A-Z]?[a-z0-9]+)/;\n  }\n\n  transformPropertyName(sourceNameParts) {\n    let result = '';\n\n    for (let i = 0, len = sourceNameParts.length; i < len; i++) {\n      if (i === 0) {\n        result += sourceNameParts[i].charAt(0).toLowerCase();\n      } else {\n        result += sourceNameParts[i].charAt(0).toUpperCase();\n      }\n\n      result += sourceNameParts[i].substring(1);\n    }\n\n    return result;\n  }\n\n}\n\n/**\r\n * PascalCaseNamingConvention\r\n *\r\n * @example ThisIsPascalCase\r\n */\nclass PascalCaseNamingConvention {\n  constructor() {\n    this.separatorCharacter = '';\n    this.splittingExpression = /(^[A-Z]+(?=$|[A-Z]{1}[a-z0-9]+)|[A-Z]?[a-z0-9]+)/;\n  }\n\n  transformPropertyName(sourceNameParts) {\n    let result = '';\n\n    for (let i = 0, len = sourceNameParts.length; i < len; i++) {\n      result += sourceNameParts[i].charAt(0).toUpperCase() + sourceNameParts[i].substring(1);\n    }\n\n    return result;\n  }\n\n}\n\n/**\r\n * SnakeCaseNamingConvention\r\n *\r\n * @example this_is_snake_case\r\n */\nclass SnakeCaseNamingConvention {\n  constructor() {\n    this.separatorCharacter = '_';\n    this.splittingExpression = /_/;\n  }\n\n  transformPropertyName(sourcePropNameParts) {\n    const len = sourcePropNameParts.length;\n\n    if (len <= 1) {\n      return sourcePropNameParts[0].toLowerCase() || '';\n    }\n\n    return sourcePropNameParts.map(p => p.toLowerCase()).join(this.separatorCharacter);\n  }\n\n}\n\nexport { AutoMapperLogger, CamelCaseNamingConvention, PascalCaseNamingConvention, SnakeCaseNamingConvention, addProfile, afterMap, beforeMap, condition, constructUsing, convertUsing, createMap, createMapper, defaultStrategyInitializerOptions, extend, forMember, forSelf, fromValue, getRecursiveValue, ignore, isDateConstructor, isEmpty, isPrimitiveConstructor, mapDefer, mapFrom, mapWith, mapWithArguments, namingConventions, nullSubstitution, preCondition, set, setMutate, setRecursiveValue, typeConverter, undefinedSubstitution };\n"],"names":["normalizeNamingConventions","namingConventions","source","destination","STRATEGY","Symbol","for","MAPPINGS","METADATA_MAP","METADATA_OBJECT_MAP","ERROR_HANDLER","NAMING_CONVENTIONS","RECURSIVE_DEPTH","RECURSIVE_COUNT","PROFILE_CONFIGURATION_CONTEXT","CUSTOM_NODE_INSPECT","getErrorHandler","mapper","getMappings","getMetadataMap","getMetadataObjectMap","getRecursiveDepth","getStrategy","getProfileConfigurationContext","get","object","path","length","index","undefined","getMapping","allowNull","_a","sourceIdentifier","destinationIdentifier","mapping","errorHandler","errorMessage","String","handle","Error","isDateConstructor","value","Object","getPrototypeOf","Date","isEmpty","Array","isArray","keys","isPrimitiveArrayEqual","a","b","every","itemA","isPrimitiveConstructor","proto","Number","Boolean","set","decomposedPath","base","decomposePath","assignEmpty","slice","assign","setMutate","obj","hasOwnProperty","mapMember","transformationMapFn","sourceObject","destinationObject","destinationMemberPath","extraArgs","sourceMemberIdentifier","destinationMemberIdentifier","transformationType","mapFn","shouldRunImplicitMap","mapArray","map","setMemberReturnFn","mapReturn","options","isMapArray","setMemberFn","setMemberMutateFn","destinationObj","destinationMember","getMemberMutateFn","memberPath","mapMutate","getMemberFn","destinationWithMetadata","propsToMap","destinationConstructor","mappingBeforeCallback","mappingAfterCallback","beforeMap","mapBeforeCallback","afterMap","mapAfterCallback","mapDestinationConstructor","metadataMap","configuredKeys","i","transformationPreConditionPredicate","transformationPreConditionDefaultValue","hasSameIdentifier","setMember","valFn","_b","originalError","constructor","name","JSON","stringify","push","destinationMetadata","hasNullMetadata","find","metadata","mapInitializedValue","isTypedConverted","prototype","toString","call","first","each","nestedMapping","memberValue","unmappedKeys","reduce","result","key","isOnDestination","isAlreadyConfigured","some","configuredKey","isWritable","getOwnPropertyDescriptor","writable","parentInfo","join","assertUnmappedProperties","AutoMapperLogger","configure","customLogger","this","configured","entries","forEach","logLevel","logImpl","log","message","console","bind","AUTOMAPPER_PREFIX","warn","warning","error","info","createMapper","strategyInitializer","strategy","mappings","metadataObjectMap","recursiveDepth","recursiveCount","profileConfigurationContext","getOptions","destinationIdentifierOrOptions","mapOptions","typeofDestinationOrOptions","Proxy","target","p","receiver","Set","Map","clear","preMap","postMap","Promise","res","setTimeout","sourceArray","destinationArray","Reflect","RECURSIVE_DATA","getRecursiveValue","recursiveMap","parent","member","parentValue","root","item","arrayMapGet","setRecursiveValue","has","arrayMapSet","nextMap","arrayMapHas","defaultStrategyInitializerOptions","applyMetadata","recursiveCountMap","getRecursiveCount","recursiveDepthMap","model","as","selfReference","instance","metaFn","metaResult","depth","count","childMetadataObjectMap","_","storeMetadata","metadataList","strict","isDefined","propertyKey","isGetterOnly","type","mapInitialize","sourcePath","getPath","sourceNamingConvention","destinationNamingConvention","keyParts","s","split","splittingExpression","filter","transformPropertyName","getFlatteningPaths","src","srcPath","splitSourcePaths","concat","paths","trueFirstPartOfSource","stopIndex","found","hasProperty","len","restPaths","transformedRestPaths","property","isSamePath","targetLen","EXCLUDE_KEYS","getPathRecursive","node","prefix","previous","hasChildPaths","from","getOwnPropertyNames","includes","child","queue","childNode","childPaths","pathsLen","uniquePaths","createInitialMapping","configurations","applyMetadataFn","sourceMetadataObjectMap","destinationMetadataObjectMap","getNamingConventions","destinationPaths","mappingProperties","hasCustomMappingProperties","sourceMetadata","destinationPath","metadataAtDestination","metadataAtSource","nestedMappingPair","transformation","typeConverter","isSourceArray","isDestinationArray","mappingTypeConverters","sourceConverters","arraySourceConverters","destinationConverter","arrayDestinationConverter","originalMapInitializeFn","srcObj","unshift","createMap","mappingConfigFnsOrIdentifier","mappingConfigFns","retrieveMetadata","identifier","values","configFn","addProfile","profile","mappingConfigurations","mappingConfiguration","add","apply","profileName","PROXY_TARGET","PROXY_OBJECT","createProxy","childPath","forMember","selector","fns","preCondOrMapMemberFn","mapMemberFn","fnSelector","resultProxy","members","m","getMembers","mappingProperty","metadataAtMember","forSelf","sourceOrMapping","selfMapping","selfMapProperties","mapProperty","sourceObj","converterOrValueSelector","input","convert","typeConverters","sourceTypeConverters","arraySourceTypeConverters","constructUsing","cb","extend","mappingToExtend","propsToExtend","propToExtendKey","propToExtendMappingProp","propToExtendNestedMapping","pKey","namingConventionsInput","isResolver","fn","mapFrom","resolve","mapWith","withDestination","withSource","withSourceValue","sourceValue","convertUsing","converter","ignore","nullSubstitution","substitution","sourceMemberPath","preCondition","predicate","defaultValue","condition","sourceMemberPaths","fromValue","rawValue","mapWithArguments","withArgumentsResolver","mapDefer","defer","undefinedSubstitution","CamelCaseNamingConvention","separatorCharacter","sourceNameParts","charAt","toLowerCase","toUpperCase","substring","PascalCaseNamingConvention","SnakeCaseNamingConvention","sourcePropNameParts"],"sourceRoot":""}