@koine/next 1.0.1 → 1.0.2

package/Theme.js

@@ -0,0 +1,1905 @@
+'use strict';
+
+var es_object_assign = require('./es.object.assign.js');
+var es_string_replace = require('./es.string.replace.js');
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var router = require('next/router');
+var react = require('@koine/react');
+var Head = require('next/head');
+var utils = require('@koine/utils');
+var Script = require('next/script');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var Head__default = /*#__PURE__*/_interopDefaultLegacy(Head);
+var Script__default = /*#__PURE__*/_interopDefaultLegacy(Script);
+
+var wellKnownSymbol$9 = es_object_assign.wellKnownSymbol;
+var create$1 = es_string_replace.objectCreate;
+var definePropertyModule$1 = es_object_assign.objectDefineProperty;
+
+var UNSCOPABLES = wellKnownSymbol$9('unscopables');
+var ArrayPrototype$1 = Array.prototype;
+
+// Array.prototype[@@unscopables]
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+if (ArrayPrototype$1[UNSCOPABLES] == undefined) {
+  definePropertyModule$1.f(ArrayPrototype$1, UNSCOPABLES, {
+    configurable: true,
+    value: create$1(null)
+  });
+}
+
+// add a key to Array.prototype[@@unscopables]
+var addToUnscopables$1 = function (key) {
+  ArrayPrototype$1[UNSCOPABLES][key] = true;
+};
+
+var iterators = {};
+
+var fails$3 = es_object_assign.fails;
+
+var correctPrototypeGetter = !fails$3(function () {
+  function F() { /* empty */ }
+  F.prototype.constructor = null;
+  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+  return Object.getPrototypeOf(new F()) !== F.prototype;
+});
+
+var global$e = es_object_assign.global;
+var hasOwn$3 = es_object_assign.hasOwnProperty_1;
+var isCallable$6 = es_object_assign.isCallable;
+var toObject = es_object_assign.toObject;
+var sharedKey = es_object_assign.sharedKey;
+var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter;
+
+var IE_PROTO = sharedKey('IE_PROTO');
+var Object$1 = global$e.Object;
+var ObjectPrototype = Object$1.prototype;
+
+// `Object.getPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.getprototypeof
+var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? Object$1.getPrototypeOf : function (O) {
+  var object = toObject(O);
+  if (hasOwn$3(object, IE_PROTO)) return object[IE_PROTO];
+  var constructor = object.constructor;
+  if (isCallable$6(constructor) && object instanceof constructor) {
+    return constructor.prototype;
+  } return object instanceof Object$1 ? ObjectPrototype : null;
+};
+
+var fails$2 = es_object_assign.fails;
+var isCallable$5 = es_object_assign.isCallable;
+var getPrototypeOf$1 = objectGetPrototypeOf;
+var redefine$4 = es_object_assign.redefine.exports;
+var wellKnownSymbol$8 = es_object_assign.wellKnownSymbol;
+
+var ITERATOR$5 = wellKnownSymbol$8('iterator');
+var BUGGY_SAFARI_ITERATORS$1 = false;
+
+// `%IteratorPrototype%` object
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator;
+
+/* eslint-disable es/no-array-prototype-keys -- safe */
+if ([].keys) {
+  arrayIterator = [].keys();
+  // Safari 8 has buggy iterators w/o `next`
+  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true;
+  else {
+    PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator));
+    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype;
+  }
+}
+
+var NEW_ITERATOR_PROTOTYPE = IteratorPrototype$2 == undefined || fails$2(function () {
+  var test = {};
+  // FF44- legacy iterators case
+  return IteratorPrototype$2[ITERATOR$5].call(test) !== test;
+});
+
+if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {};
+
+// `%IteratorPrototype%[@@iterator]()` method
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+if (!isCallable$5(IteratorPrototype$2[ITERATOR$5])) {
+  redefine$4(IteratorPrototype$2, ITERATOR$5, function () {
+    return this;
+  });
+}
+
+var iteratorsCore = {
+  IteratorPrototype: IteratorPrototype$2,
+  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1
+};
+
+var defineProperty$2 = es_object_assign.objectDefineProperty.f;
+var hasOwn$2 = es_object_assign.hasOwnProperty_1;
+var wellKnownSymbol$7 = es_object_assign.wellKnownSymbol;
+
+var TO_STRING_TAG$1 = wellKnownSymbol$7('toStringTag');
+
+var setToStringTag$3 = function (target, TAG, STATIC) {
+  if (target && !STATIC) target = target.prototype;
+  if (target && !hasOwn$2(target, TO_STRING_TAG$1)) {
+    defineProperty$2(target, TO_STRING_TAG$1, { configurable: true, value: TAG });
+  }
+};
+
+var IteratorPrototype$1 = iteratorsCore.IteratorPrototype;
+var create = es_string_replace.objectCreate;
+var createPropertyDescriptor = es_object_assign.createPropertyDescriptor;
+var setToStringTag$2 = setToStringTag$3;
+var Iterators$4 = iterators;
+
+var returnThis$1 = function () { return this; };
+
+var createIteratorConstructor$1 = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
+  var TO_STRING_TAG = NAME + ' Iterator';
+  IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
+  setToStringTag$2(IteratorConstructor, TO_STRING_TAG, false);
+  Iterators$4[TO_STRING_TAG] = returnThis$1;
+  return IteratorConstructor;
+};
+
+var global$d = es_object_assign.global;
+var isCallable$4 = es_object_assign.isCallable;
+
+var String$2 = global$d.String;
+var TypeError$6 = global$d.TypeError;
+
+var aPossiblePrototype$1 = function (argument) {
+  if (typeof argument == 'object' || isCallable$4(argument)) return argument;
+  throw TypeError$6("Can't set " + String$2(argument) + ' as a prototype');
+};
+
+/* eslint-disable no-proto -- safe */
+
+var uncurryThis$4 = es_object_assign.functionUncurryThis;
+var anObject$5 = es_object_assign.anObject;
+var aPossiblePrototype = aPossiblePrototype$1;
+
+// `Object.setPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.setprototypeof
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+// eslint-disable-next-line es/no-object-setprototypeof -- safe
+var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () {
+  var CORRECT_SETTER = false;
+  var test = {};
+  var setter;
+  try {
+    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+    setter = uncurryThis$4(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
+    setter(test, []);
+    CORRECT_SETTER = test instanceof Array;
+  } catch (error) { /* empty */ }
+  return function setPrototypeOf(O, proto) {
+    anObject$5(O);
+    aPossiblePrototype(proto);
+    if (CORRECT_SETTER) setter(O, proto);
+    else O.__proto__ = proto;
+    return O;
+  };
+}() : undefined);
+
+var $$2 = es_object_assign._export;
+var call$4 = es_object_assign.functionCall;
+var FunctionName = es_object_assign.functionName;
+var isCallable$3 = es_object_assign.isCallable;
+var createIteratorConstructor = createIteratorConstructor$1;
+var getPrototypeOf = objectGetPrototypeOf;
+var setPrototypeOf$1 = objectSetPrototypeOf;
+var setToStringTag$1 = setToStringTag$3;
+var createNonEnumerableProperty$1 = es_object_assign.createNonEnumerableProperty;
+var redefine$3 = es_object_assign.redefine.exports;
+var wellKnownSymbol$6 = es_object_assign.wellKnownSymbol;
+var Iterators$3 = iterators;
+var IteratorsCore = iteratorsCore;
+
+var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER;
+var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
+var IteratorPrototype = IteratorsCore.IteratorPrototype;
+var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
+var ITERATOR$4 = wellKnownSymbol$6('iterator');
+var KEYS = 'keys';
+var VALUES = 'values';
+var ENTRIES = 'entries';
+
+var returnThis = function () { return this; };
+
+var defineIterator$1 = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
+  createIteratorConstructor(IteratorConstructor, NAME, next);
+
+  var getIterationMethod = function (KIND) {
+    if (KIND === DEFAULT && defaultIterator) return defaultIterator;
+    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
+    switch (KIND) {
+      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
+      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
+      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
+    } return function () { return new IteratorConstructor(this); };
+  };
+
+  var TO_STRING_TAG = NAME + ' Iterator';
+  var INCORRECT_VALUES_NAME = false;
+  var IterablePrototype = Iterable.prototype;
+  var nativeIterator = IterablePrototype[ITERATOR$4]
+    || IterablePrototype['@@iterator']
+    || DEFAULT && IterablePrototype[DEFAULT];
+  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
+  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
+  var CurrentIteratorPrototype, methods, KEY;
+
+  // fix native
+  if (anyNativeIterator) {
+    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
+    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
+      if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
+        if (setPrototypeOf$1) {
+          setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype);
+        } else if (!isCallable$3(CurrentIteratorPrototype[ITERATOR$4])) {
+          redefine$3(CurrentIteratorPrototype, ITERATOR$4, returnThis);
+        }
+      }
+      // Set @@toStringTag to native iterators
+      setToStringTag$1(CurrentIteratorPrototype, TO_STRING_TAG, true);
+    }
+  }
+
+  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF
+  if (PROPER_FUNCTION_NAME$1 && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
+    if (CONFIGURABLE_FUNCTION_NAME) {
+      createNonEnumerableProperty$1(IterablePrototype, 'name', VALUES);
+    } else {
+      INCORRECT_VALUES_NAME = true;
+      defaultIterator = function values() { return call$4(nativeIterator, this); };
+    }
+  }
+
+  // export additional methods
+  if (DEFAULT) {
+    methods = {
+      values: getIterationMethod(VALUES),
+      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
+      entries: getIterationMethod(ENTRIES)
+    };
+    if (FORCED) for (KEY in methods) {
+      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
+        redefine$3(IterablePrototype, KEY, methods[KEY]);
+      }
+    } else $$2({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
+  }
+
+  // define iterator
+  if (IterablePrototype[ITERATOR$4] !== defaultIterator) {
+    redefine$3(IterablePrototype, ITERATOR$4, defaultIterator, { name: DEFAULT });
+  }
+  Iterators$3[NAME] = defaultIterator;
+
+  return methods;
+};
+
+var toIndexedObject = es_object_assign.toIndexedObject;
+var addToUnscopables = addToUnscopables$1;
+var Iterators$2 = iterators;
+var InternalStateModule$1 = es_object_assign.internalState;
+var defineProperty$1 = es_object_assign.objectDefineProperty.f;
+var defineIterator = defineIterator$1;
+var DESCRIPTORS$2 = es_object_assign.descriptors;
+
+var ARRAY_ITERATOR = 'Array Iterator';
+var setInternalState$1 = InternalStateModule$1.set;
+var getInternalState$1 = InternalStateModule$1.getterFor(ARRAY_ITERATOR);
+
+// `Array.prototype.entries` method
+// https://tc39.es/ecma262/#sec-array.prototype.entries
+// `Array.prototype.keys` method
+// https://tc39.es/ecma262/#sec-array.prototype.keys
+// `Array.prototype.values` method
+// https://tc39.es/ecma262/#sec-array.prototype.values
+// `Array.prototype[@@iterator]` method
+// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
+// `CreateArrayIterator` internal method
+// https://tc39.es/ecma262/#sec-createarrayiterator
+var es_array_iterator = defineIterator(Array, 'Array', function (iterated, kind) {
+  setInternalState$1(this, {
+    type: ARRAY_ITERATOR,
+    target: toIndexedObject(iterated), // target
+    index: 0,                          // next index
+    kind: kind                         // kind
+  });
+// `%ArrayIteratorPrototype%.next` method
+// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
+}, function () {
+  var state = getInternalState$1(this);
+  var target = state.target;
+  var kind = state.kind;
+  var index = state.index++;
+  if (!target || index >= target.length) {
+    state.target = undefined;
+    return { value: undefined, done: true };
+  }
+  if (kind == 'keys') return { value: index, done: false };
+  if (kind == 'values') return { value: target[index], done: false };
+  return { value: [index, target[index]], done: false };
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values%
+// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
+// https://tc39.es/ecma262/#sec-createmappedargumentsobject
+var values = Iterators$2.Arguments = Iterators$2.Array;
+
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+
+// V8 ~ Chrome 45- bug
+if (DESCRIPTORS$2 && values.name !== 'values') try {
+  defineProperty$1(values, 'name', { value: 'values' });
+} catch (error) { /* empty */ }
+
+// iterable DOM collections
+// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
+var domIterables = {
+  CSSRuleList: 0,
+  CSSStyleDeclaration: 0,
+  CSSValueList: 0,
+  ClientRectList: 0,
+  DOMRectList: 0,
+  DOMStringList: 0,
+  DOMTokenList: 1,
+  DataTransferItemList: 0,
+  FileList: 0,
+  HTMLAllCollection: 0,
+  HTMLCollection: 0,
+  HTMLFormElement: 0,
+  HTMLSelectElement: 0,
+  MediaList: 0,
+  MimeTypeArray: 0,
+  NamedNodeMap: 0,
+  NodeList: 1,
+  PaintRequestList: 0,
+  Plugin: 0,
+  PluginArray: 0,
+  SVGLengthList: 0,
+  SVGNumberList: 0,
+  SVGPathSegList: 0,
+  SVGPointList: 0,
+  SVGStringList: 0,
+  SVGTransformList: 0,
+  SourceBufferList: 0,
+  StyleSheetList: 0,
+  TextTrackCueList: 0,
+  TextTrackList: 0,
+  TouchList: 0
+};
+
+// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
+var documentCreateElement = es_object_assign.documentCreateElement;
+
+var classList = documentCreateElement('span').classList;
+var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype;
+
+var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1;
+
+var global$c = es_object_assign.global;
+var DOMIterables = domIterables;
+var DOMTokenListPrototype = domTokenListPrototype;
+var ArrayIteratorMethods = es_array_iterator;
+var createNonEnumerableProperty = es_object_assign.createNonEnumerableProperty;
+var wellKnownSymbol$5 = es_object_assign.wellKnownSymbol;
+
+var ITERATOR$3 = wellKnownSymbol$5('iterator');
+var TO_STRING_TAG = wellKnownSymbol$5('toStringTag');
+var ArrayValues = ArrayIteratorMethods.values;
+
+var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
+  if (CollectionPrototype) {
+    // some Chrome versions have non-configurable methods on DOMTokenList
+    if (CollectionPrototype[ITERATOR$3] !== ArrayValues) try {
+      createNonEnumerableProperty(CollectionPrototype, ITERATOR$3, ArrayValues);
+    } catch (error) {
+      CollectionPrototype[ITERATOR$3] = ArrayValues;
+    }
+    if (!CollectionPrototype[TO_STRING_TAG]) {
+      createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
+    }
+    if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
+      // some Chrome versions have non-configurable methods on DOMTokenList
+      if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
+        createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
+      } catch (error) {
+        CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
+      }
+    }
+  }
+};
+
+for (var COLLECTION_NAME in DOMIterables) {
+  handlePrototype(global$c[COLLECTION_NAME] && global$c[COLLECTION_NAME].prototype, COLLECTION_NAME);
+}
+
+handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
+
+var classof$1 = es_object_assign.classofRaw;
+var global$b = es_object_assign.global;
+
+var engineIsNode = classof$1(global$b.process) == 'process';
+
+var global$a = es_object_assign.global;
+
+var nativePromiseConstructor = global$a.Promise;
+
+var redefine$2 = es_object_assign.redefine.exports;
+
+var redefineAll$1 = function (target, src, options) {
+  for (var key in src) redefine$2(target, key, src[key], options);
+  return target;
+};
+
+var getBuiltIn$1 = es_object_assign.getBuiltIn;
+var definePropertyModule = es_object_assign.objectDefineProperty;
+var wellKnownSymbol$4 = es_object_assign.wellKnownSymbol;
+var DESCRIPTORS$1 = es_object_assign.descriptors;
+
+var SPECIES$1 = wellKnownSymbol$4('species');
+
+var setSpecies$1 = function (CONSTRUCTOR_NAME) {
+  var Constructor = getBuiltIn$1(CONSTRUCTOR_NAME);
+  var defineProperty = definePropertyModule.f;
+
+  if (DESCRIPTORS$1 && Constructor && !Constructor[SPECIES$1]) {
+    defineProperty(Constructor, SPECIES$1, {
+      configurable: true,
+      get: function () { return this; }
+    });
+  }
+};
+
+var global$9 = es_object_assign.global;
+var isPrototypeOf$3 = es_object_assign.objectIsPrototypeOf;
+
+var TypeError$5 = global$9.TypeError;
+
+var anInstance$1 = function (it, Prototype) {
+  if (isPrototypeOf$3(Prototype, it)) return it;
+  throw TypeError$5('Incorrect invocation');
+};
+
+var uncurryThis$3 = es_object_assign.functionUncurryThis;
+var aCallable$3 = es_object_assign.aCallable;
+var NATIVE_BIND = es_object_assign.functionBindNative;
+
+var bind$4 = uncurryThis$3(uncurryThis$3.bind);
+
+// optional / simple context binding
+var functionBindContext = function (fn, that) {
+  aCallable$3(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind$4(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+var wellKnownSymbol$3 = es_object_assign.wellKnownSymbol;
+var Iterators$1 = iterators;
+
+var ITERATOR$2 = wellKnownSymbol$3('iterator');
+var ArrayPrototype = Array.prototype;
+
+// check on default Array iterator
+var isArrayIteratorMethod$1 = function (it) {
+  return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it);
+};
+
+var classof = es_string_replace.classof;
+var getMethod$1 = es_object_assign.getMethod;
+var Iterators = iterators;
+var wellKnownSymbol$2 = es_object_assign.wellKnownSymbol;
+
+var ITERATOR$1 = wellKnownSymbol$2('iterator');
+
+var getIteratorMethod$2 = function (it) {
+  if (it != undefined) return getMethod$1(it, ITERATOR$1)
+    || getMethod$1(it, '@@iterator')
+    || Iterators[classof(it)];
+};
+
+var global$8 = es_object_assign.global;
+var call$3 = es_object_assign.functionCall;
+var aCallable$2 = es_object_assign.aCallable;
+var anObject$4 = es_object_assign.anObject;
+var tryToString$1 = es_object_assign.tryToString;
+var getIteratorMethod$1 = getIteratorMethod$2;
+
+var TypeError$4 = global$8.TypeError;
+
+var getIterator$1 = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator;
+  if (aCallable$2(iteratorMethod)) return anObject$4(call$3(iteratorMethod, argument));
+  throw TypeError$4(tryToString$1(argument) + ' is not iterable');
+};
+
+var call$2 = es_object_assign.functionCall;
+var anObject$3 = es_object_assign.anObject;
+var getMethod = es_object_assign.getMethod;
+
+var iteratorClose$1 = function (iterator, kind, value) {
+  var innerResult, innerError;
+  anObject$3(iterator);
+  try {
+    innerResult = getMethod(iterator, 'return');
+    if (!innerResult) {
+      if (kind === 'throw') throw value;
+      return value;
+    }
+    innerResult = call$2(innerResult, iterator);
+  } catch (error) {
+    innerError = true;
+    innerResult = error;
+  }
+  if (kind === 'throw') throw value;
+  if (innerError) throw innerResult;
+  anObject$3(innerResult);
+  return value;
+};
+
+var global$7 = es_object_assign.global;
+var bind$3 = functionBindContext;
+var call$1 = es_object_assign.functionCall;
+var anObject$2 = es_object_assign.anObject;
+var tryToString = es_object_assign.tryToString;
+var isArrayIteratorMethod = isArrayIteratorMethod$1;
+var lengthOfArrayLike = es_object_assign.lengthOfArrayLike;
+var isPrototypeOf$2 = es_object_assign.objectIsPrototypeOf;
+var getIterator = getIterator$1;
+var getIteratorMethod = getIteratorMethod$2;
+var iteratorClose = iteratorClose$1;
+
+var TypeError$3 = global$7.TypeError;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+var iterate$1 = function (iterable, unboundFunction, options) {
+  var that = options && options.that;
+  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+  var INTERRUPTED = !!(options && options.INTERRUPTED);
+  var fn = bind$3(unboundFunction, that);
+  var iterator, iterFn, index, length, result, next, step;
+
+  var stop = function (condition) {
+    if (iterator) iteratorClose(iterator, 'normal', condition);
+    return new Result(true, condition);
+  };
+
+  var callFn = function (value) {
+    if (AS_ENTRIES) {
+      anObject$2(value);
+      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+    } return INTERRUPTED ? fn(value, stop) : fn(value);
+  };
+
+  if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod(iterable);
+    if (!iterFn) throw TypeError$3(tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+        result = callFn(iterable[index]);
+        if (result && isPrototypeOf$2(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
+  }
+
+  next = iterator.next;
+  while (!(step = call$1(next, iterator)).done) {
+    try {
+      result = callFn(step.value);
+    } catch (error) {
+      iteratorClose(iterator, 'throw', error);
+    }
+    if (typeof result == 'object' && result && isPrototypeOf$2(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+var wellKnownSymbol$1 = es_object_assign.wellKnownSymbol;
+
+var ITERATOR = wellKnownSymbol$1('iterator');
+var SAFE_CLOSING = false;
+
+try {
+  var called = 0;
+  var iteratorWithReturn = {
+    next: function () {
+      return { done: !!called++ };
+    },
+    'return': function () {
+      SAFE_CLOSING = true;
+    }
+  };
+  iteratorWithReturn[ITERATOR] = function () {
+    return this;
+  };
+  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
+  Array.from(iteratorWithReturn, function () { throw 2; });
+} catch (error) { /* empty */ }
+
+var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
+  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
+  var ITERATION_SUPPORT = false;
+  try {
+    var object = {};
+    object[ITERATOR] = function () {
+      return {
+        next: function () {
+          return { done: ITERATION_SUPPORT = true };
+        }
+      };
+    };
+    exec(object);
+  } catch (error) { /* empty */ }
+  return ITERATION_SUPPORT;
+};
+
+var uncurryThis$2 = es_object_assign.functionUncurryThis;
+
+var arraySlice$1 = uncurryThis$2([].slice);
+
+var global$6 = es_object_assign.global;
+
+var TypeError$2 = global$6.TypeError;
+
+var validateArgumentsLength$1 = function (passed, required) {
+  if (passed < required) throw TypeError$2('Not enough arguments');
+  return passed;
+};
+
+var userAgent$2 = es_object_assign.engineUserAgent;
+
+var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2);
+
+var global$5 = es_object_assign.global;
+var apply = es_string_replace.functionApply;
+var bind$2 = functionBindContext;
+var isCallable$2 = es_object_assign.isCallable;
+var hasOwn$1 = es_object_assign.hasOwnProperty_1;
+var fails$1 = es_object_assign.fails;
+var html = es_string_replace.html;
+var arraySlice = arraySlice$1;
+var createElement = es_object_assign.documentCreateElement;
+var validateArgumentsLength = validateArgumentsLength$1;
+var IS_IOS$1 = engineIsIos;
+var IS_NODE$2 = engineIsNode;
+
+var set = global$5.setImmediate;
+var clear = global$5.clearImmediate;
+var process$2 = global$5.process;
+var Dispatch = global$5.Dispatch;
+var Function = global$5.Function;
+var MessageChannel = global$5.MessageChannel;
+var String$1 = global$5.String;
+var counter = 0;
+var queue$1 = {};
+var ONREADYSTATECHANGE = 'onreadystatechange';
+var location, defer, channel, port;
+
+try {
+  // Deno throws a ReferenceError on `location` access without `--location` flag
+  location = global$5.location;
+} catch (error) { /* empty */ }
+
+var run = function (id) {
+  if (hasOwn$1(queue$1, id)) {
+    var fn = queue$1[id];
+    delete queue$1[id];
+    fn();
+  }
+};
+
+var runner = function (id) {
+  return function () {
+    run(id);
+  };
+};
+
+var listener = function (event) {
+  run(event.data);
+};
+
+var post = function (id) {
+  // old engines have not location.origin
+  global$5.postMessage(String$1(id), location.protocol + '//' + location.host);
+};
+
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if (!set || !clear) {
+  set = function setImmediate(handler) {
+    validateArgumentsLength(arguments.length, 1);
+    var fn = isCallable$2(handler) ? handler : Function(handler);
+    var args = arraySlice(arguments, 1);
+    queue$1[++counter] = function () {
+      apply(fn, undefined, args);
+    };
+    defer(counter);
+    return counter;
+  };
+  clear = function clearImmediate(id) {
+    delete queue$1[id];
+  };
+  // Node.js 0.8-
+  if (IS_NODE$2) {
+    defer = function (id) {
+      process$2.nextTick(runner(id));
+    };
+  // Sphere (JS game engine) Dispatch API
+  } else if (Dispatch && Dispatch.now) {
+    defer = function (id) {
+      Dispatch.now(runner(id));
+    };
+  // Browsers with MessageChannel, includes WebWorkers
+  // except iOS - https://github.com/zloirock/core-js/issues/624
+  } else if (MessageChannel && !IS_IOS$1) {
+    channel = new MessageChannel();
+    port = channel.port2;
+    channel.port1.onmessage = listener;
+    defer = bind$2(port.postMessage, port);
+  // Browsers with postMessage, skip WebWorkers
+  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+  } else if (
+    global$5.addEventListener &&
+    isCallable$2(global$5.postMessage) &&
+    !global$5.importScripts &&
+    location && location.protocol !== 'file:' &&
+    !fails$1(post)
+  ) {
+    defer = post;
+    global$5.addEventListener('message', listener, false);
+  // IE8-
+  } else if (ONREADYSTATECHANGE in createElement('script')) {
+    defer = function (id) {
+      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
+        html.removeChild(this);
+        run(id);
+      };
+    };
+  // Rest old browsers
+  } else {
+    defer = function (id) {
+      setTimeout(runner(id), 0);
+    };
+  }
+}
+
+var task$1 = {
+  set: set,
+  clear: clear
+};
+
+var userAgent$1 = es_object_assign.engineUserAgent;
+var global$4 = es_object_assign.global;
+
+var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && global$4.Pebble !== undefined;
+
+var userAgent = es_object_assign.engineUserAgent;
+
+var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent);
+
+var global$3 = es_object_assign.global;
+var bind$1 = functionBindContext;
+var getOwnPropertyDescriptor = es_object_assign.objectGetOwnPropertyDescriptor.f;
+var macrotask = task$1.set;
+var IS_IOS = engineIsIos;
+var IS_IOS_PEBBLE = engineIsIosPebble;
+var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
+var IS_NODE$1 = engineIsNode;
+
+var MutationObserver = global$3.MutationObserver || global$3.WebKitMutationObserver;
+var document$2 = global$3.document;
+var process$1 = global$3.process;
+var Promise$1 = global$3.Promise;
+// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
+var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$3, 'queueMicrotask');
+var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
+
+var flush, head, last, notify$1, toggle, node, promise, then;
+
+// modern engines have queueMicrotask method
+if (!queueMicrotask) {
+  flush = function () {
+    var parent, fn;
+    if (IS_NODE$1 && (parent = process$1.domain)) parent.exit();
+    while (head) {
+      fn = head.fn;
+      head = head.next;
+      try {
+        fn();
+      } catch (error) {
+        if (head) notify$1();
+        else last = undefined;
+        throw error;
+      }
+    } last = undefined;
+    if (parent) parent.enter();
+  };
+
+  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
+  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
+  if (!IS_IOS && !IS_NODE$1 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
+    toggle = true;
+    node = document$2.createTextNode('');
+    new MutationObserver(flush).observe(node, { characterData: true });
+    notify$1 = function () {
+      node.data = toggle = !toggle;
+    };
+  // environments with maybe non-completely correct, but existent Promise
+  } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) {
+    // Promise.resolve without an argument throws an error in LG WebOS 2
+    promise = Promise$1.resolve(undefined);
+    // workaround of WebKit ~ iOS Safari 10.1 bug
+    promise.constructor = Promise$1;
+    then = bind$1(promise.then, promise);
+    notify$1 = function () {
+      then(flush);
+    };
+  // Node.js without promises
+  } else if (IS_NODE$1) {
+    notify$1 = function () {
+      process$1.nextTick(flush);
+    };
+  // for other environments - macrotask based on:
+  // - setImmediate
+  // - MessageChannel
+  // - window.postMessag
+  // - onreadystatechange
+  // - setTimeout
+  } else {
+    // strange IE + webpack dev server bug - use .bind(global)
+    macrotask = bind$1(macrotask, global$3);
+    notify$1 = function () {
+      macrotask(flush);
+    };
+  }
+}
+
+var microtask$1 = queueMicrotask || function (fn) {
+  var task = { fn: fn, next: undefined };
+  if (last) last.next = task;
+  if (!head) {
+    head = task;
+    notify$1();
+  } last = task;
+};
+
+var newPromiseCapability$2 = {};
+
+var aCallable$1 = es_object_assign.aCallable;
+
+var PromiseCapability = function (C) {
+  var resolve, reject;
+  this.promise = new C(function ($$resolve, $$reject) {
+    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
+    resolve = $$resolve;
+    reject = $$reject;
+  });
+  this.resolve = aCallable$1(resolve);
+  this.reject = aCallable$1(reject);
+};
+
+// `NewPromiseCapability` abstract operation
+// https://tc39.es/ecma262/#sec-newpromisecapability
+newPromiseCapability$2.f = function (C) {
+  return new PromiseCapability(C);
+};
+
+var anObject$1 = es_object_assign.anObject;
+var isObject$1 = es_object_assign.isObject;
+var newPromiseCapability$1 = newPromiseCapability$2;
+
+var promiseResolve$1 = function (C, x) {
+  anObject$1(C);
+  if (isObject$1(x) && x.constructor === C) return x;
+  var promiseCapability = newPromiseCapability$1.f(C);
+  var resolve = promiseCapability.resolve;
+  resolve(x);
+  return promiseCapability.promise;
+};
+
+var global$2 = es_object_assign.global;
+
+var hostReportErrors$1 = function (a, b) {
+  var console = global$2.console;
+  if (console && console.error) {
+    arguments.length == 1 ? console.error(a) : console.error(a, b);
+  }
+};
+
+var perform$1 = function (exec) {
+  try {
+    return { error: false, value: exec() };
+  } catch (error) {
+    return { error: true, value: error };
+  }
+};
+
+var Queue$1 = function () {
+  this.head = null;
+  this.tail = null;
+};
+
+Queue$1.prototype = {
+  add: function (item) {
+    var entry = { item: item, next: null };
+    if (this.head) this.tail.next = entry;
+    else this.head = entry;
+    this.tail = entry;
+  },
+  get: function () {
+    var entry = this.head;
+    if (entry) {
+      this.head = entry.next;
+      if (this.tail === entry) this.tail = null;
+      return entry.item;
+    }
+  }
+};
+
+var queue = Queue$1;
+
+var engineIsBrowser = typeof window == 'object';
+
+var $$1 = es_object_assign._export;
+var global$1 = es_object_assign.global;
+var getBuiltIn = es_object_assign.getBuiltIn;
+var call = es_object_assign.functionCall;
+var NativePromise = nativePromiseConstructor;
+var redefine$1 = es_object_assign.redefine.exports;
+var redefineAll = redefineAll$1;
+var setPrototypeOf = objectSetPrototypeOf;
+var setToStringTag = setToStringTag$3;
+var setSpecies = setSpecies$1;
+var aCallable = es_object_assign.aCallable;
+var isCallable$1 = es_object_assign.isCallable;
+var isObject = es_object_assign.isObject;
+var anInstance = anInstance$1;
+var inspectSource = es_object_assign.inspectSource;
+var iterate = iterate$1;
+var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
+var speciesConstructor = es_string_replace.speciesConstructor;
+var task = task$1.set;
+var microtask = microtask$1;
+var promiseResolve = promiseResolve$1;
+var hostReportErrors = hostReportErrors$1;
+var newPromiseCapabilityModule = newPromiseCapability$2;
+var perform = perform$1;
+var Queue = queue;
+var InternalStateModule = es_object_assign.internalState;
+var isForced = es_object_assign.isForced_1;
+var wellKnownSymbol = es_object_assign.wellKnownSymbol;
+var IS_BROWSER = engineIsBrowser;
+var IS_NODE = engineIsNode;
+var V8_VERSION = es_object_assign.engineV8Version;
+
+var SPECIES = wellKnownSymbol('species');
+var PROMISE = 'Promise';
+
+var getInternalState = InternalStateModule.getterFor(PROMISE);
+var setInternalState = InternalStateModule.set;
+var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
+var NativePromisePrototype = NativePromise && NativePromise.prototype;
+var PromiseConstructor = NativePromise;
+var PromisePrototype = NativePromisePrototype;
+var TypeError$1 = global$1.TypeError;
+var document$1 = global$1.document;
+var process = global$1.process;
+var newPromiseCapability = newPromiseCapabilityModule.f;
+var newGenericPromiseCapability = newPromiseCapability;
+
+var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$1.dispatchEvent);
+var NATIVE_REJECTION_EVENT = isCallable$1(global$1.PromiseRejectionEvent);
+var UNHANDLED_REJECTION = 'unhandledrejection';
+var REJECTION_HANDLED = 'rejectionhandled';
+var PENDING = 0;
+var FULFILLED = 1;
+var REJECTED = 2;
+var HANDLED = 1;
+var UNHANDLED = 2;
+var SUBCLASSING = false;
+
+var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
+
+var FORCED = isForced(PROMISE, function () {
+  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);
+  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);
+  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
+  // We can't detect it synchronously, so just check versions
+  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
+  // We can't use @@species feature detection in V8 since it causes
+  // deoptimization and performance degradation
+  // https://github.com/zloirock/core-js/issues/679
+  if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;
+  // Detect correctness of subclassing with @@species support
+  var promise = new PromiseConstructor(function (resolve) { resolve(1); });
+  var FakePromise = function (exec) {
+    exec(function () { /* empty */ }, function () { /* empty */ });
+  };
+  var constructor = promise.constructor = {};
+  constructor[SPECIES] = FakePromise;
+  SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
+  if (!SUBCLASSING) return true;
+  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;
+});
+
+var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
+  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
+});
+
+// helpers
+var isThenable = function (it) {
+  var then;
+  return isObject(it) && isCallable$1(then = it.then) ? then : false;
+};
+
+var callReaction = function (reaction, state) {
+  var value = state.value;
+  var ok = state.state == FULFILLED;
+  var handler = ok ? reaction.ok : reaction.fail;
+  var resolve = reaction.resolve;
+  var reject = reaction.reject;
+  var domain = reaction.domain;
+  var result, then, exited;
+  try {
+    if (handler) {
+      if (!ok) {
+        if (state.rejection === UNHANDLED) onHandleUnhandled(state);
+        state.rejection = HANDLED;
+      }
+      if (handler === true) result = value;
+      else {
+        if (domain) domain.enter();
+        result = handler(value); // can throw
+        if (domain) {
+          domain.exit();
+          exited = true;
+        }
+      }
+      if (result === reaction.promise) {
+        reject(TypeError$1('Promise-chain cycle'));
+      } else if (then = isThenable(result)) {
+        call(then, result, resolve, reject);
+      } else resolve(result);
+    } else reject(value);
+  } catch (error) {
+    if (domain && !exited) domain.exit();
+    reject(error);
+  }
+};
+
+var notify = function (state, isReject) {
+  if (state.notified) return;
+  state.notified = true;
+  microtask(function () {
+    var reactions = state.reactions;
+    var reaction;
+    while (reaction = reactions.get()) {
+      callReaction(reaction, state);
+    }
+    state.notified = false;
+    if (isReject && !state.rejection) onUnhandled(state);
+  });
+};
+
+var dispatchEvent = function (name, promise, reason) {
+  var event, handler;
+  if (DISPATCH_EVENT) {
+    event = document$1.createEvent('Event');
+    event.promise = promise;
+    event.reason = reason;
+    event.initEvent(name, false, true);
+    global$1.dispatchEvent(event);
+  } else event = { promise: promise, reason: reason };
+  if (!NATIVE_REJECTION_EVENT && (handler = global$1['on' + name])) handler(event);
+  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
+};
+
+var onUnhandled = function (state) {
+  call(task, global$1, function () {
+    var promise = state.facade;
+    var value = state.value;
+    var IS_UNHANDLED = isUnhandled(state);
+    var result;
+    if (IS_UNHANDLED) {
+      result = perform(function () {
+        if (IS_NODE) {
+          process.emit('unhandledRejection', value, promise);
+        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
+      });
+      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
+      if (result.error) throw result.value;
+    }
+  });
+};
+
+var isUnhandled = function (state) {
+  return state.rejection !== HANDLED && !state.parent;
+};
+
+var onHandleUnhandled = function (state) {
+  call(task, global$1, function () {
+    var promise = state.facade;
+    if (IS_NODE) {
+      process.emit('rejectionHandled', promise);
+    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
+  });
+};
+
+var bind = function (fn, state, unwrap) {
+  return function (value) {
+    fn(state, value, unwrap);
+  };
+};
+
+var internalReject = function (state, value, unwrap) {
+  if (state.done) return;
+  state.done = true;
+  if (unwrap) state = unwrap;
+  state.value = value;
+  state.state = REJECTED;
+  notify(state, true);
+};
+
+var internalResolve = function (state, value, unwrap) {
+  if (state.done) return;
+  state.done = true;
+  if (unwrap) state = unwrap;
+  try {
+    if (state.facade === value) throw TypeError$1("Promise can't be resolved itself");
+    var then = isThenable(value);
+    if (then) {
+      microtask(function () {
+        var wrapper = { done: false };
+        try {
+          call(then, value,
+            bind(internalResolve, wrapper, state),
+            bind(internalReject, wrapper, state)
+          );
+        } catch (error) {
+          internalReject(wrapper, error, state);
+        }
+      });
+    } else {
+      state.value = value;
+      state.state = FULFILLED;
+      notify(state, false);
+    }
+  } catch (error) {
+    internalReject({ done: false }, error, state);
+  }
+};
+
+// constructor polyfill
+if (FORCED) {
+  // 25.4.3.1 Promise(executor)
+  PromiseConstructor = function Promise(executor) {
+    anInstance(this, PromisePrototype);
+    aCallable(executor);
+    call(Internal, this);
+    var state = getInternalState(this);
+    try {
+      executor(bind(internalResolve, state), bind(internalReject, state));
+    } catch (error) {
+      internalReject(state, error);
+    }
+  };
+  PromisePrototype = PromiseConstructor.prototype;
+  // eslint-disable-next-line no-unused-vars -- required for `.length`
+  Internal = function Promise(executor) {
+    setInternalState(this, {
+      type: PROMISE,
+      done: false,
+      notified: false,
+      parent: false,
+      reactions: new Queue(),
+      rejection: false,
+      state: PENDING,
+      value: undefined
+    });
+  };
+  Internal.prototype = redefineAll(PromisePrototype, {
+    // `Promise.prototype.then` method
+    // https://tc39.es/ecma262/#sec-promise.prototype.then
+    // eslint-disable-next-line unicorn/no-thenable -- safe
+    then: function then(onFulfilled, onRejected) {
+      var state = getInternalPromiseState(this);
+      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
+      state.parent = true;
+      reaction.ok = isCallable$1(onFulfilled) ? onFulfilled : true;
+      reaction.fail = isCallable$1(onRejected) && onRejected;
+      reaction.domain = IS_NODE ? process.domain : undefined;
+      if (state.state == PENDING) state.reactions.add(reaction);
+      else microtask(function () {
+        callReaction(reaction, state);
+      });
+      return reaction.promise;
+    },
+    // `Promise.prototype.catch` method
+    // https://tc39.es/ecma262/#sec-promise.prototype.catch
+    'catch': function (onRejected) {
+      return this.then(undefined, onRejected);
+    }
+  });
+  OwnPromiseCapability = function () {
+    var promise = new Internal();
+    var state = getInternalState(promise);
+    this.promise = promise;
+    this.resolve = bind(internalResolve, state);
+    this.reject = bind(internalReject, state);
+  };
+  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
+    return C === PromiseConstructor || C === PromiseWrapper
+      ? new OwnPromiseCapability(C)
+      : newGenericPromiseCapability(C);
+  };
+
+  if (isCallable$1(NativePromise) && NativePromisePrototype !== Object.prototype) {
+    nativeThen = NativePromisePrototype.then;
+
+    if (!SUBCLASSING) {
+      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
+      redefine$1(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
+        var that = this;
+        return new PromiseConstructor(function (resolve, reject) {
+          call(nativeThen, that, resolve, reject);
+        }).then(onFulfilled, onRejected);
+      // https://github.com/zloirock/core-js/issues/640
+      }, { unsafe: true });
+
+      // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
+      redefine$1(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });
+    }
+
+    // make `.constructor === Promise` work for native promise-based APIs
+    try {
+      delete NativePromisePrototype.constructor;
+    } catch (error) { /* empty */ }
+
+    // make `instanceof Promise` work for native promise-based APIs
+    if (setPrototypeOf) {
+      setPrototypeOf(NativePromisePrototype, PromisePrototype);
+    }
+  }
+}
+
+$$1({ global: true, wrap: true, forced: FORCED }, {
+  Promise: PromiseConstructor
+});
+
+setToStringTag(PromiseConstructor, PROMISE, false);
+setSpecies(PROMISE);
+
+PromiseWrapper = getBuiltIn(PROMISE);
+
+// statics
+$$1({ target: PROMISE, stat: true, forced: FORCED }, {
+  // `Promise.reject` method
+  // https://tc39.es/ecma262/#sec-promise.reject
+  reject: function reject(r) {
+    var capability = newPromiseCapability(this);
+    call(capability.reject, undefined, r);
+    return capability.promise;
+  }
+});
+
+$$1({ target: PROMISE, stat: true, forced: FORCED }, {
+  // `Promise.resolve` method
+  // https://tc39.es/ecma262/#sec-promise.resolve
+  resolve: function resolve(x) {
+    return promiseResolve(this, x);
+  }
+});
+
+$$1({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
+  // `Promise.all` method
+  // https://tc39.es/ecma262/#sec-promise.all
+  all: function all(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(C);
+    var resolve = capability.resolve;
+    var reject = capability.reject;
+    var result = perform(function () {
+      var $promiseResolve = aCallable(C.resolve);
+      var values = [];
+      var counter = 0;
+      var remaining = 1;
+      iterate(iterable, function (promise) {
+        var index = counter++;
+        var alreadyCalled = false;
+        remaining++;
+        call($promiseResolve, C, promise).then(function (value) {
+          if (alreadyCalled) return;
+          alreadyCalled = true;
+          values[index] = value;
+          --remaining || resolve(values);
+        }, reject);
+      });
+      --remaining || resolve(values);
+    });
+    if (result.error) reject(result.value);
+    return capability.promise;
+  },
+  // `Promise.race` method
+  // https://tc39.es/ecma262/#sec-promise.race
+  race: function race(iterable) {
+    var C = this;
+    var capability = newPromiseCapability(C);
+    var reject = capability.reject;
+    var result = perform(function () {
+      var $promiseResolve = aCallable(C.resolve);
+      iterate(iterable, function (promise) {
+        call($promiseResolve, C, promise).then(capability.resolve, reject);
+      });
+    });
+    if (result.error) reject(result.value);
+    return capability.promise;
+  }
+});
+
+const NextProgress = ({
+  startAt: _startAt = 0.3,
+  showOnShallow: _showOnShallow = true,
+  stopDelayMs: _stopDelayMs = 200
+}) => {
+  const {
+    events
+  } = router.useRouter(); // const [progress, setProgress] = useState(0);
+
+  const [running, setRunning] = React.useState(false);
+  const timer = React.useRef(null);
+  const routeChangeStart = React.useCallback((_, {
+    shallow
+  }) => {
+    if (!shallow || _showOnShallow) {
+      // setProgress(startAt);
+      setRunning(true);
+    }
+  }, [_showOnShallow]);
+  const routeChangeEnd = React.useCallback((_, {
+    shallow
+  }) => {
+    if (!shallow || _showOnShallow) {
+      if (timer.current) {
+        clearTimeout(timer.current);
+      }
+
+      timer.current = setTimeout(() => {
+        // setProgress(100);
+        setRunning(false);
+      }, _stopDelayMs);
+    }
+  }, [_showOnShallow, _stopDelayMs, timer]);
+  React.useEffect(() => {
+    events.on("routeChangeStart", routeChangeStart);
+    events.on("routeChangeComplete", routeChangeEnd);
+    events.on("routeChangeError", routeChangeEnd);
+    return () => {
+      events.off("routeChangeStart", routeChangeStart);
+      events.off("routeChangeComplete", routeChangeEnd);
+      events.off("routeChangeError", routeChangeEnd);
+    };
+  }, [events, routeChangeStart, routeChangeEnd]);
+  return jsxRuntime.jsx(react.ProgressOverlay, {
+    running: running
+  });
+};
+
+var $ = es_object_assign._export;
+var DESCRIPTORS = es_object_assign.descriptors;
+var global = es_object_assign.global;
+var uncurryThis$1 = es_object_assign.functionUncurryThis;
+var hasOwn = es_object_assign.hasOwnProperty_1;
+var isCallable = es_object_assign.isCallable;
+var isPrototypeOf$1 = es_object_assign.objectIsPrototypeOf;
+var toString = es_string_replace.toString;
+var defineProperty = es_object_assign.objectDefineProperty.f;
+var copyConstructorProperties = es_object_assign.copyConstructorProperties;
+
+var NativeSymbol = global.Symbol;
+var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
+
+if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) ||
+  // Safari 12 bug
+  NativeSymbol().description !== undefined
+)) {
+  var EmptyStringDescriptionStore = {};
+  // wrap Symbol constructor for correct work with undefined description
+  var SymbolWrapper = function Symbol() {
+    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString(arguments[0]);
+    var result = isPrototypeOf$1(SymbolPrototype, this)
+      ? new NativeSymbol(description)
+      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
+      : description === undefined ? NativeSymbol() : NativeSymbol(description);
+    if (description === '') EmptyStringDescriptionStore[result] = true;
+    return result;
+  };
+
+  copyConstructorProperties(SymbolWrapper, NativeSymbol);
+  SymbolWrapper.prototype = SymbolPrototype;
+  SymbolPrototype.constructor = SymbolWrapper;
+
+  var NATIVE_SYMBOL = String(NativeSymbol('test')) == 'Symbol(test)';
+  var symbolToString = uncurryThis$1(SymbolPrototype.toString);
+  var symbolValueOf = uncurryThis$1(SymbolPrototype.valueOf);
+  var regexp = /^Symbol\((.*)\)[^)]+$/;
+  var replace = uncurryThis$1(''.replace);
+  var stringSlice = uncurryThis$1(''.slice);
+
+  defineProperty(SymbolPrototype, 'description', {
+    configurable: true,
+    get: function description() {
+      var symbol = symbolValueOf(this);
+      var string = symbolToString(symbol);
+      if (hasOwn(EmptyStringDescriptionStore, symbol)) return '';
+      var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1');
+      return desc === '' ? undefined : desc;
+    }
+  });
+
+  $({ global: true, forced: true }, {
+    Symbol: SymbolWrapper
+  });
+}
+
+const defaults = {
+  tplTitle: ""
+};
+/**
+ * We do a couple of things in addition while many other are removed.
+ *
+ * - Add `seo` meta object coming from a CMS probably
+ * - Add `ogimage` and `openGraph.image` as single image source
+ * - Add `og` alias to define `openGraph`
+ * - Add check for `title` equale to `templateTitle` to avoid meta titles like
+ *   "My site | My site" often happening in homepages
+ * - Remove the open graph videos and images
+ *
+ * - Shorter code
+ *
+ * @returns
+ */
+
+const buildTags = ({
+  seo,
+  hidden,
+  keywords,
+  title: _title = "",
+  titleTemplate,
+  defaultTitle,
+  noindex,
+  nofollow,
+  description,
+  languageAlternates: _languageAlternates = [],
+  twitter,
+  facebook,
+  openGraph,
+  og: ogAlias,
+  canonical,
+  metaTags,
+  linkTags
+} = {}) => {
+  const render = [];
+  const $names = {};
+  const $properties = {};
+
+  if (titleTemplate) {
+    defaults.tplTitle = titleTemplate;
+  }
+
+  _title = _title || (seo === null || seo === void 0 ? void 0 : seo.title) || "";
+
+  if (_title) {
+    if (defaults.tplTitle && defaults.tplTitle !== _title) {
+      _title = defaults.tplTitle.replace(/%s/g, _title);
+    }
+  } else if (defaultTitle) {
+    _title = defaultTitle;
+  }
+
+  if (_title) {
+    render.push(jsxRuntime.jsx("title", {
+      children: _title
+    }, "title"));
+    $properties["og:title"] = _title; // overridden later...
+  }
+
+  $names["robots"] = `${noindex || hidden ? "noindex" : "index"},${nofollow || hidden ? "nofollow" : "follow"}`;
+  description = description || (seo === null || seo === void 0 ? void 0 : seo.description);
+
+  if (description) {
+    $names["description"] = description;
+    $properties["og:description"] = description; // overridden later...
+  }
+
+  keywords = keywords || (seo === null || seo === void 0 ? void 0 : seo.keywords);
+
+  if (keywords) {
+    $names["keywords"] = utils.isArray(keywords) ? keywords.join(", ") : keywords;
+  }
+
+  if ((_languageAlternates === null || _languageAlternates === void 0 ? void 0 : _languageAlternates.length) > 0) {
+    _languageAlternates.forEach(languageAlternate => {
+      render.push(jsxRuntime.jsx("link", {
+        rel: "alternate",
+        hrefLang: languageAlternate.hrefLang,
+        href: languageAlternate.href
+      }, `languageAlternate-${languageAlternate.hrefLang}`));
+    });
+  }
+
+  if (canonical) {
+    render.push(jsxRuntime.jsx("link", {
+      rel: "canonical",
+      href: canonical
+    }, "canonical"));
+    $properties["og:url"] = canonical;
+  }
+
+  if (facebook === null || facebook === void 0 ? void 0 : facebook.appId) $properties["fb:app_id"] = facebook.appId;
+
+  if (twitter) {
+    if (twitter.cardType) $names["twitter:card"] = twitter.cardType;
+    if (twitter.site) $names["twitter:site"] = twitter.site;
+    if (twitter.handle) $names["twitter:creator"] = twitter.handle;
+  }
+
+  const og = ogAlias || openGraph;
+  if (og === null || og === void 0 ? void 0 : og.title) $properties["og:title"] = og === null || og === void 0 ? void 0 : og.title;
+  if (og === null || og === void 0 ? void 0 : og.description) $properties["og:description"] = og === null || og === void 0 ? void 0 : og.description;
+  if (og === null || og === void 0 ? void 0 : og.url) $properties["og:url"] = og.url;
+  if (og === null || og === void 0 ? void 0 : og.type) $properties["og:type"] = og.type.toLowerCase();
+  if (og === null || og === void 0 ? void 0 : og.locale) $properties["og:locale"] = og.locale;
+  if (og === null || og === void 0 ? void 0 : og.site_name) $properties["og:site_name"] = og.site_name;
+  const ogimage = (og === null || og === void 0 ? void 0 : og.image) || (seo === null || seo === void 0 ? void 0 : seo.ogimage);
+  if (ogimage) $properties["og:image"] = ogimage;
+  Object.keys($names).forEach(key => {
+    render.push(jsxRuntime.jsx("meta", {
+      name: key,
+      content: $names[key]
+    }, key));
+  });
+  Object.keys($properties).forEach(key => {
+    render.push(jsxRuntime.jsx("meta", {
+      property: key,
+      content: $properties[key]
+    }, key));
+  });
+
+  if (metaTags && metaTags.length > 0) {
+    metaTags.forEach(tag => {
+      var _a, _b, _c;
+
+      render.push(jsxRuntime.jsx("meta", Object.assign({}, tag), `meta:${(_c = (_b = (_a = tag.keyOverride) !== null && _a !== void 0 ? _a : tag.name) !== null && _b !== void 0 ? _b : tag.property) !== null && _c !== void 0 ? _c : tag.httpEquiv}`));
+    });
+  }
+
+  if (linkTags === null || linkTags === void 0 ? void 0 : linkTags.length) {
+    linkTags.forEach(tag => {
+      var _a;
+
+      render.push(jsxRuntime.jsx("link", Object.assign({}, tag), `link${(_a = tag.keyOverride) !== null && _a !== void 0 ? _a : tag.href}${tag.rel}`));
+    });
+  } // TODO: alternates and canonical
+  // canonical = 'https://www.domain.com/';
+  // languageAlternates={[{
+  //   hrefLang: 'en',
+  //   href: 'https://www.domain.com/en',
+  // }]}
+  // <link rel="alternate" hreflang="x-default" href="https://www.domain.com/nl/">
+  // <link rel="alternate" hreflang="nl" href="https://www.domain.com/nl/">
+  // <link rel="alternate" hreflang="en" href="https://www.domain.com/en/">
+
+
+  return render;
+};
+
+const _SeoDefaults = props => {
+  // const router = useRouter();
+  // props.openGraph.url = getSiteUrl(router.asPath);
+  return jsxRuntime.jsx(Head__default["default"], {
+    children: buildTags(props)
+  });
+};
+
+const SeoDefaults = /*#__PURE__*/React.memo(_SeoDefaults);
+
+var uncurryThis = es_object_assign.functionUncurryThis;
+var PROPER_FUNCTION_NAME = es_object_assign.functionName.PROPER;
+var redefine = es_object_assign.redefine.exports;
+var anObject = es_object_assign.anObject;
+var isPrototypeOf = es_object_assign.objectIsPrototypeOf;
+var $toString = es_string_replace.toString;
+var fails = es_object_assign.fails;
+var regExpFlags = es_string_replace.regexpFlags;
+
+var TO_STRING = 'toString';
+var RegExpPrototype = RegExp.prototype;
+var n$ToString = RegExpPrototype[TO_STRING];
+var getFlags = uncurryThis(regExpFlags);
+
+var NOT_GENERIC = fails(function () { return n$ToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
+// FF44- RegExp#toString has a wrong name
+var INCORRECT_NAME = PROPER_FUNCTION_NAME && n$ToString.name != TO_STRING;
+
+// `RegExp.prototype.toString` method
+// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
+if (NOT_GENERIC || INCORRECT_NAME) {
+  redefine(RegExp.prototype, TO_STRING, function toString() {
+    var R = anObject(this);
+    var p = $toString(R.source);
+    var rf = R.flags;
+    var f = $toString(rf === undefined && isPrototypeOf(RegExpPrototype, R) && !('flags' in RegExpPrototype) ? getFlags(R) : rf);
+    return '/' + p + '/' + f;
+  }, { unsafe: true });
+}
+
+const THEME_STORAGE_KEY = "theme";
+const colorSchemes = ["light", "dark"];
+const MEDIA = "(prefers-color-scheme: dark)";
+const ThemeContext = /*#__PURE__*/React.createContext({
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  setTheme: _ => {},
+  themes: []
+});
+const useTheme = () => React.useContext(ThemeContext);
+const ThemeProvider = ({
+  forcedTheme,
+  disableTransitionOnChange: _disableTransitionOnChange = false,
+  enableSystem: _enableSystem = true,
+  enableColorScheme: _enableColorScheme = true,
+  themes: _themes = ["light", "dark"],
+  defaultTheme: _defaultTheme = _enableSystem ? "system" : "light",
+  attribute: _attribute = "data-theme",
+  value,
+  children,
+  nonce
+}) => {
+  const [theme, setThemeState] = React.useState(() => getTheme(THEME_STORAGE_KEY, _defaultTheme));
+  const [resolvedTheme, setResolvedTheme] = React.useState(() => getTheme(THEME_STORAGE_KEY));
+  const attrs = !value ? _themes : Object.values(value);
+  const applyTheme = React.useCallback(theme => {
+    let resolved = theme;
+    if (utils.isServer) return; // If theme is system, resolve it before setting theme
+
+    if (theme === "system" && _enableSystem) {
+      resolved = getSystemTheme();
+    }
+
+    const name = value ? value[resolved] : resolved;
+    const enable = _disableTransitionOnChange ? disableAnimation() : null;
+    const d = document.documentElement;
+
+    if (_attribute === "class") {
+      d.classList.remove(...attrs);
+      if (name) d.classList.add(name);
+    } else {
+      if (name) {
+        d.setAttribute(_attribute, name);
+      } else {
+        d.removeAttribute(_attribute);
+      }
+    }
+
+    if (_enableColorScheme) {
+      const fallback = colorSchemes.includes(_defaultTheme) ? _defaultTheme : null;
+      const colorScheme = colorSchemes.includes(resolved) ? resolved : fallback;
+      d.style.colorScheme = colorScheme;
+    }
+
+    enable === null || enable === void 0 ? void 0 : enable();
+  }, [_attribute, attrs, _defaultTheme, _disableTransitionOnChange, _enableColorScheme, _enableSystem, value]);
+  const setTheme = React.useCallback(theme => {
+    setThemeState(theme); // Save to storage
+
+    try {
+      localStorage.setItem(THEME_STORAGE_KEY, theme);
+    } catch (e) {// Unsupported
+    }
+  }, []);
+  const handleMediaQuery = React.useCallback(e => {
+    const resolved = getSystemTheme(e);
+    setResolvedTheme(resolved);
+
+    if (theme === "system" && _enableSystem && !forcedTheme) {
+      applyTheme("system");
+    }
+  }, [theme, _enableSystem, forcedTheme, applyTheme]); // Always listen to System preference
+
+  React.useEffect(() => {
+    const media = window.matchMedia(MEDIA); // Intentionally use deprecated listener methods to support iOS & old browsers
+
+    media.addListener(handleMediaQuery);
+    handleMediaQuery(media);
+    return () => media.removeListener(handleMediaQuery);
+  }, [handleMediaQuery]); // localStorage event handling
+
+  React.useEffect(() => {
+    const handleStorage = e => {
+      if (e.key !== THEME_STORAGE_KEY) {
+        return;
+      } // If default theme set, use it if localstorage === null (happens on local storage manual deletion)
+
+
+      const theme = e.newValue || _defaultTheme;
+      setTheme(theme);
+    };
+
+    window.addEventListener("storage", handleStorage);
+    return () => window.removeEventListener("storage", handleStorage);
+  }, [_defaultTheme, setTheme]); // Whenever theme or forcedTheme changes, apply it
+
+  React.useEffect(() => {
+    applyTheme(forcedTheme !== null && forcedTheme !== void 0 ? forcedTheme : theme);
+  }, [applyTheme, forcedTheme, theme]);
+  return jsxRuntime.jsxs(ThemeContext.Provider, Object.assign({
+    value: {
+      theme,
+      setTheme,
+      forcedTheme,
+      resolvedTheme: theme === "system" ? resolvedTheme : theme,
+      themes: _enableSystem ? [..._themes, "system"] : _themes,
+      systemTheme: _enableSystem ? resolvedTheme : undefined
+    }
+  }, {
+    children: [jsxRuntime.jsx(ThemeScript, Object.assign({}, {
+      forcedTheme,
+      disableTransitionOnChange: _disableTransitionOnChange,
+      enableSystem: _enableSystem,
+      enableColorScheme: _enableColorScheme,
+      themes: _themes,
+      defaultTheme: _defaultTheme,
+      attribute: _attribute,
+      value,
+      children,
+      attrs,
+      nonce
+    })), children]
+  }));
+};
+const ThemeScript = /*#__PURE__*/React.memo(({
+  forcedTheme,
+  attribute,
+  enableSystem,
+  enableColorScheme,
+  defaultTheme,
+  value,
+  attrs,
+  nonce
+}) => {
+  const defaultSystem = defaultTheme === "system"; // Code-golfing the amount of characters in the script
+
+  const optimization = (() => {
+    const removeClasses = `d.remove(${attrs.map(t => `'${t}'`).join(",")})`;
+    return `var d=document.documentElement.classList;${removeClasses};`;
+  })();
+
+  const fallbackColorScheme = (() => {
+    if (!enableColorScheme) {
+      return "";
+    }
+
+    const fallback = colorSchemes.includes(defaultTheme) ? defaultTheme : null;
+
+    if (fallback) {
+      return `if(e==='light'||e==='dark'||!e)d.style.colorScheme=e||'${defaultTheme}'`;
+    } else {
+      return `if(e==='light'||e==='dark')d.style.colorScheme=e`;
+    }
+  })();
+
+  const updateDOM = (name, literal = false, setColorScheme = true) => {
+    const resolvedName = value ? value[name] : name;
+    const val = literal ? name + `|| ''` : `'${resolvedName}'`;
+    let text = ""; // MUCH faster to set colorScheme alongside HTML attribute/class
+    // as it only incurs 1 style recalculation rather than 2
+    // This can save over 250ms of work for pages with big DOM
+
+    if (enableColorScheme && setColorScheme && !literal && colorSchemes.includes(name)) {
+      text += `d.style.colorScheme = '${name}';`;
+    }
+
+    if (attribute === "class") {
+      if (literal || resolvedName) {
+        text += `d.add(${val})`;
+      } else {
+        text += `null`;
+      }
+    } else {
+      if (resolvedName) {
+        text += `d[s](n, ${val})`;
+      }
+    }
+
+    return text;
+  };
+
+  const scriptSrc = (() => {
+    if (forcedTheme) {
+      return `!function(){${optimization}${updateDOM(forcedTheme)}}()`;
+    }
+
+    if (enableSystem) {
+      return `!function(){try {${optimization}var e=localStorage.getItem('${THEME_STORAGE_KEY}');if("system"===e||(!e&&${defaultSystem})){var t="${MEDIA}",m=window.matchMedia(t);if(m.media!==t||m.matches){${updateDOM("dark")}}else{${updateDOM("light")}}}else if(e){${value ? `var x=${JSON.stringify(value)};` : ""}${updateDOM(value ? `x[e]` : "e", true)}}${!defaultSystem ? `else{` + updateDOM(defaultTheme, false, false) + "}" : ""}${fallbackColorScheme}}catch(e){}}()`;
+    }
+
+    return `!function(){try{${optimization}var e=localStorage.getItem("${THEME_STORAGE_KEY}");if(e){${value ? `var x=${JSON.stringify(value)};` : ""}${updateDOM(value ? `x[e]` : "e", true)}}else{${updateDOM(defaultTheme, false, false)};}${fallbackColorScheme}}catch(t){}}();`;
+  })(); // We MUST use next/script's `beforeInteractive` strategy to avoid flashing on load.
+  // However, it only accepts the `src` prop, not `dangerouslySetInnerHTML` or `children`
+  // But our script cannot be external because it changes at runtime based on React props
+  // so we trick next/script by passing `src` as a base64 JS script
+
+
+  const encodedScript = `data:text/javascript;base64,${encodeBase64(scriptSrc)}`;
+  return jsxRuntime.jsx(Script__default["default"], {
+    id: "next-theme-script",
+    strategy: "beforeInteractive",
+    src: encodedScript,
+    nonce: nonce
+  });
+}, // Never re-render this component
+() => true); // Helpers
+
+const getTheme = (key, fallback) => {
+  if (utils.isServer) return undefined;
+  let theme;
+
+  try {
+    theme = localStorage.getItem(key) || undefined;
+  } catch (e) {// Unsupported
+  }
+
+  return theme || fallback;
+};
+
+const disableAnimation = () => {
+  const css = document.createElement("style");
+  css.appendChild(document.createTextNode(`*{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}`));
+  document.head.appendChild(css);
+  return () => {
+    // Force restyle
+    (() => window.getComputedStyle(document.body))(); // Wait for next tick before removing
+
+
+    setTimeout(() => {
+      document.head.removeChild(css);
+    }, 1);
+  };
+};
+
+const getSystemTheme = e => {
+  if (!e) e = window.matchMedia(MEDIA);
+  const isDark = e.matches;
+  const systemTheme = isDark ? "dark" : "light";
+  return systemTheme;
+};
+
+const encodeBase64 = str => {
+  return utils.isServer ? Buffer.from(str).toString("base64") : btoa(str);
+};
+
+exports.NextProgress = NextProgress;
+exports.SeoDefaults = SeoDefaults;
+exports.ThemeProvider = ThemeProvider;
+exports.buildTags = buildTags;
+exports.engineIsNode = engineIsNode;
+exports.useTheme = useTheme;