{"version":3,"sources":["webpack:///./node_modules/tiny-cookie/tiny-cookie.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/shvl/dist/shvl.es.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/recaptcha-v3/dist/ReCaptchaLoader.js"],"names":["root","factory","this","Cookie","key","value","opts","get","remove","set","escapeRe","str","replace","convert","res","p","hasOwnProperty","expires","computeExpires","toUTCString","Date","lastCh","charAt","length","parseInt","setFullYear","getFullYear","setMonth","getMonth","setDate","getDate","setHours","getHours","setMinutes","getMinutes","setSeconds","getSeconds","enabled","document","cookie","raw","reKey","RegExp","exec","decodeURIComponent","getRaw","encodeURIComponent","setRaw","Object","defineProperty","exports","ReCaptchaLoader_1","load","getInstance","ReCaptchaInstance_1","ReCaptchaInstance","global","undefined","Op","prototype","hasOwn","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","inModule","module","runtime","regeneratorRuntime","wrap","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","call","Gp","GeneratorFunctionPrototype","Generator","create","GeneratorFunction","constructor","displayName","isGeneratorFunction","genFun","ctor","name","mark","setPrototypeOf","__proto__","awrap","arg","__await","defineIteratorMethods","AsyncIterator","async","innerFn","outerFn","self","tryLocsList","iter","next","then","result","done","toString","keys","object","push","reverse","pop","Context","reset","skipTempReset","prev","sent","_sent","delegate","method","tryEntries","forEach","resetTryEntry","isNaN","slice","stop","rootEntry","rootRecord","completion","type","rval","dispatchException","exception","context","handle","loc","caught","record","i","entry","tryLoc","hasCatch","hasFinally","catchLoc","finallyLoc","Error","abrupt","finallyEntry","complete","afterLoc","finish","thrown","delegateYield","iterable","resultName","nextLoc","protoGenerator","generator","_invoke","makeInvokeMethod","tryCatch","fn","obj","err","invoke","resolve","reject","Promise","unwrapped","previousPromise","enqueue","callInvokeWithMethodAndArg","state","doneResult","delegateResult","maybeInvokeDelegate","return","TypeError","info","pushTryEntry","locs","iteratorMethod","Function","siteKey","recaptcha","styleContainer","execute","action","_this","getSiteKey","hideBadge","createElement","innerHTML","head","appendChild","showBadge","removeChild","t","n","r","split","reduce","e","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","fun","setTimeout","runClearTimeout","marker","clearTimeout","currentQueue","queue","draining","queueIndex","cleanUpNextTick","concat","drainQueue","timeout","len","run","Item","array","noop","nextTick","args","Array","arguments","apply","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","ELoadingState","ReCaptchaLoader","options","getLoadingState","LOADED","instance","LOADING","instanceSiteKey","successfulLoadingConsumers","errorLoadingRunnable","reason","setLoadingState","loader","loadScript","useRecaptchaNet","renderParameters","grecaptcha","v","autoHideBadge","catch","error","loadingState","NOT_LOADED","scriptElement","setAttribute","scriptBase","parametersQuery","buildQueryString","src","addEventListener","waitForScriptToLoad","onerror","parameters","parameterKeys","map","parameterKey","callback","window","ready"],"mappings":"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","file":"js/chunk-vendors~f9ca8911-legacy.e07e866b.js","sourcesContent":["/*!\n * tiny-cookie - A tiny cookie manipulation plugin\n * https://github.com/Alex1990/tiny-cookie\n * Under the MIT license | (c) Alex Chao\n */\n\n!(function(root, factory) {\n\n  // Uses CommonJS, AMD or browser global to create a jQuery plugin.\n  // See: https://github.com/umdjs/umd\n  if (typeof define === 'function' && define.amd) {\n    // Expose this plugin as an AMD module. Register an anonymous module.\n    define(factory);\n  } else if (typeof exports === 'object') {\n    // Node/CommonJS module\n    module.exports = factory();\n  } else {\n    // Browser globals \n    root.Cookie = factory();\n  }\n\n}(this, function() {\n\n  'use strict';\n\n  // The public function which can get/set/remove cookie.\n  function Cookie(key, value, opts) {\n    if (value === void 0) {\n      return Cookie.get(key);\n    } else if (value === null) {\n      Cookie.remove(key);\n    } else {\n      Cookie.set(key, value, opts);\n    }\n  }\n\n  // Check if the cookie is enabled.\n  Cookie.enabled = function() {\n    var key = '__test_key';\n    var enabled;\n\n    document.cookie = key + '=1';\n    enabled = !!document.cookie;\n\n    if (enabled) Cookie.remove(key);\n\n    return enabled;\n  };\n\n  // Get the cookie value by the key.\n  Cookie.get = function(key, raw) {\n    if (typeof key !== 'string' || !key) return null;\n\n    key = '(?:^|; )' + escapeRe(key) + '(?:=([^;]*?))?(?:;|$)';\n\n    var reKey = new RegExp(key);\n    var res = reKey.exec(document.cookie);\n\n    return res !== null ? (raw ? res[1] : decodeURIComponent(res[1])) : null;\n  };\n\n  // Get the cookie's value without decoding.\n  Cookie.getRaw = function(key) {\n    return Cookie.get(key, true);\n  };\n\n  // Set a cookie.\n  Cookie.set = function(key, value, raw, opts) {\n    if (raw !== true) {\n      opts = raw;\n      raw = false;\n    }\n    opts = opts ? convert(opts) : convert({});\n    var cookie = key + '=' + (raw ? value : encodeURIComponent(value)) + opts;\n    document.cookie = cookie;\n  };\n\n  // Set a cookie without encoding the value.\n  Cookie.setRaw = function(key, value, opts) {\n    Cookie.set(key, value, true, opts);\n  };\n\n  // Remove a cookie by the specified key.\n  Cookie.remove = function(key) {\n    Cookie.set(key, 'a', { expires: new Date() });\n  };\n\n  // Helper function\n  // ---------------\n\n  // Escape special characters.\n  function escapeRe(str) {\n    return str.replace(/[.*+?^$|[\\](){}\\\\-]/g, '\\\\$&');\n  }\n\n  // Convert an object to a cookie option string.\n  function convert(opts) {\n    var res = '';\n\n    for (var p in opts) {\n      if (opts.hasOwnProperty(p)) {\n\n        if (p === 'expires') {\n          var expires = opts[p];\n          if (typeof expires !== 'object') {\n            expires += typeof expires === 'number' ? 'D' : '';\n            expires = computeExpires(expires);\n          }\n          opts[p] = expires.toUTCString();\n        }\n\n        if (p === 'secure') {\n          if (opts[p]) {\n            res += ';' + p;\n          }\n\n          continue;\n        }\n\n        res += ';' + p + '=' + opts[p];\n      }\n    }\n\n    if (!opts.hasOwnProperty('path')) {\n      res += ';path=/';\n    }\n\n    return res;\n  }\n\n  // Return a future date by the given string.\n  function computeExpires(str) {\n    var expires = new Date();\n    var lastCh = str.charAt(str.length - 1);\n    var value = parseInt(str, 10);\n\n    switch (lastCh) {\n      case 'Y': expires.setFullYear(expires.getFullYear() + value); break;\n      case 'M': expires.setMonth(expires.getMonth() + value); break;\n      case 'D': expires.setDate(expires.getDate() + value); break;\n      case 'h': expires.setHours(expires.getHours() + value); break;\n      case 'm': expires.setMinutes(expires.getMinutes() + value); break;\n      case 's': expires.setSeconds(expires.getSeconds() + value); break;\n      default: expires = new Date(str);\n    }\n\n    return expires;\n  }\n\n  return Cookie;\n\n}));\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ReCaptchaLoader_1 = require(\"./ReCaptchaLoader\");\nexports.load = ReCaptchaLoader_1.load;\nexports.getInstance = ReCaptchaLoader_1.getInstance;\nvar ReCaptchaInstance_1 = require(\"./ReCaptchaInstance\");\nexports.ReCaptchaInstance = 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\n!(function(global) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\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  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\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    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  runtime.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  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 = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\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      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.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  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\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  runtime.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\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 Promise.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 Promise.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. If the Promise is rejected, however, the\n          // result for this iteration will be rejected with the same\n          // reason. Note that rejections of yielded Promises are not\n          // thrown back into the generator function, as is the case\n          // when an awaited Promise is rejected. This difference in\n          // behavior between yield and await is important, because it\n          // allows the consumer to decide what to do with the yielded\n          // rejection (swallow it and continue, manually .throw it back\n          // into the generator, abandon iteration, whatever). With\n          // await, by contrast, there is no opportunity to examine the\n          // rejection reason outside the generator function, so the\n          // only option is to throw it from the await expression, and\n          // let the generator function handle the exception.\n          result.value = unwrapped;\n          resolve(result);\n        }, reject);\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(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    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  runtime.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  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.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 method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        if (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\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' 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  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  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  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  runtime.keys = function(object) {\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) {\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    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  runtime.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  // In sloppy mode, unbound `this` refers to the global object, fallback to\n  // Function constructor if we're in global strict mode. That is sadly a form\n  // of indirect eval which violates Content Security Policy.\n  (function() { return this })() || Function(\"return this\")()\n);\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ReCaptchaInstance = (function () {\n    function ReCaptchaInstance(siteKey, recaptcha) {\n        this.siteKey = siteKey;\n        this.recaptcha = recaptcha;\n        this.styleContainer = null;\n    }\n    ReCaptchaInstance.prototype.execute = function (action) {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            _this.recaptcha.execute(_this.siteKey, { action: action }).then(resolve, reject);\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        this.styleContainer = document.createElement('style');\n        this.styleContainer.innerHTML = '.grecaptcha-badge{display:none !important;}';\n        document.head.appendChild(this.styleContainer);\n    };\n    ReCaptchaInstance.prototype.showBadge = function () {\n        if (this.styleContainer === null)\n            return;\n        document.head.removeChild(this.styleContainer);\n        this.styleContainer = null;\n    };\n    return ReCaptchaInstance;\n}());\nexports.ReCaptchaInstance = ReCaptchaInstance;\n","function t(t,n,r){return void 0===(t=(n.split?n.split(\".\"):n).reduce(function(t,n){return t&&t[n]},t))?r:t}function n(t,n,r,e){return(n=n.split?n.split(\".\"):n).slice(0,-1).reduce(function(t,n){return t[n]=t[n]||{}},t)[n.pop()]=r,t}export{t as get,n as set};\n//# sourceMappingURL=shvl.es.js.map\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 });\nvar ReCaptchaInstance_1 = require(\"./ReCaptchaInstance\");\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        if (ReCaptchaLoader.getLoadingState() === ELoadingState.LOADED)\n            if (ReCaptchaLoader.instance.getSiteKey() === siteKey)\n                return Promise.resolve(ReCaptchaLoader.instance);\n            else\n                return Promise.reject(new Error('reCAPTCHA already loaded with different site key!'));\n        if (ReCaptchaLoader.getLoadingState() === ELoadingState.LOADING) {\n            if (siteKey !== ReCaptchaLoader.instanceSiteKey)\n                return Promise.reject('reCAPTCHA already loaded with different site key!');\n            return new Promise(function (resolve, reject) {\n                ReCaptchaLoader.successfulLoadingConsumers.push(function (instance) { return resolve(instance); });\n                ReCaptchaLoader.errorLoadingRunnable.push(function (reason) { return reject(); });\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.renderParameters || {}).then(function () {\n                ReCaptchaLoader.setLoadingState(ELoadingState.LOADED);\n                var instance = new ReCaptchaInstance_1.ReCaptchaInstance(siteKey, grecaptcha);\n                ReCaptchaLoader.successfulLoadingConsumers.forEach(function (v) { return v(instance); });\n                ReCaptchaLoader.successfulLoadingConsumers = [];\n                if (options.autoHideBadge || false)\n                    instance.hideBadge();\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        else\n            return ReCaptchaLoader.loadingState;\n    };\n    ReCaptchaLoader.prototype.loadScript = function (siteKey, useRecaptchaNet, renderParameters) {\n        var _this = this;\n        if (useRecaptchaNet === void 0) { useRecaptchaNet = false; }\n        if (renderParameters === void 0) { renderParameters = {}; }\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            scriptBase = 'https://recaptcha.net/recaptcha/api.js';\n        var parametersQuery = this.buildQueryString(renderParameters);\n        scriptElement.src = scriptBase + '?render=' + siteKey + parametersQuery;\n        return new Promise(function (resolve, reject) {\n            scriptElement.addEventListener('load', _this.waitForScriptToLoad(function () {\n                resolve(scriptElement);\n            }), false);\n            scriptElement.onerror = function (error) {\n                reject(new Error('Something went wrong while loading ReCaptcha. (' + error.toString() + ')'));\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        return '&' + Object.keys(parameters).map(function (parameterKey) {\n            return parameterKey + '=' + parameters[parameterKey];\n        });\n    };\n    ReCaptchaLoader.prototype.waitForScriptToLoad = function (callback) {\n        var _this = this;\n        return function () {\n            if (window.grecaptcha === undefined)\n                setTimeout(function () {\n                    _this.waitForScriptToLoad(callback);\n                }, 25);\n            else\n                window.grecaptcha.ready(function () {\n                    callback();\n                });\n        };\n    };\n    ReCaptchaLoader.loadingState = null;\n    ReCaptchaLoader.instance = null;\n    ReCaptchaLoader.instanceSiteKey = null;\n    ReCaptchaLoader.successfulLoadingConsumers = [];\n    ReCaptchaLoader.errorLoadingRunnable = [];\n    return ReCaptchaLoader;\n}());\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 = {}));\nexports.load = ReCaptchaLoader.load;\nexports.getInstance = ReCaptchaLoader.getInstance;\n"],"sourceRoot":""}