{"version":3,"sources":["webpack:///./node_modules/v-money/dist/v-money.js","webpack:///./node_modules/recaptcha-v3/dist/ReCaptcha.js","webpack:///./node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/recaptcha-v3/dist/ReCaptchaInstance.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/recaptcha-v3/dist/ReCaptchaLoader.js"],"names":["e","t","module","exports","this","r","n","i","l","call","m","c","d","o","Object","defineProperty","configurable","enumerable","get","__esModule","default","prototype","hasOwnProperty","p","s","a","prefix","suffix","thousands","decimal","precision","u","value","tagName","toLocaleUpperCase","getElementsByTagName","length","oninput","selectionEnd","Math","max","b","dispatchEvent","onfocus","arguments","toFixed","indexOf","split","f","parseFloat","replace","min","pow","toString","setSelectionRange","document","activeElement","setTimeout","createEvent","initEvent","keys","map","directive","component","window","Vue","use","name","props","required","type","Number","String","masked","Boolean","directives","money","data","formattedValue","watch","immediate","handler","$props","methods","change","$emit","target","concat","reduce","options","render","staticRenderFns","_scopeId","computed","forEach","esModule","$createElement","_self","_c","rawName","expression","staticClass","attrs","domProps","on","ReCaptchaInstance","getInstance","load","ReCaptchaLoader_1","ReCaptchaInstance_1","runtime","undefined","Op","hasOwn","obj","key","desc","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","writable","err","wrap","innerFn","outerFn","self","tryLocsList","protoGenerator","Generator","generator","create","context","Context","makeInvokeMethod","tryCatch","fn","arg","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","method","_invoke","AsyncIterator","PromiseImpl","invoke","resolve","reject","record","result","__await","then","unwrapped","error","previousPromise","enqueue","callInvokeWithMethodAndArg","state","Error","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","done","methodName","TypeError","info","resultName","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","push","resetTryEntry","completion","reset","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","constructor","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","val","object","reverse","pop","skipTempReset","prev","charAt","slice","stop","rootEntry","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","globalThis","Function","__awaiter","thisArg","_arguments","P","adopt","fulfilled","step","rejected","apply","__generator","body","y","g","_","label","trys","ops","verb","v","op","siteKey","recaptchaID","recaptcha","styleContainer","execute","action","_a","enterprise","getSiteKey","hideBadge","createElement","innerHTML","head","appendChild","showBadge","removeChild","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","runClearTimeout","marker","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","len","run","Item","array","noop","nextTick","args","Array","title","browser","env","argv","version","versions","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","ELoadingState","ReCaptchaLoader","getLoadingState","LOADED","instance","LOADING","instanceSiteKey","successfulLoadingConsumers","errorLoadingRunnable","reason","setLoadingState","loader","loadScript","useRecaptchaNet","useEnterprise","renderParameters","customUrl","widgetID","doExplicitRender","grecaptcha","explicitRenderParameters","autoHideBadge","catch","loadingState","NOT_LOADED","_this","scriptElement","setAttribute","scriptBase","parametersQuery","buildQueryString","src","addEventListener","waitForScriptToLoad","onerror","parameters","parameterKeys","filter","parameterKey","join","callback","SCRIPT_LOAD_DELAY","ready","isEnterprise","augmentedParameters","sitekey","badge","size","tabindex","container"],"mappings":"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","file":"js/chunk-vendors~f9ca8911-legacy.60e51021.js","sourcesContent":["(function(e,t){\"object\"==typeof exports&&\"object\"==typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define([],t):\"object\"==typeof exports?exports.VMoney=t():e.VMoney=t()})(this,function(){return function(e){function t(r){if(n[r])return n[r].exports;var i=n[r]={i:r,l:!1,exports:{}};return e[r].call(i.exports,i,i.exports,t),i.l=!0,i.exports}var n={};return t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,n,r){t.o(e,n)||Object.defineProperty(e,n,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var n=e&&e.__esModule?function(){return e.default}:function(){return e};return t.d(n,\"a\",n),n},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p=\".\",t(t.s=9)}([function(e,t,n){\"use strict\";t.a={prefix:\"\",suffix:\"\",thousands:\",\",decimal:\".\",precision:2}},function(e,t,n){\"use strict\";var r=n(2),i=n(5),u=n(0);t.a=function(e,t){if(t.value){var o=n.i(i.a)(u.a,t.value);if(\"INPUT\"!==e.tagName.toLocaleUpperCase()){var a=e.getElementsByTagName(\"input\");1!==a.length||(e=a[0])}e.oninput=function(){var t=e.value.length-e.selectionEnd;e.value=n.i(r.a)(e.value,o),t=Math.max(t,o.suffix.length),t=e.value.length-t,t=Math.max(t,o.prefix.length+1),n.i(r.b)(e,t),e.dispatchEvent(n.i(r.c)(\"change\"))},e.onfocus=function(){n.i(r.b)(e,e.value.length-o.suffix.length)},e.oninput(),e.dispatchEvent(n.i(r.c)(\"input\"))}}},function(e,t,n){\"use strict\";function r(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:m.a;\"number\"==typeof e&&(e=e.toFixed(o(t.precision)));var n=e.indexOf(\"-\")>=0?\"-\":\"\",r=u(e),i=c(r,t.precision),a=d(i).split(\".\"),p=a[0],l=a[1];return p=f(p,t.thousands),t.prefix+n+s(p,l,t.decimal)+t.suffix}function i(e,t){var n=e.indexOf(\"-\")>=0?-1:1,r=u(e),i=c(r,t);return parseFloat(i)*n}function u(e){return d(e).replace(/\\D+/g,\"\")||\"0\"}function o(e){return a(0,e,20)}function a(e,t,n){return Math.max(e,Math.min(t,n))}function c(e,t){var n=Math.pow(10,t);return(parseFloat(e)/n).toFixed(o(t))}function f(e,t){return e.replace(/(\\d)(?=(?:\\d{3})+\\b)/gm,\"$1\"+t)}function s(e,t,n){return t?e+n+t:e}function d(e){return e?e.toString():\"\"}function p(e,t){var n=function(){e.setSelectionRange(t,t)};e===document.activeElement&&(n(),setTimeout(n,1))}function l(e){var t=document.createEvent(\"Event\");return t.initEvent(e,!0,!0),t}var m=n(0);n.d(t,\"a\",function(){return r}),n.d(t,\"d\",function(){return i}),n.d(t,\"b\",function(){return p}),n.d(t,\"c\",function(){return l})},function(e,t,n){\"use strict\";function r(e,t){t&&Object.keys(t).map(function(e){a.a[e]=t[e]}),e.directive(\"money\",o.a),e.component(\"money\",u.a)}Object.defineProperty(t,\"__esModule\",{value:!0});var i=n(6),u=n.n(i),o=n(1),a=n(0);n.d(t,\"Money\",function(){return u.a}),n.d(t,\"VMoney\",function(){return o.a}),n.d(t,\"options\",function(){return a.a}),n.d(t,\"VERSION\",function(){return c});var c=\"0.8.1\";t.default=r,\"undefined\"!=typeof window&&window.Vue&&window.Vue.use(r)},function(e,t,n){\"use strict\";Object.defineProperty(t,\"__esModule\",{value:!0});var r=n(1),i=n(0),u=n(2);t.default={name:\"Money\",props:{value:{required:!0,type:[Number,String],default:0},masked:{type:Boolean,default:!1},precision:{type:Number,default:function(){return i.a.precision}},decimal:{type:String,default:function(){return i.a.decimal}},thousands:{type:String,default:function(){return i.a.thousands}},prefix:{type:String,default:function(){return i.a.prefix}},suffix:{type:String,default:function(){return i.a.suffix}}},directives:{money:r.a},data:function(){return{formattedValue:\"\"}},watch:{value:{immediate:!0,handler:function(e,t){var r=n.i(u.a)(e,this.$props);r!==this.formattedValue&&(this.formattedValue=r)}}},methods:{change:function(e){this.$emit(\"input\",this.masked?e.target.value:n.i(u.d)(e.target.value,this.precision))}}}},function(e,t,n){\"use strict\";t.a=function(e,t){return e=e||{},t=t||{},Object.keys(e).concat(Object.keys(t)).reduce(function(n,r){return n[r]=void 0===t[r]?e[r]:t[r],n},{})}},function(e,t,n){var r=n(7)(n(4),n(8),null,null);e.exports=r.exports},function(e,t){e.exports=function(e,t,n,r){var i,u=e=e||{},o=typeof e.default;\"object\"!==o&&\"function\"!==o||(i=e,u=e.default);var a=\"function\"==typeof u?u.options:u;if(t&&(a.render=t.render,a.staticRenderFns=t.staticRenderFns),n&&(a._scopeId=n),r){var c=a.computed||(a.computed={});Object.keys(r).forEach(function(e){var t=r[e];c[e]=function(){return t}})}return{esModule:i,exports:u,options:a}}},function(e,t){e.exports={render:function(){var e=this,t=e.$createElement;return(e._self._c||t)(\"input\",{directives:[{name:\"money\",rawName:\"v-money\",value:{precision:e.precision,decimal:e.decimal,thousands:e.thousands,prefix:e.prefix,suffix:e.suffix},expression:\"{precision, decimal, thousands, prefix, suffix}\"}],staticClass:\"v-money\",attrs:{type:\"tel\"},domProps:{value:e.formattedValue},on:{change:e.change}})},staticRenderFns:[]}},function(e,t,n){e.exports=n(3)}])});","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ReCaptchaInstance = exports.getInstance = exports.load = void 0;\nvar ReCaptchaLoader_1 = require(\"./ReCaptchaLoader\");\nObject.defineProperty(exports, \"load\", { enumerable: true, get: function () { return ReCaptchaLoader_1.load; } });\nObject.defineProperty(exports, \"getInstance\", { enumerable: true, get: function () { return ReCaptchaLoader_1.getInstance; } });\nvar ReCaptchaInstance_1 = require(\"./ReCaptchaInstance\");\nObject.defineProperty(exports, \"ReCaptchaInstance\", { enumerable: true, get: function () { return ReCaptchaInstance_1.ReCaptchaInstance; } });\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; };\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    defineProperty(generator, \"_invoke\", { value: makeInvokeMethod(innerFn, self, context) });\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = GeneratorFunctionPrototype;\n  defineProperty(Gp, \"constructor\", { value: GeneratorFunctionPrototype, configurable: true });\n  defineProperty(\n    GeneratorFunctionPrototype,\n    \"constructor\",\n    { value: GeneratorFunction, configurable: true }\n  );\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    defineProperty(this, \"_invoke\", { value: enqueue });\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  });\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var methodName = context.method;\n    var method = delegate.iterator[methodName];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method, or a missing .next mehtod, always terminate the\n      // yield* loop.\n      context.delegate = null;\n\n      // Note: [\"return\"] must be used for ES3 parsing compatibility.\n      if (methodName === \"throw\" && delegate.iterator[\"return\"]) {\n        // If the delegate iterator has a return method, give it a\n        // chance to clean up.\n        context.method = \"return\";\n        context.arg = undefined;\n        maybeInvokeDelegate(delegate, context);\n\n        if (context.method === \"throw\") {\n          // If maybeInvokeDelegate(context) changed context.method from\n          // \"return\" to \"throw\", let that override the TypeError below.\n          return ContinueSentinel;\n        }\n      }\n      if (methodName !== \"return\") {\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a '\" + methodName + \"' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  define(Gp, iteratorSymbol, function() {\n    return this;\n  });\n\n  define(Gp, \"toString\", function() {\n    return \"[object Generator]\";\n  });\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(val) {\n    var object = Object(val);\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable || iterable === \"\") {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    throw new TypeError(typeof iterable + \" is not iterable\");\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, in modern engines\n  // we can explicitly access globalThis. In older engines we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ReCaptchaInstance = void 0;\nvar ReCaptchaInstance = (function () {\n    function ReCaptchaInstance(siteKey, recaptchaID, recaptcha) {\n        this.siteKey = siteKey;\n        this.recaptchaID = recaptchaID;\n        this.recaptcha = recaptcha;\n        this.styleContainer = null;\n    }\n    ReCaptchaInstance.prototype.execute = function (action) {\n        return __awaiter(this, void 0, void 0, function () {\n            return __generator(this, function (_a) {\n                return [2, this.recaptcha.enterprise ? this.recaptcha.enterprise.execute(this.recaptchaID, { action: action }) : this.recaptcha.execute(this.recaptchaID, { action: action })];\n            });\n        });\n    };\n    ReCaptchaInstance.prototype.getSiteKey = function () {\n        return this.siteKey;\n    };\n    ReCaptchaInstance.prototype.hideBadge = function () {\n        if (this.styleContainer !== null) {\n            return;\n        }\n        this.styleContainer = document.createElement('style');\n        this.styleContainer.innerHTML = '.grecaptcha-badge{visibility:hidden !important;}';\n        document.head.appendChild(this.styleContainer);\n    };\n    ReCaptchaInstance.prototype.showBadge = function () {\n        if (this.styleContainer === null) {\n            return;\n        }\n        document.head.removeChild(this.styleContainer);\n        this.styleContainer = null;\n    };\n    return ReCaptchaInstance;\n}());\nexports.ReCaptchaInstance = ReCaptchaInstance;\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getInstance = exports.load = void 0;\nvar ReCaptchaInstance_1 = require(\"./ReCaptchaInstance\");\nvar ELoadingState;\n(function (ELoadingState) {\n    ELoadingState[ELoadingState[\"NOT_LOADED\"] = 0] = \"NOT_LOADED\";\n    ELoadingState[ELoadingState[\"LOADING\"] = 1] = \"LOADING\";\n    ELoadingState[ELoadingState[\"LOADED\"] = 2] = \"LOADED\";\n})(ELoadingState || (ELoadingState = {}));\nvar ReCaptchaLoader = (function () {\n    function ReCaptchaLoader() {\n    }\n    ReCaptchaLoader.load = function (siteKey, options) {\n        if (options === void 0) { options = {}; }\n        if (typeof document === 'undefined') {\n            return Promise.reject(new Error('This is a library for the browser!'));\n        }\n        if (ReCaptchaLoader.getLoadingState() === ELoadingState.LOADED) {\n            if (ReCaptchaLoader.instance.getSiteKey() === siteKey) {\n                return Promise.resolve(ReCaptchaLoader.instance);\n            }\n            else {\n                return Promise.reject(new Error('reCAPTCHA already loaded with different site key!'));\n            }\n        }\n        if (ReCaptchaLoader.getLoadingState() === ELoadingState.LOADING) {\n            if (siteKey !== ReCaptchaLoader.instanceSiteKey) {\n                return Promise.reject(new Error('reCAPTCHA already loaded with different site key!'));\n            }\n            return new Promise(function (resolve, reject) {\n                ReCaptchaLoader.successfulLoadingConsumers.push(function (instance) { return resolve(instance); });\n                ReCaptchaLoader.errorLoadingRunnable.push(function (reason) { return reject(reason); });\n            });\n        }\n        ReCaptchaLoader.instanceSiteKey = siteKey;\n        ReCaptchaLoader.setLoadingState(ELoadingState.LOADING);\n        var loader = new ReCaptchaLoader();\n        return new Promise(function (resolve, reject) {\n            loader.loadScript(siteKey, options.useRecaptchaNet || false, options.useEnterprise || false, options.renderParameters ? options.renderParameters : {}, options.customUrl).then(function () {\n                ReCaptchaLoader.setLoadingState(ELoadingState.LOADED);\n                var widgetID = loader.doExplicitRender(grecaptcha, siteKey, options.explicitRenderParameters ? options.explicitRenderParameters : {}, options.useEnterprise || false);\n                var instance = new ReCaptchaInstance_1.ReCaptchaInstance(siteKey, widgetID, grecaptcha);\n                ReCaptchaLoader.successfulLoadingConsumers.forEach(function (v) { return v(instance); });\n                ReCaptchaLoader.successfulLoadingConsumers = [];\n                if (options.autoHideBadge) {\n                    instance.hideBadge();\n                }\n                ReCaptchaLoader.instance = instance;\n                resolve(instance);\n            }).catch(function (error) {\n                ReCaptchaLoader.errorLoadingRunnable.forEach(function (v) { return v(error); });\n                ReCaptchaLoader.errorLoadingRunnable = [];\n                reject(error);\n            });\n        });\n    };\n    ReCaptchaLoader.getInstance = function () {\n        return ReCaptchaLoader.instance;\n    };\n    ReCaptchaLoader.setLoadingState = function (state) {\n        ReCaptchaLoader.loadingState = state;\n    };\n    ReCaptchaLoader.getLoadingState = function () {\n        if (ReCaptchaLoader.loadingState === null) {\n            return ELoadingState.NOT_LOADED;\n        }\n        else {\n            return ReCaptchaLoader.loadingState;\n        }\n    };\n    ReCaptchaLoader.prototype.loadScript = function (siteKey, useRecaptchaNet, useEnterprise, renderParameters, customUrl) {\n        var _this = this;\n        if (useRecaptchaNet === void 0) { useRecaptchaNet = false; }\n        if (useEnterprise === void 0) { useEnterprise = false; }\n        if (renderParameters === void 0) { renderParameters = {}; }\n        if (customUrl === void 0) { customUrl = ''; }\n        var scriptElement = document.createElement('script');\n        scriptElement.setAttribute('recaptcha-v3-script', '');\n        var scriptBase = 'https://www.google.com/recaptcha/api.js';\n        if (useRecaptchaNet) {\n            if (useEnterprise) {\n                scriptBase = 'https://recaptcha.net/recaptcha/enterprise.js';\n            }\n            else {\n                scriptBase = 'https://recaptcha.net/recaptcha/api.js';\n            }\n        }\n        if (useEnterprise) {\n            scriptBase = 'https://www.google.com/recaptcha/enterprise.js';\n        }\n        if (customUrl) {\n            scriptBase = customUrl;\n        }\n        if (renderParameters.render) {\n            renderParameters.render = undefined;\n        }\n        var parametersQuery = this.buildQueryString(renderParameters);\n        scriptElement.src = scriptBase + '?render=explicit' + parametersQuery;\n        return new Promise(function (resolve, reject) {\n            scriptElement.addEventListener('load', _this.waitForScriptToLoad(function () {\n                resolve(scriptElement);\n            }, useEnterprise), false);\n            scriptElement.onerror = function (error) {\n                ReCaptchaLoader.setLoadingState(ELoadingState.NOT_LOADED);\n                reject(error);\n            };\n            document.head.appendChild(scriptElement);\n        });\n    };\n    ReCaptchaLoader.prototype.buildQueryString = function (parameters) {\n        var parameterKeys = Object.keys(parameters);\n        if (parameterKeys.length < 1) {\n            return '';\n        }\n        return '&' + Object.keys(parameters)\n            .filter(function (parameterKey) {\n            return !!parameters[parameterKey];\n        })\n            .map(function (parameterKey) {\n            return parameterKey + '=' + parameters[parameterKey];\n        }).join('&');\n    };\n    ReCaptchaLoader.prototype.waitForScriptToLoad = function (callback, useEnterprise) {\n        var _this = this;\n        return function () {\n            if (window.grecaptcha === undefined) {\n                setTimeout(function () {\n                    _this.waitForScriptToLoad(callback, useEnterprise);\n                }, ReCaptchaLoader.SCRIPT_LOAD_DELAY);\n            }\n            else {\n                if (useEnterprise) {\n                    window.grecaptcha.enterprise.ready(function () {\n                        callback();\n                    });\n                }\n                else {\n                    window.grecaptcha.ready(function () {\n                        callback();\n                    });\n                }\n            }\n        };\n    };\n    ReCaptchaLoader.prototype.doExplicitRender = function (grecaptcha, siteKey, parameters, isEnterprise) {\n        var augmentedParameters = {\n            sitekey: siteKey,\n            badge: parameters.badge,\n            size: parameters.size,\n            tabindex: parameters.tabindex\n        };\n        if (parameters.container) {\n            if (isEnterprise) {\n                return grecaptcha.enterprise.render(parameters.container, augmentedParameters);\n            }\n            else {\n                return grecaptcha.render(parameters.container, augmentedParameters);\n            }\n        }\n        else {\n            if (isEnterprise) {\n                return grecaptcha.enterprise.render(augmentedParameters);\n            }\n            else {\n                return grecaptcha.render(augmentedParameters);\n            }\n        }\n    };\n    ReCaptchaLoader.loadingState = null;\n    ReCaptchaLoader.instance = null;\n    ReCaptchaLoader.instanceSiteKey = null;\n    ReCaptchaLoader.successfulLoadingConsumers = [];\n    ReCaptchaLoader.errorLoadingRunnable = [];\n    ReCaptchaLoader.SCRIPT_LOAD_DELAY = 25;\n    return ReCaptchaLoader;\n}());\nexports.load = ReCaptchaLoader.load;\nexports.getInstance = ReCaptchaLoader.getInstance;\n"],"sourceRoot":""}