{"version":3,"file":"index.cjs","sources":["../CodableType.ts","../utils/readers.ts","../utils/misc.ts","../utils/typedArrays.ts","../utils/assert.ts","../utils/errors.ts","../builtin.ts","../DecodeContext.ts","../EncodeContext.ts","../utils/path.ts","../decorators/PrivateMetadata.ts","../decorators/registry.ts","../ExternalReference.ts","../utils/Escaper.ts","../format.ts","../specialStrings.ts","../utils/security.ts","../decode.ts","../encode.ts","../dependencies.ts","../temporal.ts","../Coder.ts","../decorators/codable.ts","../decorators/prototype.ts","../decorators/properties.ts","../decorators/encode.ts","../decorators/codableClass.ts","../decorators/utils.ts","../decorators/external.ts","../extendJSON.ts"],"sourcesContent":["import { Tag, TagKey } from \"./format\";\n\nimport { AnyClass } from \"./types\";\nimport { CodableDependencies } from \"./dependencies\";\nimport { DecodeContext } from \"./DecodeContext\";\nimport { EncodeContext } from \"./EncodeContext\";\n\ninterface ReaderHandler<T> {\n  get: () => T;\n  set: (value: T) => boolean;\n}\n\n/**\n * A bit special, optional option of custom codable types you will most likely never need to provide.\n *\n * Sometimes, CodableJSON needs to update some value inside of the decoded object after it was created.\n *\n * It happens in case of circular references, eg. when some object references itself.\n *\n * If this is the case, it is impossible to create the object in a single line of code, because it would\n * need to look like `const foo = new Set([foo])` (`foo` is used before it is ready)\n *\n * You will need instead:\n * const foo = new Set();\n * foo.add(foo);\n *\n * Thus, reader takes instance and UpdateRequest (which allows you to read 'input' path of some data we want to update or read)\n * and it has to return { get, set } functions that will read or write to the actual object.\n *\n * For example, in case of `$$Set`, if it is called with path like /2 ([\"2\"]), it means we either want to get or change the 3rd item of the set.\n *\n * The most complext case is `$$Map`, so will give it as an example.\n *\n * Maps encode its input as an array of entries, eg [[\"foo\", 1], [\"bar\", 2]].\n *\n * Thus path to set or get something inside the map is a set of 2 numbers.\n * - the first = index of the map entry\n * - the second = 0 if we want to get or set the key, 1 if we want to get or set the value\n *\n * eg if we have a map like `const map = new Map([[\"foo\", 1], [\"bar\", 2]])`,\n * and we want to change /1/1 to `3` it means we want to change 2nd entry (\"bar\") value to `3`\n * like `map.set(\"bar\", 3)`\n *\n * reader: (map, request) => {\n *   // index of the entry path points to\n *   const entryIndex = Number(request.getNextPathSegment());\n *   // 0 if path points to key, 1 if path points to value\n *   const keyOrValue: EntryTarget = Number(request.getNextPathSegment());\n *\n *   if (isNaN(entryIndex)) throw new Error(\"Expected number for entry index, got NaN\");\n *   if (isNaN(keyOrValue)) throw new Error(\"Expected number for entry target, got NaN\");\n *\n *   // path points to key - we either want to get or set the key\n *   if (keyOrValue === 0) {\n *     return {\n *       get: () => getMapKeyByIndex(map, entryIndex),\n *       set: (newKey) => updateMapKeyByIndex(map, entryIndex, newKey),\n *     };\n *   }\n *\n *   // path points to value - we either want to get or set the value\n *   if (keyOrValue === 1) {\n *     return {\n *       get: () => getMapValueByIndex(map, entryIndex),\n *       set: (newValue) => updateMapValueByIndex(map, entryIndex, newValue),\n *     };\n *   }\n *\n *   throw new Error(`Entry path should be either 0 or 1, got ${keyOrValue}`);\n * }\n *\n * ----------------\n *\n * By default, reading and writing is way simpler,\n * eg if input is { foo: \"bar\"}, and the object is { foo: \"bar\" },\n * to change path /foo to \"baz\", you can just do: object[\"foo\"] = \"baz\"\n *\n * which is what will happen by default.\n */\nexport type CodableReader<T> = (item: T, segments: IterableIterator<string>) => ReaderHandler<unknown>;\n\nexport interface CodableTypeOptions<Item> {\n  priority?: number;\n  dependencies?: CodableDependencies;\n  isFlat?: boolean;\n  /**\n   * If provided, will allow Coder instance to faster find it in the registry for some input\n   */\n  Class?: AnyClass | AnyClass[];\n  reader?: CodableReader<Item>;\n}\n\nexport const defaultCodableReader: CodableReader<any> = (item, segments) => {\n  const [key] = segments;\n\n  return {\n    get: () => Reflect.get(item, key),\n    set: (value) => Reflect.set(item, key, value),\n  };\n};\n\ninterface CodableTypeDefinition<Item, Data> {\n  name: string;\n  canHandle: (value: unknown) => value is Item;\n  encode: (data: Item, context: EncodeContext) => Data;\n  decode: (data: Data, context: DecodeContext, referenceId: number | null) => Item;\n  options?: CodableTypeOptions<Item>;\n}\n\nexport function createTag<Name extends string, Data>(name: Name, data: Data) {\n  return {\n    [`$$${name}`]: data,\n  } as Tag<Data, Name>;\n}\n\n/**\n * Custom class types have priority = amount of classes they extend. This is to ensure that child classes are checked first.\n * However, we still want built-in types, like `Map`, to be checked before those as they are certainly more common.\n *\n * If it is 0, custom class types would always be checked before built-in types, degrading performance.\n */\nexport const DEFAULT_CODABLE_TYPE_PRIORITY = 10;\n\nexport class CodableType<Item = any, Data = any> {\n  constructor(readonly definition: CodableTypeDefinition<Item, Data>) {\n    this.name = definition.name;\n    this.tagKey = `$$${this.name}`;\n    this.priority = definition.options?.priority ?? DEFAULT_CODABLE_TYPE_PRIORITY;\n    this.hasDefaultPriority = this.priority === DEFAULT_CODABLE_TYPE_PRIORITY;\n    this.dependencies = definition.options?.dependencies ?? null;\n    this.isFlat = definition.options?.isFlat ?? false;\n    this.reader = definition.options?.reader ?? defaultCodableReader;\n\n    if (definition.options?.Class) {\n      const classOrClasses = definition.options.Class;\n\n      if (Array.isArray(classOrClasses)) {\n        this.classes = classOrClasses;\n      } else {\n        this.classes = [classOrClasses];\n      }\n    }\n  }\n\n  readonly name: string;\n  readonly priority: number;\n  readonly hasDefaultPriority: boolean;\n  readonly dependencies: CodableDependencies | null;\n  readonly isFlat: boolean;\n  readonly classes: AnyClass[] | undefined;\n\n  readonly tagKey: TagKey<typeof this.name>;\n\n  readonly reader: CodableReader<Item>;\n\n  encode(original: Item, context: EncodeContext): Data {\n    return this.definition.encode(original, context);\n  }\n\n  encodeTag(original: Item, context: EncodeContext): Tag<Data, typeof this.name> {\n    return createTag(this.name, this.encode(original, context));\n  }\n\n  decode(data: Data, context: DecodeContext, referenceId: number | null): Item {\n    return this.definition.decode(data, context, referenceId);\n  }\n\n  canHandle(original: unknown): original is Item {\n    return this.definition.canHandle(original);\n  }\n\n  createTag(data: Data): Tag<Data, typeof this.name> {\n    return createTag(this.name, data);\n  }\n}\n\nexport function codableType<Item, Data>(\n  name: string,\n  canHandle: (value: unknown) => value is Item,\n  encode: (data: Item, context: EncodeContext) => Data,\n  decode: (data: Data, context: DecodeContext, referenceId: number | null) => Item,\n  options?: CodableTypeOptions<Item>,\n): CodableType<Item, Data> {\n  return new CodableType({\n    name,\n    canHandle,\n    encode,\n    decode,\n    options,\n  });\n}\n\nexport function codableClassType<Class extends AnyClass>(\n  name: string,\n  Class: Class,\n  getConstructorArgs: (instance: InstanceType<Class>) => ConstructorParameters<Class>,\n  options?: CodableTypeOptions<InstanceType<Class>>,\n): CodableType<InstanceType<Class>, ConstructorParameters<Class>> {\n  return codableType(\n    name,\n    (value): value is InstanceType<Class> => value instanceof Class,\n    (instance) => getConstructorArgs(instance),\n    (data) => new Class(...data),\n    {\n      ...options,\n      Class,\n    },\n  );\n}\n\nexport function getIsCodableType(value: unknown): value is CodableType {\n  return value instanceof CodableType;\n}\n","function getIsIndexInBounds(index: number, length: number): boolean {\n  return index >= 0 && index < length;\n}\n\nfunction getNthFromIterable<T>(target: Iterable<T>, index: number): T {\n  let i = 0;\n  for (const item of target) {\n    if (i === index) return item;\n    i++;\n  }\n\n  throw new Error(`Index out of bounds: ${index}`);\n}\n\nexport function setInSetAtIndex(set: Set<unknown>, index: number, value: unknown) {\n  if (!getIsIndexInBounds(index, set.size)) return false;\n\n  const values = [...set];\n  values[index] = value;\n\n  set.clear();\n\n  for (const item of values) {\n    set.add(item);\n  }\n\n  return true;\n}\n\nexport function getInSetAtIndex<T>(target: Set<T>, index: number): T {\n  if (!getIsIndexInBounds(index, target.size)) throw new Error(`Index out of bounds: ${index}`);\n\n  return getNthFromIterable(target.values(), index);\n}\n\nexport function updateMapValueByIndex(map: Map<unknown, unknown>, index: number, newValue: unknown) {\n  const entry = getMapEntryByIndex(map, index);\n\n  map.set(entry[EntryIndex.Key], newValue);\n  return true;\n}\n\nexport function updateMapKeyByIndex(map: Map<unknown, unknown>, index: number, newValue: unknown) {\n  const entries = [...map.entries()];\n\n  if (!getIsIndexInBounds(index, entries.length)) return false;\n\n  entries[index][EntryIndex.Key] = newValue;\n\n  map.clear();\n\n  for (const [key, value] of entries) {\n    map.set(key, value);\n  }\n\n  return true;\n}\n\nfunction getMapEntryByIndex<K, V>(map: Map<K, V>, entryIndex: number): [K, V] {\n  if (!getIsIndexInBounds(entryIndex, map.size)) throw new Error(`Index out of bounds: ${entryIndex}`);\n\n  return getNthFromIterable(map.entries(), entryIndex);\n}\n\nexport function getMapValueByIndex(map: Map<unknown, unknown>, entryIndex: number) {\n  return getMapEntryByIndex(map, entryIndex)[EntryIndex.Value];\n}\n\nexport function getMapKeyByIndex(map: Map<unknown, unknown>, entryIndex: number) {\n  return getMapEntryByIndex(map, entryIndex)[EntryIndex.Key];\n}\n\nexport enum EntryIndex {\n  Key = 0,\n  Value = 1,\n}\n","import { getIsObject } from \"../is\";\n\nexport type Thunk<T> = T | (() => Thunk<T>);\n\nexport function resolveThunk<T>(thunk: Thunk<T>): T {\n  let result = thunk;\n\n  while (typeof result === \"function\") {\n    result = (result as () => Thunk<T>)();\n  }\n\n  return result;\n}\n\nexport function getSymbolKey(symbol: symbol): string {\n  const nativeKey = Symbol.keyFor(symbol);\n  if (nativeKey) return nativeKey;\n\n  const toStringResult = symbol.toString(); // eg \"Symbol(foo)\"\n  return toStringResult.slice(7, -1); // \"foo\"\n}\n\nexport function removeUndefinedProperties<T extends Record<string, unknown>>(input: T): T {\n  const result: Record<string, unknown> = {};\n\n  for (const key of Object.keys(input)) {\n    const value = input[key as keyof T];\n    if (value !== undefined) {\n      result[key] = value;\n    }\n  }\n\n  return result as T;\n}\n\nlet i = 0;\n\nconst objectId = new WeakMap<object, number>();\n\nexport function getObjectId(object: object): number {\n  if (!getIsObject(object)) return -1;\n\n  if (objectId.has(object)) {\n    return objectId.get(object)!;\n  }\n\n  const id = i++;\n  objectId.set(object, id);\n  return id;\n}\n\nexport function consumeArray<T>(source: T[], ignoreIf: (value: T) => boolean) {\n  return {\n    next() {\n      while (true) {\n        const segment = source.shift()!;\n\n        if (ignoreIf && ignoreIf(segment)) {\n          continue;\n        }\n\n        return {\n          value: segment,\n          done: false,\n        };\n      }\n    },\n    get isDone() {\n      return source.length === 0;\n    },\n    [Symbol.iterator]() {\n      return this;\n    },\n  } satisfies IterableIterator<T> & { readonly isDone: boolean };\n}\n","import { getIsNotNull } from \"../is\";\n\nexport const TYPED_ARRAY_MAP = {\n  Uint8Array: typeof Uint8Array !== \"undefined\" ? Uint8Array : null,\n  Uint8ClampedArray: typeof Uint8ClampedArray !== \"undefined\" ? Uint8ClampedArray : null,\n  Uint16Array: typeof Uint16Array !== \"undefined\" ? Uint16Array : null,\n  Uint32Array: typeof Uint32Array !== \"undefined\" ? Uint32Array : null,\n  Int8Array: typeof Int8Array !== \"undefined\" ? Int8Array : null,\n  Int16Array: typeof Int16Array !== \"undefined\" ? Int16Array : null,\n  Int32Array: typeof Int32Array !== \"undefined\" ? Int32Array : null,\n  Float32Array: typeof Float32Array !== \"undefined\" ? Float32Array : null,\n  Float64Array: typeof Float64Array !== \"undefined\" ? Float64Array : null,\n} as const;\n\nexport const TYPED_ARRAY_CLASSES = Object.values(TYPED_ARRAY_MAP).filter(getIsNotNull);\n\nexport type TypedArrayTypeName = keyof typeof TYPED_ARRAY_MAP;\nexport type TypedArray = InstanceType<NonNullable<(typeof TYPED_ARRAY_MAP)[TypedArrayTypeName]>>;\n","export function assert(condition: boolean, message: string | Error): asserts condition {\n  if (!condition) {\n    if (message instanceof Error) {\n      throw message;\n    }\n\n    throw new Error(message);\n  }\n}\n\nexport function assertGet<T>(value: T | null | undefined, message: string | Error): T {\n  assert(value !== null && value !== undefined, message);\n\n  return value;\n}\n\nexport function narrowType<T>(value: unknown): asserts value is T {}\n\nexport function assertNumeric<T extends number = number>(value: string | number): T {\n  value = Number(value);\n\n  if (isNaN(value)) throw new Error(\"Expected number, got NaN\");\n\n  return value as T;\n}\n","export function getErrorExtraProperties(\n  error: Error,\n): Record<string, unknown> | null {\n  const properties: Record<string, unknown> = {};\n\n  let isEmpty = true;\n\n  for (const key of Object.keys(error)) {\n    if (key === \"message\" || key === \"name\" || key === \"cause\") continue;\n\n    properties[key] = error[key as keyof Error];\n    isEmpty = false;\n  }\n\n  if (isEmpty) return null;\n\n  return properties;\n}\n","import { CodableReader, codableType } from \"./CodableType\";\nimport {\n  EntryIndex,\n  getInSetAtIndex,\n  getMapKeyByIndex,\n  getMapValueByIndex,\n  setInSetAtIndex,\n  updateMapKeyByIndex,\n  updateMapValueByIndex,\n} from \"./utils/readers\";\nimport { getSymbolKey, removeUndefinedProperties } from \"./utils/misc\";\n\nimport { EncodeContext } from \"./EncodeContext\";\nimport { TYPED_ARRAY_MAP } from \"./utils/typedArrays\";\nimport { assertNumeric } from \"./utils/assert\";\nimport { getErrorExtraProperties } from \"./utils/errors\";\nimport { getIsNotNull } from \"./is\";\n\n/**\n * This is the list of all built-in coders that are used to encode and decode basic types.\n *\n * Note: put the most popular types at the beginning of the file to improve encoding performance.\n */\n\nfunction getIsValidDate(date: Date): boolean {\n  return !isNaN(date.getTime());\n}\n\nexport const $$date = codableType(\n  \"Date\",\n  (value) => value instanceof Date,\n  (date) => {\n    if (!getIsValidDate(date)) return null;\n\n    return date.toISOString();\n  },\n  (maybeISOString) => {\n    if (maybeISOString === null) return new Date(\"invalid\");\n\n    return new Date(maybeISOString);\n  },\n  {\n    isFlat: true,\n    Class: Date,\n  },\n);\n\nconst setReader: CodableReader<Set<unknown>> = (set, [indexString]) => {\n  const index = assertNumeric(indexString);\n\n  return {\n    get: () => getInSetAtIndex(set, index),\n    set: (value) => setInSetAtIndex(set, index, value),\n  };\n};\n\nexport const $$set = codableType(\n  \"Set\",\n  (value) => value instanceof Set,\n  (set) => [...set],\n  (array) => new Set(array),\n  {\n    Class: Set,\n    reader: setReader,\n  },\n);\n\nconst mapReader: CodableReader<Map<unknown, unknown>> = (map, [entryIndexString, indexInEntryString]) => {\n  // index of the entry path points to\n  const entryIndex = assertNumeric(entryIndexString);\n  // 0 if path points to key, 1 if path points to value\n  const indexInEntry = assertNumeric<EntryIndex>(indexInEntryString);\n\n  switch (indexInEntry) {\n    case EntryIndex.Key:\n      return {\n        get: () => getMapKeyByIndex(map, entryIndex),\n        set: (value) => updateMapKeyByIndex(map, entryIndex, value),\n      };\n    case EntryIndex.Value:\n      return {\n        get: () => getMapValueByIndex(map, entryIndex),\n        set: (value) => updateMapValueByIndex(map, entryIndex, value),\n      };\n    default:\n      throw new Error(`Entry path should be either 0 or 1, got ${indexInEntry}`);\n  }\n};\n\nexport const $$map = codableType(\n  \"Map\",\n  (value) => value instanceof Map,\n  (map) => [...map.entries()],\n  (entries) => new Map(entries),\n  {\n    Class: Map,\n    reader: mapReader,\n  },\n);\n\nexport const $$error = codableType(\n  \"Error\",\n  (value) => value instanceof Error,\n  (error: Error, context: EncodeContext) => {\n    const shouldIncludeErrorStack = context.options?.includeErrorStack ?? false;\n\n    const extraProperties = getErrorExtraProperties(error) ?? undefined;\n    const name = error.name && error.name !== \"Error\" ? error.name : undefined;\n    const cause = error.cause;\n    const message = error.message;\n    const stack = shouldIncludeErrorStack ? error.stack : undefined;\n\n    if (!extraProperties && !name && !cause && !stack) {\n      return message;\n    }\n\n    return removeUndefinedProperties({\n      message,\n      name,\n      cause,\n      properties: extraProperties,\n      stack,\n    });\n  },\n  (messageOrData) => {\n    if (typeof messageOrData === \"string\") return new Error(messageOrData);\n\n    const { message, name, cause, properties, stack } = messageOrData;\n\n    const error = new Error(message, { cause });\n\n    if (stack) {\n      error.stack = stack;\n    }\n\n    if (name && name !== \"Error\") {\n      error.name = name;\n    }\n\n    if (properties) {\n      Object.assign(error, properties);\n    }\n\n    return error;\n  },\n  {\n    Class: Error,\n  },\n);\n\nexport const $$undefined = codableType(\n  \"undefined\",\n  (value) => value === undefined,\n  () => null,\n  () => undefined,\n  {\n    isFlat: true,\n  },\n);\n\nexport const $$bigInt = codableType(\n  \"BigInt\",\n  (value) => typeof value === \"bigint\",\n  (bigInt) => bigInt.toString(),\n  (string) => BigInt(string),\n  {\n    isFlat: true,\n  },\n);\n\nexport const $$regexp = codableType(\n  \"RegExp\",\n  (value) => value instanceof RegExp,\n  ({ source, flags }) => {\n    return `/${source}/${flags}`;\n  },\n  (string) => {\n    const [source, flags] = string.split(\"/\").slice(1);\n    return new RegExp(source, flags);\n  },\n  {\n    isFlat: true,\n    Class: RegExp,\n  },\n);\n\nexport const $$url = codableType(\n  \"URL\",\n  (value) => value instanceof URL,\n  (url) => url.toString(),\n  (string) => new URL(string),\n  {\n    isFlat: true,\n    Class: URL,\n  },\n);\n\nconst symbolsRegistry = new Map<string, symbol>();\n\nexport const $$symbol = codableType(\n  \"Symbol\",\n  (value) => typeof value === \"symbol\",\n  (symbol) => {\n    const symbolKey = getSymbolKey(symbol);\n\n    symbolsRegistry.set(symbolKey, symbol);\n\n    return symbolKey;\n  },\n  (symbolKey) => symbolsRegistry.get(symbolKey) ?? Symbol.for(symbolKey),\n  {\n    isFlat: true,\n  },\n);\n\nexport const typedArrays = Object.entries(TYPED_ARRAY_MAP)\n  .map(([name, TypedArrayClass]) => {\n    if (!TypedArrayClass) return null;\n\n    return codableType(\n      name,\n      (value): value is InstanceType<typeof TypedArrayClass> => value instanceof TypedArrayClass,\n      (value) => [...value],\n      (array) => new TypedArrayClass(array),\n      {\n        // Almost flat, but can contain NaN\n        isFlat: false,\n        Class: TypedArrayClass,\n      },\n    );\n  })\n  .filter(getIsNotNull);\n\nexport const $$urlSearchParams = codableType(\n  \"URLSearchParams\",\n  (value) => value instanceof URLSearchParams,\n  (urlSearchParams) => urlSearchParams.toString(),\n  (string) => new URLSearchParams(string),\n  {\n    isFlat: false,\n    Class: URLSearchParams,\n  },\n);\n","import { Coder } from \"./Coder\";\nimport { Path } from \"./utils/path\";\n\nexport interface DecodeOptions {\n  externalReferences?: Record<string, unknown>;\n}\n\nexport class DecodeContext {\n  // Will be filled while decoding the data\n  resolvedRefs = new Map<number, object>();\n\n  pendingReferences = new Map<number, Set<Path>>();\n\n  registerPendingReference(id: number, path: Path) {\n    const paths = this.pendingReferences.get(id) ?? new Set();\n    paths.add(path);\n    this.pendingReferences.set(id, paths);\n  }\n\n  /**\n   * Some object needed by some alias (list prepared before) is ready to be used.\n   */\n  registerRef(id: number, object: object) {\n    this.resolvedRefs.set(id, object);\n  }\n\n  resolveRefId(id: number): object | null {\n    return this.resolvedRefs.get(id) ?? null;\n  }\n\n  private readonly warnedOnce = new Set<string>();\n\n  warnOnce(key: string, message: string) {\n    if (this.warnedOnce.has(key)) return;\n\n    this.warnedOnce.add(key);\n\n    console.warn(message);\n  }\n\n  readonly externalReferencesMap: Map<string, unknown>;\n\n  constructor(\n    readonly coder: Coder,\n    readonly options?: DecodeOptions,\n  ) {\n    this.externalReferencesMap = new Map(Object.entries(options?.externalReferences ?? {}));\n  }\n}\n","import { JSONArray, JSONObject } from \"./types\";\n\nimport { Coder } from \"./Coder\";\n\nexport type UnknownMode = \"unchanged\" | \"null\" | \"throw\";\n\nexport interface EncodeOptions {\n  /**\n   * What should happen if some custom class instance is passed to encode, but no\n   * matching type is found.\n   *\n   * - \"unchanged\": Pass the input as is to the encoded output\n   * - \"null\": Replace the input with null in the encoded output\n   * - \"throw\": Throw an error if no matching type is found\n   *\n   * @default \"null\"\n   */\n  unknownInputMode?: UnknownMode;\n\n  /**\n   * Should encoder detect if the same object is seen multiple times in the input so it can\n   * re-create those references later, when decoding the data?\n   *\n   * Note: if disabled, and your input contains circular references, the encoder will throw an error.\n   *\n   * @default true\n   */\n  preserveReferences?: boolean;\n\n  /**\n   * @default false\n   */\n  includeErrorStack?: boolean;\n}\n\nexport class EncodeContext {\n  constructor(\n    readonly coder: Coder,\n    readonly options?: EncodeOptions,\n  ) {\n    this.unknownMode = options?.unknownInputMode ?? \"null\";\n    this.preserveReferences = options?.preserveReferences ?? true;\n  }\n\n  readonly unknownMode: UnknownMode;\n  readonly preserveReferences: boolean;\n\n  private seenObjects = new WeakSet<object>();\n  private refIdsRegistry = new Map<object, number>();\n\n  private markedAsReferenced = new WeakSet<object>();\n  private encodedObjects = new Map<object, JSONObject | JSONArray>();\n\n  private markAllEncodedAsReferenced() {\n    for (const [original, id] of this.refIdsRegistry.entries()) {\n      const encoded = this.encodedObjects.get(original);\n\n      if (!encoded) {\n        throw new Error(\"Encoded object not found\");\n      }\n\n      this.markEncodedAsReferenced(original, id);\n    }\n  }\n\n  finalize() {\n    this.markAllEncodedAsReferenced();\n  }\n\n  private markEncodedAsReferenced(original: object, id: number) {\n    if (this.markedAsReferenced.has(original)) return;\n\n    const encoded = this.encodedObjects.get(original);\n\n    if (!encoded) {\n      throw new Error(\"Encoded object not found\");\n    }\n\n    if (Array.isArray(encoded)) {\n      encoded.unshift(`$$id:${id}`);\n    } else {\n      encoded[\"$$id\"] = id;\n    }\n\n    this.markedAsReferenced.add(original);\n  }\n\n  registerEncoded(original: object, encoded: JSONObject | JSONArray) {\n    if (!this.preserveReferences) return;\n\n    if (this.encodedObjects.has(original)) {\n      console.warn(\"Object already encoded\", original, encoded);\n      return;\n    }\n\n    this.encodedObjects.set(original, encoded);\n  }\n\n  /**\n   * Call it the first time some object is seen.\n   */\n  registerNewSeenObject(object: object) {\n    if (!this.preserveReferences) return;\n\n    this.seenObjects.add(object);\n  }\n\n  /**\n   * Returns where the object was first seen at.\n   */\n  getAlreadySeenObjectId(original: object): number | null {\n    if (!this.preserveReferences) return null;\n\n    if (!this.seenObjects.has(original)) {\n      return null;\n    }\n\n    const existingId = this.refIdsRegistry.get(original);\n\n    if (existingId !== undefined) {\n      return existingId;\n    }\n\n    const id = this.refIdsRegistry.size;\n\n    this.refIdsRegistry.set(original, id);\n\n    return id;\n  }\n}\n","export type Path = string;\n\nexport const ROOT_PATH: Path = \"/\";\n\n/**\n * This function is called extremely often, so it's optimized for performance.\n *\n * Current path was heavily benchmarked\n */\nfunction escapePathSegment(segment: string): string {\n  if (typeof segment === \"number\") return String(segment);\n\n  if (segment.includes(\"~\") || segment.includes(\"/\")) {\n    return segment.replaceAll(\"~\", \"~0\").replaceAll(\"/\", \"~1\");\n  }\n\n  return segment;\n}\n\nfunction unescapePathSegment(segment: string): string {\n  return segment.replaceAll(\"~0\", \"~\").replaceAll(\"~1\", \"/\");\n}\n\nexport function splitPath(path: Path): string[] {\n  const segments = path.split(\"/\").map(unescapePathSegment);\n\n  if (path.startsWith(\"/\")) {\n    // remove first empty segment\n    segments.shift();\n  }\n\n  return segments;\n}\n\nexport function addPathSegment(currentPointer: Path, newSegment: string): Path {\n  switch (currentPointer) {\n    case \"/\":\n    case \"\":\n      return `/${escapePathSegment(newSegment)}`;\n    default:\n      return `${currentPointer}/${escapePathSegment(newSegment)}`;\n  }\n}\n\nexport function addNumberPathSegment(currentPointer: Path, newSegment: number): Path {\n  switch (currentPointer) {\n    case \"/\":\n    case \"\":\n      return `/${newSegment}`;\n    default:\n      return `${currentPointer}/${newSegment}`;\n  }\n}\n","type WithMetadata<T> = T & { [Symbol.metadata]?: DecoratorMetadata };\n\nexport function getMetadataKey<T extends object>(Class: T): DecoratorMetadata | null {\n  if (!Class) return null;\n\n  return (Class as WithMetadata<T>)[Symbol.metadata] ?? null;\n}\n\nif (!Symbol.metadata) {\n  Reflect.set(Symbol, \"metadata\", Symbol.for(\"Symbol.metadata\"));\n}\n\nexport class PrivateMetadata<T> {\n  private registry = new WeakMap<DecoratorMetadata, T>();\n\n  getFor(Class: object) {\n    const key = getMetadataKey(Class);\n\n    if (!key) return null;\n\n    return this.get(key);\n  }\n\n  get(key: DecoratorMetadata): T | null {\n    return this.registry.get(key) ?? null;\n  }\n\n  getOrInit(key: DecoratorMetadata, initializer: () => T) {\n    if (this.registry.has(key)) return this.registry.get(key)!;\n\n    const value = initializer();\n\n    this.registry.set(key, value);\n\n    return value;\n  }\n\n  has(key: DecoratorMetadata) {\n    return this.registry.has(key);\n  }\n\n  set(key: DecoratorMetadata, value: T) {\n    this.registry.set(key, value);\n  }\n\n  init(key: DecoratorMetadata, value: T) {\n    if (this.registry.has(key)) return this.registry.get(key)!;\n\n    this.registry.set(key, value);\n\n    return value;\n  }\n}\n","import { PrivateMetadata, getMetadataKey } from \"./PrivateMetadata\";\n\nimport { AnyClass } from \"./types\";\nimport { CodableDependencies } from \"../dependencies\";\nimport { CodableType } from \"../CodableType\";\nimport { getIsObject } from \"../is\";\n\nexport interface FieldMetadata {\n  encodeAs?: string;\n}\n\nexport type ClassCodableType<T extends AnyClass> = CodableType<InstanceType<T>, ConstructorParameters<T>>;\n\nexport type CodableClassFieldsMap<T extends AnyClass = AnyClass> = Map<keyof InstanceType<T>, FieldMetadata>;\n\nexport interface CodableClassMetadata<T extends AnyClass = AnyClass> {\n  name: string;\n  codableType: ClassCodableType<T>;\n}\n\nexport const codableClassRegistry = new PrivateMetadata<CodableClassMetadata>();\nexport const codableClassFieldsRegistry = new PrivateMetadata<CodableClassFieldsMap>();\nexport const externalClassFieldsRegistry = new PrivateMetadata<Map<string, { key: string; isOptional: boolean }>>();\n\nexport function getIsCodableClass(Class: object): Class is AnyClass {\n  const key = getMetadataKey(Class);\n\n  if (!key) return false;\n\n  return codableClassRegistry.has(key);\n}\n\nexport function getIsCodableClassInstance(instance: object): InstanceType<AnyClass> {\n  if (!getIsObject(instance)) return false;\n\n  const key = getMetadataKey(instance.constructor);\n\n  if (!key) return false;\n\n  return codableClassRegistry.has(key);\n}\n\nexport function getCodableClassType<T extends AnyClass>(Class: T): ClassCodableType<T> | null {\n  const key = getMetadataKey(Class);\n\n  if (!key) return null;\n\n  const codableType = codableClassRegistry.get(key)?.codableType;\n\n  if (!codableType) return null;\n\n  return codableType as CodableType<any, any>;\n}\n","import { codableType } from \"./CodableType\";\n\nexport class ExternalReference<T> {\n  constructor(\n    readonly key: string,\n    readonly isOptional = false,\n  ) {}\n}\n\nexport function externalReference<T>(key: string, isOptional = false): T {\n  return new ExternalReference<T>(key, isOptional) as unknown as T;\n}\n\nexport const $$externalReference = codableType(\n  \"external\",\n  (value) => value instanceof ExternalReference,\n  (ref) => {\n    return { key: ref.key, isOptional: ref.isOptional };\n  },\n  ({ key, isOptional }, context) => {\n    if (!context.externalReferencesMap.has(key)) {\n      if (isOptional) return void 0;\n\n      throw new Error(`External reference \"${key}\" not found`);\n    }\n\n    // Special case - it expect us to return instance of ExternalReference,\n    // but we actually return the value from the external references map\n    return context.externalReferencesMap.get(key) as any;\n  },\n  {\n    Class: ExternalReference,\n    isFlat: true,\n  },\n);\n","type Matcher = RegExp;\n\nfunction wrapPatternAsGroup(pattern: string) {\n  return `(?:${pattern})`;\n}\n\nfunction preparePatterns(pattern: RegExp) {\n  let { source, flags } = pattern;\n\n  source = source.replaceAll(\"^\", \"\");\n  source = wrapPatternAsGroup(source);\n\n  const maybeAlreadyEscapedPattern = new RegExp(`^\\\\~*${source}$`, flags);\n  const alreadyEscapedPattern = new RegExp(`^\\\\~+${source}$`, flags);\n\n  return {\n    maybeAlreadyEscapedPattern,\n    alreadyEscapedPattern,\n  };\n}\n\nexport class Escaper {\n  readonly maybeAlreadyEscapedPattern: RegExp;\n  readonly alreadyEscapedPattern: RegExp;\n\n  constructor(readonly pattern: RegExp) {\n    const { maybeAlreadyEscapedPattern, alreadyEscapedPattern } = preparePatterns(pattern);\n    this.maybeAlreadyEscapedPattern = maybeAlreadyEscapedPattern;\n    this.alreadyEscapedPattern = alreadyEscapedPattern;\n  }\n\n  getShouldEscape(input: string): boolean {\n    return this.maybeAlreadyEscapedPattern.test(input);\n  }\n\n  getShouldUnescape(input: string): boolean {\n    return this.alreadyEscapedPattern.test(input);\n  }\n\n  getIsMaybeEscaped(input: string): boolean {\n    return this.maybeAlreadyEscapedPattern.test(input);\n  }\n\n  getIsAlreadyEscaped(input: string): boolean {\n    return this.alreadyEscapedPattern.test(input);\n  }\n\n  getIsMatching(input: string): boolean {\n    return this.pattern.test(input);\n  }\n\n  escape(input: string) {\n    if (!this.getShouldEscape(input)) {\n      return input;\n    }\n\n    return `~${input}`;\n  }\n\n  unescape(input: string) {\n    if (this.getShouldUnescape(input)) {\n      return input.slice(1);\n    }\n\n    return input;\n  }\n}\n\nexport function createEscaper(pattern: RegExp) {\n  return new Escaper(pattern);\n}\n","import { JSONValue } from \"./types\";\nimport { createEscaper } from \"./utils/Escaper\";\n\nexport type TagKey<T extends string = string> = `$$${T}`;\n\nexport function getIsTagKey(key: string): key is TagKey {\n  if (!key) return false;\n\n  return key.startsWith(\"$$\") && key.length > 2;\n}\n\nexport function getIsReferencedTag(input: JSONValue): input is Required<RefIdTag> {\n  return typeof input === \"object\" && input !== null && typeof (input as any)[\"$$id\"] === \"number\";\n}\n\ntype RefIdTag = {\n  $$id?: number;\n};\n\nexport type Tag<V = unknown, T extends string = string> = RefIdTag & {\n  [key in TagKey<T>]: V;\n};\n\nexport type RefAlias = Tag<number, \"ref\">;\n\nexport function getTagValue<T>(tag: Tag<T>) {\n  return Object.values(tag)[0];\n}\n\nexport const $$recordSpecialProperty = createEscaper(/^json$|^\\$\\$.+$/);\n\nexport const $$arrayRefId = createEscaper(/\\$\\$id:(\\d+)$/);\n","const SPECIAL_STRINGS_REGEXP = /^\\~*\\$\\$(?:undefined|NaN|-0|Infinity|-Infinity|empty)$/;\n\nexport const INFINITY_STRING = \"$$Infinity\";\nexport const NEGATIVE_INFINITY_STRING = \"$$-Infinity\";\nexport const NEGATIVE_ZERO_STRING = \"$$-0\";\nexport const NaN_STRING = \"$$NaN\";\nexport const UNDEFINED_STRING = \"$$undefined\";\nexport const ARRAY_EMPTY_STRING = \"$$empty\";\n\nexport function maybeEscapeSpecialString(input: string) {\n  if (SPECIAL_STRINGS_REGEXP.test(input)) {\n    return `~${input}`;\n  }\n\n  return input;\n}\n\nexport function maybeEncodeNumber(input: number) {\n  switch (input) {\n    case Infinity:\n      return INFINITY_STRING;\n    case -Infinity:\n      return NEGATIVE_INFINITY_STRING;\n    case 0:\n      if (1 / input === -Infinity) return NEGATIVE_ZERO_STRING;\n      return input;\n  }\n\n  if (isNaN(input)) return \"$$NaN\";\n\n  return input;\n}\n\nexport function decodeMaybeSpecialString(input: string) {\n  switch (input) {\n    case UNDEFINED_STRING:\n      return undefined;\n    case NaN_STRING:\n      return NaN;\n    case NEGATIVE_ZERO_STRING:\n      return -0;\n    case INFINITY_STRING:\n      return Infinity;\n    case NEGATIVE_INFINITY_STRING:\n      return -Infinity;\n  }\n\n  // if (!SPECIAL_STRINGS_REGEXP.test(input)) return input;\n\n  if (input.startsWith(\"~\") && SPECIAL_STRINGS_REGEXP.test(input)) return input.slice(1);\n\n  return input;\n}\n","export function getIsForbiddenProperty(property: string): boolean {\n  switch (property) {\n    case \"__proto__\":\n    case \"prototype\":\n    case \"constructor\":\n      return true;\n    default:\n      return false;\n  }\n}\n","import {\n  $$arrayRefId,\n  $$recordSpecialProperty,\n  RefAlias,\n  Tag,\n  TagKey,\n  getIsReferencedTag,\n  getIsTagKey,\n} from \"./format\";\nimport { ARRAY_EMPTY_STRING, decodeMaybeSpecialString } from \"./specialStrings\";\nimport { Path, addNumberPathSegment, addPathSegment } from \"./utils/path\";\n\nimport { Coder } from \"./Coder\";\nimport { DecodeContext } from \"./DecodeContext\";\nimport { JSONValue } from \"./types\";\nimport { getIsForbiddenProperty } from \"./utils/security\";\n\nfunction resolveRefAlias<T>(input: RefAlias, context: DecodeContext, path: Path): T {\n  const referencedObject = context.resolveRefId(input.$$ref);\n\n  if (!referencedObject) {\n    context.registerPendingReference(input.$$ref, path);\n\n    /**\n     * TODO: Assumption here is that data is always encoded and decoded in the same order,\n     * aka if we encode aka. meet some object as the first, it will also be decoded as the first\n     * out of all other places where the same reference is used.\n     *\n     * If this is not the case, we might need some flag to indicate we need to wait and perform\n     * aliases resolution later.\n     */\n    return null as T;\n  }\n\n  return referencedObject as T;\n}\n\nfunction resolveTypeTag<T>(tag: Tag<JSONValue>, tagKey: TagKey, context: DecodeContext, coder: Coder, path: Path): T {\n  const typeName = tagKey.slice(2); // eg \"$$set\" -> \"set\"\n\n  const matchingType = coder.getTypeByName(typeName);\n\n  if (!matchingType) {\n    console.warn(`Unknown custom type: ${typeName}. Returning the raw value.`);\n    return tag[tagKey] as T;\n  }\n\n  /**\n   * Decode data is present at eg input[\"$$set\"], but it might contain some nested data that\n   * needs to be decoded first.\n   */\n\n  const payload = decodeInput(tag[tagKey], context, coder, addPathSegment(path, tagKey));\n\n  const result = matchingType.decode(payload, context, tag.$$id ?? null) as T;\n\n  if (getIsReferencedTag(tag)) {\n    // We know it is an object, otherwise nothing would be able to reference it in the first place\n    context.registerRef(tag.$$id, result as object);\n  }\n\n  return result;\n}\n\nfunction getMaybeCustomTypeTag(refId: number | undefined, keys: string[]) {\n  if (refId === undefined) {\n    const first = keys[0];\n\n    if (keys.length === 1 && getIsTagKey(first)) return first as TagKey;\n\n    return false as const;\n  }\n\n  if (keys.length !== 2) return false as const;\n\n  if (keys[0] === \"$$id\" && getIsTagKey(keys[1])) return keys[1] as TagKey;\n  if (keys[1] === \"$$id\" && getIsTagKey(keys[0])) return keys[0] as TagKey;\n\n  return false as const;\n}\n\nexport function decodeInput<T>(input: JSONValue, context: DecodeContext, coder: Coder, path: Path): T {\n  if (input === null) return input as T;\n\n  switch (typeof input) {\n    case \"string\":\n      return decodeMaybeSpecialString(input) as T;\n    case \"boolean\":\n    case \"number\":\n      return input as T;\n    case \"symbol\":\n    case \"bigint\":\n    case \"function\":\n    case \"undefined\":\n      return input as T;\n  }\n\n  if (Array.isArray(input)) {\n    const result: any[] = [];\n\n    const first = input[0];\n\n    if (typeof first === \"string\" && $$arrayRefId.getIsMaybeEscaped(first)) {\n      if ($$arrayRefId.getIsAlreadyEscaped(first)) {\n        input[0] = $$arrayRefId.unescape(first);\n      } else {\n        const [, id] = $$arrayRefId.pattern.exec(first)!;\n        context.registerRef(Number(id), result);\n        input = input.slice(1);\n      }\n    }\n\n    // We are ready to process the array\n    for (let index = 0; index < input.length; index++) {\n      const inputToDecode = input[index];\n\n      if (inputToDecode === ARRAY_EMPTY_STRING) {\n        result.length++;\n        continue;\n      }\n\n      const decoded = decodeInput<any>(inputToDecode, context, coder, addNumberPathSegment(path, index));\n\n      // tag was marked as being referenced by something else, eg { $$id: 0, $$set: [1, 2, 3] }\n      if (getIsReferencedTag(inputToDecode)) {\n        // register it so this other thing will be able to resolve its reference later by id\n        context.registerRef(inputToDecode[\"$$id\"], decoded);\n      }\n\n      result[index] = decoded;\n    }\n\n    return result as T;\n  }\n\n  // It is a record - it might be a few things dependong on its format:\n\n  const keys = Object.keys(input);\n\n  // It is a ref alias, eg { $$ref: 0 }, we need to replace it with the object it is referencing\n  if (keys.length === 1 && typeof input.$$ref === \"number\") {\n    return resolveRefAlias<T>(input as RefAlias, context, path);\n  }\n\n  /**\n   * It is either a custom type tag, eg { $$set: [1, 2, 3] } or a plain JSON record.\n   *\n   * Both can be marked as being referenced by something else, eg\n   * { $$id: 0, $$set: [1, 2, 3] }\n   * { $$id: 0, foo: \"bar\" }\n   */\n\n  // Let's see if it is marked as being referenced by something else\n  let refid: number | undefined = input[\"$$id\"] as number | undefined;\n\n  if (typeof refid !== \"number\") {\n    refid = undefined;\n  }\n\n  // Let's see if it is matching a format of a custom type tag\n  // refid is passed as optimization as we already know it, to make it easier to decide if input is matching\n  // a custom type tag format\n  const customTypeTag = getMaybeCustomTypeTag(refid, keys);\n\n  if (customTypeTag) {\n    // it is a custom type tag\n    const result = resolveTypeTag<T>(input, customTypeTag, context, coder, path);\n\n    // tag was marked as being referenced by something else, eg { $$id: 0, $$set: [1, 2, 3] }\n    if (refid !== undefined) {\n      // register it so this other thing will be able to resolve its reference later by id\n      context.registerRef(refid, result as object);\n    }\n\n    return result;\n  }\n\n  // it is a plain JSON record\n\n  // create a reference as quickly as possible, and register it if it is marked as being referenced by something else\n  // this is needed in case some property of this very object is referencing itself (if so, it will need this\n  // reference very soon)\n  const result: Record<string, any> = {};\n\n  if (refid !== undefined) {\n    context.registerRef(refid, result as object);\n  }\n\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n\n    // \"$$id\" is a special marker not meant to be part of the result\n    if (key === \"$$id\" || getIsForbiddenProperty(key)) continue;\n\n    const inputValue = input[key];\n\n    const decoded = decodeInput<any>(inputValue, context, coder, addPathSegment(path, key));\n\n    const unescapedKey = $$recordSpecialProperty.unescape(key);\n\n    // If the key was escpaed, use unescaped version for assigning data to the result\n    result[unescapedKey] = decoded;\n\n    if (getIsReferencedTag(inputValue)) {\n      context.registerRef(inputValue.$$id, decoded);\n    }\n  }\n\n  return result as T;\n}\n","import { $$arrayRefId, $$recordSpecialProperty } from \"./format\";\nimport { $$bigInt, $$symbol } from \"./builtin\";\nimport { ARRAY_EMPTY_STRING, UNDEFINED_STRING, maybeEncodeNumber, maybeEscapeSpecialString } from \"./specialStrings\";\n\nimport { EncodeContext } from \"./EncodeContext\";\nimport { JSONValue } from \"./types\";\nimport { createTag } from \"./CodableType\";\nimport { getIsForbiddenProperty } from \"./utils/security\";\nimport { narrowType } from \"./utils/assert\";\n\nconst OBJECT_PROTOTYPE = Object.prototype;\n\nfunction encodeArray(input: unknown[], context: EncodeContext): JSONValue {\n  const result: any[] = [];\n\n  context.registerEncoded(input, result);\n\n  for (let i = 0; i < input.length; i++) {\n    const inputValue = input[i];\n\n    // empty gap in the array\n    if (inputValue === undefined && !Object.hasOwn(input, i)) {\n      result[i] = ARRAY_EMPTY_STRING;\n      continue;\n    }\n\n    if (i === 0 && typeof inputValue === \"string\" && $$arrayRefId.getShouldEscape(inputValue)) {\n      result[i] = $$arrayRefId.escape(inputValue);\n      continue;\n    }\n\n    // We push instead of `result[i], because it is possible that array was marked referenced with markEncodedAsReferenced\n    result[i] = performEncode(inputValue, context);\n  }\n\n  return result;\n}\n\nfunction encodeRecord(input: Record<string, unknown>, context: EncodeContext): JSONValue {\n  const keys = Object.keys(input);\n\n  const result = {} as Record<string, any>;\n\n  context.registerEncoded(input, result);\n\n  // Seems the fastest way to iterate (https://jsfiddle.net/hikarii_flow/295v7sb3/)\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n\n    narrowType<keyof typeof input>(key);\n\n    const encodeKey = $$recordSpecialProperty.escape(key);\n\n    /**\n     * We are setting properties on the result object, so we need to skip forbidden properties\n     * such as `__proto__`, `constructor`, `prototype`, etc.\n     *\n     * This could be a potential security risk, allowing attackers to pollute the prototype chain.\n     */\n    if (getIsForbiddenProperty(key)) continue;\n\n    result[encodeKey] = performEncode(input[key], context);\n  }\n\n  return result;\n}\n\nfunction encodeCustomType(input: object, context: EncodeContext): JSONValue {\n  const matchingType = context.coder.getMatchingTypeForObject(input);\n\n  if (!matchingType) {\n    switch (context.unknownMode) {\n      case \"unchanged\":\n        return input as JSONValue;\n      case \"null\":\n        return null;\n      case \"throw\":\n        throw new Error(\"Not able to encode - no matching type found\", input);\n    }\n  }\n\n  /**\n   * wrapper is an object like { $$set: [1, 2, 3] }\n   *\n   * `$$set` tells what type it is, and `[1, 2, 3]` is the data needed to decode it later\n   */\n  let encodedTypeData = matchingType.encode(input, context);\n\n  if (!matchingType.isFlat) {\n    encodedTypeData = performEncode(encodedTypeData, context);\n  }\n\n  const tag = matchingType.createTag(encodedTypeData);\n\n  context.registerEncoded(input, tag);\n\n  return tag;\n}\n\nexport function performEncode(input: unknown, context: EncodeContext): JSONValue {\n  if (input === null) return null;\n\n  switch (typeof input) {\n    case \"boolean\":\n      return input;\n    case \"string\":\n      return maybeEscapeSpecialString(input);\n    case \"number\":\n      return maybeEncodeNumber(input);\n    case \"symbol\":\n      return $$symbol.encodeTag(input, context);\n    case \"bigint\":\n      return $$bigInt.encodeTag(input, context);\n    case \"undefined\":\n      return UNDEFINED_STRING;\n    // We do not encode functions\n    case \"function\":\n      return input as unknown as JSONValue;\n  }\n\n  // Either a record or an array\n\n  if (context.preserveReferences) {\n    // See if this object was already present before at some other path\n    const refId = context.getAlreadySeenObjectId(input);\n\n    // If so, instead of continuing - return an alias to the already seen object\n    if (refId !== null) return createTag(\"ref\", refId);\n\n    /**\n     * It is seen for the first time, register it so if it is seen again - we can return an alias to the already seen object\n     */\n    context.registerNewSeenObject(input);\n  }\n\n  if (Array.isArray(input)) {\n    return encodeArray(input, context);\n  }\n\n  const inputPrototype = Object.getPrototypeOf(input);\n\n  // Plain record aka {}\n  if (inputPrototype === OBJECT_PROTOTYPE || inputPrototype === null) {\n    return encodeRecord(input as Record<string, unknown>, context);\n  }\n\n  return encodeCustomType(input, context);\n}\n","import { CodableType, getIsCodableType } from \"./CodableType\";\nimport { Thunk, resolveThunk } from \"./utils/misc\";\n\nimport { AnyClass } from \"./decorators/types\";\nimport { getCodableClassType } from \"./decorators/registry\";\nimport { getIsNotNull } from \"./is\";\n\nexport type CodableDependency = AnyClass | CodableType;\n\nexport type CodableDependencies = Thunk<CodableDependency[]>;\n\nfunction resolveDependency(dependency: CodableDependency): CodableType | null {\n  if (getIsCodableType(dependency)) return dependency;\n\n  const codableClassType = getCodableClassType(dependency);\n\n  if (!codableClassType) return null;\n\n  return codableClassType;\n}\n\nfunction getDirectDependencies(dependency: CodableDependency): CodableDependency[] | null {\n  if (getIsCodableType(dependency)) {\n    return resolveThunk(dependency.dependencies);\n  }\n\n  const codableClassType = getCodableClassType(dependency);\n\n  if (!codableClassType) return null;\n\n  return resolveThunk(codableClassType.dependencies);\n}\n\nfunction addToSet<T>(source: Set<T>, values: Iterable<T>) {\n  for (const value of values) {\n    source.add(value);\n  }\n}\n\nexport function resolveCodableDependencies(dependency: CodableDependency): Set<CodableType> {\n  const resolvedDependencies: Set<CodableDependency> = new Set();\n\n  let dependenciesToCheck = new Set<CodableDependency>([dependency]);\n\n  while (true) {\n    if (dependenciesToCheck.size === 0) break;\n\n    for (const dependency of dependenciesToCheck) {\n      dependenciesToCheck.delete(dependency);\n\n      if (resolvedDependencies.has(dependency)) continue;\n      resolvedDependencies.add(dependency);\n\n      const nestedDependencies = getDirectDependencies(dependency);\n\n      if (!nestedDependencies) continue;\n\n      addToSet(resolvedDependencies, nestedDependencies);\n      addToSet(dependenciesToCheck, nestedDependencies);\n    }\n  }\n\n  resolvedDependencies.delete(dependency);\n\n  const resolvedTypes = Array.from(resolvedDependencies).map(resolveDependency).filter(getIsNotNull);\n\n  return new Set(resolvedTypes);\n}\n","import type * as _ from \"temporal-polyfill/global\";\n\nimport { AnyClass } from \"./types\";\nimport { codableType } from \"./CodableType\";\n\ntype TemporalNamespace = typeof globalThis.Temporal;\n\ntype AnyTemporalClass = { new (...args: any[]): any; from(isoString: string): any };\n\nfunction createTemporalTypeFromClass<T extends AnyTemporalClass>(name: string, TemporalClass: T) {\n  return codableType(\n    name,\n    (thing): thing is typeof TemporalClass => thing instanceof TemporalClass,\n    (temporal) => temporal.toString(),\n    (isoString) => TemporalClass.from(isoString),\n  );\n}\n\nexport function createTemporalTypes(Temporal: TemporalNamespace) {\n  const classes = {\n    Instant: Temporal.Instant,\n    Duration: Temporal.Duration,\n    PlainDate: Temporal.PlainDate,\n    PlainDateTime: Temporal.PlainDateTime,\n    PlainMonthDay: Temporal.PlainMonthDay,\n    PlainTime: Temporal.PlainTime,\n    PlainYearMonth: Temporal.PlainYearMonth,\n    ZonedDateTime: Temporal.ZonedDateTime,\n  } as const;\n\n  return Object.entries(classes).map(([name, TemporalClass]) => {\n    return createTemporalTypeFromClass(name, TemporalClass);\n  });\n}\n\nexport const temporalTypes =\n  typeof globalThis.Temporal !== \"undefined\" ? createTemporalTypes(globalThis.Temporal) : null;\n","import * as builtinTypesMap from \"./builtin\";\n\nimport { CodableType, CodableTypeOptions, codableType, defaultCodableReader, getIsCodableType } from \"./CodableType\";\nimport { DecodeContext, DecodeOptions } from \"./DecodeContext\";\nimport { EncodeContext, EncodeOptions } from \"./EncodeContext\";\nimport { Path, ROOT_PATH, splitPath } from \"./utils/path\";\nimport { Transformer, getIsSuperJSONResult, getSuperjsonTransformer } from \"./compat\";\nimport { getCodableClassType, getIsCodableClass } from \"./decorators/registry\";\nimport { getIsObject, getIsRecord } from \"./is\";\n\nimport { $$externalReference } from \"./ExternalReference\";\nimport { AnyClass } from \"./decorators/types\";\nimport { JSONValue } from \"./types\";\nimport { assertGet } from \"./utils/assert\";\nimport { consumeArray } from \"./utils/misc\";\nimport { decodeInput } from \"./decode\";\nimport { getIsTagKey } from \"./format\";\nimport { performEncode } from \"./encode\";\nimport { resolveCodableDependencies } from \"./dependencies\";\nimport { temporalTypes } from \"./temporal\";\n\nconst typeCandidates: Array<CodableType | Array<CodableType>> = [\n  ...Object.values(builtinTypesMap),\n  ...Object.values(temporalTypes ?? {}),\n  $$externalReference,\n];\n\nconst BUILTIN_TYPES = typeCandidates\n  .map((codableTypeOrCodableTypes) => {\n    if (Array.isArray(codableTypeOrCodableTypes)) {\n      return codableTypeOrCodableTypes;\n    }\n\n    return [codableTypeOrCodableTypes];\n  })\n  .flat()\n  .filter(getIsCodableType);\n\nconst DEFAULT_TYPES = [...BUILTIN_TYPES].filter(getIsCodableType);\n\nfunction getSortedTypes(types: CodableType[]) {\n  return types.sort((a, b) => {\n    return b.priority - a.priority;\n  });\n}\n\nfunction fillMapWithTypes(map: Map<string, CodableType>, types: CodableType[]) {\n  map.clear();\n\n  for (const type of types) {\n    if (map.has(type.name)) {\n      throw new Error(`Coder type \"${type.name}\" already registered`);\n    }\n\n    map.set(type.name, type);\n  }\n}\n\nfunction createTypesMap(types: CodableType[]) {\n  const sortedTypes = getSortedTypes(types);\n\n  const map = new Map<string, CodableType>();\n\n  fillMapWithTypes(map, sortedTypes);\n\n  return map;\n}\n\ntype CodableTypeOrClass = CodableType | AnyClass;\n\nfunction updateTypesOrderByPriority(currentTypes: Map<string, CodableType>) {\n  const sortedTypes = getSortedTypes([...currentTypes.values()]);\n\n  const needsReordering = sortedTypes.some((type) => !type.hasDefaultPriority);\n\n  if (!needsReordering) return;\n\n  fillMapWithTypes(currentTypes, sortedTypes);\n}\n\nexport class Coder {\n  private readonly typesMap = new Map<string, CodableType>();\n  private readonly codableTypeByClassMap = new Map<AnyClass, CodableType>();\n\n  constructor(extraTypes: CodableTypeOrClass[] = []) {\n    this.typesMap = createTypesMap([...DEFAULT_TYPES]);\n\n    this.register(...extraTypes);\n  }\n\n  get transformer(): Transformer {\n    return {\n      serialize: (value: any) => this.encode(value),\n      deserialize: (value: any) => this.decode(value),\n    };\n  }\n\n  private refreshCodableTypeByClassMap() {\n    this.codableTypeByClassMap.clear();\n\n    for (const type of this.typesMap.values()) {\n      if (type.classes) {\n        for (const Class of type.classes) {\n          this.codableTypeByClassMap.set(Class, type);\n        }\n      }\n    }\n  }\n\n  private organizeTypes() {\n    updateTypesOrderByPriority(this.typesMap);\n    this.refreshCodableTypeByClassMap();\n  }\n\n  getTypeByName(name: string): CodableType | null {\n    return this.typesMap.get(name) ?? null;\n  }\n\n  private getHasType(type: CodableType): boolean {\n    const existingType = this.getTypeByName(type.name);\n\n    return type === existingType;\n  }\n\n  register(...typesOrClasses: CodableTypeOrClass[]) {\n    if (typesOrClasses.length === 0) return;\n\n    if (this.isDefault) {\n      throw new Error(\n        \"Cannot register types on the default coder. Create a custom coder instance using `new Coder()` and register types on that instance.\",\n      );\n    }\n\n    const dependenciesToRegister = new Set<CodableType>();\n\n    for (const typeOrClass of typesOrClasses) {\n      const codableType = getIsCodableClass(typeOrClass)\n        ? assertGet(getCodableClassType(typeOrClass), `Codable class \"${typeOrClass.name}\" not registered`)\n        : typeOrClass;\n\n      if (this.getHasType(codableType)) continue;\n\n      if (this.typesMap.has(codableType.name)) {\n        throw new Error(`Other codable type with name \"${codableType.name}\" already registered`);\n      }\n\n      this.typesMap.set(codableType.name, codableType);\n\n      for (const dependency of resolveCodableDependencies(codableType)) {\n        dependenciesToRegister.add(dependency);\n      }\n    }\n\n    this.register(...dependenciesToRegister);\n\n    this.organizeTypes();\n  }\n\n  addType<Item, Data>(\n    name: string,\n    canEncode: (value: unknown) => value is Item,\n    encode: (data: Item) => Data,\n    decode: (data: Data) => Item,\n    options?: CodableTypeOptions<Item>,\n  ) {\n    return this.register(codableType(name, canEncode, encode, decode, options));\n  }\n\n  encode<T>(value: T, options?: EncodeOptions): JSONValue {\n    const encodeContext = new EncodeContext(this, options);\n\n    const result = performEncode(value, encodeContext);\n\n    encodeContext.finalize();\n\n    return result;\n  }\n\n  decode<T>(value: JSONValue, options?: DecodeOptions): T {\n    if (getIsSuperJSONResult(value)) {\n      const transformer = getSuperjsonTransformer();\n      if (transformer) return transformer.deserialize(value) as T;\n\n      console.warn(\n        `Seems you are decoding SuperJSON encoded data. Please enable compatibility mode by importing \"codablejson/superjson\" somewhere early in your code.`,\n      );\n    }\n\n    const context = new DecodeContext(this, options);\n\n    const result = decodeInput<T>(value, context, this, ROOT_PATH);\n\n    this.resolvePendingReferencesInOutput(result, context);\n\n    return result;\n  }\n\n  stringify<T>(value: T, prettyPrint?: boolean): string {\n    return JSON.stringify(this.encode(value), null, prettyPrint ? 2 : undefined);\n  }\n\n  parse<T>(value: string): T {\n    return this.decode(JSON.parse(value));\n  }\n\n  clone<T>(value: T): T {\n    return this.decode<T>(this.encode(value));\n  }\n\n  getMatchingTypeForObject<T extends object>(input: T): CodableType<T> | null {\n    const codableTypeByClass = this.codableTypeByClassMap.get(input.constructor as AnyClass);\n\n    if (codableTypeByClass?.canHandle(input)) {\n      return codableTypeByClass;\n    }\n\n    for (const type of this.typesMap.values()) {\n      if (type.canHandle(input)) {\n        return type;\n      }\n    }\n\n    return null;\n  }\n\n  get isDefault() {\n    return this === codablejson;\n  }\n\n  private resolvePendingReferencesInOutput(output: any, context: DecodeContext) {\n    for (const [refId, paths] of context.pendingReferences) {\n      const referenceTarget = context.resolvedRefs.get(refId);\n\n      if (!referenceTarget) continue;\n\n      for (const path of paths) {\n        const didUpdate = this.updateValueInOutput(output, path, referenceTarget);\n\n        if (!didUpdate) {\n          console.warn(`Failed to update value at path ${path}`);\n        }\n      }\n    }\n  }\n\n  private updateValueInOutput(root: object, path: Path, value: unknown) {\n    const segmentsConsumer = consumeArray(splitPath(path), getIsTagKey);\n\n    let current = root;\n\n    while (true) {\n      const matchingType = this.getMatchingTypeForObject(current);\n\n      const reader = matchingType?.reader ?? defaultCodableReader;\n\n      const { get, set } = reader(current, segmentsConsumer);\n\n      if (segmentsConsumer.isDone) {\n        // We are at the end of the path, so we can set the value\n        return set(value);\n      }\n\n      // Read the value and keep traversing the path\n      const result = get();\n\n      if (!getIsObject(result)) {\n        console.warn(`Expected object at path ${path}, got ${typeof result}`);\n        return false;\n      }\n\n      current = result;\n    }\n  }\n}\n\nexport function createCoder(extraTypes: CodableType[] = []) {\n  return new Coder(extraTypes);\n}\n\nexport const codablejson = createCoder();\n\nexport function decode<T>(value: JSONValue, options?: DecodeOptions): T {\n  return codablejson.decode(value, options);\n}\n\nexport function encode<T>(value: T): JSONValue {\n  return codablejson.encode(value);\n}\n\nexport function stringify<T>(value: T, prettyPrint?: boolean): string {\n  return codablejson.stringify(value, prettyPrint);\n}\n\nexport function parse<T>(value: string): T {\n  return codablejson.parse(value);\n}\n\nexport function clone<T>(value: T): T {\n  return codablejson.clone(value);\n}\n","import { PrivateMetadata, getMetadataKey } from \"./PrivateMetadata\";\nimport { codableClassFieldsRegistry, externalClassFieldsRegistry } from \"./registry\";\n\nimport { AnyClass } from \"./types\";\nimport { removeUndefinedProperties } from \"../utils/misc\";\n\ntype CodableFieldDecoratorContext<T, V> = ClassFieldDecoratorContext<T, V> | ClassAccessorDecoratorContext<T, V>;\n\nexport function getRegisteredCodableFields(Class: AnyClass) {\n  return codableClassFieldsRegistry.getFor(Class);\n}\n\ninterface CodableOptions {\n  encodeAs?: string;\n}\n\ntype CodableOptionsInput = string | CodableOptions;\n\nfunction resolveCodableOptions(options?: CodableOptionsInput): CodableOptions | null {\n  if (typeof options === \"string\") {\n    return { encodeAs: options };\n  }\n\n  return options ?? null;\n}\n\nexport function codable<T, V>(optionsInput?: CodableOptionsInput) {\n  const options = resolveCodableOptions(optionsInput);\n  return function codable<T, V>(initialValue: any, context: CodableFieldDecoratorContext<T, V>) {\n    if (context.kind !== \"accessor\" && context.kind !== \"field\") {\n      throw new Error(\"Codable decorator can only be used on fields or accessors\");\n    }\n\n    const isSymbolName = typeof context.name === \"symbol\";\n\n    if (isSymbolName) throw new Error(\"Symbol property names are not supported\");\n\n    if (externalClassFieldsRegistry.get(context.metadata)?.has(context.name)) {\n      throw new Error(\"Codable decorator cannot be used on external properties\");\n    }\n\n    const fieldsMap = codableClassFieldsRegistry.getOrInit(context.metadata, () => new Map());\n\n    fieldsMap.set(context.name, removeUndefinedProperties({ encodeAs: options?.encodeAs }));\n  };\n}\n","import { AnyClass } from \"./types\";\n\nexport function* iteratePrototypeChain(Class: object): Generator<object> {\n  let current = Class;\n  while (\n    current !== null &&\n    current !== Function.prototype &&\n    current !== Object.prototype\n  ) {\n    yield current;\n    current = Object.getPrototypeOf(current);\n  }\n}\n\nexport function getPrototypeChainLength(Class: AnyClass): number {\n  return [...iteratePrototypeChain(Class)].length;\n}\n","import { CodableClassFieldsMap, externalClassFieldsRegistry } from \"./registry\";\n\nimport { AnyClass } from \"./types\";\nimport { getIsForbiddenProperty } from \"../utils/security\";\nimport { getRegisteredCodableFields } from \"./codable\";\nimport { iteratePrototypeChain } from \"./prototype\";\n\nfunction collectRegisteredCodableFields(Class: AnyClass, keysMap: CodableClassFieldsMap) {\n  for (const ClassInPrototype of iteratePrototypeChain(Class)) {\n    const registeredKeysMap = getRegisteredCodableFields(ClassInPrototype as AnyClass);\n\n    if (!registeredKeysMap) continue;\n\n    for (const [key, metadata] of registeredKeysMap.entries()) {\n      keysMap.set(key, metadata);\n    }\n  }\n\n  if (keysMap.size === 0) return null;\n\n  return keysMap;\n}\n\nexport function getCodableProperties(Class: AnyClass) {\n  const keysMap: CodableClassFieldsMap = new Map();\n\n  collectRegisteredCodableFields(Class, keysMap);\n\n  return keysMap;\n}\n\nexport function getExternalProperties(Class: AnyClass) {\n  const externalFieldsMap = externalClassFieldsRegistry.getFor(Class);\n\n  if (!externalFieldsMap) return null;\n\n  return externalFieldsMap;\n}\n","import { CodableClassFieldsMap, FieldMetadata } from \"./registry\";\nimport { getCodableProperties, getExternalProperties } from \"./properties\";\n\nimport { AnyClass } from \"./types\";\nimport { externalReference } from \"../ExternalReference\";\n\nexport type ClassEncoder<T extends AnyClass> = (instance: InstanceType<T>) => ConstructorParameters<T>;\n\nfunction mergeMaps<T, U>(map1: Map<T, U>, map2: Map<T, U>): Map<T, U> {\n  const result = new Map(map1);\n  for (const [key, value] of map2.entries()) {\n    result.set(key, value);\n  }\n  return result;\n}\n\nfunction getFieldsInfo<T extends AnyClass>(\n  Class: T,\n  fieldsFromOptions: CodableClassFieldsMap<T>,\n): CodableClassFieldsMap<T> {\n  const fieldsFromProperties = getCodableProperties(Class);\n\n  return mergeMaps(fieldsFromProperties, fieldsFromOptions);\n}\n\nexport function createDefaultClassEncoder<T extends AnyClass>(\n  Class: T,\n  fieldsFromOptions: CodableClassFieldsMap<T>,\n): ClassEncoder<T> {\n  let fields: CodableClassFieldsMap<T> | null = null;\n\n  // Makes iteration faster by avoiding assignments to local variables\n  let instanceKey: string | number | symbol;\n  let metadata: FieldMetadata;\n\n  let externalKey: string;\n  let externalRef: { key: string; isOptional: boolean };\n\n  return (instance: InstanceType<T>) => {\n    const externalKeysMap = getExternalProperties(Class);\n    const data: Record<string, any> = {};\n\n    if (!fields) {\n      fields = getFieldsInfo(Class, fieldsFromOptions);\n    }\n\n    for ([instanceKey, metadata] of fields.entries()) {\n      const encodeAs = metadata.encodeAs ?? instanceKey;\n      data[encodeAs as string] = instance[instanceKey];\n    }\n\n    if (externalKeysMap) {\n      for ([externalKey, externalRef] of externalKeysMap.entries()) {\n        data[externalKey] = externalReference(externalRef.key, externalRef.isOptional);\n      }\n    }\n\n    return [data] as ConstructorParameters<T>;\n  };\n}\n\nexport type ClassDecoder<T extends AnyClass> = (data: ConstructorParameters<T>) => InstanceType<T>;\n\n/**\n * Returns map like { \"encoded_key\": \"instance_key\" }\n *\n * If it is empty, it means that no keys are remapped.\n */\nfunction createRemappingMap(fields: CodableClassFieldsMap): Map<string, string> {\n  const remappingMap = new Map<string, string>();\n  for (const [classKey, fieldMeta] of fields.entries()) {\n    const encodedAsKey = fieldMeta.encodeAs ?? classKey;\n\n    if (encodedAsKey !== classKey) {\n      remappingMap.set(encodedAsKey as string, classKey as string);\n    }\n  }\n\n  return remappingMap;\n}\n\nfunction unmapKeys(data: Record<string, any>, remappingMap: Map<string, string>): Record<string, any> {\n  const unmappedData: Record<string, any> = {};\n\n  for (const [classOrEncodedKey, value] of Object.entries(data)) {\n    const instanceKey = remappingMap.get(classOrEncodedKey) ?? classOrEncodedKey;\n    unmappedData[instanceKey as string] = value;\n  }\n\n  return unmappedData;\n}\n\nexport function createClassDecoder<T extends AnyClass>(\n  Class: T,\n  isDefaultEncoder: boolean,\n  keysFromOptions: CodableClassFieldsMap<T>,\n): ClassDecoder<T> {\n  let fields: CodableClassFieldsMap<T> | null = null;\n  let remappingMap: Map<string, string> | null = null;\n\n  return (data: ConstructorParameters<T>) => {\n    if (!isDefaultEncoder) {\n      return new Class(...data);\n    }\n\n    let [dataInput] = data;\n\n    if (!fields) {\n      fields = getFieldsInfo(Class, keysFromOptions);\n    }\n\n    if (remappingMap === null) {\n      remappingMap = createRemappingMap(fields);\n    }\n\n    if (remappingMap.size > 0) {\n      dataInput = unmapKeys(dataInput, remappingMap);\n    }\n\n    const instance = new Class(dataInput);\n\n    Object.assign(instance, dataInput);\n\n    return instance;\n  };\n}\n","import { AnyClass, ClassDecorator, MakeRequired, MemberwiseClass } from \"./types\";\nimport { ClassDecoder, ClassEncoder, createClassDecoder, createDefaultClassEncoder } from \"./encode\";\nimport { CodableClassFieldsMap, FieldMetadata, codableClassFieldsRegistry, codableClassRegistry } from \"./registry\";\nimport { CodableType, codableType } from \"../CodableType\";\n\nimport { CodableDependencies } from \"../dependencies\";\nimport { getPrototypeChainLength } from \"./prototype\";\nimport { narrowType } from \"../utils/assert\";\n\nexport type CodableClassKeys<T extends AnyClass> = Array<keyof InstanceType<T>> | CodableClassFieldsMap<T>;\n\ntype CodableClassKeysInput<T extends AnyClass> = Array<keyof InstanceType<T>> | Record<keyof InstanceType<T>, string>;\n\nfunction resolveKeys<T extends AnyClass>(keys: CodableClassKeysInput<T>): CodableClassFieldsMap<T> {\n  if (Array.isArray(keys)) {\n    const entries = keys.map((key) => [key, {} as FieldMetadata] as const);\n\n    return new Map(entries);\n  }\n\n  const entries = Object.entries(keys).map(([key, value]) => {\n    return [\n      //\n      key,\n      { encodeAs: value } as FieldMetadata,\n    ] as const;\n  });\n\n  return new Map(entries);\n}\n\nexport interface CodableClassOptions<T extends AnyClass> {\n  dependencies?: CodableDependencies;\n  encode?: ClassEncoder<T>;\n  keys?: CodableClassKeysInput<T>;\n}\n\ntype CodableClassDecoratorArgs<T extends AnyClass> =\n  T extends MemberwiseClass<T>\n    ? // Memberwise class does not require an encode function\n      [string, CodableClassOptions<T> | void]\n    : // Non-memberwise is constructer in a custom way so we require an explicit encode function\n      [string, MakeRequired<CodableClassOptions<T>, \"encode\">];\n\nexport function codableClass<T extends AnyClass>(\n  ...[name, maybeOptions]: CodableClassDecoratorArgs<T>\n): ClassDecorator<T> {\n  narrowType<CodableClassOptions<T> | undefined>(maybeOptions);\n\n  return (Class: T, context: ClassDecoratorContext<T>) => {\n    const isUsingDefaultEncoder = maybeOptions?.encode === undefined;\n\n    const keysFromOptions = resolveKeys(maybeOptions?.keys ?? []);\n\n    const encoder: ClassEncoder<T> = maybeOptions?.encode ?? createDefaultClassEncoder(Class, keysFromOptions);\n    const decoder: ClassDecoder<T> = createClassDecoder(Class, isUsingDefaultEncoder, keysFromOptions);\n\n    const type = codableType(\n      name,\n      (value): value is InstanceType<T> => value instanceof Class,\n      encoder,\n      decoder,\n      /**\n       * If we have Foo and Bar extending Foo, Bar should always be the first to try to match.\n       * As Foo is the parent class, it will also match Bar, resulting in incorrect data being decoded.\n       */\n      {\n        priority: getPrototypeChainLength(Class),\n        dependencies: maybeOptions?.dependencies,\n        Class,\n        reader: (item, [_, key]) => {\n          // Custom class data has a form of array of constructor arguments\n          // The first one is memberwise object and this is what we want, we ignore the first (0) index\n\n          return {\n            get: () => Reflect.get(item, key),\n            set: (value) => Reflect.set(item, key, value),\n          };\n        },\n      },\n    );\n\n    codableClassRegistry.init(context.metadata, {\n      name,\n      codableType: type as CodableType<any, any>,\n    });\n\n    const fieldsMap = codableClassFieldsRegistry.getOrInit(context.metadata, () => new Map());\n\n    for (const [key, metadata] of keysFromOptions.entries()) {\n      if (fieldsMap.has(key)) continue;\n\n      fieldsMap.set(key, metadata);\n    }\n  };\n}\n","type PropDecorator = (value: any, context: any) => any;\n\nexport function combineDecorators(...decorators: PropDecorator[]): PropDecorator {\n  const [first, ...rest] = decorators;\n\n  return function (value: any, context: any) {\n    let result = first(value, context);\n\n    for (const decorator of rest) {\n      result = decorator(result, context);\n    }\n\n    return result;\n  };\n}\n","import { codableClassFieldsRegistry, externalClassFieldsRegistry } from \"./registry\";\n\nimport { AnyClass } from \"./types\";\n\ntype CodableFieldDecoratorContext<T, V> = ClassFieldDecoratorContext<T, V> | ClassAccessorDecoratorContext<T, V>;\n\nexport function getRegisteredCodableFields(Class: AnyClass) {\n  return codableClassFieldsRegistry.getFor(Class);\n}\n\nexport function external<T, V>(key: string, isOptional = false) {\n  return function external<T, V>(initialValue: any, context: CodableFieldDecoratorContext<T, V>) {\n    const externalFieldsMap = externalClassFieldsRegistry.getOrInit(context.metadata, () => new Map());\n\n    if (typeof context.name !== \"string\") {\n      throw new Error(\"External decorator can only be used on string properties\");\n    }\n\n    if (codableClassFieldsRegistry.get(context.metadata)?.has(context.name)) {\n      throw new Error(\"External decorator cannot be used on codable properties\");\n    }\n\n    externalFieldsMap.set(context.name, { key, isOptional });\n  };\n}\n","import { Coder, codablejson } from \"./Coder\";\n\nlet isExtended = false;\n\nexport function extendJSONWithCodableJSON(coder: Coder = codablejson) {\n  if (isExtended) {\n    throw new Error(\"JSON is already extended. Make sure to undo the other extension first.\");\n  }\n\n  isExtended = true;\n\n  const JSONparse = JSON.parse;\n  const JSONstringify = JSON.stringify;\n\n  JSON.stringify = (value, replacer?: any, space?: any) => {\n    value = codablejson.encode(value);\n\n    return JSONstringify(value, replacer, space);\n  };\n\n  JSON.parse = (text, reviver) => {\n    const rawParsed = JSONparse(text, reviver);\n\n    return codablejson.decode(rawParsed);\n  };\n\n  return function restoreJSON() {\n    JSON.parse = JSONparse;\n    JSON.stringify = JSONstringify;\n\n    isExtended = false;\n  };\n}\n"],"names":["encode","decode","EntryIndex","getIsNotNull","getIsObject","codableType","result","dependency","getIsSuperJSONResult","getSuperjsonTransformer","codable","entries","external"],"mappings":"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"}