{"version":3,"file":"static/js/38.1c7e494a.chunk.js","mappings":"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","sources":["../node_modules/base64-js/index.js","../node_modules/compare-versions/index.js","../node_modules/@babel/runtime/helpers/esm/typeof.js","../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","../node_modules/@babel/runtime/helpers/esm/toPrimitive.js","../node_modules/@babel/runtime/helpers/esm/defineProperty.js","../node_modules/react-native-web/dist/exports/Platform/index.js","../node_modules/expo-modules-core/src/environment/browser.web.ts","../node_modules/expo-modules-core/src/Platform.ts","../node_modules/expo-modules-core/src/errors/CodedError.ts","../node_modules/expo-modules-core/src/sweet/setUpErrorManager.fx.ts","../node_modules/expo-modules-core/src/PermissionsInterface.ts","../node_modules/expo-crypto/src/Crypto.types.ts","../node_modules/expo-crypto/src/ExpoCrypto.web.ts","../node_modules/expo-crypto/src/Crypto.ts","../node_modules/expo-standard-web-crypto/src/getRandomValues.ts","../node_modules/expo-standard-web-crypto/src/index.ts"],"sourcesContent":["'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/* global define */\n(function (root, factory) {\n  /* istanbul ignore next */\n  if (typeof define === 'function' && define.amd) {\n    define([], factory);\n  } else if (typeof exports === 'object') {\n    module.exports = factory();\n  } else {\n    root.compareVersions = factory();\n  }\n}(this, function () {\n\n  var semver = /^v?(?:\\d+)(\\.(?:[x*]|\\d+)(\\.(?:[x*]|\\d+)(\\.(?:[x*]|\\d+))?(?:-[\\da-z\\-]+(?:\\.[\\da-z\\-]+)*)?(?:\\+[\\da-z\\-]+(?:\\.[\\da-z\\-]+)*)?)?)?$/i;\n\n  function indexOrEnd(str, q) {\n    return str.indexOf(q) === -1 ? str.length : str.indexOf(q);\n  }\n\n  function split(v) {\n    var c = v.replace(/^v/, '').replace(/\\+.*$/, '');\n    var patchIndex = indexOrEnd(c, '-');\n    var arr = c.substring(0, patchIndex).split('.');\n    arr.push(c.substring(patchIndex + 1));\n    return arr;\n  }\n\n  function tryParse(v) {\n    return isNaN(Number(v)) ? v : Number(v);\n  }\n\n  function validate(version) {\n    if (typeof version !== 'string') {\n      throw new TypeError('Invalid argument expected string');\n    }\n    if (!semver.test(version)) {\n      throw new Error('Invalid argument not valid semver (\\''+version+'\\' received)');\n    }\n  }\n\n  function compareVersions(v1, v2) {\n    [v1, v2].forEach(validate);\n\n    var s1 = split(v1);\n    var s2 = split(v2);\n\n    for (var i = 0; i < Math.max(s1.length - 1, s2.length - 1); i++) {\n      var n1 = parseInt(s1[i] || 0, 10);\n      var n2 = parseInt(s2[i] || 0, 10);\n\n      if (n1 > n2) return 1;\n      if (n2 > n1) return -1;\n    }\n\n    var sp1 = s1[s1.length - 1];\n    var sp2 = s2[s2.length - 1];\n\n    if (sp1 && sp2) {\n      var p1 = sp1.split('.').map(tryParse);\n      var p2 = sp2.split('.').map(tryParse);\n\n      for (i = 0; i < Math.max(p1.length, p2.length); i++) {\n        if (p1[i] === undefined || typeof p2[i] === 'string' && typeof p1[i] === 'number') return -1;\n        if (p2[i] === undefined || typeof p1[i] === 'string' && typeof p2[i] === 'number') return 1;\n\n        if (p1[i] > p2[i]) return 1;\n        if (p2[i] > p1[i]) return -1;\n      }\n    } else if (sp1 || sp2) {\n      return sp1 ? -1 : 1;\n    }\n\n    return 0;\n  };\n\n  var allowedOperators = [\n    '>',\n    '>=',\n    '=',\n    '<',\n    '<='\n  ];\n\n  var operatorResMap = {\n    '>': [1],\n    '>=': [0, 1],\n    '=': [0],\n    '<=': [-1, 0],\n    '<': [-1]\n  };\n\n  function validateOperator(op) {\n    if (typeof op !== 'string') {\n      throw new TypeError('Invalid operator type, expected string but got ' + typeof op);\n    }\n    if (allowedOperators.indexOf(op) === -1) {\n      throw new TypeError('Invalid operator, expected one of ' + allowedOperators.join('|'));\n    }\n  }\n\n  compareVersions.validate = function(version) {\n    return typeof version === 'string' && semver.test(version);\n  }\n\n  compareVersions.compare = function (v1, v2, operator) {\n    // Validate operator\n    validateOperator(operator);\n\n    // since result of compareVersions can only be -1 or 0 or 1\n    // a simple map can be used to replace switch\n    var res = compareVersions(v1, v2);\n    return operatorResMap[operator].indexOf(res) > -1;\n  }\n\n  return compareVersions;\n}));\n","export default function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nexport default function toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : String(i);\n}","import _typeof from \"./typeof.js\";\nexport default function toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}","import toPropertyKey from \"./toPropertyKey.js\";\nexport default function _defineProperty(obj, key, value) {\n  key = toPropertyKey(key);\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}","/**\n * Copyright (c) Nicolas Gallagher.\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nvar Platform = {\n  OS: 'web',\n  select: obj => 'web' in obj ? obj.web : obj.default,\n  get isTesting() {\n    if (process.env.NODE_ENV === 'test') {\n      return true;\n    }\n    return false;\n  }\n};\nexport default Platform;","declare global {\n  // Add IE-specific interface to Window\n  interface Window {\n    attachEvent(event: string, listener: EventListener): boolean;\n  }\n}\n\n// Used for delegating node actions when browser APIs aren't available\n// like in SSR websites.\nexport const isDOMAvailable = typeof window !== 'undefined' && !!window.document?.createElement;\nexport const canUseEventListeners =\n  isDOMAvailable && !!(window.addEventListener || window.attachEvent);\nexport const canUseViewport = isDOMAvailable && !!window.screen;\nexport const isAsyncDebugging = false;\n","import { Platform as ReactNativePlatform, PlatformOSType } from 'react-native';\n\nimport {\n  isDOMAvailable,\n  canUseEventListeners,\n  canUseViewport,\n  isAsyncDebugging,\n} from './environment/browser';\n\nexport type PlatformSelectOSType = PlatformOSType | 'native' | 'electron' | 'default';\n\nexport type PlatformSelect = <T>(specifics: { [platform in PlatformSelectOSType]?: T }) => T;\n\nconst Platform = {\n  /**\n   * Denotes the currently running platform.\n   * Can be one of ios, android, web.\n   */\n  OS: ReactNativePlatform.OS,\n  /**\n   * Returns the value with the matching platform.\n   * Object keys can be any of ios, android, native, web, default.\n   *\n   * @ios ios, native, default\n   * @android android, native, default\n   * @web web, default\n   */\n  select: ReactNativePlatform.select as PlatformSelect,\n  /**\n   * Denotes if the DOM API is available in the current environment.\n   * The DOM is not available in native React runtimes and Node.js.\n   */\n  isDOMAvailable,\n  /**\n   * Denotes if the current environment can attach event listeners\n   * to the window. This will return false in native React\n   * runtimes and Node.js.\n   */\n  canUseEventListeners,\n  /**\n   * Denotes if the current environment can inspect properties of the\n   * screen on which the current window is being rendered. This will\n   * return false in native React runtimes and Node.js.\n   */\n  canUseViewport,\n  /**\n   * If the JavaScript is being executed in a remote JavaScript environment.\n   * When `true`, synchronous native invocations cannot be executed.\n   */\n  isAsyncDebugging,\n};\n\nexport default Platform;\n","/**\n * A general error class that should be used for all errors in Expo modules.\n * Guarantees a `code` field that can be used to differentiate between different\n * types of errors without further subclassing Error.\n */\nexport class CodedError extends Error {\n  code: string;\n  info?: any;\n\n  constructor(code: string, message: string) {\n    super(message);\n    this.code = code;\n  }\n}\n","import { EventEmitter } from '../EventEmitter';\nimport Platform from '../Platform';\nimport { CodedError } from '../errors/CodedError';\nimport NativeErrorManager from './NativeErrorManager';\n\nif (__DEV__ && Platform.OS === 'android' && NativeErrorManager) {\n  const onNewException = 'ExpoModulesCoreErrorManager.onNewException';\n  const eventEmitter = new EventEmitter(NativeErrorManager);\n\n  eventEmitter.addListener(onNewException, ({ message }: { message: string }) => {\n    console.error(message);\n  });\n}\n\n// We have to export `CodedError` via global object to use in later in the C++ code.\nglobal.ExpoModulesCore_CodedError = CodedError;\n","export enum PermissionStatus {\n  /**\n   * User has granted the permission.\n   */\n  GRANTED = 'granted',\n  /**\n   * User hasn't granted or denied the permission yet.\n   */\n  UNDETERMINED = 'undetermined',\n  /**\n   * User has denied the permission.\n   */\n  DENIED = 'denied',\n}\n\n/**\n * Permission expiration time. Currently, all permissions are granted permanently.\n */\nexport type PermissionExpiration = 'never' | number;\n\n/**\n * An object obtained by permissions get and request functions.\n */\nexport interface PermissionResponse {\n  /**\n   * Determines the status of the permission.\n   */\n  status: PermissionStatus;\n  /**\n   * Determines time when the permission expires.\n   */\n  expires: PermissionExpiration;\n  /**\n   * A convenience boolean that indicates if the permission is granted.\n   */\n  granted: boolean;\n  /**\n   * Indicates if user can be asked again for specific permission.\n   * If not, one should be directed to the Settings app\n   * in order to enable/disable the permission.\n   */\n  canAskAgain: boolean;\n}\n","// @needsAudit\n/**\n * [`Cryptographic hash function`](https://developer.mozilla.org/en-US/docs/Glossary/Cryptographic_hash_function)\n */\nexport enum CryptoDigestAlgorithm {\n  /**\n   * `160` bits.\n   */\n  SHA1 = 'SHA-1',\n  /**\n   * `256` bits. Collision Resistant.\n   */\n  SHA256 = 'SHA-256',\n  /**\n   * `384` bits. Collision Resistant.\n   */\n  SHA384 = 'SHA-384',\n  /**\n   * `512` bits. Collision Resistant.\n   */\n  SHA512 = 'SHA-512',\n  /**\n   * `128` bits.\n   * @platform ios\n   */\n  MD2 = 'MD2',\n  /**\n   * `128` bits.\n   * @platform ios\n   */\n  MD4 = 'MD4',\n  /**\n   * `128` bits.\n   * @platform android\n   * @platform ios\n   */\n  MD5 = 'MD5',\n}\n\n// @needsAudit\nexport enum CryptoEncoding {\n  HEX = 'hex',\n  /**\n   * Has trailing padding. Does not wrap lines. Does not have a trailing newline.\n   */\n  BASE64 = 'base64',\n}\n\n// @needsAudit\nexport type CryptoDigestOptions = {\n  /**\n   * Format the digest is returned in.\n   */\n  encoding: CryptoEncoding;\n};\n\n// @docsMissing\nexport type Digest = string;\n","import { CodedError, TypedArray } from 'expo-modules-core';\n\nimport { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions } from './Crypto.types';\n\nconst getCrypto = (): Crypto => window.crypto ?? (window as any).msCrypto;\n\nexport default {\n  get name(): string {\n    return 'ExpoCrypto';\n  },\n  async digestStringAsync(\n    algorithm: CryptoDigestAlgorithm,\n    data: string,\n    options: CryptoDigestOptions\n  ): Promise<string> {\n    if (!crypto.subtle) {\n      throw new CodedError(\n        'ERR_CRYPTO_UNAVAILABLE',\n        'Access to the WebCrypto API is restricted to secure origins (https).'\n      );\n    }\n    const encoder = new TextEncoder();\n    const buffer = encoder.encode(data);\n    const hashedData = await crypto.subtle.digest(algorithm, buffer);\n    if (options.encoding === CryptoEncoding.HEX) {\n      return hexString(hashedData);\n    } else if (options.encoding === CryptoEncoding.BASE64) {\n      return btoa(String.fromCharCode(...new Uint8Array(hashedData)));\n    }\n    throw new CodedError('ERR_CRYPTO_DIGEST', 'Invalid encoding type provided.');\n  },\n  getRandomBytes(length: number): Uint8Array {\n    const array = new Uint8Array(length);\n    return getCrypto().getRandomValues(array);\n  },\n  async getRandomBytesAsync(length: number): Promise<Uint8Array> {\n    const array = new Uint8Array(length);\n    return getCrypto().getRandomValues(array);\n  },\n  getRandomValues(typedArray: TypedArray) {\n    return getCrypto().getRandomValues(typedArray);\n  },\n  randomUUID() {\n    return getCrypto().randomUUID();\n  },\n  digestAsync(algorithm: AlgorithmIdentifier, data: ArrayBuffer): Promise<ArrayBuffer> {\n    return getCrypto().subtle.digest(algorithm, data);\n  },\n};\n\nfunction hexString(buffer: ArrayBuffer): string {\n  const byteArray = new Uint8Array(buffer);\n\n  const hexCodes = [...byteArray].map((value) => {\n    const hexCode = value.toString(16);\n    const paddedHexCode = hexCode.padStart(2, '0');\n    return paddedHexCode;\n  });\n\n  return hexCodes.join('');\n}\n","import { toByteArray } from 'base64-js';\nimport { UnavailabilityError, UintBasedTypedArray, IntBasedTypedArray } from 'expo-modules-core';\n\nimport { CryptoDigestAlgorithm, CryptoEncoding, CryptoDigestOptions, Digest } from './Crypto.types';\nimport ExpoCrypto from './ExpoCrypto';\n\ndeclare const global: any;\n\nexport * from './Crypto.types';\n\nclass CryptoError extends TypeError {\n  code = 'ERR_CRYPTO';\n\n  constructor(message: string) {\n    super(`expo-crypto: ${message}`);\n  }\n}\n\n// @needsAudit\n/**\n * Generates completely random bytes using native implementations. The `byteCount` property\n * is a `number` indicating the number of bytes to generate in the form of a `Uint8Array`.\n * Falls back to `Math.random` during development to prevent issues with React Native Debugger.\n * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.\n * @return An array of random bytes with the same length as the `byteCount`.\n */\nexport function getRandomBytes(byteCount: number): Uint8Array {\n  assertByteCount(byteCount, 'getRandomBytes');\n  const validByteCount = Math.floor(byteCount);\n  if (__DEV__) {\n    if (!global.nativeCallSyncHook || global.__REMOTEDEV__) {\n      // remote javascript debugging is enabled\n      const array = new Uint8Array(validByteCount);\n      for (let i = 0; i < validByteCount; i++) {\n        array[i] = Math.floor(Math.random() * 256);\n      }\n      return array;\n    }\n  }\n  if (ExpoCrypto.getRandomBytes) {\n    return ExpoCrypto.getRandomBytes(validByteCount);\n  } else if (ExpoCrypto.getRandomBase64String) {\n    const base64 = ExpoCrypto.getRandomBase64String(validByteCount);\n    return toByteArray(base64);\n  } else {\n    throw new UnavailabilityError('expo-crypto', 'getRandomBytes');\n  }\n}\n\n// @needsAudit\n/**\n * Generates completely random bytes using native implementations. The `byteCount` property\n * is a `number` indicating the number of bytes to generate in the form of a `Uint8Array`.\n * @param byteCount - A number within the range from `0` to `1024`. Anything else will throw a `TypeError`.\n * @return A promise that fulfills with an array of random bytes with the same length as the `byteCount`.\n */\nexport async function getRandomBytesAsync(byteCount: number): Promise<Uint8Array> {\n  assertByteCount(byteCount, 'getRandomBytesAsync');\n  const validByteCount = Math.floor(byteCount);\n  if (ExpoCrypto.getRandomBytesAsync) {\n    return await ExpoCrypto.getRandomBytesAsync(validByteCount);\n  } else if (ExpoCrypto.getRandomBase64StringAsync) {\n    const base64 = await ExpoCrypto.getRandomBase64StringAsync(validByteCount);\n    return toByteArray(base64);\n  } else {\n    throw new UnavailabilityError('expo-crypto', 'getRandomBytesAsync');\n  }\n}\n\nfunction assertByteCount(value: any, methodName: string): void {\n  if (\n    typeof value !== 'number' ||\n    isNaN(value) ||\n    Math.floor(value) < 0 ||\n    Math.floor(value) > 1024\n  ) {\n    throw new TypeError(\n      `expo-crypto: ${methodName}(${value}) expected a valid number from range 0...1024`\n    );\n  }\n}\n\nfunction assertAlgorithm(algorithm: CryptoDigestAlgorithm): void {\n  if (!Object.values(CryptoDigestAlgorithm).includes(algorithm)) {\n    throw new CryptoError(\n      `Invalid algorithm provided. Expected one of: CryptoDigestAlgorithm.${Object.keys(\n        CryptoDigestAlgorithm\n      ).join(', AlgCryptoDigestAlgorithmorithm.')}`\n    );\n  }\n}\n\nfunction assertData(data: string): void {\n  if (typeof data !== 'string') {\n    throw new CryptoError(`Invalid data provided. Expected a string.`);\n  }\n}\n\nfunction assertEncoding(encoding: CryptoEncoding): void {\n  if (!Object.values(CryptoEncoding).includes(encoding)) {\n    throw new CryptoError(\n      `Invalid encoding provided. Expected one of: CryptoEncoding.${Object.keys(\n        CryptoEncoding\n      ).join(', CryptoEncoding.')}`\n    );\n  }\n}\n\n// @needsAudit\n/**\n * The `digestStringAsync()` method of `Crypto` generates a digest of the supplied `data` string with the provided digest `algorithm`.\n * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,\n * meaning that it's very difficult to generate multiple inputs that have equal digest values.\n * You can specify the returned string format as one of `CryptoEncoding`. By default, the resolved value will be formatted as a `HEX` string.\n * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.\n *\n * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.\n * @param data The value that will be used to generate a digest.\n * @param options Format of the digest string. Defaults to: `CryptoDigestOptions.HEX`.\n * @return Return a Promise which fulfills with a value representing the hashed input.\n *\n * @example\n * ```ts\n * const digest = await Crypto.digestStringAsync(\n *   Crypto.CryptoDigestAlgorithm.SHA512,\n *   '🥓 Easy to Digest! 💙'\n * );\n * ```\n */\nexport async function digestStringAsync(\n  algorithm: CryptoDigestAlgorithm,\n  data: string,\n  options: CryptoDigestOptions = { encoding: CryptoEncoding.HEX }\n): Promise<Digest> {\n  if (!ExpoCrypto.digestStringAsync) {\n    throw new UnavailabilityError('expo-crypto', 'digestStringAsync');\n  }\n\n  assertAlgorithm(algorithm);\n  assertData(data);\n  assertEncoding(options.encoding);\n\n  return await ExpoCrypto.digestStringAsync(algorithm, data, options);\n}\n\n/**\n * The `getRandomValues()` method of `Crypto` fills a provided `TypedArray` with cryptographically secure random values.\n *\n * @param typedArray An integer based [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) to fill with cryptographically secure random values. It modifies the input array in place.\n * @return The input array filled with cryptographically secure random values.\n *\n * @example\n * ```ts\n * const byteArray = new Uint8Array(16);\n * Crypto.getRandomValues(byteArray);\n * console.log('Your lucky bytes: ' + byteArray);\n * ```\n */\nexport function getRandomValues<T extends IntBasedTypedArray | UintBasedTypedArray>(\n  typedArray: T\n): T {\n  ExpoCrypto.getRandomValues(typedArray);\n  return typedArray;\n}\n\n/**\n * The `randomUUID()` method returns a unique identifier based on the V4 UUID spec (RFC4122).\n * It uses cryptographically secure random values to generate the UUID.\n *\n * @return A string containing a newly generated UUIDv4 identifier\n * @example\n * ```ts\n * const UUID = Crypto.randomUUID();\n * console.log('Your UUID: ' + UUID);\n * ```\n */\nexport function randomUUID(): string {\n  return ExpoCrypto.randomUUID();\n}\n\nconst digestLengths = {\n  [CryptoDigestAlgorithm.SHA1]: 20,\n  [CryptoDigestAlgorithm.SHA256]: 32,\n  [CryptoDigestAlgorithm.SHA384]: 48,\n  [CryptoDigestAlgorithm.SHA512]: 64,\n  [CryptoDigestAlgorithm.MD2]: 16,\n  [CryptoDigestAlgorithm.MD4]: 16,\n  [CryptoDigestAlgorithm.MD5]: 16,\n};\n\n/**\n * The `digest()` method of `Crypto` generates a digest of the supplied `TypedArray` of bytes `data` with the provided digest `algorithm`.\n * A digest is a short fixed-length value derived from some variable-length input. **Cryptographic digests** should exhibit _collision-resistance_,\n * meaning that it's very difficult to generate multiple inputs that have equal digest values.\n * On web, this method can only be called from a secure origin (HTTPS) otherwise, an error will be thrown.\n *\n * @param algorithm The cryptographic hash function to use to transform a block of data into a fixed-size output.\n * @param data The value that will be used to generate a digest.\n * @return A Promise which fulfills with an ArrayBuffer representing the hashed input.\n * @example\n * ```ts\n * const array = new Uint8Array([1, 2, 3, 4, 5]);\n * const digest = await Crypto.digest(Crypto.CryptoDigestAlgorithm.SHA512, array);\n * console.log('Your digest: ' + digest);\n * ```\n */\nexport function digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer> {\n  return new Promise((resolve, reject) => {\n    try {\n      if (typeof ExpoCrypto.digestAsync === 'function') {\n        resolve(ExpoCrypto.digestAsync(algorithm, data));\n      } else {\n        const output = new Uint8Array(digestLengths[algorithm]);\n        ExpoCrypto.digest(algorithm, output, data);\n        resolve(output.buffer);\n      }\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n","import { getRandomValues as expoCryptoGetRandomValues } from 'expo-crypto';\n\nconst MAX_RANDOM_BYTES = 65536;\n\ntype IntegerArray =\n  | Int8Array\n  | Uint8Array\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Uint32Array\n  | Uint8ClampedArray;\n\n/**\n * An implementation of Crypto.getRandomValues that uses expo-random's secure random generator if\n * available and falls back to Math.random (cryptographically insecure) when synchronous bridged\n * methods are unavailable.\n *\n * See https://www.w3.org/TR/WebCryptoAPI/#Crypto-method-getRandomValues\n */\nexport default function getRandomValues<TArray extends ArrayBufferView>(values: TArray): TArray {\n  if (arguments.length < 1) {\n    throw new TypeError(\n      `An ArrayBuffer view must be specified as the destination for the random values`\n    );\n  }\n\n  if (\n    !(values instanceof Int8Array) &&\n    !(values instanceof Uint8Array) &&\n    !(values instanceof Int16Array) &&\n    !(values instanceof Uint16Array) &&\n    !(values instanceof Int32Array) &&\n    !(values instanceof Uint32Array) &&\n    !(values instanceof Uint8ClampedArray)\n  ) {\n    throw new TypeError(`The provided ArrayBuffer view is not an integer-typed array`);\n  }\n\n  if (values.byteLength > MAX_RANDOM_BYTES) {\n    throw new QuotaExceededError(\n      `The ArrayBuffer view's byte length (${values.byteLength}) exceeds the number of bytes of entropy available via this API (${MAX_RANDOM_BYTES})`\n    );\n  }\n\n  try {\n    // NOTE: Consider implementing `fillRandomBytes` to populate the given TypedArray directly\n    expoCryptoGetRandomValues(values);\n  } catch {\n    // TODO: rethrow the error if it's not due to a lack of synchronous methods\n    console.warn(`Random.getRandomBytes is not supported; falling back to insecure Math.random`);\n    return getRandomValuesInsecure(values);\n  }\n\n  return values;\n}\n\nexport function getRandomValuesInsecure<TArray extends IntegerArray>(values: TArray): TArray {\n  // Write random bytes to the given TypedArray's underlying ArrayBuffer\n  const byteView = new Uint8Array(values.buffer, values.byteOffset, values.byteLength);\n  for (let i = 0; i < byteView.length; i++) {\n    // The range of Math.random() is [0, 1) and the ToUint8 abstract operation rounds down\n    byteView[i] = Math.random() * 256;\n  }\n  return values;\n}\n\nclass QuotaExceededError extends Error {\n  name = 'QuotaExceededError';\n  code = 22; // QUOTA_EXCEEDED_ERR\n}\n","/*global crypto*/\nimport getRandomValues from './getRandomValues';\n\nclass Crypto {\n  getRandomValues<TArray extends ArrayBufferView>(values: TArray): TArray {\n    return getRandomValues(values);\n  }\n}\n\nconst webCrypto = typeof crypto !== 'undefined' ? crypto : new Crypto();\n\nexport default webCrypto;\n\nexport function polyfillWebCrypto(): void {\n  if (typeof crypto === 'undefined') {\n    Object.defineProperty(window, 'crypto', {\n      configurable: true,\n      enumerable: true,\n      get: () => webCrypto,\n    });\n  }\n}\n"],"names":["lookup","revLookup","Arr","Uint8Array","Array","code","i","charCodeAt","getLens","b64","len","length","Error","validLen","indexOf","encodeChunk","uint8","start","end","tmp","num","output","push","join","define","semver","indexOrEnd","str","q","split","v","c","replace","patchIndex","arr","substring","tryParse","isNaN","Number","validate","version","TypeError","test","compareVersions","v1","v2","forEach","s1","s2","Math","max","n1","parseInt","n2","sp1","sp2","p1","map","p2","undefined","allowedOperators","operatorResMap","validateOperator","op","compare","operator","res","_typeof","o","Symbol","iterator","constructor","prototype","toPropertyKey","t","r","e","toPrimitive","call","String","obj","key","value","Object","defineProperty","enumerable","configurable","writable","OS","select","web","default","isTesting","isDOMAvailable","window","_window$document","document","createElement","canUseEventListeners","addEventListener","attachEvent","canUseViewport","screen","ReactNativePlatform","CodedError","message","super","_defineProperty","this","global","ExpoModulesCore_CodedError","PermissionStatus","CryptoDigestAlgorithm","CryptoEncoding","getCrypto","_window$crypto","crypto","msCrypto","name","digestStringAsync","algorithm","data","options","subtle","buffer","TextEncoder","encode","hashedData","digest","encoding","HEX","byteArray","toString","padStart","hexString","BASE64","btoa","fromCharCode","getRandomBytes","array","getRandomValues","getRandomBytesAsync","typedArray","randomUUID","digestAsync","SHA1","SHA256","SHA384","SHA512","MD2","MD4","MD5","values","arguments","Int8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Uint8ClampedArray","byteLength","QuotaExceededError","concat","ExpoCrypto","console","warn","byteView","byteOffset","random","getRandomValuesInsecure","webCrypto","polyfillWebCrypto","get"],"sourceRoot":""}