{"version":3,"names":["NativeReanimatedModule","shouldBeUseWeb","registerWorkletStackDetails","jsVersion","shareableMappingCache","shareableMappingFlag","SHOULD_BE_USE_WEB","MAGIC_KEY","isHostObject","value","isPlainJSObject","object","Object","getPrototypeOf","prototype","INACCESSIBLE_OBJECT","__init","Proxy","get","_","prop","Error","String","set","VALID_ARRAY_VIEWS_NAMES","DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD","processedObjectAtThresholdDepth","makeShareableCloneRecursive","shouldPersistRemote","arguments","length","undefined","depth","type","isTypeObject","isTypeFunction","cached","toAdapt","Array","isArray","map","element","__workletHash","__DEV__","babelVersion","__initData","version","getWorkletCode","__stackDetails","key","entries","RegExp","pattern","source","flags","handle","ArrayBuffer","isView","buffer","typeName","constructor","name","includes","global","inaccessibleObject","freeze","adopted","makeShareableClone","WORKLET_CODE_THRESHOLD","_value$__initData","code","substring","isRemoteFunction","__remoteFunction","makeShareableCloneOnUIRecursive","cloneRecursive","_makeShareableClone","makeShareableJS","makeShareableNative","makeShareable"],"sources":["shareables.ts"],"sourcesContent":["'use strict';\nimport NativeReanimatedModule from './NativeReanimated';\nimport type {\n  ShareableRef,\n  FlatShareableRef,\n  __WorkletFunction,\n} from './commonTypes';\nimport { shouldBeUseWeb } from './PlatformChecker';\nimport { registerWorkletStackDetails } from './errors';\nimport { jsVersion } from './platform-specific/jsVersion';\nimport {\n  shareableMappingCache,\n  shareableMappingFlag,\n} from './shareableMappingCache';\n\n// for web/chrome debugger/jest environments this file provides a stub implementation\n// where no shareable references are used. Instead, the objects themselves are used\n// instead of shareable references, because of the fact that we don't have to deal with\n// runnning the code on separate VMs.\nconst SHOULD_BE_USE_WEB = shouldBeUseWeb();\n\nconst MAGIC_KEY = 'REANIMATED_MAGIC_KEY';\n\nfunction isHostObject(value: NonNullable<object>) {\n  'worklet';\n  // We could use JSI to determine whether an object is a host object, however\n  // the below workaround works well and is way faster than an additional JSI call.\n  // We use the fact that host objects have broken implementation of `hasOwnProperty`\n  // and hence return true for all `in` checks regardless of the key we ask for.\n  return MAGIC_KEY in value;\n}\n\nfunction isPlainJSObject(object: object): object is object {\n  return Object.getPrototypeOf(object) === Object.prototype;\n}\n\n// The below object is used as a replacement for objects that cannot be transferred\n// as shareable values. In makeShareableCloneRecursive we detect if an object is of\n// a plain Object.prototype and only allow such objects to be transferred. This lets\n// us avoid all sorts of react internals from leaking into the UI runtime. To make it\n// possible to catch errors when someone actually tries to access such object on the UI\n// runtime, we use the below Proxy object which is instantiated on the UI runtime and\n// throws whenever someone tries to access its fields.\nconst INACCESSIBLE_OBJECT = {\n  __init: () => {\n    'worklet';\n    return new Proxy(\n      {},\n      {\n        get: (_: unknown, prop: string | symbol) => {\n          if (\n            prop === '_isReanimatedSharedValue' ||\n            prop === '__remoteFunction'\n          ) {\n            // not very happy about this check here, but we need to allow for\n            // \"inaccessible\" objects to be tested with isSharedValue check\n            // as it is being used in the mappers when extracting inputs recursively\n            // as well as with isRemoteFunction when cloning objects recursively.\n            // Apparently we can't check if a key exists there as HostObjects always\n            // return true for such tests, so the only possibility for us is to\n            // actually access that key and see if it is set to true. We therefore\n            // need to allow for this key to be accessed here.\n            return false;\n          }\n          throw new Error(\n            `[Reanimated] Trying to access property \\`${String(\n              prop\n            )}\\` of an object which cannot be sent to the UI runtime.`\n          );\n        },\n        set: () => {\n          throw new Error(\n            '[Reanimated] Trying to write to an object which cannot be sent to the UI runtime.'\n          );\n        },\n      }\n    );\n  },\n};\n\nconst VALID_ARRAY_VIEWS_NAMES = [\n  'Int8Array',\n  'Uint8Array',\n  'Uint8ClampedArray',\n  'Int16Array',\n  'Uint16Array',\n  'Int32Array',\n  'Uint32Array',\n  'Float32Array',\n  'Float64Array',\n  'BigInt64Array',\n  'BigUint64Array',\n  'DataView',\n];\n\nconst DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD = 30;\n// Below variable stores object that we process in makeShareableCloneRecursive at the specified depth.\n// We use it to check if later on the function reenters with the same object\nlet processedObjectAtThresholdDepth: unknown;\n\nexport function makeShareableCloneRecursive<T>(\n  value: any,\n  shouldPersistRemote = false,\n  depth = 0\n): ShareableRef<T> {\n  if (SHOULD_BE_USE_WEB) {\n    return value;\n  }\n  if (depth >= DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {\n    // if we reach certain recursion depth we suspect that we are dealing with a cyclic object.\n    // this type of objects are not supported and cannot be trasferred as shareable, so we\n    // implement a simple detection mechanism that remembers the value at a given depth and\n    // tests whether we try reenter this method later on with the same value. If that happens\n    // we throw an appropriate error.\n    if (depth === DETECT_CYCLIC_OBJECT_DEPTH_THRESHOLD) {\n      processedObjectAtThresholdDepth = value;\n    } else if (value === processedObjectAtThresholdDepth) {\n      throw new Error(\n        '[Reanimated] Trying to convert a cyclic object to a shareable. This is not supported.'\n      );\n    }\n  } else {\n    processedObjectAtThresholdDepth = undefined;\n  }\n  // This one actually may be worth to be moved to c++, we also need similar logic to run on the UI thread\n  const type = typeof value;\n  const isTypeObject = type === 'object';\n  const isTypeFunction = type === 'function';\n  if ((isTypeObject || isTypeFunction) && value !== null) {\n    const cached = shareableMappingCache.get(value);\n    if (cached === shareableMappingFlag) {\n      return value;\n    } else if (cached !== undefined) {\n      return cached as ShareableRef<T>;\n    } else {\n      let toAdapt: any;\n      if (Array.isArray(value)) {\n        toAdapt = value.map((element) =>\n          makeShareableCloneRecursive(element, shouldPersistRemote, depth + 1)\n        );\n      } else if (isTypeFunction && value.__workletHash === undefined) {\n        // this is a remote function\n        toAdapt = value;\n      } else if (isHostObject(value)) {\n        // for host objects we pass the reference to the object as shareable and\n        // then recreate new host object wrapping the same instance on the UI thread.\n        // there is no point of iterating over keys as we do for regular objects.\n        toAdapt = value;\n      } else if (isPlainJSObject(value) || isTypeFunction) {\n        toAdapt = {};\n        if (value.__workletHash !== undefined) {\n          // we are converting a worklet\n          if (__DEV__) {\n            const babelVersion = value.__initData.version;\n            if (babelVersion !== undefined && babelVersion !== jsVersion) {\n              throw new Error(`[Reanimated] Mismatch between JavaScript code version and Reanimated Babel plugin version (${jsVersion} vs. ${babelVersion}).        \nSee \\`https://docs.swmansion.com/react-native-reanimated/docs/guides/troubleshooting#mismatch-between-javascript-code-version-and-reanimated-babel-plugin-version\\` for more details.\nOffending code was: \\`${getWorkletCode(value)}\\``);\n            }\n            registerWorkletStackDetails(\n              value.__workletHash,\n              value.__stackDetails\n            );\n          }\n          if (value.__stackDetails) {\n            // `Error` type of value cannot be copied to the UI thread, so we\n            // remove it after we handled it in dev mode or delete it to ignore it in production mode.\n            // Not removing this would cause an infinite loop in production mode and it just\n            // seems more elegant to handle it this way.\n            delete value.__stackDetails;\n          }\n          // to save on transferring static __initData field of worklet structure\n          // we request shareable value to persist its UI counterpart. This means\n          // that the __initData field that contains long strings represeting the\n          // worklet code, source map, and location, will always be\n          // serialized/deserialized once.\n          toAdapt.__initData = makeShareableCloneRecursive(\n            value.__initData,\n            true,\n            depth + 1\n          );\n        }\n\n        for (const [key, element] of Object.entries(value)) {\n          if (key === '__initData' && toAdapt.__initData !== undefined) {\n            continue;\n          }\n          toAdapt[key] = makeShareableCloneRecursive(\n            element,\n            shouldPersistRemote,\n            depth + 1\n          );\n        }\n      } else if (value instanceof RegExp) {\n        const pattern = value.source;\n        const flags = value.flags;\n        const handle = makeShareableCloneRecursive({\n          __init: () => {\n            'worklet';\n            return new RegExp(pattern, flags);\n          },\n        });\n        shareableMappingCache.set(value, handle);\n        return handle as ShareableRef<T>;\n      } else if (value instanceof ArrayBuffer) {\n        toAdapt = value;\n      } else if (ArrayBuffer.isView(value)) {\n        // typed array (e.g. Int32Array, Uint8ClampedArray) or DataView\n        const buffer = value.buffer;\n        const typeName = value.constructor.name;\n        const handle = makeShareableCloneRecursive({\n          __init: () => {\n            'worklet';\n            if (!VALID_ARRAY_VIEWS_NAMES.includes(typeName)) {\n              throw new Error(\n                `[Reanimated] Invalid array view name \\`${typeName}\\`.`\n              );\n            }\n            const constructor = global[typeName as keyof typeof global];\n            if (constructor === undefined) {\n              throw new Error(\n                `[Reanimated] Constructor for \\`${typeName}\\` not found.`\n              );\n            }\n            return new constructor(buffer);\n          },\n        });\n        shareableMappingCache.set(value, handle);\n        return handle as ShareableRef<T>;\n      } else {\n        // This is reached for object types that are not of plain Object.prototype.\n        // We don't support such objects from being transferred as shareables to\n        // the UI runtime and hence we replace them with \"inaccessible object\"\n        // which is implemented as a Proxy object that throws on any attempt\n        // of accessing its fields. We argue that such objects can sometimes leak\n        // as attributes of objects being captured by worklets but should never\n        // be used on the UI runtime regardless. If they are being accessed, the user\n        // will get an appropriate error message.\n        const inaccessibleObject =\n          makeShareableCloneRecursive<T>(INACCESSIBLE_OBJECT);\n        shareableMappingCache.set(value, inaccessibleObject);\n        return inaccessibleObject;\n      }\n      if (__DEV__) {\n        // we freeze objects that are transformed to shareable. This should help\n        // detect issues when someone modifies data after it's been converted to\n        // shareable. Meaning that they may be doing a faulty assumption in their\n        // code expecting that the updates are going to automatically populate to\n        // the object sent to the UI thread. If the user really wants some objects\n        // to be mutable they should use shared values instead.\n        Object.freeze(value);\n      }\n      const adopted = NativeReanimatedModule.makeShareableClone(\n        toAdapt,\n        shouldPersistRemote\n      );\n      shareableMappingCache.set(value, adopted);\n      shareableMappingCache.set(adopted);\n      return adopted;\n    }\n  }\n  return NativeReanimatedModule.makeShareableClone(value, shouldPersistRemote);\n}\n\nconst WORKLET_CODE_THRESHOLD = 255;\n\nfunction getWorkletCode(value: __WorkletFunction) {\n  // @ts-ignore this is fine\n  const code = value?.__initData?.code;\n  if (!code) {\n    return 'unknown';\n  }\n  if (code.length > WORKLET_CODE_THRESHOLD) {\n    return `${code.substring(0, WORKLET_CODE_THRESHOLD)}...`;\n  }\n  return code;\n}\n\ntype RemoteFunction<T> = {\n  __remoteFunction: FlatShareableRef<T>;\n};\n\nfunction isRemoteFunction<T>(value: {\n  __remoteFunction?: unknown;\n}): value is RemoteFunction<T> {\n  'worklet';\n  return !!value.__remoteFunction;\n}\n\nexport function makeShareableCloneOnUIRecursive<T>(\n  value: T\n): FlatShareableRef<T> {\n  'worklet';\n  if (SHOULD_BE_USE_WEB) {\n    // @ts-ignore web is an interesting place where we don't run a secondary VM on the UI thread\n    // see more details in the comment where USE_STUB_IMPLEMENTATION is defined.\n    return value;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-shadow\n  function cloneRecursive(value: T): FlatShareableRef<T> {\n    if (\n      (typeof value === 'object' && value !== null) ||\n      typeof value === 'function'\n    ) {\n      if (isHostObject(value)) {\n        // We call `_makeShareableClone` to wrap the provided HostObject\n        // inside ShareableJSRef.\n        return _makeShareableClone(value) as FlatShareableRef<T>;\n      }\n      if (isRemoteFunction<T>(value)) {\n        // RemoteFunctions are created by us therefore they are\n        // a Shareable out of the box and there is no need to\n        // call `_makeShareableClone`.\n        return value.__remoteFunction;\n      }\n      if (Array.isArray(value)) {\n        return _makeShareableClone(\n          value.map(cloneRecursive)\n        ) as FlatShareableRef<T>;\n      }\n      const toAdapt: Record<string, FlatShareableRef<T>> = {};\n      for (const [key, element] of Object.entries(value)) {\n        toAdapt[key] = cloneRecursive(element);\n      }\n      return _makeShareableClone(toAdapt) as FlatShareableRef<T>;\n    }\n    return _makeShareableClone(value);\n  }\n  return cloneRecursive(value);\n}\n\nfunction makeShareableJS<T extends object>(value: T): T {\n  return value;\n}\n\nfunction makeShareableNative<T extends object>(value: T): T {\n  if (shareableMappingCache.get(value)) {\n    return value;\n  }\n  const handle = makeShareableCloneRecursive({\n    __init: () => {\n      'worklet';\n      return value;\n    },\n  });\n  shareableMappingCache.set(value, handle);\n  return value;\n}\n\n/**\n * This function creates a value on UI with persistent state - changes to it on the UI\n * thread will be seen by all worklets. Use it when you want to create a value\n * that is read and written only on the UI thread.\n */\nexport const makeShareable = SHOULD_BE_USE_WEB\n  ? makeShareableJS\n  : makeShareableNative;\n"],"mappings":"AAAA,YAAY;;AACZ,OAAOA,sBAAsB,MAAM,oBAAoB;AAMvD,SAASC,cAAc,QAAQ,mBAAmB;AAClD,SAASC,2BAA2B,QAAQ,UAAU;AACtD,SAASC,SAAS,QAAQ,+BAA+B;AACzD,SACEC,qBAAqB,EACrBC,oBAAoB,QACf,yBAAyB;;AAEhC;AACA;AACA;AACA;AACA,MAAMC,iBAAiB,GAAGL,cAAc,EAAE;AAE1C,MAAMM,SAAS,GAAG,sBAAsB;AAExC,SAASC,YAAYA,CAACC,KAA0B,EAAE;EAChD,SAAS;;EACT;EACA;EACA;EACA;EACA,OAAOF,SAAS,IAAIE,KAAK;AAC3B;AAEA,SAASC,eAAeA,CAACC,MAAc,EAAoB;EACzD,OAAOC,MAAM,CAACC,cAAc,CAACF,MAAM,CAAC,KAAKC,MAAM,CAACE,SAAS;AAC3D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAmB,GAAG;EAC1BC,MAAM,EAAEA,CAAA,KAAM;IACZ,SAAS;;IACT,OAAO,IAAIC,KAAK,CACd,CAAC,CAAC,EACF;MACEC,GAAG,EAAEA,CAACC,CAAU,EAAEC,IAAqB,KAAK;QAC1C,IACEA,IAAI,KAAK,0BAA0B,IACnCA,IAAI,KAAK,kBAAkB,EAC3B;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA,OAAO,KAAK;QACd;QACA,MAAM,IAAIC,KAAK,CACZ,4CAA2CC,MAAM,CAChDF,IAAI,CACJ,yDAAwD,CAC3D;MACH,CAAC;MACDG,GAAG,EAAEA,CAAA,KAAM;QACT,MAAM,IAAIF,KAAK,CACb,mFAAmF,CACpF;MACH;IACF,CAAC,CACF;EACH;AACF,CAAC;AAED,MAAMG,uBAAuB,GAAG,CAC9B,WAAW,EACX,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,UAAU,CACX;AAED,MAAMC,oCAAoC,GAAG,EAAE;AAC/C;AACA;AACA,IAAIC,+BAAwC;AAE5C,OAAO,SAASC,2BAA2BA,CACzClB,KAAU,EAGO;EAAA,IAFjBmB,mBAAmB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,KAAK;EAAA,IAC3BG,KAAK,GAAAH,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC;EAET,IAAIvB,iBAAiB,EAAE;IACrB,OAAOG,KAAK;EACd;EACA,IAAIuB,KAAK,IAAIP,oCAAoC,EAAE;IACjD;IACA;IACA;IACA;IACA;IACA,IAAIO,KAAK,KAAKP,oCAAoC,EAAE;MAClDC,+BAA+B,GAAGjB,KAAK;IACzC,CAAC,MAAM,IAAIA,KAAK,KAAKiB,+BAA+B,EAAE;MACpD,MAAM,IAAIL,KAAK,CACb,uFAAuF,CACxF;IACH;EACF,CAAC,MAAM;IACLK,+BAA+B,GAAGK,SAAS;EAC7C;EACA;EACA,MAAME,IAAI,GAAG,OAAOxB,KAAK;EACzB,MAAMyB,YAAY,GAAGD,IAAI,KAAK,QAAQ;EACtC,MAAME,cAAc,GAAGF,IAAI,KAAK,UAAU;EAC1C,IAAI,CAACC,YAAY,IAAIC,cAAc,KAAK1B,KAAK,KAAK,IAAI,EAAE;IACtD,MAAM2B,MAAM,GAAGhC,qBAAqB,CAACc,GAAG,CAACT,KAAK,CAAC;IAC/C,IAAI2B,MAAM,KAAK/B,oBAAoB,EAAE;MACnC,OAAOI,KAAK;IACd,CAAC,MAAM,IAAI2B,MAAM,KAAKL,SAAS,EAAE;MAC/B,OAAOK,MAAM;IACf,CAAC,MAAM;MACL,IAAIC,OAAY;MAChB,IAAIC,KAAK,CAACC,OAAO,CAAC9B,KAAK,CAAC,EAAE;QACxB4B,OAAO,GAAG5B,KAAK,CAAC+B,GAAG,CAAEC,OAAO,IAC1Bd,2BAA2B,CAACc,OAAO,EAAEb,mBAAmB,EAAEI,KAAK,GAAG,CAAC,CAAC,CACrE;MACH,CAAC,MAAM,IAAIG,cAAc,IAAI1B,KAAK,CAACiC,aAAa,KAAKX,SAAS,EAAE;QAC9D;QACAM,OAAO,GAAG5B,KAAK;MACjB,CAAC,MAAM,IAAID,YAAY,CAACC,KAAK,CAAC,EAAE;QAC9B;QACA;QACA;QACA4B,OAAO,GAAG5B,KAAK;MACjB,CAAC,MAAM,IAAIC,eAAe,CAACD,KAAK,CAAC,IAAI0B,cAAc,EAAE;QACnDE,OAAO,GAAG,CAAC,CAAC;QACZ,IAAI5B,KAAK,CAACiC,aAAa,KAAKX,SAAS,EAAE;UACrC;UACA,IAAIY,OAAO,EAAE;YACX,MAAMC,YAAY,GAAGnC,KAAK,CAACoC,UAAU,CAACC,OAAO;YAC7C,IAAIF,YAAY,KAAKb,SAAS,IAAIa,YAAY,KAAKzC,SAAS,EAAE;cAC5D,MAAM,IAAIkB,KAAK,CAAE,8FAA6FlB,SAAU,QAAOyC,YAAa;AAC1J;AACA,wBAAwBG,cAAc,CAACtC,KAAK,CAAE,IAAG,CAAC;YACtC;YACAP,2BAA2B,CACzBO,KAAK,CAACiC,aAAa,EACnBjC,KAAK,CAACuC,cAAc,CACrB;UACH;UACA,IAAIvC,KAAK,CAACuC,cAAc,EAAE;YACxB;YACA;YACA;YACA;YACA,OAAOvC,KAAK,CAACuC,cAAc;UAC7B;UACA;UACA;UACA;UACA;UACA;UACAX,OAAO,CAACQ,UAAU,GAAGlB,2BAA2B,CAC9ClB,KAAK,CAACoC,UAAU,EAChB,IAAI,EACJb,KAAK,GAAG,CAAC,CACV;QACH;QAEA,KAAK,MAAM,CAACiB,GAAG,EAAER,OAAO,CAAC,IAAI7B,MAAM,CAACsC,OAAO,CAACzC,KAAK,CAAC,EAAE;UAClD,IAAIwC,GAAG,KAAK,YAAY,IAAIZ,OAAO,CAACQ,UAAU,KAAKd,SAAS,EAAE;YAC5D;UACF;UACAM,OAAO,CAACY,GAAG,CAAC,GAAGtB,2BAA2B,CACxCc,OAAO,EACPb,mBAAmB,EACnBI,KAAK,GAAG,CAAC,CACV;QACH;MACF,CAAC,MAAM,IAAIvB,KAAK,YAAY0C,MAAM,EAAE;QAClC,MAAMC,OAAO,GAAG3C,KAAK,CAAC4C,MAAM;QAC5B,MAAMC,KAAK,GAAG7C,KAAK,CAAC6C,KAAK;QACzB,MAAMC,MAAM,GAAG5B,2BAA2B,CAAC;UACzCX,MAAM,EAAEA,CAAA,KAAM;YACZ,SAAS;;YACT,OAAO,IAAImC,MAAM,CAACC,OAAO,EAAEE,KAAK,CAAC;UACnC;QACF,CAAC,CAAC;QACFlD,qBAAqB,CAACmB,GAAG,CAACd,KAAK,EAAE8C,MAAM,CAAC;QACxC,OAAOA,MAAM;MACf,CAAC,MAAM,IAAI9C,KAAK,YAAY+C,WAAW,EAAE;QACvCnB,OAAO,GAAG5B,KAAK;MACjB,CAAC,MAAM,IAAI+C,WAAW,CAACC,MAAM,CAAChD,KAAK,CAAC,EAAE;QACpC;QACA,MAAMiD,MAAM,GAAGjD,KAAK,CAACiD,MAAM;QAC3B,MAAMC,QAAQ,GAAGlD,KAAK,CAACmD,WAAW,CAACC,IAAI;QACvC,MAAMN,MAAM,GAAG5B,2BAA2B,CAAC;UACzCX,MAAM,EAAEA,CAAA,KAAM;YACZ,SAAS;;YACT,IAAI,CAACQ,uBAAuB,CAACsC,QAAQ,CAACH,QAAQ,CAAC,EAAE;cAC/C,MAAM,IAAItC,KAAK,CACZ,0CAAyCsC,QAAS,KAAI,CACxD;YACH;YACA,MAAMC,WAAW,GAAGG,MAAM,CAACJ,QAAQ,CAAwB;YAC3D,IAAIC,WAAW,KAAK7B,SAAS,EAAE;cAC7B,MAAM,IAAIV,KAAK,CACZ,kCAAiCsC,QAAS,eAAc,CAC1D;YACH;YACA,OAAO,IAAIC,WAAW,CAACF,MAAM,CAAC;UAChC;QACF,CAAC,CAAC;QACFtD,qBAAqB,CAACmB,GAAG,CAACd,KAAK,EAAE8C,MAAM,CAAC;QACxC,OAAOA,MAAM;MACf,CAAC,MAAM;QACL;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,MAAMS,kBAAkB,GACtBrC,2BAA2B,CAAIZ,mBAAmB,CAAC;QACrDX,qBAAqB,CAACmB,GAAG,CAACd,KAAK,EAAEuD,kBAAkB,CAAC;QACpD,OAAOA,kBAAkB;MAC3B;MACA,IAAIrB,OAAO,EAAE;QACX;QACA;QACA;QACA;QACA;QACA;QACA/B,MAAM,CAACqD,MAAM,CAACxD,KAAK,CAAC;MACtB;MACA,MAAMyD,OAAO,GAAGlE,sBAAsB,CAACmE,kBAAkB,CACvD9B,OAAO,EACPT,mBAAmB,CACpB;MACDxB,qBAAqB,CAACmB,GAAG,CAACd,KAAK,EAAEyD,OAAO,CAAC;MACzC9D,qBAAqB,CAACmB,GAAG,CAAC2C,OAAO,CAAC;MAClC,OAAOA,OAAO;IAChB;EACF;EACA,OAAOlE,sBAAsB,CAACmE,kBAAkB,CAAC1D,KAAK,EAAEmB,mBAAmB,CAAC;AAC9E;AAEA,MAAMwC,sBAAsB,GAAG,GAAG;AAElC,SAASrB,cAAcA,CAACtC,KAAwB,EAAE;EAAA,IAAA4D,iBAAA;EAChD;EACA,MAAMC,IAAI,GAAG7D,KAAK,aAALA,KAAK,wBAAA4D,iBAAA,GAAL5D,KAAK,CAAEoC,UAAU,cAAAwB,iBAAA,uBAAjBA,iBAAA,CAAmBC,IAAI;EACpC,IAAI,CAACA,IAAI,EAAE;IACT,OAAO,SAAS;EAClB;EACA,IAAIA,IAAI,CAACxC,MAAM,GAAGsC,sBAAsB,EAAE;IACxC,OAAQ,GAAEE,IAAI,CAACC,SAAS,CAAC,CAAC,EAAEH,sBAAsB,CAAE,KAAI;EAC1D;EACA,OAAOE,IAAI;AACb;AAMA,SAASE,gBAAgBA,CAAI/D,KAE5B,EAA8B;EAC7B,SAAS;;EACT,OAAO,CAAC,CAACA,KAAK,CAACgE,gBAAgB;AACjC;AAEA,OAAO,SAASC,+BAA+BA,CAC7CjE,KAAQ,EACa;EACrB,SAAS;;EACT,IAAIH,iBAAiB,EAAE;IACrB;IACA;IACA,OAAOG,KAAK;EACd;EACA;EACA,SAASkE,cAAcA,CAAClE,KAAQ,EAAuB;IACrD,IACG,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,IAC5C,OAAOA,KAAK,KAAK,UAAU,EAC3B;MACA,IAAID,YAAY,CAACC,KAAK,CAAC,EAAE;QACvB;QACA;QACA,OAAOmE,mBAAmB,CAACnE,KAAK,CAAC;MACnC;MACA,IAAI+D,gBAAgB,CAAI/D,KAAK,CAAC,EAAE;QAC9B;QACA;QACA;QACA,OAAOA,KAAK,CAACgE,gBAAgB;MAC/B;MACA,IAAInC,KAAK,CAACC,OAAO,CAAC9B,KAAK,CAAC,EAAE;QACxB,OAAOmE,mBAAmB,CACxBnE,KAAK,CAAC+B,GAAG,CAACmC,cAAc,CAAC,CAC1B;MACH;MACA,MAAMtC,OAA4C,GAAG,CAAC,CAAC;MACvD,KAAK,MAAM,CAACY,GAAG,EAAER,OAAO,CAAC,IAAI7B,MAAM,CAACsC,OAAO,CAACzC,KAAK,CAAC,EAAE;QAClD4B,OAAO,CAACY,GAAG,CAAC,GAAG0B,cAAc,CAAClC,OAAO,CAAC;MACxC;MACA,OAAOmC,mBAAmB,CAACvC,OAAO,CAAC;IACrC;IACA,OAAOuC,mBAAmB,CAACnE,KAAK,CAAC;EACnC;EACA,OAAOkE,cAAc,CAAClE,KAAK,CAAC;AAC9B;AAEA,SAASoE,eAAeA,CAAmBpE,KAAQ,EAAK;EACtD,OAAOA,KAAK;AACd;AAEA,SAASqE,mBAAmBA,CAAmBrE,KAAQ,EAAK;EAC1D,IAAIL,qBAAqB,CAACc,GAAG,CAACT,KAAK,CAAC,EAAE;IACpC,OAAOA,KAAK;EACd;EACA,MAAM8C,MAAM,GAAG5B,2BAA2B,CAAC;IACzCX,MAAM,EAAEA,CAAA,KAAM;MACZ,SAAS;;MACT,OAAOP,KAAK;IACd;EACF,CAAC,CAAC;EACFL,qBAAqB,CAACmB,GAAG,CAACd,KAAK,EAAE8C,MAAM,CAAC;EACxC,OAAO9C,KAAK;AACd;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMsE,aAAa,GAAGzE,iBAAiB,GAC1CuE,eAAe,GACfC,mBAAmB"}