{"version":3,"file":"js/708.js","mappings":"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","sources":["webpack://nocodenodeweb/./node_modules/@paypal/react-paypal-js/dist/esm/react-paypal-js.js","webpack://nocodenodeweb/./node_modules/buffer/index.js"],"sourcesContent":["/*!\n * react-paypal-js v8.7.0 (2024-09-16T17:52:54.237Z)\n * Copyright 2020-present, PayPal, Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport React, { createContext, useContext, useRef, useState, useEffect, useReducer } from 'react';\n\n/**\n * Enum for the SDK script resolve status,\n *\n * @enum {string}\n */\nvar SCRIPT_LOADING_STATE;\n(function (SCRIPT_LOADING_STATE) {\n  SCRIPT_LOADING_STATE[\"INITIAL\"] = \"initial\";\n  SCRIPT_LOADING_STATE[\"PENDING\"] = \"pending\";\n  SCRIPT_LOADING_STATE[\"REJECTED\"] = \"rejected\";\n  SCRIPT_LOADING_STATE[\"RESOLVED\"] = \"resolved\";\n})(SCRIPT_LOADING_STATE || (SCRIPT_LOADING_STATE = {}));\n/**\n * Enum for the PayPalScriptProvider context dispatch actions\n *\n * @enum {string}\n */\nvar DISPATCH_ACTION;\n(function (DISPATCH_ACTION) {\n  DISPATCH_ACTION[\"LOADING_STATUS\"] = \"setLoadingStatus\";\n  DISPATCH_ACTION[\"RESET_OPTIONS\"] = \"resetOptions\";\n  DISPATCH_ACTION[\"SET_BRAINTREE_INSTANCE\"] = \"braintreeInstance\";\n})(DISPATCH_ACTION || (DISPATCH_ACTION = {}));\n/**\n * Enum for all the available hosted fields\n *\n * @enum {string}\n */\nvar PAYPAL_HOSTED_FIELDS_TYPES;\n(function (PAYPAL_HOSTED_FIELDS_TYPES) {\n  PAYPAL_HOSTED_FIELDS_TYPES[\"NUMBER\"] = \"number\";\n  PAYPAL_HOSTED_FIELDS_TYPES[\"CVV\"] = \"cvv\";\n  PAYPAL_HOSTED_FIELDS_TYPES[\"EXPIRATION_DATE\"] = \"expirationDate\";\n  PAYPAL_HOSTED_FIELDS_TYPES[\"EXPIRATION_MONTH\"] = \"expirationMonth\";\n  PAYPAL_HOSTED_FIELDS_TYPES[\"EXPIRATION_YEAR\"] = \"expirationYear\";\n  PAYPAL_HOSTED_FIELDS_TYPES[\"POSTAL_CODE\"] = \"postalCode\";\n})(PAYPAL_HOSTED_FIELDS_TYPES || (PAYPAL_HOSTED_FIELDS_TYPES = {}));\nvar __assign = function () {\n  __assign = Object.assign || function __assign(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n      s = arguments[i];\n      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n    }\n    return t;\n  };\n  return __assign.apply(this, arguments);\n};\nfunction __rest(s, e) {\n  var t = {};\n  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];\n  }\n  return t;\n}\nfunction __spreadArray(to, from, pack) {\n  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n    if (ar || !(i in from)) {\n      if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n      ar[i] = from[i];\n    }\n  }\n  return to.concat(ar || Array.prototype.slice.call(from));\n}\ntypeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\n  var e = new Error(message);\n  return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\n};\n\n/*********************************************\n * Common reference to the script identifier *\n *********************************************/\n// keep this script id value in kebab-case format\nvar SCRIPT_ID = \"data-react-paypal-script-id\";\nvar SDK_SETTINGS = {\n  DATA_CLIENT_TOKEN: \"dataClientToken\",\n  DATA_JS_SDK_LIBRARY: \"dataJsSdkLibrary\",\n  DATA_LIBRARY_VALUE: \"react-paypal-js\",\n  DATA_NAMESPACE: \"dataNamespace\",\n  DATA_SDK_INTEGRATION_SOURCE: \"dataSdkIntegrationSource\",\n  DATA_USER_ID_TOKEN: \"dataUserIdToken\"\n};\nvar LOAD_SCRIPT_ERROR = \"Failed to load the PayPal JS SDK script.\";\n/****************************\n * Braintree error messages *\n ****************************/\nvar EMPTY_BRAINTREE_AUTHORIZATION_ERROR_MESSAGE = \"Invalid authorization data. Use dataClientToken or dataUserIdToken to authorize.\";\nvar braintreeVersion = \"3.84.0\";\nvar BRAINTREE_SOURCE = \"https://js.braintreegateway.com/web/\".concat(braintreeVersion, \"/js/client.min.js\");\nvar BRAINTREE_PAYPAL_CHECKOUT_SOURCE = \"https://js.braintreegateway.com/web/\".concat(braintreeVersion, \"/js/paypal-checkout.min.js\");\n/*********************\n * PayPal namespaces *\n *********************/\nvar DEFAULT_PAYPAL_NAMESPACE = \"paypal\";\nvar DEFAULT_BRAINTREE_NAMESPACE = \"braintree\";\n/*****************\n * Hosted Fields *\n *****************/\nvar HOSTED_FIELDS_CHILDREN_ERROR = \"To use HostedFields you must use it with at least 3 children with types: [number, cvv, expirationDate] includes\";\nvar HOSTED_FIELDS_DUPLICATE_CHILDREN_ERROR = \"Cannot use duplicate HostedFields as children\";\n/*******************\n * Script Provider *\n *******************/\nvar SCRIPT_PROVIDER_REDUCER_ERROR = \"usePayPalScriptReducer must be used within a PayPalScriptProvider\";\nvar CARD_FIELDS_DUPLICATE_CHILDREN_ERROR = \"Cannot use duplicate CardFields as children\";\nvar CARD_FIELDS_CONTEXT_ERROR = \"Individual CardFields must be rendered inside the PayPalCardFieldsProvider\";\n\n/**\n * Get the namespace from the window in the browser\n * this is useful to get the paypal object from window\n * after load PayPal SDK script\n *\n * @param namespace the name space to return\n * @returns the namespace if exists or undefined otherwise\n */\nfunction getPayPalWindowNamespace$1(namespace) {\n  if (namespace === void 0) {\n    namespace = DEFAULT_PAYPAL_NAMESPACE;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return window[namespace];\n}\n/**\n * Get a namespace from the window in the browser\n * this is useful to get the braintree from window\n * after load Braintree script\n *\n * @param namespace the name space to return\n * @returns the namespace if exists or undefined otherwise\n */\nfunction getBraintreeWindowNamespace(namespace) {\n  if (namespace === void 0) {\n    namespace = DEFAULT_BRAINTREE_NAMESPACE;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return window[namespace];\n}\n/**\n * Creates a string hash code based on the string argument\n *\n * @param str the source input string to hash\n * @returns string hash code\n */\nfunction hashStr(str) {\n  var hash = \"\";\n  for (var i = 0; i < str.length; i++) {\n    var total = str[i].charCodeAt(0) * i;\n    if (str[i + 1]) {\n      total += str[i + 1].charCodeAt(0) * (i - 1);\n    }\n    hash += String.fromCharCode(97 + Math.abs(total) % 26);\n  }\n  return hash;\n}\nfunction generateErrorMessage(_a) {\n  var reactComponentName = _a.reactComponentName,\n    sdkComponentKey = _a.sdkComponentKey,\n    _b = _a.sdkRequestedComponents,\n    sdkRequestedComponents = _b === void 0 ? \"\" : _b,\n    _c = _a.sdkDataNamespace,\n    sdkDataNamespace = _c === void 0 ? DEFAULT_PAYPAL_NAMESPACE : _c;\n  var requiredOptionCapitalized = sdkComponentKey.charAt(0).toUpperCase().concat(sdkComponentKey.substring(1));\n  var errorMessage = \"Unable to render <\".concat(reactComponentName, \" /> because window.\").concat(sdkDataNamespace, \".\").concat(requiredOptionCapitalized, \" is undefined.\");\n  // The JS SDK only loads the buttons component by default.\n  // All other components like messages and marks must be requested using the \"components\" query parameter\n  var requestedComponents = typeof sdkRequestedComponents === \"string\" ? sdkRequestedComponents : sdkRequestedComponents.join(\",\");\n  if (!requestedComponents.includes(sdkComponentKey)) {\n    var expectedComponents = [requestedComponents, sdkComponentKey].filter(Boolean).join();\n    errorMessage += \"\\nTo fix the issue, add '\".concat(sdkComponentKey, \"' to the list of components passed to the parent PayPalScriptProvider:\") + \"\\n`<PayPalScriptProvider options={{ components: '\".concat(expectedComponents, \"'}}>`.\");\n  }\n  return errorMessage;\n}\n\n/**\n * Generate a new random identifier for react-paypal-js\n *\n * @returns the {@code string} containing the random library name\n */\nfunction getScriptID(options) {\n  // exclude the data-react-paypal-script-id value from the options hash\n  var _a = options,\n    _b = SCRIPT_ID;\n  _a[_b];\n  var paypalScriptOptions = __rest(_a, [_b + \"\"]);\n  return \"react-paypal-js-\".concat(hashStr(JSON.stringify(paypalScriptOptions)));\n}\n/**\n * Destroy the PayPal SDK from the document page\n *\n * @param reactPayPalScriptID the script identifier\n */\nfunction destroySDKScript(reactPayPalScriptID) {\n  var scriptNode = self.document.querySelector(\"script[\".concat(SCRIPT_ID, \"=\\\"\").concat(reactPayPalScriptID, \"\\\"]\"));\n  if (scriptNode === null || scriptNode === void 0 ? void 0 : scriptNode.parentNode) {\n    scriptNode.parentNode.removeChild(scriptNode);\n  }\n}\n/**\n * Reducer function to handle complex state changes on the context\n *\n * @param state  the current state on the context object\n * @param action the action to be executed on the previous state\n * @returns a the same state if the action wasn't found, or a new state otherwise\n */\nfunction scriptReducer(state, action) {\n  var _a, _b;\n  switch (action.type) {\n    case DISPATCH_ACTION.LOADING_STATUS:\n      if (typeof action.value === \"object\") {\n        return __assign(__assign({}, state), {\n          loadingStatus: action.value.state,\n          loadingStatusErrorMessage: action.value.message\n        });\n      }\n      return __assign(__assign({}, state), {\n        loadingStatus: action.value\n      });\n    case DISPATCH_ACTION.RESET_OPTIONS:\n      // destroy existing script to make sure only one script loads at a time\n      destroySDKScript(state.options[SCRIPT_ID]);\n      return __assign(__assign({}, state), {\n        loadingStatus: SCRIPT_LOADING_STATE.PENDING,\n        options: __assign(__assign((_a = {}, _a[SDK_SETTINGS.DATA_SDK_INTEGRATION_SOURCE] = SDK_SETTINGS.DATA_LIBRARY_VALUE, _a), action.value), (_b = {}, _b[SCRIPT_ID] = \"\".concat(getScriptID(action.value)), _b))\n      });\n    case DISPATCH_ACTION.SET_BRAINTREE_INSTANCE:\n      return __assign(__assign({}, state), {\n        braintreePayPalCheckoutInstance: action.value\n      });\n    default:\n      {\n        return state;\n      }\n  }\n}\n// Create the React context to use in the script provider component\nvar ScriptContext = createContext(null);\n\n/**\n * Check if the context is valid and ready to dispatch actions.\n *\n * @param scriptContext the result of connecting to the context provider\n * @returns strict context avoiding null values in the type\n */\nfunction validateReducer(scriptContext) {\n  if (typeof (scriptContext === null || scriptContext === void 0 ? void 0 : scriptContext.dispatch) === \"function\" && scriptContext.dispatch.length !== 0) {\n    return scriptContext;\n  }\n  throw new Error(SCRIPT_PROVIDER_REDUCER_ERROR);\n}\n/**\n * Check if the dataClientToken or the dataUserIdToken are\n * set in the options of the context.\n * @type dataClientToken is use to pass a client token\n * @type dataUserIdToken is use to pass a client tokenization key\n *\n * @param scriptContext the result of connecting to the context provider\n * @throws an {@link Error} if both dataClientToken and the dataUserIdToken keys are null or undefined\n * @returns strict context if one of the keys are defined\n */\nvar validateBraintreeAuthorizationData = function (scriptContext) {\n  var _a, _b;\n  if (!((_a = scriptContext === null || scriptContext === void 0 ? void 0 : scriptContext.options) === null || _a === void 0 ? void 0 : _a[SDK_SETTINGS.DATA_CLIENT_TOKEN]) && !((_b = scriptContext === null || scriptContext === void 0 ? void 0 : scriptContext.options) === null || _b === void 0 ? void 0 : _b[SDK_SETTINGS.DATA_USER_ID_TOKEN])) {\n    throw new Error(EMPTY_BRAINTREE_AUTHORIZATION_ERROR_MESSAGE);\n  }\n  return scriptContext;\n};\n\n/**\n * Custom hook to get access to the Script context and\n * dispatch actions to modify the state on the {@link ScriptProvider} component\n *\n * @returns a tuple containing the state of the context and\n * a dispatch function to modify the state\n */\nfunction usePayPalScriptReducer() {\n  var scriptContext = validateReducer(useContext(ScriptContext));\n  var derivedStatusContext = __assign(__assign({}, scriptContext), {\n    isInitial: scriptContext.loadingStatus === SCRIPT_LOADING_STATE.INITIAL,\n    isPending: scriptContext.loadingStatus === SCRIPT_LOADING_STATE.PENDING,\n    isResolved: scriptContext.loadingStatus === SCRIPT_LOADING_STATE.RESOLVED,\n    isRejected: scriptContext.loadingStatus === SCRIPT_LOADING_STATE.REJECTED\n  });\n  return [derivedStatusContext, scriptContext.dispatch];\n}\n/**\n * Custom hook to get access to the ScriptProvider context\n *\n * @returns the latest state of the context\n */\nfunction useScriptProviderContext() {\n  var scriptContext = validateBraintreeAuthorizationData(validateReducer(useContext(ScriptContext)));\n  return [scriptContext, scriptContext.dispatch];\n}\n\n// Create the React context to use in the PayPal hosted fields provider\nvar PayPalHostedFieldsContext = createContext({});\n\n/**\n * Custom hook to get access to the PayPal Hosted Fields instance.\n * The instance represent the returned object after the render process\n * With this object a user can submit the fields and dynamically modify the cards\n *\n * @returns the hosted fields instance if is available in the component\n */\nfunction usePayPalHostedFields() {\n  return useContext(PayPalHostedFieldsContext);\n}\n\n/**\nThis `<PayPalButtons />` component supports rendering [buttons](https://developer.paypal.com/docs/business/javascript-sdk/javascript-sdk-reference/#buttons) for PayPal, Venmo, and alternative payment methods.\nIt relies on the `<PayPalScriptProvider />` parent component for managing state related to loading the JS SDK script.\n*/\nvar PayPalButtons = function (_a) {\n  var _b;\n  var _c = _a.className,\n    className = _c === void 0 ? \"\" : _c,\n    _d = _a.disabled,\n    disabled = _d === void 0 ? false : _d,\n    children = _a.children,\n    _e = _a.forceReRender,\n    forceReRender = _e === void 0 ? [] : _e,\n    buttonProps = __rest(_a, [\"className\", \"disabled\", \"children\", \"forceReRender\"]);\n  var isDisabledStyle = disabled ? {\n    opacity: 0.38\n  } : {};\n  var classNames = \"\".concat(className, \" \").concat(disabled ? \"paypal-buttons-disabled\" : \"\").trim();\n  var buttonsContainerRef = useRef(null);\n  var buttons = useRef(null);\n  var _f = usePayPalScriptReducer()[0],\n    isResolved = _f.isResolved,\n    options = _f.options;\n  var _g = useState(null),\n    initActions = _g[0],\n    setInitActions = _g[1];\n  var _h = useState(true),\n    isEligible = _h[0],\n    setIsEligible = _h[1];\n  var _j = useState(null),\n    setErrorState = _j[1];\n  function closeButtonsComponent() {\n    if (buttons.current !== null) {\n      buttons.current.close().catch(function () {\n        // ignore errors when closing the component\n      });\n    }\n  }\n  if ((_b = buttons.current) === null || _b === void 0 ? void 0 : _b.updateProps) {\n    buttons.current.updateProps({\n      message: buttonProps.message\n    });\n  }\n  // useEffect hook for rendering the buttons\n  useEffect(function () {\n    // verify the sdk script has successfully loaded\n    if (isResolved === false) {\n      return closeButtonsComponent;\n    }\n    var paypalWindowNamespace = getPayPalWindowNamespace$1(options.dataNamespace);\n    // verify dependency on window object\n    if (paypalWindowNamespace === undefined || paypalWindowNamespace.Buttons === undefined) {\n      setErrorState(function () {\n        throw new Error(generateErrorMessage({\n          reactComponentName: PayPalButtons.displayName,\n          sdkComponentKey: \"buttons\",\n          sdkRequestedComponents: options.components,\n          sdkDataNamespace: options[SDK_SETTINGS.DATA_NAMESPACE]\n        }));\n      });\n      return closeButtonsComponent;\n    }\n    var decoratedOnInit = function (data, actions) {\n      setInitActions(actions);\n      if (typeof buttonProps.onInit === \"function\") {\n        buttonProps.onInit(data, actions);\n      }\n    };\n    try {\n      buttons.current = paypalWindowNamespace.Buttons(__assign(__assign({}, buttonProps), {\n        onInit: decoratedOnInit\n      }));\n    } catch (err) {\n      return setErrorState(function () {\n        throw new Error(\"Failed to render <PayPalButtons /> component. Failed to initialize:  \".concat(err));\n      });\n    }\n    // only render the button when eligible\n    if (buttons.current.isEligible() === false) {\n      setIsEligible(false);\n      return closeButtonsComponent;\n    }\n    if (!buttonsContainerRef.current) {\n      return closeButtonsComponent;\n    }\n    buttons.current.render(buttonsContainerRef.current).catch(function (err) {\n      // component failed to render, possibly because it was closed or destroyed.\n      if (buttonsContainerRef.current === null || buttonsContainerRef.current.children.length === 0) {\n        // paypal buttons container is no longer in the DOM, we can safely ignore the error\n        return;\n      }\n      // paypal buttons container is still in the DOM\n      setErrorState(function () {\n        throw new Error(\"Failed to render <PayPalButtons /> component. \".concat(err));\n      });\n    });\n    return closeButtonsComponent;\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, __spreadArray(__spreadArray([isResolved], forceReRender, true), [buttonProps.fundingSource], false));\n  // useEffect hook for managing disabled state\n  useEffect(function () {\n    if (initActions === null) {\n      return;\n    }\n    if (disabled === true) {\n      initActions.disable().catch(function () {\n        // ignore errors when disabling the component\n      });\n    } else {\n      initActions.enable().catch(function () {\n        // ignore errors when enabling the component\n      });\n    }\n  }, [disabled, initActions]);\n  return React.createElement(React.Fragment, null, isEligible ? React.createElement(\"div\", {\n    ref: buttonsContainerRef,\n    style: isDisabledStyle,\n    className: classNames\n  }) : children);\n};\nPayPalButtons.displayName = \"PayPalButtons\";\nfunction findScript(url, attributes) {\n  var currentScript = document.querySelector(\"script[src=\\\"\".concat(url, \"\\\"]\"));\n  if (currentScript === null) return null;\n  var nextScript = createScriptElement(url, attributes);\n  var currentScriptClone = currentScript.cloneNode();\n  delete currentScriptClone.dataset.uidAuto;\n  if (Object.keys(currentScriptClone.dataset).length !== Object.keys(nextScript.dataset).length) {\n    return null;\n  }\n  var isExactMatch = true;\n  Object.keys(currentScriptClone.dataset).forEach(function (key) {\n    if (currentScriptClone.dataset[key] !== nextScript.dataset[key]) {\n      isExactMatch = false;\n    }\n  });\n  return isExactMatch ? currentScript : null;\n}\nfunction insertScriptElement(_a) {\n  var url = _a.url,\n    attributes = _a.attributes,\n    onSuccess = _a.onSuccess,\n    onError = _a.onError;\n  var newScript = createScriptElement(url, attributes);\n  newScript.onerror = onError;\n  newScript.onload = onSuccess;\n  document.head.insertBefore(newScript, document.head.firstElementChild);\n}\nfunction processOptions(options) {\n  var environment = options.environment;\n  var sdkBaseUrl = environment === \"sandbox\" ? \"https://www.sandbox.paypal.com/sdk/js\" : \"https://www.paypal.com/sdk/js\";\n  delete options.environment;\n  if (options.sdkBaseUrl) {\n    sdkBaseUrl = options.sdkBaseUrl;\n    delete options.sdkBaseUrl;\n  }\n  var optionsWithStringIndex = options;\n  var _a = Object.keys(optionsWithStringIndex).filter(function (key) {\n      return typeof optionsWithStringIndex[key] !== \"undefined\" && optionsWithStringIndex[key] !== null && optionsWithStringIndex[key] !== \"\";\n    }).reduce(function (accumulator, key) {\n      var value = optionsWithStringIndex[key].toString();\n      key = camelCaseToKebabCase(key);\n      if (key.substring(0, 4) === \"data\" || key === \"crossorigin\") {\n        accumulator.attributes[key] = value;\n      } else {\n        accumulator.queryParams[key] = value;\n      }\n      return accumulator;\n    }, {\n      queryParams: {},\n      attributes: {}\n    }),\n    queryParams = _a.queryParams,\n    attributes = _a.attributes;\n  if (queryParams[\"merchant-id\"] && queryParams[\"merchant-id\"].indexOf(\",\") !== -1) {\n    attributes[\"data-merchant-id\"] = queryParams[\"merchant-id\"];\n    queryParams[\"merchant-id\"] = \"*\";\n  }\n  return {\n    url: \"\".concat(sdkBaseUrl, \"?\").concat(objectToQueryString(queryParams)),\n    attributes: attributes\n  };\n}\nfunction camelCaseToKebabCase(str) {\n  var replacer = function (match, indexOfMatch) {\n    return (indexOfMatch ? \"-\" : \"\") + match.toLowerCase();\n  };\n  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, replacer);\n}\nfunction objectToQueryString(params) {\n  var queryString = \"\";\n  Object.keys(params).forEach(function (key) {\n    if (queryString.length !== 0) queryString += \"&\";\n    queryString += key + \"=\" + params[key];\n  });\n  return queryString;\n}\nfunction createScriptElement(url, attributes) {\n  if (attributes === void 0) {\n    attributes = {};\n  }\n  var newScript = document.createElement(\"script\");\n  newScript.src = url;\n  Object.keys(attributes).forEach(function (key) {\n    newScript.setAttribute(key, attributes[key]);\n    if (key === \"data-csp-nonce\") {\n      newScript.setAttribute(\"nonce\", attributes[\"data-csp-nonce\"]);\n    }\n  });\n  return newScript;\n}\nfunction loadScript(options, PromisePonyfill) {\n  if (PromisePonyfill === void 0) {\n    PromisePonyfill = Promise;\n  }\n  validateArguments(options, PromisePonyfill);\n  if (typeof document === \"undefined\") return PromisePonyfill.resolve(null);\n  var _a = processOptions(options),\n    url = _a.url,\n    attributes = _a.attributes;\n  var namespace = attributes[\"data-namespace\"] || \"paypal\";\n  var existingWindowNamespace = getPayPalWindowNamespace(namespace);\n  if (!attributes[\"data-js-sdk-library\"]) {\n    attributes[\"data-js-sdk-library\"] = \"paypal-js\";\n  }\n  if (findScript(url, attributes) && existingWindowNamespace) {\n    return PromisePonyfill.resolve(existingWindowNamespace);\n  }\n  return loadCustomScript({\n    url: url,\n    attributes: attributes\n  }, PromisePonyfill).then(function () {\n    var newWindowNamespace = getPayPalWindowNamespace(namespace);\n    if (newWindowNamespace) {\n      return newWindowNamespace;\n    }\n    throw new Error(\"The window.\".concat(namespace, \" global variable is not available.\"));\n  });\n}\nfunction loadCustomScript(options, PromisePonyfill) {\n  if (PromisePonyfill === void 0) {\n    PromisePonyfill = Promise;\n  }\n  validateArguments(options, PromisePonyfill);\n  var url = options.url,\n    attributes = options.attributes;\n  if (typeof url !== \"string\" || url.length === 0) {\n    throw new Error(\"Invalid url.\");\n  }\n  if (typeof attributes !== \"undefined\" && typeof attributes !== \"object\") {\n    throw new Error(\"Expected attributes to be an object.\");\n  }\n  return new PromisePonyfill(function (resolve, reject) {\n    if (typeof document === \"undefined\") return resolve();\n    insertScriptElement({\n      url: url,\n      attributes: attributes,\n      onSuccess: function () {\n        return resolve();\n      },\n      onError: function () {\n        var defaultError = new Error(\"The script \\\"\".concat(url, \"\\\" failed to load. Check the HTTP status code and response body in DevTools to learn more.\"));\n        return reject(defaultError);\n      }\n    });\n  });\n}\nfunction getPayPalWindowNamespace(namespace) {\n  return window[namespace];\n}\nfunction validateArguments(options, PromisePonyfill) {\n  if (typeof options !== \"object\" || options === null) {\n    throw new Error(\"Expected an options object.\");\n  }\n  var environment = options.environment;\n  if (environment && environment !== \"production\" && environment !== \"sandbox\") {\n    throw new Error('The `environment` option must be either \"production\" or \"sandbox\".');\n  }\n  if (typeof PromisePonyfill !== \"undefined\" && typeof PromisePonyfill !== \"function\") {\n    throw new Error(\"Expected PromisePonyfill to be a function.\");\n  }\n}\n\n/**\n * Simple check to determine if the Braintree is a valid namespace.\n *\n * @param braintreeSource the source {@link BraintreeNamespace}\n * @returns a boolean representing if the namespace is valid.\n */\nvar isValidBraintreeNamespace = function (braintreeSource) {\n  var _a, _b;\n  if (typeof ((_a = braintreeSource === null || braintreeSource === void 0 ? void 0 : braintreeSource.client) === null || _a === void 0 ? void 0 : _a.create) !== \"function\" && typeof ((_b = braintreeSource === null || braintreeSource === void 0 ? void 0 : braintreeSource.paypalCheckout) === null || _b === void 0 ? void 0 : _b.create) !== \"function\") {\n    throw new Error(\"The braintreeNamespace property is not a valid BraintreeNamespace type.\");\n  }\n  return true;\n};\n/**\n * Use `actions.braintree` to provide an interface for the paypalCheckoutInstance\n * through the createOrder, createBillingAgreement and onApprove callbacks\n *\n * @param braintreeButtonProps the component button options\n * @returns a new copy of the component button options casted as {@link PayPalButtonsComponentProps}\n */\nvar decorateActions = function (buttonProps, payPalCheckoutInstance) {\n  var createOrderRef = buttonProps.createOrder;\n  var createBillingAgreementRef = buttonProps.createBillingAgreement;\n  var onApproveRef = buttonProps.onApprove;\n  if (typeof createOrderRef === \"function\") {\n    buttonProps.createOrder = function (data, actions) {\n      return createOrderRef(data, __assign(__assign({}, actions), {\n        braintree: payPalCheckoutInstance\n      }));\n    };\n  }\n  if (typeof createBillingAgreementRef === \"function\") {\n    buttonProps.createBillingAgreement = function (data, actions) {\n      return createBillingAgreementRef(data, __assign(__assign({}, actions), {\n        braintree: payPalCheckoutInstance\n      }));\n    };\n  }\n  if (typeof onApproveRef === \"function\") {\n    buttonProps.onApprove = function (data, actions) {\n      return onApproveRef(data, __assign(__assign({}, actions), {\n        braintree: payPalCheckoutInstance\n      }));\n    };\n  }\n  return __assign({}, buttonProps);\n};\n/**\n * Get the Braintree namespace from the component props.\n * If the prop `braintreeNamespace` is undefined will try to load it from the CDN.\n * This function allows users to set the braintree manually on the `BraintreePayPalButtons` component.\n *\n * Use case can be for example legacy sites using AMD/UMD modules,\n * trying to integrate the `BraintreePayPalButtons` component.\n * If we attempt to load the Braintree from the CDN won't define the braintree namespace.\n * This happens because the braintree script is an UMD module.\n * After detecting the AMD on the global scope will create an anonymous module using `define`\n * and the `BraintreePayPalButtons` won't be able to get access to the `window.braintree` namespace\n * from the global context.\n *\n * @param braintreeSource the source {@link BraintreeNamespace}\n * @returns the {@link BraintreeNamespace}\n */\nvar getBraintreeNamespace = function (braintreeSource) {\n  if (braintreeSource && isValidBraintreeNamespace(braintreeSource)) {\n    return Promise.resolve(braintreeSource);\n  }\n  return Promise.all([loadCustomScript({\n    url: BRAINTREE_SOURCE\n  }), loadCustomScript({\n    url: BRAINTREE_PAYPAL_CHECKOUT_SOURCE\n  })]).then(function () {\n    return getBraintreeWindowNamespace();\n  });\n};\n\n/**\nThis `<BraintreePayPalButtons />` component renders the [Braintree PayPal Buttons](https://developer.paypal.com/braintree/docs/guides/paypal/overview) for Braintree Merchants.\nIt relies on the `<PayPalScriptProvider />` parent component for managing state related to loading the JS SDK script.\n\nNote: You are able to make your integration using the client token or using the tokenization key.\n\n- To use the client token integration set the key `dataClientToken` in the `PayPayScriptProvider` component's options.\n- To use the tokenization key integration set the key `dataUserIdToken` in the `PayPayScriptProvider` component's options.\n*/\nvar BraintreePayPalButtons = function (_a) {\n  var _b = _a.className,\n    className = _b === void 0 ? \"\" : _b,\n    _c = _a.disabled,\n    disabled = _c === void 0 ? false : _c,\n    children = _a.children,\n    _d = _a.forceReRender,\n    forceReRender = _d === void 0 ? [] : _d,\n    braintreeNamespace = _a.braintreeNamespace,\n    merchantAccountId = _a.merchantAccountId,\n    buttonProps = __rest(_a, [\"className\", \"disabled\", \"children\", \"forceReRender\", \"braintreeNamespace\", \"merchantAccountId\"]);\n  var _e = useState(null),\n    setErrorState = _e[1];\n  var _f = useScriptProviderContext(),\n    providerContext = _f[0],\n    dispatch = _f[1];\n  useEffect(function () {\n    getBraintreeNamespace(braintreeNamespace).then(function (braintree) {\n      var clientTokenizationKey = providerContext.options[SDK_SETTINGS.DATA_USER_ID_TOKEN];\n      var clientToken = providerContext.options[SDK_SETTINGS.DATA_CLIENT_TOKEN];\n      return braintree.client.create({\n        authorization: clientTokenizationKey || clientToken\n      }).then(function (clientInstance) {\n        var merchantProp = merchantAccountId ? {\n          merchantAccountId: merchantAccountId\n        } : {};\n        return braintree.paypalCheckout.create(__assign(__assign({}, merchantProp), {\n          client: clientInstance\n        }));\n      }).then(function (paypalCheckoutInstance) {\n        dispatch({\n          type: DISPATCH_ACTION.SET_BRAINTREE_INSTANCE,\n          value: paypalCheckoutInstance\n        });\n      });\n    }).catch(function (err) {\n      setErrorState(function () {\n        throw new Error(\"\".concat(LOAD_SCRIPT_ERROR, \" \").concat(err));\n      });\n    });\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [providerContext.options]);\n  return React.createElement(React.Fragment, null, providerContext.braintreePayPalCheckoutInstance && React.createElement(PayPalButtons, __assign({\n    className: className,\n    disabled: disabled,\n    forceReRender: forceReRender\n  }, decorateActions(buttonProps, providerContext.braintreePayPalCheckoutInstance)), children));\n};\n\n/**\nThe `<PayPalMarks />` component is used for conditionally rendering different payment options using radio buttons.\nThe [Display PayPal Buttons with other Payment Methods guide](https://developer.paypal.com/docs/business/checkout/add-capabilities/buyer-experience/#display-paypal-buttons-with-other-payment-methods) describes this style of integration in detail.\nIt relies on the `<PayPalScriptProvider />` parent component for managing state related to loading the JS SDK script.\n\nThis component can also be configured to use a single funding source similar to the [standalone buttons](https://developer.paypal.com/docs/business/checkout/configure-payments/standalone-buttons/) approach.\nA `FUNDING` object is exported by this library which has a key for every available funding source option.\n*/\nvar PayPalMarks = function (_a) {\n  var _b = _a.className,\n    className = _b === void 0 ? \"\" : _b,\n    children = _a.children,\n    markProps = __rest(_a, [\"className\", \"children\"]);\n  var _c = usePayPalScriptReducer()[0],\n    isResolved = _c.isResolved,\n    options = _c.options;\n  var markContainerRef = useRef(null);\n  var _d = useState(true),\n    isEligible = _d[0],\n    setIsEligible = _d[1];\n  var _e = useState(null),\n    setErrorState = _e[1];\n  /**\n   * Render PayPal Mark into the DOM\n   */\n  var renderPayPalMark = function (mark) {\n    var current = markContainerRef.current;\n    // only render the mark when eligible\n    if (!current || !mark.isEligible()) {\n      return setIsEligible(false);\n    }\n    // Remove any children before render it again\n    if (current.firstChild) {\n      current.removeChild(current.firstChild);\n    }\n    mark.render(current).catch(function (err) {\n      // component failed to render, possibly because it was closed or destroyed.\n      if (current === null || current.children.length === 0) {\n        // paypal marks container is no longer in the DOM, we can safely ignore the error\n        return;\n      }\n      // paypal marks container is still in the DOM\n      setErrorState(function () {\n        throw new Error(\"Failed to render <PayPalMarks /> component. \".concat(err));\n      });\n    });\n  };\n  useEffect(function () {\n    // verify the sdk script has successfully loaded\n    if (isResolved === false) {\n      return;\n    }\n    var paypalWindowNamespace = getPayPalWindowNamespace$1(options[SDK_SETTINGS.DATA_NAMESPACE]);\n    // verify dependency on window object\n    if (paypalWindowNamespace === undefined || paypalWindowNamespace.Marks === undefined) {\n      return setErrorState(function () {\n        throw new Error(generateErrorMessage({\n          reactComponentName: PayPalMarks.displayName,\n          sdkComponentKey: \"marks\",\n          sdkRequestedComponents: options.components,\n          sdkDataNamespace: options[SDK_SETTINGS.DATA_NAMESPACE]\n        }));\n      });\n    }\n    renderPayPalMark(paypalWindowNamespace.Marks(__assign({}, markProps)));\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [isResolved, markProps.fundingSource]);\n  return React.createElement(React.Fragment, null, isEligible ? React.createElement(\"div\", {\n    ref: markContainerRef,\n    className: className\n  }) : children);\n};\nPayPalMarks.displayName = \"PayPalMarks\";\n\n/**\nThis `<PayPalMessages />` messages component renders a credit messaging on upstream merchant sites.\nIt relies on the `<PayPalScriptProvider />` parent component for managing state related to loading the JS SDK script.\n*/\nvar PayPalMessages = function (_a) {\n  var _b = _a.className,\n    className = _b === void 0 ? \"\" : _b,\n    _c = _a.forceReRender,\n    forceReRender = _c === void 0 ? [] : _c,\n    messageProps = __rest(_a, [\"className\", \"forceReRender\"]);\n  var _d = usePayPalScriptReducer()[0],\n    isResolved = _d.isResolved,\n    options = _d.options;\n  var messagesContainerRef = useRef(null);\n  var messages = useRef(null);\n  var _e = useState(null),\n    setErrorState = _e[1];\n  useEffect(function () {\n    // verify the sdk script has successfully loaded\n    if (isResolved === false) {\n      return;\n    }\n    var paypalWindowNamespace = getPayPalWindowNamespace$1(options[SDK_SETTINGS.DATA_NAMESPACE]);\n    // verify dependency on window object\n    if (paypalWindowNamespace === undefined || paypalWindowNamespace.Messages === undefined) {\n      return setErrorState(function () {\n        throw new Error(generateErrorMessage({\n          reactComponentName: PayPalMessages.displayName,\n          sdkComponentKey: \"messages\",\n          sdkRequestedComponents: options.components,\n          sdkDataNamespace: options[SDK_SETTINGS.DATA_NAMESPACE]\n        }));\n      });\n    }\n    messages.current = paypalWindowNamespace.Messages(__assign({}, messageProps));\n    messages.current.render(messagesContainerRef.current).catch(function (err) {\n      // component failed to render, possibly because it was closed or destroyed.\n      if (messagesContainerRef.current === null || messagesContainerRef.current.children.length === 0) {\n        // paypal messages container is no longer in the DOM, we can safely ignore the error\n        return;\n      }\n      // paypal messages container is still in the DOM\n      setErrorState(function () {\n        throw new Error(\"Failed to render <PayPalMessages /> component. \".concat(err));\n      });\n    });\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, __spreadArray([isResolved], forceReRender, true));\n  return React.createElement(\"div\", {\n    ref: messagesContainerRef,\n    className: className\n  });\n};\nPayPalMessages.displayName = \"PayPalMessages\";\n\n/**\nThis `<PayPalScriptProvider />` component takes care of loading the JS SDK `<script>`.\nIt manages state for script loading so children components like `<PayPalButtons />` know when it's safe to use the `window.paypal` global namespace.\n\nNote: You always should use this component as a wrapper for  `PayPalButtons`, `PayPalMarks`, `PayPalMessages` and `BraintreePayPalButtons` components.\n */\nvar PayPalScriptProvider = function (_a) {\n  var _b;\n  var _c = _a.options,\n    options = _c === void 0 ? {\n      clientId: \"test\"\n    } : _c,\n    children = _a.children,\n    _d = _a.deferLoading,\n    deferLoading = _d === void 0 ? false : _d;\n  var _e = useReducer(scriptReducer, {\n      options: __assign(__assign({}, options), (_b = {}, _b[SDK_SETTINGS.DATA_JS_SDK_LIBRARY] = SDK_SETTINGS.DATA_LIBRARY_VALUE, _b[SDK_SETTINGS.DATA_SDK_INTEGRATION_SOURCE] = SDK_SETTINGS.DATA_LIBRARY_VALUE, _b[SCRIPT_ID] = \"\".concat(getScriptID(options)), _b)),\n      loadingStatus: deferLoading ? SCRIPT_LOADING_STATE.INITIAL : SCRIPT_LOADING_STATE.PENDING\n    }),\n    state = _e[0],\n    dispatch = _e[1];\n  useEffect(function () {\n    if (deferLoading === false && state.loadingStatus === SCRIPT_LOADING_STATE.INITIAL) {\n      return dispatch({\n        type: DISPATCH_ACTION.LOADING_STATUS,\n        value: SCRIPT_LOADING_STATE.PENDING\n      });\n    }\n    if (state.loadingStatus !== SCRIPT_LOADING_STATE.PENDING) {\n      return;\n    }\n    var isSubscribed = true;\n    loadScript(state.options).then(function () {\n      if (isSubscribed) {\n        dispatch({\n          type: DISPATCH_ACTION.LOADING_STATUS,\n          value: SCRIPT_LOADING_STATE.RESOLVED\n        });\n      }\n    }).catch(function (err) {\n      console.error(\"\".concat(LOAD_SCRIPT_ERROR, \" \").concat(err));\n      if (isSubscribed) {\n        dispatch({\n          type: DISPATCH_ACTION.LOADING_STATUS,\n          value: {\n            state: SCRIPT_LOADING_STATE.REJECTED,\n            message: String(err)\n          }\n        });\n      }\n    });\n    return function () {\n      isSubscribed = false;\n    };\n  }, [state.options, deferLoading, state.loadingStatus]);\n  return React.createElement(ScriptContext.Provider, {\n    value: __assign(__assign({}, state), {\n      dispatch: dispatch\n    })\n  }, children);\n};\n\n/**\n * Custom hook to store registered hosted fields children\n * Each `PayPalHostedField` component should be registered on the parent provider\n *\n * @param initialValue the initially registered components\n * @returns at first, an {@link Object} containing the registered hosted fields,\n * and at the second a function handler to register the hosted fields components\n */\nvar useHostedFieldsRegister = function (initialValue) {\n  if (initialValue === void 0) {\n    initialValue = {};\n  }\n  var registeredFields = useRef(initialValue);\n  var registerHostedField = function (component) {\n    registeredFields.current = __assign(__assign({}, registeredFields.current), component);\n  };\n  return [registeredFields, registerHostedField];\n};\n\n/**\n * Throw an exception if the HostedFields is not found in the paypal namespace\n * Probably cause for this problem is not sending the hosted-fields string\n * as part of the components props in options\n * {@code <PayPalScriptProvider options={{ components: 'hosted-fields'}}>}\n *\n * @param param0 and object containing the components and namespace defined in options\n * @throws {@code Error}\n *\n */\nvar generateMissingHostedFieldsError = function (_a) {\n  var _b = _a.components,\n    components = _b === void 0 ? \"\" : _b,\n    _c = SDK_SETTINGS.DATA_NAMESPACE,\n    _d = _a[_c],\n    dataNamespace = _d === void 0 ? DEFAULT_PAYPAL_NAMESPACE : _d;\n  var expectedComponents = components ? \"\".concat(components, \",hosted-fields\") : \"hosted-fields\";\n  var errorMessage = \"Unable to render <PayPalHostedFieldsProvider /> because window.\".concat(dataNamespace, \".HostedFields is undefined.\");\n  if (!components.includes(\"hosted-fields\")) {\n    errorMessage += \"\\nTo fix the issue, add 'hosted-fields' to the list of components passed to the parent PayPalScriptProvider: <PayPalScriptProvider options={{ components: '\".concat(expectedComponents, \"'}}>\");\n  }\n  return errorMessage;\n};\n/**\n * Validate the expiration date component. Valid combinations are:\n * 1- Only the `expirationDate` field exists.\n * 2- Only the `expirationMonth` and `expirationYear` fields exist. Cannot be used with the `expirationDate` field.\n *\n * @param registerTypes\n * @returns @type {true} when the children are valid\n */\nvar validateExpirationDate = function (registerTypes) {\n  return !registerTypes.includes(PAYPAL_HOSTED_FIELDS_TYPES.EXPIRATION_DATE) && !registerTypes.includes(PAYPAL_HOSTED_FIELDS_TYPES.EXPIRATION_MONTH) && !registerTypes.includes(PAYPAL_HOSTED_FIELDS_TYPES.EXPIRATION_YEAR);\n};\n/**\n * Check if we find the [number, expiration, cvv] in children\n *\n * @param requiredChildren the list with required children [number, expiration, cvv]\n * @param registerTypes    the list of all the children types pass to the parent\n * @throw an @type {Error} when not find the default children\n */\nvar hasDefaultChildren = function (registerTypes) {\n  if (!registerTypes.includes(PAYPAL_HOSTED_FIELDS_TYPES.NUMBER) || !registerTypes.includes(PAYPAL_HOSTED_FIELDS_TYPES.CVV) || validateExpirationDate(registerTypes)) {\n    throw new Error(HOSTED_FIELDS_CHILDREN_ERROR);\n  }\n};\n/**\n * Check if we don't have duplicate children types\n *\n * @param registerTypes the list of all the children types pass to the parent\n * @throw an @type {Error} when duplicate types was found\n */\nvar noDuplicateChildren = function (registerTypes) {\n  if (registerTypes.length !== new Set(registerTypes).size) {\n    throw new Error(HOSTED_FIELDS_DUPLICATE_CHILDREN_ERROR);\n  }\n};\n/**\n * Validate the hosted field children in the PayPalHostedFieldsProvider component.\n * These are the rules:\n * 1- We need to find 3 default children for number, expiration, cvv\n * 2- No duplicate children are allowed\n * 3- No invalid combinations of `expirationDate`, `expirationMonth`, and `expirationYear`\n *\n * @param childrenList     the list of children\n * @param requiredChildren the list with required children [number, expiration, cvv]\n */\nvar validateHostedFieldChildren = function (registeredFields) {\n  hasDefaultChildren(registeredFields);\n  noDuplicateChildren(registeredFields);\n};\n\n/**\nThis `<PayPalHostedFieldsProvider />` provider component wraps the form field elements and accepts props like `createOrder()`.\n\nThis provider component is designed to be used with the `<PayPalHostedField />` component.\n\nWarning: If you don't see anything in the screen probably your client is ineligible.\nTo handle this problem make sure to use the prop `notEligibleError` and pass a component with a custom message.\nTake a look to this link if that is the case: https://developer.paypal.com/docs/checkout/advanced/integrate/\n*/\nvar PayPalHostedFieldsProvider = function (_a) {\n  var styles = _a.styles,\n    createOrder = _a.createOrder,\n    notEligibleError = _a.notEligibleError,\n    children = _a.children,\n    installments = _a.installments;\n  var _b = useScriptProviderContext()[0],\n    options = _b.options,\n    loadingStatus = _b.loadingStatus;\n  var _c = useState(true),\n    isEligible = _c[0],\n    setIsEligible = _c[1];\n  var _d = useState(),\n    cardFields = _d[0],\n    setCardFields = _d[1];\n  var _e = useState(null),\n    setErrorState = _e[1];\n  var hostedFieldsContainerRef = useRef(null);\n  var hostedFields = useRef();\n  var _f = useHostedFieldsRegister(),\n    registeredFields = _f[0],\n    registerHostedField = _f[1];\n  useEffect(function () {\n    var _a;\n    validateHostedFieldChildren(Object.keys(registeredFields.current));\n    // Only render the hosted fields when script is loaded and hostedFields is eligible\n    if (!(loadingStatus === SCRIPT_LOADING_STATE.RESOLVED)) {\n      return;\n    }\n    // Get the hosted fields from the [window.paypal.HostedFields] SDK\n    hostedFields.current = getPayPalWindowNamespace$1(options[SDK_SETTINGS.DATA_NAMESPACE]).HostedFields;\n    if (!hostedFields.current) {\n      throw new Error(generateMissingHostedFieldsError((_a = {\n        components: options.components\n      }, _a[SDK_SETTINGS.DATA_NAMESPACE] = options[SDK_SETTINGS.DATA_NAMESPACE], _a)));\n    }\n    if (!hostedFields.current.isEligible()) {\n      return setIsEligible(false);\n    }\n    // Clean all the fields before the rerender\n    if (cardFields) {\n      cardFields.teardown();\n    }\n    hostedFields.current.render({\n      // Call your server to set up the transaction\n      createOrder: createOrder,\n      fields: registeredFields.current,\n      installments: installments,\n      styles: styles\n    }).then(function (cardFieldsInstance) {\n      if (hostedFieldsContainerRef.current) {\n        setCardFields(cardFieldsInstance);\n      }\n    }).catch(function (err) {\n      setErrorState(function () {\n        throw new Error(\"Failed to render <PayPalHostedFieldsProvider /> component. \".concat(err));\n      });\n    });\n  }, [loadingStatus, styles]); // eslint-disable-line react-hooks/exhaustive-deps\n  return React.createElement(\"div\", {\n    ref: hostedFieldsContainerRef\n  }, isEligible ? React.createElement(PayPalHostedFieldsContext.Provider, {\n    value: {\n      cardFields: cardFields,\n      registerHostedField: registerHostedField\n    }\n  }, children) : notEligibleError);\n};\n\n/**\nThis `<PayPalHostedField />` component renders individual fields for [Hosted Fields](https://developer.paypal.com/docs/business/checkout/advanced-card-payments/integrate#3-add-javascript-sdk-and-card-form) integrations.\nIt relies on the `<PayPalHostedFieldsProvider />` parent component for managing state related to loading the JS SDK script\nand execute some validations before the rendering the fields.\n\nTo use the PayPal hosted fields you need to define at least three fields:\n\n- A card number field\n- The CVV code from the client card\n- The expiration date\n\nYou can define the expiration date as a single field similar to the example below,\nor you are able to define it in [two separate fields](https://paypal.github.io/react-paypal-js//?path=/docs/paypal-paypalhostedfields--expiration-date). One for the month and second for year.\n\nNote: Take care when using multiple instances of the PayPal Hosted Fields on the same page.\nThe component will fail to render when any of the selectors return more than one element.\n*/\nvar PayPalHostedField = function (_a) {\n  var hostedFieldType = _a.hostedFieldType,\n    // eslint-disable-line @typescript-eslint/no-unused-vars\n    options = _a.options,\n    // eslint-disable-line @typescript-eslint/no-unused-vars\n    props = __rest(_a, [\"hostedFieldType\", \"options\"]);\n  var hostedFieldContext = useContext(PayPalHostedFieldsContext);\n  useEffect(function () {\n    var _a;\n    if (!(hostedFieldContext === null || hostedFieldContext === void 0 ? void 0 : hostedFieldContext.registerHostedField)) {\n      throw new Error(\"The HostedField cannot be register in the PayPalHostedFieldsProvider parent component\");\n    }\n    // Register in the parent provider\n    hostedFieldContext.registerHostedField((_a = {}, _a[hostedFieldType] = {\n      selector: options.selector,\n      placeholder: options.placeholder,\n      type: options.type,\n      formatInput: options.formatInput,\n      maskInput: options.maskInput,\n      select: options.select,\n      maxlength: options.maxlength,\n      minlength: options.minlength,\n      prefill: options.prefill,\n      rejectUnsupportedCards: options.rejectUnsupportedCards\n    }, _a));\n  }, []); // eslint-disable-line react-hooks/exhaustive-deps\n  return React.createElement(\"div\", __assign({}, props));\n};\n\n/**\n * Throw an exception if the CardFields is not found in the paypal namespace\n * Probably cause for this problem is not sending the card-fields string\n * as part of the components props in options\n * {@code <PayPalScriptProvider options={{ components: 'card-fields'}}>}\n *\n * @param param0 and object containing the components and namespace defined in options\n * @throws {@code Error}\n *\n */\nvar generateMissingCardFieldsError = function (_a) {\n  var _b = _a.components,\n    components = _b === void 0 ? \"\" : _b,\n    _c = SDK_SETTINGS.DATA_NAMESPACE,\n    _d = _a[_c],\n    dataNamespace = _d === void 0 ? DEFAULT_PAYPAL_NAMESPACE : _d;\n  var expectedComponents = components ? \"\".concat(components, \",card-fields\") : \"card-fields\";\n  var errorMessage = \"Unable to render <PayPalCardFieldsProvider /> because window.\".concat(dataNamespace, \".CardFields is undefined.\");\n  if (!components.includes(\"card-fields\")) {\n    errorMessage += \"\\nTo fix the issue, add 'card-fields' to the list of components passed to the parent PayPalScriptProvider: <PayPalScriptProvider options={{ components: '\".concat(expectedComponents, \"'}}>\");\n  }\n  return errorMessage;\n};\nfunction ignore() {\n  return;\n}\nfunction hasChildren(container) {\n  var _a;\n  return !!((_a = container.current) === null || _a === void 0 ? void 0 : _a.children.length);\n}\nvar PayPalCardFieldsContext = createContext({\n  cardFieldsForm: null,\n  fields: {},\n  registerField: ignore,\n  unregisterField: ignore // implementation is inside hook and passed through the provider\n});\nvar usePayPalCardFields = function () {\n  return useContext(PayPalCardFieldsContext);\n};\nvar usePayPalCardFieldsRegistry = function () {\n  var _a = useState(null),\n    setError = _a[1];\n  var registeredFields = useRef({});\n  var registerField = function () {\n    var props = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n      props[_i] = arguments[_i];\n    }\n    var fieldName = props[0],\n      options = props[1],\n      cardFields = props[2];\n    if (registeredFields.current[fieldName]) {\n      setError(function () {\n        throw new Error(CARD_FIELDS_DUPLICATE_CHILDREN_ERROR);\n      });\n    }\n    registeredFields.current[fieldName] = cardFields === null || cardFields === void 0 ? void 0 : cardFields[fieldName](options);\n    return registeredFields.current[fieldName];\n  };\n  var unregisterField = function (fieldName) {\n    var field = registeredFields.current[fieldName];\n    if (field) {\n      field.close().catch(ignore);\n      delete registeredFields.current[fieldName];\n    }\n  };\n  return {\n    fields: registeredFields.current,\n    registerField: registerField,\n    unregisterField: unregisterField\n  };\n};\nvar FullWidthContainer = function (_a) {\n  var children = _a.children;\n  return React.createElement(\"div\", {\n    style: {\n      width: \"100%\"\n    }\n  }, children);\n};\n\n/**\nThe `<PayPalCardFieldsProvider />` is a context provider that is designed to support the rendering and state management of PayPal CardFields in your application.\n\nThe context provider will initialize the `CardFields` instance from the JS SDK and determine eligibility to render the CardField components. Once the `CardFields` are initialized, the context provider will manage the state of the `CardFields` instance as well as the reference to each individual card field.\n\nPassing the `inputEvents` and `style` props to the context provider will apply them to each of the individual field components.\n\nThe state managed by the provider is accessible through our custom hook `usePayPalCardFields`.\n\n*/\nvar PayPalCardFieldsProvider = function (_a) {\n  var children = _a.children,\n    props = __rest(_a, [\"children\"]);\n  var _b = usePayPalScriptReducer()[0],\n    isResolved = _b.isResolved,\n    options = _b.options;\n  var _c = usePayPalCardFieldsRegistry(),\n    fields = _c.fields,\n    registerField = _c.registerField,\n    unregisterField = _c.unregisterField;\n  var _d = useState(null),\n    cardFieldsForm = _d[0],\n    setCardFieldsForm = _d[1];\n  var cardFieldsInstance = useRef(null);\n  var _e = useState(false),\n    isEligible = _e[0],\n    setIsEligible = _e[1];\n  // We set the error inside state so that it can be caught by React's error boundary\n  var _f = useState(null),\n    setError = _f[1];\n  useEffect(function () {\n    var _a, _b, _c;\n    if (!isResolved) {\n      return;\n    }\n    try {\n      cardFieldsInstance.current = (_c = (_b = (_a = getPayPalWindowNamespace$1(options[SDK_SETTINGS.DATA_NAMESPACE])).CardFields) === null || _b === void 0 ? void 0 : _b.call(_a, __assign({}, props))) !== null && _c !== void 0 ? _c : null;\n    } catch (error) {\n      setError(function () {\n        throw new Error(\"Failed to render <PayPalCardFieldsProvider /> component. Failed to initialize:  \".concat(error));\n      });\n      return;\n    }\n    if (!cardFieldsInstance.current) {\n      setError(function () {\n        var _a;\n        throw new Error(generateMissingCardFieldsError((_a = {\n          components: options.components\n        }, _a[SDK_SETTINGS.DATA_NAMESPACE] = options[SDK_SETTINGS.DATA_NAMESPACE], _a)));\n      });\n      return;\n    }\n    setIsEligible(cardFieldsInstance.current.isEligible());\n    setCardFieldsForm(cardFieldsInstance.current);\n    return function () {\n      setCardFieldsForm(null);\n      cardFieldsInstance.current = null;\n    };\n  }, [isResolved]); // eslint-disable-line react-hooks/exhaustive-deps\n  if (!isEligible) {\n    // TODO: What should be returned here?\n    return React.createElement(\"div\", null);\n  }\n  return React.createElement(FullWidthContainer, null, React.createElement(PayPalCardFieldsContext.Provider, {\n    value: {\n      cardFieldsForm: cardFieldsForm,\n      fields: fields,\n      registerField: registerField,\n      unregisterField: unregisterField\n    }\n  }, children));\n};\nvar PayPalCardField = function (_a) {\n  var className = _a.className,\n    fieldName = _a.fieldName,\n    options = __rest(_a, [\"className\", \"fieldName\"]);\n  var _b = usePayPalCardFields(),\n    cardFieldsForm = _b.cardFieldsForm,\n    registerField = _b.registerField,\n    unregisterField = _b.unregisterField;\n  var containerRef = useRef(null);\n  // Set errors is state so that they can be caught by React's error boundary\n  var _c = useState(null),\n    setError = _c[1];\n  function closeComponent() {\n    unregisterField(fieldName);\n  }\n  useEffect(function () {\n    if (!cardFieldsForm) {\n      setError(function () {\n        throw new Error(CARD_FIELDS_CONTEXT_ERROR);\n      });\n      return closeComponent;\n    }\n    if (!containerRef.current) {\n      return closeComponent;\n    }\n    var registeredField = registerField(fieldName, options, cardFieldsForm);\n    registeredField === null || registeredField === void 0 ? void 0 : registeredField.render(containerRef.current).catch(function (err) {\n      if (!hasChildren(containerRef)) {\n        // Component no longer in the DOM, we can safely ignore the error\n        return;\n      }\n      // Component is still in the DOM\n      setError(function () {\n        throw new Error(\"Failed to render <PayPal\".concat(fieldName, \" /> component. \").concat(err));\n      });\n    });\n    return closeComponent;\n  }, []); // eslint-disable-line react-hooks/exhaustive-deps\n  return React.createElement(\"div\", {\n    ref: containerRef,\n    className: className\n  });\n};\nvar PayPalNameField = function (options) {\n  return React.createElement(PayPalCardField, __assign({\n    fieldName: \"NameField\"\n  }, options));\n};\nvar PayPalNumberField = function (options) {\n  return React.createElement(PayPalCardField, __assign({\n    fieldName: \"NumberField\"\n  }, options));\n};\nvar PayPalExpiryField = function (options) {\n  return React.createElement(PayPalCardField, __assign({\n    fieldName: \"ExpiryField\"\n  }, options));\n};\nvar PayPalCVVField = function (options) {\n  return React.createElement(PayPalCardField, __assign({\n    fieldName: \"CVVField\"\n  }, options));\n};\nvar FlexContainer = function (_a) {\n  var children = _a.children;\n  return React.createElement(\"div\", {\n    style: {\n      display: \"flex\",\n      width: \"100%\"\n    }\n  }, children);\n};\n\n/**\nThis `<PayPalCardFieldsForm />` component renders the 4 individual fields for [Card Fields](https://developer.paypal.com/docs/business/checkout/advanced-card-payments/integrate#3-add-javascript-sdk-and-card-form) integrations.\nThis setup relies on the `<PayPalCardFieldsProvider />` parent component, which manages the state related to loading the JS SDK script and performs certain validations before rendering the fields.\n\n\n\nNote: If you want to have more granular control over the layout of how the fields are rendered, you can alternatively use our Individual Fields.\n*/\nvar PayPalCardFieldsForm = function (_a) {\n  var className = _a.className;\n  return React.createElement(\"div\", {\n    className: className\n  }, React.createElement(PayPalCardField, {\n    fieldName: \"NameField\"\n  }), React.createElement(PayPalCardField, {\n    fieldName: \"NumberField\"\n  }), React.createElement(FlexContainer, null, React.createElement(FullWidthContainer, null, React.createElement(PayPalCardField, {\n    fieldName: \"ExpiryField\"\n  })), React.createElement(FullWidthContainer, null, React.createElement(PayPalCardField, {\n    fieldName: \"CVVField\"\n  }))));\n};\nvar FUNDING$1 = {\n  PAYPAL: \"paypal\",\n  VENMO: \"venmo\",\n  APPLEPAY: \"applepay\",\n  ITAU: \"itau\",\n  CREDIT: \"credit\",\n  PAYLATER: \"paylater\",\n  CARD: \"card\",\n  IDEAL: \"ideal\",\n  SEPA: \"sepa\",\n  BANCONTACT: \"bancontact\",\n  GIROPAY: \"giropay\",\n  SOFORT: \"sofort\",\n  EPS: \"eps\",\n  MYBANK: \"mybank\",\n  P24: \"p24\",\n  PAYU: \"payu\",\n  BLIK: \"blik\",\n  TRUSTLY: \"trustly\",\n  OXXO: \"oxxo\",\n  BOLETO: \"boleto\",\n  BOLETOBANCARIO: \"boletobancario\",\n  WECHATPAY: \"wechatpay\",\n  MERCADOPAGO: \"mercadopago\",\n  MULTIBANCO: \"multibanco\",\n  SATISPAY: \"satispay\",\n  PAIDY: \"paidy\",\n  ZIMPLER: \"zimpler\",\n  MAXIMA: \"maxima\"\n};\n[FUNDING$1.IDEAL, FUNDING$1.BANCONTACT, FUNDING$1.GIROPAY, FUNDING$1.SOFORT, FUNDING$1.EPS, FUNDING$1.MYBANK, FUNDING$1.P24, FUNDING$1.PAYU, FUNDING$1.BLIK, FUNDING$1.TRUSTLY, FUNDING$1.OXXO, FUNDING$1.BOLETO, FUNDING$1.BOLETOBANCARIO, FUNDING$1.WECHATPAY, FUNDING$1.MERCADOPAGO, FUNDING$1.MULTIBANCO, FUNDING$1.SATISPAY, FUNDING$1.PAIDY, FUNDING$1.MAXIMA, FUNDING$1.ZIMPLER];\n\n// We do not re-export `FUNDING` from the `sdk-constants` module\n// directly because it has no type definitions.\n//\n// See https://github.com/paypal/react-paypal-js/issues/125\nvar FUNDING = FUNDING$1;\nexport { BraintreePayPalButtons, DISPATCH_ACTION, FUNDING, PAYPAL_HOSTED_FIELDS_TYPES, PayPalButtons, PayPalCVVField, PayPalCardFieldsContext, PayPalCardFieldsForm, PayPalCardFieldsProvider, PayPalExpiryField, PayPalHostedField, PayPalHostedFieldsProvider, PayPalMarks, PayPalMessages, PayPalNameField, PayPalNumberField, PayPalScriptProvider, SCRIPT_LOADING_STATE, ScriptContext, destroySDKScript, getScriptID, scriptReducer, usePayPalCardFields, usePayPalHostedFields, usePayPalScriptReducer, useScriptProviderContext };\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n    : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Print warning and recommend using `buffer` v4.x which has an Object\n *               implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n    typeof console.error === 'function') {\n  console.error(\n    'This browser lacks typed array (Uint8Array) support which is required by ' +\n    '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n  )\n}\n\nfunction typedArraySupport () {\n  // Can typed array instances can be augmented?\n  try {\n    const arr = new Uint8Array(1)\n    const proto = { foo: function () { return 42 } }\n    Object.setPrototypeOf(proto, Uint8Array.prototype)\n    Object.setPrototypeOf(arr, proto)\n    return arr.foo() === 42\n  } catch (e) {\n    return false\n  }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.buffer\n  }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n  enumerable: true,\n  get: function () {\n    if (!Buffer.isBuffer(this)) return undefined\n    return this.byteOffset\n  }\n})\n\nfunction createBuffer (length) {\n  if (length > K_MAX_LENGTH) {\n    throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n  }\n  // Return an augmented `Uint8Array` instance\n  const buf = new Uint8Array(length)\n  Object.setPrototypeOf(buf, Buffer.prototype)\n  return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new TypeError(\n        'The \"string\" argument must be of type string. Received type number'\n      )\n    }\n    return allocUnsafe(arg)\n  }\n  return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n  if (typeof value === 'string') {\n    return fromString(value, encodingOrOffset)\n  }\n\n  if (ArrayBuffer.isView(value)) {\n    return fromArrayView(value)\n  }\n\n  if (value == null) {\n    throw new TypeError(\n      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n      'or Array-like Object. Received type ' + (typeof value)\n    )\n  }\n\n  if (isInstance(value, ArrayBuffer) ||\n      (value && isInstance(value.buffer, ArrayBuffer))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof SharedArrayBuffer !== 'undefined' &&\n      (isInstance(value, SharedArrayBuffer) ||\n      (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n    return fromArrayBuffer(value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'number') {\n    throw new TypeError(\n      'The \"value\" argument must not be of type number. Received type number'\n    )\n  }\n\n  const valueOf = value.valueOf && value.valueOf()\n  if (valueOf != null && valueOf !== value) {\n    return Buffer.from(valueOf, encodingOrOffset, length)\n  }\n\n  const b = fromObject(value)\n  if (b) return b\n\n  if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n      typeof value[Symbol.toPrimitive] === 'function') {\n    return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n  }\n\n  throw new TypeError(\n    'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n    'or Array-like Object. Received type ' + (typeof value)\n  )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be of type number')\n  } else if (size < 0) {\n    throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n  }\n}\n\nfunction alloc (size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpreted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(size).fill(fill, encoding)\n      : createBuffer(size).fill(fill)\n  }\n  return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  assertSize(size)\n  return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('Unknown encoding: ' + encoding)\n  }\n\n  const length = byteLength(string, encoding) | 0\n  let buf = createBuffer(length)\n\n  const actual = buf.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    buf = buf.slice(0, actual)\n  }\n\n  return buf\n}\n\nfunction fromArrayLike (array) {\n  const length = array.length < 0 ? 0 : checked(array.length) | 0\n  const buf = createBuffer(length)\n  for (let i = 0; i < length; i += 1) {\n    buf[i] = array[i] & 255\n  }\n  return buf\n}\n\nfunction fromArrayView (arrayView) {\n  if (isInstance(arrayView, Uint8Array)) {\n    const copy = new Uint8Array(arrayView)\n    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n  }\n  return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\"offset\" is outside of buffer bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\"length\" is outside of buffer bounds')\n  }\n\n  let buf\n  if (byteOffset === undefined && length === undefined) {\n    buf = new Uint8Array(array)\n  } else if (length === undefined) {\n    buf = new Uint8Array(array, byteOffset)\n  } else {\n    buf = new Uint8Array(array, byteOffset, length)\n  }\n\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(buf, Buffer.prototype)\n\n  return buf\n}\n\nfunction fromObject (obj) {\n  if (Buffer.isBuffer(obj)) {\n    const len = checked(obj.length) | 0\n    const buf = createBuffer(len)\n\n    if (buf.length === 0) {\n      return buf\n    }\n\n    obj.copy(buf, 0, 0, len)\n    return buf\n  }\n\n  if (obj.length !== undefined) {\n    if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n      return createBuffer(0)\n    }\n    return fromArrayLike(obj)\n  }\n\n  if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n    return fromArrayLike(obj.data)\n  }\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= K_MAX_LENGTH) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return b != null && b._isBuffer === true &&\n    b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n  if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n  if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError(\n      'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n    )\n  }\n\n  if (a === b) return 0\n\n  let x = a.length\n  let y = b.length\n\n  for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!Array.isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  let i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  const buffer = Buffer.allocUnsafe(length)\n  let pos = 0\n  for (i = 0; i < list.length; ++i) {\n    let buf = list[i]\n    if (isInstance(buf, Uint8Array)) {\n      if (pos + buf.length > buffer.length) {\n        if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n        buf.copy(buffer, pos)\n      } else {\n        Uint8Array.prototype.set.call(\n          buffer,\n          buf,\n          pos\n        )\n      }\n    } else if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    } else {\n      buf.copy(buffer, pos)\n    }\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    throw new TypeError(\n      'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n      'Received type ' + typeof string\n    )\n  }\n\n  const len = string.length\n  const mustMatch = (arguments.length > 2 && arguments[2] === true)\n  if (!mustMatch && len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) {\n          return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n        }\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  let loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  const i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  const len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (let i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  const len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (let i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  const len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (let i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  const length = this.length\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  let str = ''\n  const max = exports.INSPECT_MAX_BYTES\n  str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n  if (this.length > max) str += ' ... '\n  return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n  Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (isInstance(target, Uint8Array)) {\n    target = Buffer.from(target, target.offset, target.byteLength)\n  }\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError(\n      'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n      'Received type ' + (typeof target)\n    )\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  let x = thisEnd - thisStart\n  let y = end - start\n  const len = Math.min(x, y)\n\n  const thisCopy = this.slice(thisStart, thisEnd)\n  const targetCopy = target.slice(start, end)\n\n  for (let i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset // Coerce to Number.\n  if (numberIsNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  let indexSize = 1\n  let arrLength = arr.length\n  let valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  let i\n  if (dir) {\n    let foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      let found = true\n      for (let j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  const remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  const strLen = string.length\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  let i\n  for (i = 0; i < length; ++i) {\n    const parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (numberIsNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset >>> 0\n    if (isFinite(length)) {\n      length = length >>> 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  const remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  let loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return asciiWrite(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  const res = []\n\n  let i = start\n  while (i < end) {\n    const firstByte = buf[i]\n    let codePoint = null\n    let bytesPerSequence = (firstByte > 0xEF)\n      ? 4\n      : (firstByte > 0xDF)\n          ? 3\n          : (firstByte > 0xBF)\n              ? 2\n              : 1\n\n    if (i + bytesPerSequence <= end) {\n      let secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  const len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  let res = ''\n  let i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  let ret = ''\n  end = Math.min(buf.length, end)\n\n  for (let i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  const len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  let out = ''\n  for (let i = start; i < end; ++i) {\n    out += hexSliceLookupTable[buf[i]]\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  const bytes = buf.slice(start, end)\n  let res = ''\n  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n  for (let i = 0; i < bytes.length - 1; i += 2) {\n    res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  const len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  const newBuf = this.subarray(start, end)\n  // Return an augmented `Uint8Array` instance\n  Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  let val = this[offset + --byteLength]\n  let mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const lo = first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24\n\n  const hi = this[++offset] +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    last * 2 ** 24\n\n  return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const hi = first * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  const lo = this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last\n\n  return (BigInt(hi) << BigInt(32)) + BigInt(lo)\n})\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let val = this[offset]\n  let mul = 1\n  let i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  let i = byteLength\n  let mul = 1\n  let val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  const val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = this[offset + 4] +\n    this[offset + 5] * 2 ** 8 +\n    this[offset + 6] * 2 ** 16 +\n    (last << 24) // Overflow\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(first +\n    this[++offset] * 2 ** 8 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n  offset = offset >>> 0\n  validateNumber(offset, 'offset')\n  const first = this[offset]\n  const last = this[offset + 7]\n  if (first === undefined || last === undefined) {\n    boundsError(offset, this.length - 8)\n  }\n\n  const val = (first << 24) + // Overflow\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    this[++offset]\n\n  return (BigInt(val) << BigInt(32)) +\n    BigInt(this[++offset] * 2 ** 24 +\n    this[++offset] * 2 ** 16 +\n    this[++offset] * 2 ** 8 +\n    last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  offset = offset >>> 0\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let mul = 1\n  let i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  byteLength = byteLength >>> 0\n  if (!noAssert) {\n    const maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset + 3] = (value >>> 24)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 1] = (value >>> 8)\n  this[offset] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  lo = lo >> 8\n  buf[offset++] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  hi = hi >> 8\n  buf[offset++] = hi\n  return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n  checkIntBI(value, min, max, buf, offset, 7)\n\n  let lo = Number(value & BigInt(0xffffffff))\n  buf[offset + 7] = lo\n  lo = lo >> 8\n  buf[offset + 6] = lo\n  lo = lo >> 8\n  buf[offset + 5] = lo\n  lo = lo >> 8\n  buf[offset + 4] = lo\n  let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n  buf[offset + 3] = hi\n  hi = hi >> 8\n  buf[offset + 2] = hi\n  hi = hi >> 8\n  buf[offset + 1] = hi\n  hi = hi >> 8\n  buf[offset] = hi\n  return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = 0\n  let mul = 1\n  let sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    const limit = Math.pow(2, (8 * byteLength) - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  let i = byteLength - 1\n  let mul = 1\n  let sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  this[offset] = (value >>> 8)\n  this[offset + 1] = (value & 0xff)\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  this[offset] = (value & 0xff)\n  this[offset + 1] = (value >>> 8)\n  this[offset + 2] = (value >>> 16)\n  this[offset + 3] = (value >>> 24)\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  this[offset] = (value >>> 24)\n  this[offset + 1] = (value >>> 16)\n  this[offset + 2] = (value >>> 8)\n  this[offset + 3] = (value & 0xff)\n  return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n  return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n  return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  value = +value\n  offset = offset >>> 0\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  const len = end - start\n\n  if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n    // Use built-in when available, missing from IE11\n    this.copyWithin(targetStart, start, end)\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, end),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n    if (val.length === 1) {\n      const code = val.charCodeAt(0)\n      if ((encoding === 'utf8' && code < 128) ||\n          encoding === 'latin1') {\n        // Fast path: If `val` fits into a single byte, use that numeric value.\n        val = code\n      }\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  } else if (typeof val === 'boolean') {\n    val = Number(val)\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  let i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    const bytes = Buffer.isBuffer(val)\n      ? val\n      : Buffer.from(val, encoding)\n    const len = bytes.length\n    if (len === 0) {\n      throw new TypeError('The value \"' + val +\n        '\" is invalid for argument \"value\"')\n    }\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n  errors[sym] = class NodeError extends Base {\n    constructor () {\n      super()\n\n      Object.defineProperty(this, 'message', {\n        value: getMessage.apply(this, arguments),\n        writable: true,\n        configurable: true\n      })\n\n      // Add the error code to the name to include it in the stack trace.\n      this.name = `${this.name} [${sym}]`\n      // Access the stack to generate the error message including the error code\n      // from the name.\n      this.stack // eslint-disable-line no-unused-expressions\n      // Reset the name to the actual name.\n      delete this.name\n    }\n\n    get code () {\n      return sym\n    }\n\n    set code (value) {\n      Object.defineProperty(this, 'code', {\n        configurable: true,\n        enumerable: true,\n        value,\n        writable: true\n      })\n    }\n\n    toString () {\n      return `${this.name} [${sym}]: ${this.message}`\n    }\n  }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n  function (name) {\n    if (name) {\n      return `${name} is outside of buffer bounds`\n    }\n\n    return 'Attempt to access memory outside buffer bounds'\n  }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n  function (name, actual) {\n    return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n  }, TypeError)\nE('ERR_OUT_OF_RANGE',\n  function (str, range, input) {\n    let msg = `The value of \"${str}\" is out of range.`\n    let received = input\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    }\n    msg += ` It must be ${range}. Received ${received}`\n    return msg\n  }, RangeError)\n\nfunction addNumericalSeparator (val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n  validateNumber(offset, 'offset')\n  if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n    boundsError(offset, buf.length - (byteLength + 1))\n  }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n  if (value > max || value < min) {\n    const n = typeof min === 'bigint' ? 'n' : ''\n    let range\n    if (byteLength > 3) {\n      if (min === 0 || min === BigInt(0)) {\n        range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n      } else {\n        range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n                `${(byteLength + 1) * 8 - 1}${n}`\n      }\n    } else {\n      range = `>= ${min}${n} and <= ${max}${n}`\n    }\n    throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n  }\n  checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n  if (typeof value !== 'number') {\n    throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n}\n\nfunction boundsError (value, length, type) {\n  if (Math.floor(value) !== value) {\n    validateNumber(value, type)\n    throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n  }\n\n  if (length < 0) {\n    throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n  }\n\n  throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n                                    `>= ${type ? 1 : 0} and <= ${length}`,\n                                    value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node takes equal signs as end of the Base64 encoding\n  str = str.split('=')[0]\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = str.trim().replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  let codePoint\n  const length = string.length\n  let leadSurrogate = null\n  const bytes = []\n\n  for (let i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  let c, hi, lo\n  const byteArray = []\n  for (let i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  let i\n  for (i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n  return obj instanceof type ||\n    (obj != null && obj.constructor != null && obj.constructor.name != null &&\n      obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n  // For IE11 support\n  return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n  const alphabet = '0123456789abcdef'\n  const table = new Array(256)\n  for (let i = 0; i < 16; ++i) {\n    const i16 = i * 16\n    for (let j = 0; j < 16; ++j) {\n      table[i16 + j] = alphabet[i] + alphabet[j]\n    }\n  }\n  return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n  return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n  throw new Error('BigInt not supported')\n}\n"],"names":["SCRIPT_LOADING_STATE","DISPATCH_ACTION","PAYPAL_HOSTED_FIELDS_TYPES","__assign","Object","assign","t","s","i","n","arguments","length","p","prototype","hasOwnProperty","call","apply","this","__rest","e","indexOf","getOwnPropertySymbols","propertyIsEnumerable","__spreadArray","to","from","pack","ar","l","Array","slice","concat","SuppressedError","SCRIPT_ID","SDK_SETTINGS","braintreeVersion","DEFAULT_PAYPAL_NAMESPACE","SCRIPT_PROVIDER_REDUCER_ERROR","getPayPalWindowNamespace$1","namespace","window","generateErrorMessage","_a","reactComponentName","sdkComponentKey","_b","sdkRequestedComponents","_c","sdkDataNamespace","requiredOptionCapitalized","charAt","toUpperCase","substring","errorMessage","requestedComponents","join","includes","expectedComponents","filter","Boolean","getScriptID","options","paypalScriptOptions","str","hash","total","charCodeAt","String","fromCharCode","Math","abs","hashStr","JSON","stringify","scriptReducer","state","action","reactPayPalScriptID","scriptNode","type","LOADING_STATUS","value","loadingStatus","loadingStatusErrorMessage","message","RESET_OPTIONS","self","document","querySelector","parentNode","removeChild","PENDING","SET_BRAINTREE_INSTANCE","braintreePayPalCheckoutInstance","ScriptContext","createContext","usePayPalScriptReducer","scriptContext","dispatch","Error","validateReducer","useContext","isInitial","INITIAL","isPending","isResolved","RESOLVED","isRejected","REJECTED","PayPalButtons","className","_d","disabled","children","_e","forceReRender","buttonProps","isDisabledStyle","opacity","classNames","trim","buttonsContainerRef","useRef","buttons","_f","_g","useState","initActions","setInitActions","_h","isEligible","setIsEligible","setErrorState","closeButtonsComponent","current","close","catch","updateProps","useEffect","paypalWindowNamespace","dataNamespace","undefined","Buttons","displayName","components","onInit","data","actions","err","render","fundingSource","disable","enable","ref","style","createScriptElement","url","attributes","newScript","createElement","src","keys","forEach","key","setAttribute","loadScript","PromisePonyfill","Promise","validateArguments","resolve","sdkBaseUrl","environment","params","queryString","optionsWithStringIndex","reduce","accumulator","replacer","toString","match","indexOfMatch","toLowerCase","replace","queryParams","processOptions","existingWindowNamespace","getPayPalWindowNamespace","currentScript","nextScript","currentScriptClone","cloneNode","dataset","uidAuto","isExactMatch","findScript","reject","onSuccess","onError","onerror","onload","head","insertBefore","firstElementChild","insertScriptElement","defaultError","loadCustomScript","then","newWindowNamespace","PayPalMarks","markProps","markContainerRef","Marks","mark","firstChild","renderPayPalMark","PayPalMessages","messageProps","messagesContainerRef","messages","Messages","PayPalScriptProvider","clientId","deferLoading","useReducer","isSubscribed","console","error","Provider","ignore","cardFieldsForm","fields","registerField","unregisterField","FUNDING","PAYPAL","VENMO","APPLEPAY","ITAU","CREDIT","PAYLATER","CARD","IDEAL","SEPA","BANCONTACT","GIROPAY","SOFORT","EPS","MYBANK","P24","PAYU","BLIK","TRUSTLY","OXXO","BOLETO","BOLETOBANCARIO","WECHATPAY","MERCADOPAGO","MULTIBANCO","SATISPAY","PAIDY","ZIMPLER","MAXIMA","base64","ieee754","customInspectSymbol","Symbol","exports","K_MAX_LENGTH","createBuffer","RangeError","buf","Uint8Array","setPrototypeOf","Buffer","arg","encodingOrOffset","TypeError","allocUnsafe","string","encoding","isEncoding","byteLength","actual","write","fromString","ArrayBuffer","isView","arrayView","isInstance","copy","fromArrayBuffer","buffer","byteOffset","fromArrayLike","fromArrayView","SharedArrayBuffer","valueOf","b","obj","isBuffer","len","checked","numberIsNaN","isArray","fromObject","toPrimitive","assertSize","size","array","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","m","bidirectionalIndexOf","val","dir","arrayIndexOf","lastIndexOf","arr","indexSize","arrLength","valLength","read","readUInt16BE","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","byteArray","push","asciiToBytes","base64Write","ucs2Write","units","c","hi","lo","utf16leToBytes","fromByteArray","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","decodeCodePointsArray","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","defineProperty","enumerable","get","poolSize","alloc","fill","allocUnsafeSlow","_isBuffer","compare","a","x","y","list","pos","set","swap16","swap32","swap64","toLocaleString","equals","inspect","max","target","thisStart","thisEnd","thisCopy","targetCopy","isFinite","toJSON","_arr","ret","out","hexSliceLookupTable","bytes","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","BigInt","wrtBigUInt64BE","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","mul","readUintBE","readUIntBE","readUint8","readUInt8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readUInt32BE","readBigUInt64LE","defineBigIntMethod","validateNumber","first","last","boundsError","readBigUInt64BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readBigInt64LE","readBigInt64BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUIntLE","writeUintBE","writeUIntBE","writeUint8","writeUInt8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUInt16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeUInt32BE","writeBigUInt64LE","writeBigUInt64BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","code","errors","E","sym","getMessage","Base","constructor","super","writable","configurable","name","stack","addNumericalSeparator","range","ERR_OUT_OF_RANGE","checkBounds","ERR_INVALID_ARG_TYPE","floor","ERR_BUFFER_OUT_OF_BOUNDS","input","msg","received","isInteger","INVALID_BASE64_RE","Infinity","leadSurrogate","toByteArray","split","base64clean","dst","alphabet","table","i16","fn","BufferBigIntNotDefined"],"sourceRoot":""}