/*
  options.target      - name of the target object
  options.global      - target is the global object
  options.stat        - export as static methods of target
  options.proto       - export as prototype methods of target
  options.real        - real prototype method for the `pure` version
  options.forced      - export even if the native feature is available
  options.bind        - bind methods to the target, required for the `pure` version
  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
  options.sham        - add a flag to not completely full polyfills
  options.enumerable  - export as enumerable property
  options.noTargetGet - prevent calling a getter on target
  options.name        - the .name of the function if it does not match the key
*/

/* , mapfn = undefined, thisArg = undefined */

/* , thisArg */

/* empty */

/* eslint-disable es/no-array-prototype-keys -- safe */

/* eslint-disable es/no-symbol -- required for testing */

/* eslint-disable no-proto -- safe */

/* global ActiveXObject -- old IE, WSH */

/* harmony default export */

/* ignore */

/*#__PURE__*/

/**
 * Copyright (c) 2014-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

/******/

/***/

// "consumed" by the delegate iterator. If context.method was

// "return", allow the original .return call to continue in the

// .constructor.prototype properties for functions that return Generator

// .throw, and .return (see defineIteratorMethods).

// .throw, and .return methods.

// 2 ** 53 - 1 == 9007199254740991

// 25.4.3.1 Promise(executor)

// @@iterator function is called on it. Some browsers' implementations of the

// @ts-ignore

// A .throw or .return when the delegate iterator has no .throw

// A Generator should always return itself as the iterator object when the

// Array#includes uses SameValueZero equality algorithm

// Array#indexOf ignores holes, Array#includes - not

// Assign the result of the finished delegate to the temporary

// AsyncIterator objects; they just return a Promise for the value of

// Avoid propagating failures to Promises returned by later

// Be forgiving, per 25.3.3.3.3 of the spec:

// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should

// CONCATENATED MODULE: ./src/main/frontend/src/disable-login/src/createUsernamePasswordDisabledText.js

// CONCATENATED MODULE: ./src/main/frontend/src/disable-login/src/disable-login.js

// CONCATENATED MODULE: ./src/main/frontend/src/disable-login/src/disableLoginFields.js

// CONCATENATED MODULE: ./src/main/frontend/src/disable-login/src/fetchDisabledText.ts

// CONCATENATED MODULE: ./src/main/frontend/src/disable-login/src/index.ts

// CSP to forbid Function, and you're not willing to fix either of those

// Call delegate.iterator[context.method](context.arg) and handle the

// Chrome 38 Symbol has incorrect toString conversion

// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances

// Define Generator.prototype.{next,throw,return} in terms of the

// Define the unified helper method that is used to implement .next,

// Deliberately forget the last sent value so that we don't

// Deno throws a ReferenceError on `location` access without `--location` flag

// Detect IE8's incomplete defineProperty implementation

// Detect correctness of subclassing with @@species support

// Dispatch the exception by looping back around to the

// Don't enum bug & hidden keys

// Dummy constructor functions that we use as the .constructor and

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.object.to-string.js

// EXTERNAL MODULE: ./node_modules/core-js/modules/es.promise.js

// Exception thrown outside of any try block that could handle

// FF44- legacy iterators case

// For the native GeneratorFunction constructor, the best we can

// GenStateExecuting and loop back for another invocation.

// Helper for a popular repeating case of the spec:

// Helper for defining the .next, .throw, and .return methods of the

// IE 8 has a broken Object.defineProperty that only works on DOM objects.

// IE8- don't enum bug keys

// If a rejected Promise was yielded, throw the rejection back

// If an exception is thrown from innerFn, we leave state ===

// If context.method was "throw" but the delegate handled the

// If enqueue has been called before, then we want to wait until

// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).

// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.

// If the delegate iterator has a return method, give it a

// If the dispatched exception was caught by a catch block,

// Ignore the finally entry if control is not jumping to a

// Iterator interface in terms of a single ._invoke method.

// Let integer be ? ToInteger(index).

// Node.js 0.8-

// Node.js 0.9+ & IE10+ has setImmediate, otherwise:

// Not sure about the optimal order of these conditions:

// Note that simple async functions are implemented on top of

// Note: ["return"] must be used for ES3 parsing compatibility.

// Promise.resolve without an argument throws an error in LG WebOS 2

// Rather than returning an object with a next method, we keep

// Regardless of whether this script is executing as a CommonJS module

// Resetting context._sent for legacy support of Babel's

// Resume execution at the desired location (see delegateYield).

// Return an iterator with no values.

// Safari 8 has buggy iterators w/o `next`

// See https://github.com/facebook/regenerator/issues/274 for more details.

// Set @@toStringTag to native iterators

// Setting context._sent for legacy support of Babel's

// Thank's IE8 for his funny defineProperty

// The ._invoke method unifies the implementations of the .next,

// The context.catch method must only be called with a location

// The delegate iterator is finished, so forget it and continue with

// The root entry object (effectively a try statement without a catch

// This environment has a native %IteratorPrototype%; use it instead

// This is a polyfill for %IteratorPrototype% for environments that

// This module should not be running in strict mode, so the above

// To avoid creating an additional object, we just hang the .value

// Try/catch helper to minimize deoptimizations. Returns a completion

// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test

// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables

// WSH

// We can't detect it synchronously, so just check versions

// We can't use @@species feature detection in V8 since it causes

// We need Promise#finally in the pure version for preventing prototype pollution

// When a yielded Promise is resolved, its final value becomes

// Within the body of any async function, `await x` is transformed to

// Works with __proto__ only. Old v8 can't work with null proto objects.

// `%IteratorPrototype%[@@iterator]()` method

// `%StringIteratorPrototype%.next` method

// `Array.from` method

// `Array.from` method implementation

// `Array.prototype.every` method

// `Array.prototype.filterReject` method

// `Array.prototype.filter` method

// `Array.prototype.findIndex` method

// `Array.prototype.find` method

// `Array.prototype.forEach` method

// `Array.prototype.forEach` method implementation

// `Array.prototype.includes` method

// `Array.prototype.indexOf` method

// `Array.prototype.map` method

// `Array.prototype.some` method

// `ArraySpeciesCreate` abstract operation

// `Assert: IsCallable(argument) is true`

// `Assert: IsConstructor(argument) is true`

// `Assert: Type(argument) is Object`

// `GetMethod` abstract operation

// `IsArray` abstract operation

// `IsCallable` abstract operation

// `IsConstructor` abstract operation

// `NewPromiseCapability` abstract operation

// `Object.create` method

// `Object.defineProperties` method

// `Object.defineProperty` method

// `Object.getOwnPropertyDescriptor` method

// `Object.getOwnPropertyNames` method

// `Object.getPrototypeOf` method

// `Object.keys` method

// `Object.prototype.propertyIsEnumerable` method implementation

// `Object.prototype.toString` method

// `Object.prototype.toString` method implementation

// `Object.setPrototypeOf` method

// `OrdinaryToPrimitive` abstract operation

// `Promise.all` method

// `Promise.prototype.catch` method

// `Promise.prototype.then` method

// `Promise.race` method

// `Promise.reject` method

// `Promise.resolve` method

// `RequireObjectCoercible` abstract operation

// `SpeciesConstructor` abstract operation

// `String.prototype.at` method

// `String.prototype.codePointAt` method

// `String.prototype[@@iterator]` method

// `ToInteger` abstract operation

// `ToLength` abstract operation

// `ToObject` abstract operation

// `ToPrimitive` abstract operation

// `ToPropertyKey` abstract operation

// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances

// `hasOwn.call(value, "__await")` to determine if the yielded value is

// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test

// a part of `ArraySpeciesCreate` abstract operation

// accidentally pass it on to the delegate.

// add "__proto__" for Object.getPrototypeOf polyfill

// add a flag to not completely full polyfills

// all object keys, includes non-enumerable and symbols

// all previous Promises have been resolved before calling invoke,

// already have an existing method we want to call, so there's no need

// also ensures that the minifier will not anonymize the function.

// also except WebOS Webkit https://github.com/zloirock/core-js/issues/898

// and .done properties off the next function object itself. This

// any necessary setup in a predictable way. This predictability

// argument that corresponds to a known catch block.

// assignment should always work unless something is misconfigured. Just

// async functions in terms of async generators, it is especially

// avoid memory leak

// browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339

// call invoke immediately, without waiting on a callback to fire,

// call something on iterator step with safe closing on error

// can throw

// chance to clean up.

// check on default Array iterator

// constructor polyfill

// contained in target

// context.dispatchException(context.arg) call above.

// context.method was "next", forget context.arg since it has been

// cross-realm fallback

// current iteration.

// define iterator

// delegate iterator, or by modifying context.method and context.arg,

// deoptimization and performance degradation

// do is to check its .name property.

// don't natively support it.

// enqueue has not been called before, then it is important to

// eslint-disable-next-line es/no-array-from -- required for testing

// eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing

// eslint-disable-next-line es/no-array-isarray -- safe

// eslint-disable-next-line es/no-array-prototype-foreach -- safe

// eslint-disable-next-line es/no-global-this -- safe

// eslint-disable-next-line es/no-object-defineproperties -- safe

// eslint-disable-next-line es/no-object-defineproperty -- requied for testing

// eslint-disable-next-line es/no-object-defineproperty -- required for testing

// eslint-disable-next-line es/no-object-defineproperty -- safe

// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe

// eslint-disable-next-line es/no-object-getownpropertynames -- safe

// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing

// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe

// eslint-disable-next-line es/no-object-getprototypeof -- required for testing

// eslint-disable-next-line es/no-object-getprototypeof -- safe

// eslint-disable-next-line es/no-object-keys -- safe

// eslint-disable-next-line es/no-object-setprototypeof -- safe

// eslint-disable-next-line no-new-func -- fallback

// eslint-disable-next-line no-new-func -- spec requirement

// eslint-disable-next-line no-prototype-builtins -- safe

// eslint-disable-next-line no-restricted-globals -- safe

// eslint-disable-next-line no-self-compare -- NaN check

// eslint-disable-next-line no-unused-vars -- required for `.length`

// eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing

// every

// exception, let the outer generator proceed normally. If

// execute code before the first await. Since we implement simple

// executor callback, and why async functions synchronously

// export additional methods

// extend global

// fallback for non-array-like ES3 and non-enumerable old V8 strings

// filter

// filterReject

// find

// findIndex

// fix Array.prototype.{ values, @@iterator }.name in V8 / FF

// fix native

// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods

// function.sent implementation.

// getting tag from ES6+ `Object.prototype.toString`

// has a stable shape and so hopefully should be cheap to allocate.

// have been (and was previously) designed to take a closure to be

// https://bugs.chromium.org/p/chromium/issues/detail?id=830565

// https://github.com/mathiasbynens/String.prototype.at

// https://github.com/tc39/proposal-array-filtering

// https://github.com/zloirock/core-js/issues/475

// https://github.com/zloirock/core-js/issues/640

// https://github.com/zloirock/core-js/issues/679

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028

// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume

// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator

// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next

// https://tc39.es/ecma262/#sec-array.from

// https://tc39.es/ecma262/#sec-array.prototype.every

// https://tc39.es/ecma262/#sec-array.prototype.filter

// https://tc39.es/ecma262/#sec-array.prototype.find

// https://tc39.es/ecma262/#sec-array.prototype.findIndex

// https://tc39.es/ecma262/#sec-array.prototype.foreach

// https://tc39.es/ecma262/#sec-array.prototype.includes

// https://tc39.es/ecma262/#sec-array.prototype.indexof

// https://tc39.es/ecma262/#sec-array.prototype.map

// https://tc39.es/ecma262/#sec-array.prototype.some

// https://tc39.es/ecma262/#sec-arrayspeciescreate

// https://tc39.es/ecma262/#sec-getmethod

// https://tc39.es/ecma262/#sec-isarray

// https://tc39.es/ecma262/#sec-iscallable

// https://tc39.es/ecma262/#sec-isconstructor

// https://tc39.es/ecma262/#sec-newpromisecapability

// https://tc39.es/ecma262/#sec-object.create

// https://tc39.es/ecma262/#sec-object.defineproperties

// https://tc39.es/ecma262/#sec-object.defineproperty

// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor

// https://tc39.es/ecma262/#sec-object.getownpropertynames

// https://tc39.es/ecma262/#sec-object.getprototypeof

// https://tc39.es/ecma262/#sec-object.keys

// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable

// https://tc39.es/ecma262/#sec-object.prototype.tostring

// https://tc39.es/ecma262/#sec-object.setprototypeof

// https://tc39.es/ecma262/#sec-ordinarytoprimitive

// https://tc39.es/ecma262/#sec-promise.all

// https://tc39.es/ecma262/#sec-promise.prototype.catch

// https://tc39.es/ecma262/#sec-promise.prototype.then

// https://tc39.es/ecma262/#sec-promise.race

// https://tc39.es/ecma262/#sec-promise.reject

// https://tc39.es/ecma262/#sec-promise.resolve

// https://tc39.es/ecma262/#sec-requireobjectcoercible

// https://tc39.es/ecma262/#sec-speciesconstructor

// https://tc39.es/ecma262/#sec-string.prototype-@@iterator

// https://tc39.es/ecma262/#sec-string.prototype.codepointat

// https://tc39.es/ecma262/#sec-tointeger

// https://tc39.es/ecma262/#sec-tolength

// https://tc39.es/ecma262/#sec-toobject

// https://tc39.es/ecma262/#sec-toprimitive

// https://tc39.es/ecma262/#sec-topropertykey

// if a Content Security Policy forbids using Function, but in that case

// if the target is not iterable or it's an array with the default iterator - use a simple case

// important to get this right, even though it requires care.

// in case runtime.js accidentally runs in strict mode, in modern engines

// in every case, so we don't have to touch the arguments object. The

// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`

// injected easily by `bin/regenerator --include-runtime script.js`.

// into the async generator function so it can be handled there.

// invocations of the iterator.

// invoked without arguments, but in all the cases we care about we

// is why the Promise constructor synchronously invokes its

// it, so set the completion value of the entire function to

// iterable DOM collections

// iterator prototype chain incorrectly implement this, causing the Generator

// location outside the try/catch block.

// locations where there is no enclosing try statement.

// make `.constructor === Promise` work for native promise-based APIs

// make `Promise#then` return a polyfilled `Promise` for native promise-based APIs

// make `instanceof Promise` work for native promise-based APIs

// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`

// map

// meant to be awaited.

// method, or a missing .next mehtod, always terminate the

// minifier not to mangle the names of these two functions.

// modern engines have queueMicrotask method

// object to not be returned from this call. This ensures that doesn't happen.

// objects. For full spec compliance, you may wish to configure your

// of the polyfill.

// old engines have not location.origin

// only additional allocation required is the completion record, which

// optimisation for array iterators

// optional / simple context binding

// or a finally block) gives us a place to store values thrown from

// or not, return the runtime object so that we can declare the variable

// outer generator.

// problems, please detail your unique predicament in a GitHub issue.

// record like context.tryEntries[i].completion. This interface could

// regeneratorRuntime in the outer scope, which allows this module to be

// result, either by returning a { value, done } result from the

// setting context.delegate to null, and returning the ContinueSentinel.

// so that results are always delivered in the correct order. If

// so that the async generator function has the opportunity to do

// some

// some Chrome versions have non-configurable methods on DOMTokenList

// statics

// strange IE + webpack dev server bug - use .call(global)

// strict mode using a global Function call. This could conceivably fail

// the .value of the Promise<{value,done}> result for the

// the final result produced by the iterator.

// the method takes exactly one argument, since that happens to be true

// the outer generator.

// the proper solution is to fix the accidental strict mode problem. If

// then let that catch block handle the exception normally.

// things simple and return the next function itself.

// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper

// throw the exception.

// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346

// to create a new function object. We can even get away with assuming

// toObject with fallback for non-array-like ES3 strings

// unified ._invoke helper method.

// variable length - can't use forEach

// variable specified by delegate.resultName (see delegateYield).

// we can explicitly access globalThis. In older engines we can escape

// we can't check .prototype since constructors produced by .bind haven't it

// webpackRuntimeModules

// workaround of WebKit ~ iOS Safari 10.1 bug

// yield* loop.

// you've misconfigured your bundler to force strict mode and applied a

//if (usernameInput !== null) {
