@frollo/frollo-web-ui 2.0.0 → 3.0.1

package/esm/add-to-unscopables-2400f45b.js

@@ -0,0 +1,25 @@
+import { w as wellKnownSymbol$1, F as objectDefineProperty } from './is-forced-752b5893.js';
+import { o as objectCreate } from './object-create-f6f3a673.js';
+
+var wellKnownSymbol = wellKnownSymbol$1;
+var create = objectCreate;
+var defineProperty = objectDefineProperty.f;
+
+var UNSCOPABLES = wellKnownSymbol('unscopables');
+var ArrayPrototype = Array.prototype;
+
+// Array.prototype[@@unscopables]
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+if (ArrayPrototype[UNSCOPABLES] == undefined) {
+  defineProperty(ArrayPrototype, UNSCOPABLES, {
+    configurable: true,
+    value: create(null)
+  });
+}
+
+// add a key to Array.prototype[@@unscopables]
+var addToUnscopables = function (key) {
+  ArrayPrototype[UNSCOPABLES][key] = true;
+};
+
+export { addToUnscopables as a };

package/esm/array-iteration-107f927f.js

@@ -0,0 +1,92 @@
+import { f as functionUncurryThis, k as aCallable$1, R as functionBindNative, S as indexedObject, e as toObject$1, l as lengthOfArrayLike$1 } from './is-forced-752b5893.js';
+import { a as arraySpeciesCreate$1 } from './array-species-create-a5f5503b.js';
+
+var uncurryThis$1 = functionUncurryThis;
+var aCallable = aCallable$1;
+var NATIVE_BIND = functionBindNative;
+
+var bind$1 = uncurryThis$1(uncurryThis$1.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind$1(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var bind = functionBindContext;
+var uncurryThis = functionUncurryThis;
+var IndexedObject = indexedObject;
+var toObject = toObject$1;
+var lengthOfArrayLike = lengthOfArrayLike$1;
+var arraySpeciesCreate = arraySpeciesCreate$1;
+
+var push = uncurryThis([].push);
+
+// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
+var createMethod = function (TYPE) {
+  var IS_MAP = TYPE == 1;
+  var IS_FILTER = TYPE == 2;
+  var IS_SOME = TYPE == 3;
+  var IS_EVERY = TYPE == 4;
+  var IS_FIND_INDEX = TYPE == 6;
+  var IS_FILTER_REJECT = TYPE == 7;
+  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+  return function ($this, callbackfn, that, specificCreate) {
+    var O = toObject($this);
+    var self = IndexedObject(O);
+    var boundFunction = bind(callbackfn, that);
+    var length = lengthOfArrayLike(self);
+    var index = 0;
+    var create = specificCreate || arraySpeciesCreate;
+    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
+    var value, result;
+    for (;length > index; index++) if (NO_HOLES || index in self) {
+      value = self[index];
+      result = boundFunction(value, index, O);
+      if (TYPE) {
+        if (IS_MAP) target[index] = result; // map
+        else if (result) switch (TYPE) {
+          case 3: return true;              // some
+          case 5: return value;             // find
+          case 6: return index;             // findIndex
+          case 2: push(target, value);      // filter
+        } else switch (TYPE) {
+          case 4: return false;             // every
+          case 7: push(target, value);      // filterReject
+        }
+      }
+    }
+    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
+  };
+};
+
+var arrayIteration = {
+  // `Array.prototype.forEach` method
+  // https://tc39.es/ecma262/#sec-array.prototype.foreach
+  forEach: createMethod(0),
+  // `Array.prototype.map` method
+  // https://tc39.es/ecma262/#sec-array.prototype.map
+  map: createMethod(1),
+  // `Array.prototype.filter` method
+  // https://tc39.es/ecma262/#sec-array.prototype.filter
+  filter: createMethod(2),
+  // `Array.prototype.some` method
+  // https://tc39.es/ecma262/#sec-array.prototype.some
+  some: createMethod(3),
+  // `Array.prototype.every` method
+  // https://tc39.es/ecma262/#sec-array.prototype.every
+  every: createMethod(4),
+  // `Array.prototype.find` method
+  // https://tc39.es/ecma262/#sec-array.prototype.find
+  find: createMethod(5),
+  // `Array.prototype.findIndex` method
+  // https://tc39.es/ecma262/#sec-array.prototype.findIndex
+  findIndex: createMethod(6),
+  // `Array.prototype.filterReject` method
+  // https://github.com/tc39/proposal-array-filtering
+  filterReject: createMethod(7)
+};
+
+export { arrayIteration as a, functionBindContext as f };

package/esm/array-method-has-species-support-3d413468.js

@@ -0,0 +1,23 @@
+import { h as fails$1, w as wellKnownSymbol$1, m as engineV8Version } from './is-forced-752b5893.js';
+
+var fails = fails$1;
+var wellKnownSymbol = wellKnownSymbol$1;
+var V8_VERSION = engineV8Version;
+
+var SPECIES = wellKnownSymbol('species');
+
+var arrayMethodHasSpeciesSupport = function (METHOD_NAME) {
+  // We can't use this feature detection in V8 since it causes
+  // deoptimization and serious performance degradation
+  // https://github.com/zloirock/core-js/issues/677
+  return V8_VERSION >= 51 || !fails(function () {
+    var array = [];
+    var constructor = array.constructor = {};
+    constructor[SPECIES] = function () {
+      return { foo: 1 };
+    };
+    return array[METHOD_NAME](Boolean).foo !== 1;
+  });
+};
+
+export { arrayMethodHasSpeciesSupport as a };

package/esm/array-method-is-strict-055b1830.js

@@ -0,0 +1,14 @@
+import { h as fails$1 } from './is-forced-752b5893.js';
+
+'use strict';
+var fails = fails$1;
+
+var arrayMethodIsStrict = function (METHOD_NAME, argument) {
+  var method = [][METHOD_NAME];
+  return !!method && fails(function () {
+    // eslint-disable-next-line no-useless-call -- required for testing
+    method.call(null, argument || function () { return 1; }, 1);
+  });
+};
+
+export { arrayMethodIsStrict as a };

package/esm/array-species-create-a5f5503b.js

@@ -0,0 +1,97 @@
+import { p as classofRaw, f as functionUncurryThis, h as fails$1, x as isCallable$1, B as getBuiltIn$1, V as inspectSource$1, n as isObject$1, w as wellKnownSymbol$1 } from './is-forced-752b5893.js';
+import { c as classof$2 } from './classof-39c30bd5.js';
+
+var classof$1 = classofRaw;
+
+// `IsArray` abstract operation
+// https://tc39.es/ecma262/#sec-isarray
+// eslint-disable-next-line es-x/no-array-isarray -- safe
+var isArray$1 = Array.isArray || function isArray(argument) {
+  return classof$1(argument) == 'Array';
+};
+
+var uncurryThis = functionUncurryThis;
+var fails = fails$1;
+var isCallable = isCallable$1;
+var classof = classof$2;
+var getBuiltIn = getBuiltIn$1;
+var inspectSource = inspectSource$1;
+
+var noop = function () { /* empty */ };
+var empty = [];
+var construct = getBuiltIn('Reflect', 'construct');
+var constructorRegExp = /^\s*(?:class|function)\b/;
+var exec = uncurryThis(constructorRegExp.exec);
+var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
+
+var isConstructorModern = function isConstructor(argument) {
+  if (!isCallable(argument)) return false;
+  try {
+    construct(noop, empty, argument);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+var isConstructorLegacy = function isConstructor(argument) {
+  if (!isCallable(argument)) return false;
+  switch (classof(argument)) {
+    case 'AsyncFunction':
+    case 'GeneratorFunction':
+    case 'AsyncGeneratorFunction': return false;
+  }
+  try {
+    // we can't check .prototype since constructors produced by .bind haven't it
+    // `Function#toString` throws on some built-it function in some legacy engines
+    // (for example, `DOMQuad` and similar in FF41-)
+    return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
+  } catch (error) {
+    return true;
+  }
+};
+
+isConstructorLegacy.sham = true;
+
+// `IsConstructor` abstract operation
+// https://tc39.es/ecma262/#sec-isconstructor
+var isConstructor$1 = !construct || fails(function () {
+  var called;
+  return isConstructorModern(isConstructorModern.call)
+    || !isConstructorModern(Object)
+    || !isConstructorModern(function () { called = true; })
+    || called;
+}) ? isConstructorLegacy : isConstructorModern;
+
+var isArray = isArray$1;
+var isConstructor = isConstructor$1;
+var isObject = isObject$1;
+var wellKnownSymbol = wellKnownSymbol$1;
+
+var SPECIES = wellKnownSymbol('species');
+var $Array = Array;
+
+// a part of `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesConstructor$1 = function (originalArray) {
+  var C;
+  if (isArray(originalArray)) {
+    C = originalArray.constructor;
+    // cross-realm fallback
+    if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;
+    else if (isObject(C)) {
+      C = C[SPECIES];
+      if (C === null) C = undefined;
+    }
+  } return C === undefined ? $Array : C;
+};
+
+var arraySpeciesConstructor = arraySpeciesConstructor$1;
+
+// `ArraySpeciesCreate` abstract operation
+// https://tc39.es/ecma262/#sec-arrayspeciescreate
+var arraySpeciesCreate = function (originalArray, length) {
+  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
+};
+
+export { arraySpeciesCreate as a, isConstructor$1 as b, isArray$1 as i };

package/esm/{classof-088c9833.js → classof-39c30bd5.js}

@@ -1,5 +1,4 @@
-import { w as wellKnownSymbol$2, l as isCallable$1 } from './function-name-c49146fc.js';
-import { m as classofRaw$1 } from './is-forced-fd46b5f2.js';
+import { w as wellKnownSymbol$2, x as isCallable$1, p as classofRaw$1 } from './is-forced-752b5893.js';
 
 var wellKnownSymbol$1 = wellKnownSymbol$2;
 

package/esm/create-property-534611fd.js

@@ -0,0 +1,14 @@
+import { W as toPropertyKey$1, F as objectDefineProperty, Q as createPropertyDescriptor$1 } from './is-forced-752b5893.js';
+
+'use strict';
+var toPropertyKey = toPropertyKey$1;
+var definePropertyModule = objectDefineProperty;
+var createPropertyDescriptor = createPropertyDescriptor$1;
+
+var createProperty = function (object, key, value) {
+  var propertyKey = toPropertyKey(key);
+  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
+  else object[propertyKey] = value;
+};
+
+export { createProperty as c };

package/esm/delete-property-or-throw-8032646c.js

@@ -0,0 +1,31 @@
+import { e as toObject$1, h as fails$1, M as tryToString$1 } from './is-forced-752b5893.js';
+import { _ as _export } from './export-a37ba078.js';
+import { o as objectKeys } from './object-keys-4f5bf4e7.js';
+
+var es_object_keys = {};
+
+var $ = _export;
+var toObject = toObject$1;
+var nativeKeys = objectKeys;
+var fails = fails$1;
+
+var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });
+
+// `Object.keys` method
+// https://tc39.es/ecma262/#sec-object.keys
+$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
+  keys: function keys(it) {
+    return nativeKeys(toObject(it));
+  }
+});
+
+'use strict';
+var tryToString = tryToString$1;
+
+var $TypeError = TypeError;
+
+var deletePropertyOrThrow = function (O, P) {
+  if (!delete O[P]) throw $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));
+};
+
+export { deletePropertyOrThrow as d };

package/esm/does-not-exceed-safe-integer-31d08811.js

@@ -0,0 +1,11 @@
+import './is-forced-752b5893.js';
+
+var $TypeError = TypeError;
+var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
+
+var doesNotExceedSafeInteger = function (it) {
+  if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');
+  return it;
+};
+
+export { doesNotExceedSafeInteger as d };

package/esm/es.array.concat-987938be.js

@@ -0,0 +1,69 @@
+import { h as fails$1, n as isObject$1, e as toObject$1, l as lengthOfArrayLike$1, w as wellKnownSymbol$1, m as engineV8Version } from './is-forced-752b5893.js';
+import { _ as _export } from './export-a37ba078.js';
+import { i as isArray$1, a as arraySpeciesCreate$1 } from './array-species-create-a5f5503b.js';
+import { d as doesNotExceedSafeInteger$1 } from './does-not-exceed-safe-integer-31d08811.js';
+import { c as createProperty$1 } from './create-property-534611fd.js';
+import { a as arrayMethodHasSpeciesSupport$1 } from './array-method-has-species-support-3d413468.js';
+
+var es_array_concat = {};
+
+'use strict';
+var $ = _export;
+var fails = fails$1;
+var isArray = isArray$1;
+var isObject = isObject$1;
+var toObject = toObject$1;
+var lengthOfArrayLike = lengthOfArrayLike$1;
+var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1;
+var createProperty = createProperty$1;
+var arraySpeciesCreate = arraySpeciesCreate$1;
+var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$1;
+var wellKnownSymbol = wellKnownSymbol$1;
+var V8_VERSION = engineV8Version;
+
+var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
+
+// We can't use this feature detection in V8 since it causes
+// deoptimization and serious performance degradation
+// https://github.com/zloirock/core-js/issues/679
+var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {
+  var array = [];
+  array[IS_CONCAT_SPREADABLE] = false;
+  return array.concat()[0] !== array;
+});
+
+var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');
+
+var isConcatSpreadable = function (O) {
+  if (!isObject(O)) return false;
+  var spreadable = O[IS_CONCAT_SPREADABLE];
+  return spreadable !== undefined ? !!spreadable : isArray(O);
+};
+
+var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;
+
+// `Array.prototype.concat` method
+// https://tc39.es/ecma262/#sec-array.prototype.concat
+// with adding support of @@isConcatSpreadable and @@species
+$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
+  // eslint-disable-next-line no-unused-vars -- required for `.length`
+  concat: function concat(arg) {
+    var O = toObject(this);
+    var A = arraySpeciesCreate(O, 0);
+    var n = 0;
+    var i, k, length, len, E;
+    for (i = -1, length = arguments.length; i < length; i++) {
+      E = i === -1 ? O : arguments[i];
+      if (isConcatSpreadable(E)) {
+        len = lengthOfArrayLike(E);
+        doesNotExceedSafeInteger(n + len);
+        for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);
+      } else {
+        doesNotExceedSafeInteger(n + 1);
+        createProperty(A, n++, E);
+      }
+    }
+    A.length = n;
+    return A;
+  }
+});

package/esm/{es.array.find-54b8f84b.js → es.array.find-dfa1f42f.js}

@@ -1,9 +1,8 @@
-import './function-name-c49146fc.js';
-import { t as toStringTagSupport, c as classof$1 } from './classof-088c9833.js';
-import { d as defineBuiltIn$1 } from './is-forced-fd46b5f2.js';
-import { _ as _export } from './object-keys-3c73c404.js';
-import { a as arrayIteration } from './array-iteration-4f83e223.js';
-import { a as addToUnscopables$1 } from './add-to-unscopables-a5032b1d.js';
+import { b as defineBuiltIn$1 } from './is-forced-752b5893.js';
+import { t as toStringTagSupport, c as classof$1 } from './classof-39c30bd5.js';
+import { _ as _export } from './export-a37ba078.js';
+import { a as arrayIteration } from './array-iteration-107f927f.js';
+import { a as addToUnscopables$1 } from './add-to-unscopables-2400f45b.js';
 
 var es_object_toString = {};
 

package/esm/{es.array.includes-9a6e4066.js → es.array.includes-91be7771.js}

@@ -1,7 +1,6 @@
-import { j as fails$1 } from './function-name-c49146fc.js';
-import { _ as _export } from './object-keys-3c73c404.js';
-import { n as arrayIncludes } from './is-forced-fd46b5f2.js';
-import { a as addToUnscopables$1 } from './add-to-unscopables-a5032b1d.js';
+import { I as arrayIncludes, h as fails$1 } from './is-forced-752b5893.js';
+import { _ as _export } from './export-a37ba078.js';
+import { a as addToUnscopables$1 } from './add-to-unscopables-2400f45b.js';
 
 var es_array_includes = {};
 

package/esm/{es.function.name-2fa3a718.js → es.function.name-557cb1f9.js}

@@ -1,4 +1,4 @@
-import { d as descriptors, n as functionName, f as functionUncurryThis, o as objectDefineProperty } from './function-name-c49146fc.js';
+import { d as descriptors, N as functionName, f as functionUncurryThis, F as objectDefineProperty } from './is-forced-752b5893.js';
 
 var es_function_name = {};
 

package/esm/{es.number.constructor-b7faae1f.js → es.number.constructor-1249bd78.js}

@@ -1,6 +1,5 @@
-import { l as isCallable$2, f as functionUncurryThis, c as anObject$1, C as isObject$1, r as requireObjectCoercible$1, d as descriptors, g as global$1, k as hasOwnProperty_1, D as objectIsPrototypeOf, E as isSymbol$1, F as toPrimitive$1, j as fails$1, o as objectDefineProperty } from './function-name-c49146fc.js';
-import { h as isForced_1, d as defineBuiltIn$1, f as objectGetOwnPropertyNames, g as objectGetOwnPropertyDescriptor } from './is-forced-fd46b5f2.js';
-import { t as toString$1 } from './to-string-c2bd1f4d.js';
+import { x as isCallable$2, f as functionUncurryThis, q as anObject$1, n as isObject$1, r as requireObjectCoercible$1, d as descriptors, g as global$1, H as isForced_1, b as defineBuiltIn$1, D as hasOwnProperty_1, J as objectIsPrototypeOf, K as isSymbol$1, L as toPrimitive$1, h as fails$1, C as objectGetOwnPropertyNames, E as objectGetOwnPropertyDescriptor, F as objectDefineProperty } from './is-forced-752b5893.js';
+import { t as toString$1 } from './to-string-12728fd2.js';
 
 var es_number_constructor = {};