(function () {
  'use strict';

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);
    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      enumerableOnly && (symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      })), keys.push.apply(keys, symbols);
    }
    return keys;
  }
  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = null != arguments[i] ? arguments[i] : {};
      i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
    return target;
  }
  function _regeneratorRuntime() {
    _regeneratorRuntime = function () {
      return exports;
    };
    var exports = {},
      Op = Object.prototype,
      hasOwn = Op.hasOwnProperty,
      defineProperty = Object.defineProperty || function (obj, key, desc) {
        obj[key] = desc.value;
      },
      $Symbol = "function" == typeof Symbol ? Symbol : {},
      iteratorSymbol = $Symbol.iterator || "@@iterator",
      asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
      toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
    function define(obj, key, value) {
      return Object.defineProperty(obj, key, {
        value: value,
        enumerable: !0,
        configurable: !0,
        writable: !0
      }), obj[key];
    }
    try {
      define({}, "");
    } catch (err) {
      define = function (obj, key, value) {
        return obj[key] = value;
      };
    }
    function wrap(innerFn, outerFn, self, tryLocsList) {
      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
        generator = Object.create(protoGenerator.prototype),
        context = new Context(tryLocsList || []);
      return defineProperty(generator, "_invoke", {
        value: makeInvokeMethod(innerFn, self, context)
      }), generator;
    }
    function tryCatch(fn, obj, arg) {
      try {
        return {
          type: "normal",
          arg: fn.call(obj, arg)
        };
      } catch (err) {
        return {
          type: "throw",
          arg: err
        };
      }
    }
    exports.wrap = wrap;
    var ContinueSentinel = {};
    function Generator() {}
    function GeneratorFunction() {}
    function GeneratorFunctionPrototype() {}
    var IteratorPrototype = {};
    define(IteratorPrototype, iteratorSymbol, function () {
      return this;
    });
    var getProto = Object.getPrototypeOf,
      NativeIteratorPrototype = getProto && getProto(getProto(values([])));
    NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
    function defineIteratorMethods(prototype) {
      ["next", "throw", "return"].forEach(function (method) {
        define(prototype, method, function (arg) {
          return this._invoke(method, arg);
        });
      });
    }
    function AsyncIterator(generator, PromiseImpl) {
      function invoke(method, arg, resolve, reject) {
        var record = tryCatch(generator[method], generator, arg);
        if ("throw" !== record.type) {
          var result = record.arg,
            value = result.value;
          return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
            invoke("next", value, resolve, reject);
          }, function (err) {
            invoke("throw", err, resolve, reject);
          }) : PromiseImpl.resolve(value).then(function (unwrapped) {
            result.value = unwrapped, resolve(result);
          }, function (error) {
            return invoke("throw", error, resolve, reject);
          });
        }
        reject(record.arg);
      }
      var previousPromise;
      defineProperty(this, "_invoke", {
        value: function (method, arg) {
          function callInvokeWithMethodAndArg() {
            return new PromiseImpl(function (resolve, reject) {
              invoke(method, arg, resolve, reject);
            });
          }
          return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
        }
      });
    }
    function makeInvokeMethod(innerFn, self, context) {
      var state = "suspendedStart";
      return function (method, arg) {
        if ("executing" === state) throw new Error("Generator is already running");
        if ("completed" === state) {
          if ("throw" === method) throw arg;
          return doneResult();
        }
        for (context.method = method, context.arg = arg;;) {
          var delegate = context.delegate;
          if (delegate) {
            var delegateResult = maybeInvokeDelegate(delegate, context);
            if (delegateResult) {
              if (delegateResult === ContinueSentinel) continue;
              return delegateResult;
            }
          }
          if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
            if ("suspendedStart" === state) throw state = "completed", context.arg;
            context.dispatchException(context.arg);
          } else "return" === context.method && context.abrupt("return", context.arg);
          state = "executing";
          var record = tryCatch(innerFn, self, context);
          if ("normal" === record.type) {
            if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
            return {
              value: record.arg,
              done: context.done
            };
          }
          "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
        }
      };
    }
    function maybeInvokeDelegate(delegate, context) {
      var method = delegate.iterator[context.method];
      if (undefined === method) {
        if (context.delegate = null, "throw" === context.method) {
          if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
          context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
        }
        return ContinueSentinel;
      }
      var record = tryCatch(method, delegate.iterator, context.arg);
      if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
      var info = record.arg;
      return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
    }
    function pushTryEntry(locs) {
      var entry = {
        tryLoc: locs[0]
      };
      1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
    }
    function resetTryEntry(entry) {
      var record = entry.completion || {};
      record.type = "normal", delete record.arg, entry.completion = record;
    }
    function Context(tryLocsList) {
      this.tryEntries = [{
        tryLoc: "root"
      }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
    }
    function values(iterable) {
      if (iterable) {
        var iteratorMethod = iterable[iteratorSymbol];
        if (iteratorMethod) return iteratorMethod.call(iterable);
        if ("function" == typeof iterable.next) return iterable;
        if (!isNaN(iterable.length)) {
          var i = -1,
            next = function next() {
              for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
              return next.value = undefined, next.done = !0, next;
            };
          return next.next = next;
        }
      }
      return {
        next: doneResult
      };
    }
    function doneResult() {
      return {
        value: undefined,
        done: !0
      };
    }
    return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
      value: GeneratorFunctionPrototype,
      configurable: !0
    }), defineProperty(GeneratorFunctionPrototype, "constructor", {
      value: GeneratorFunction,
      configurable: !0
    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
      var ctor = "function" == typeof genFun && genFun.constructor;
      return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
    }, exports.mark = function (genFun) {
      return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
    }, exports.awrap = function (arg) {
      return {
        __await: arg
      };
    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
      return this;
    }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
      void 0 === PromiseImpl && (PromiseImpl = Promise);
      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
        return result.done ? result.value : iter.next();
      });
    }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
      return this;
    }), define(Gp, "toString", function () {
      return "[object Generator]";
    }), exports.keys = function (val) {
      var object = Object(val),
        keys = [];
      for (var key in object) keys.push(key);
      return keys.reverse(), function next() {
        for (; keys.length;) {
          var key = keys.pop();
          if (key in object) return next.value = key, next.done = !1, next;
        }
        return next.done = !0, next;
      };
    }, exports.values = values, Context.prototype = {
      constructor: Context,
      reset: function (skipTempReset) {
        if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
      },
      stop: function () {
        this.done = !0;
        var rootRecord = this.tryEntries[0].completion;
        if ("throw" === rootRecord.type) throw rootRecord.arg;
        return this.rval;
      },
      dispatchException: function (exception) {
        if (this.done) throw exception;
        var context = this;
        function handle(loc, caught) {
          return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
        }
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i],
            record = entry.completion;
          if ("root" === entry.tryLoc) return handle("end");
          if (entry.tryLoc <= this.prev) {
            var hasCatch = hasOwn.call(entry, "catchLoc"),
              hasFinally = hasOwn.call(entry, "finallyLoc");
            if (hasCatch && hasFinally) {
              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
            } else if (hasCatch) {
              if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
            } else {
              if (!hasFinally) throw new Error("try statement without catch or finally");
              if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
            }
          }
        }
      },
      abrupt: function (type, arg) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
            var finallyEntry = entry;
            break;
          }
        }
        finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
        var record = finallyEntry ? finallyEntry.completion : {};
        return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
      },
      complete: function (record, afterLoc) {
        if ("throw" === record.type) throw record.arg;
        return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
      },
      finish: function (finallyLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
        }
      },
      catch: function (tryLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          if (entry.tryLoc === tryLoc) {
            var record = entry.completion;
            if ("throw" === record.type) {
              var thrown = record.arg;
              resetTryEntry(entry);
            }
            return thrown;
          }
        }
        throw new Error("illegal catch attempt");
      },
      delegateYield: function (iterable, resultName, nextLoc) {
        return this.delegate = {
          iterator: values(iterable),
          resultName: resultName,
          nextLoc: nextLoc
        }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
      }
    }, exports;
  }
  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
      var info = gen[key](arg);
      var value = info.value;
    } catch (error) {
      reject(error);
      return;
    }
    if (info.done) {
      resolve(value);
    } else {
      Promise.resolve(value).then(_next, _throw);
    }
  }
  function _asyncToGenerator(fn) {
    return function () {
      var self = this,
        args = arguments;
      return new Promise(function (resolve, reject) {
        var gen = fn.apply(self, args);
        function _next(value) {
          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
        }
        function _throw(err) {
          asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
        }
        _next(undefined);
      });
    };
  }
  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
    return obj;
  }
  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };
    return _setPrototypeOf(o, p);
  }
  function _isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;
    try {
      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }
  function _construct(Parent, args, Class) {
    if (_isNativeReflectConstruct()) {
      _construct = Reflect.construct.bind();
    } else {
      _construct = function _construct(Parent, args, Class) {
        var a = [null];
        a.push.apply(a, args);
        var Constructor = Function.bind.apply(Parent, a);
        var instance = new Constructor();
        if (Class) _setPrototypeOf(instance, Class.prototype);
        return instance;
      };
    }
    return _construct.apply(null, arguments);
  }
  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }
  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
    return arr2;
  }
  function _createForOfIteratorHelper(o, allowArrayLike) {
    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
    if (!it) {
      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
        if (it) o = it;
        var i = 0;
        var F = function () {};
        return {
          s: F,
          n: function () {
            if (i >= o.length) return {
              done: true
            };
            return {
              done: false,
              value: o[i++]
            };
          },
          e: function (e) {
            throw e;
          },
          f: F
        };
      }
      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
    }
    var normalCompletion = true,
      didErr = false,
      err;
    return {
      s: function () {
        it = it.call(o);
      },
      n: function () {
        var step = it.next();
        normalCompletion = step.done;
        return step;
      },
      e: function (e) {
        didErr = true;
        err = e;
      },
      f: function () {
        try {
          if (!normalCompletion && it.return != null) it.return();
        } finally {
          if (didErr) throw err;
        }
      }
    };
  }

  function styleInject(css, ref) {
    if (ref === void 0) ref = {};
    var insertAt = ref.insertAt;
    if (!css || typeof document === 'undefined') {
      return;
    }
    var head = document.head || document.getElementsByTagName('head')[0];
    var style = document.createElement('style');
    style.type = 'text/css';
    if (insertAt === 'top') {
      if (head.firstChild) {
        head.insertBefore(style, head.firstChild);
      } else {
        head.appendChild(style);
      }
    } else {
      head.appendChild(style);
    }
    if (style.styleSheet) {
      style.styleSheet.cssText = css;
    } else {
      style.appendChild(document.createTextNode(css));
    }
  }

  var css_248z$2 = ".wwt-cc-btn, .wwt-cc-btn-primary, .wwt-cc-no-button {\n  transition: transform .1s ease-in-out,box-shadow .1s ease-in-out,background-color .1s ease-in-out,border-color .1s ease-in-out;\n  border-width: 0;\n  padding: 0.5rem 2rem;\n  font-family: sans-serif;\n  font-size: 1.125rem;\n  border-radius: 0.25rem;\n  white-space: nowrap; }\n\n.wwt-cc-btn-primary {\n  background-color: #006dc7;\n  color: white;\n  font-weight: 600; }\n  .wwt-cc-btn-primary:hover {\n    background-color: #339eee; }\n\n.wwt-cc-no-button {\n  background: none;\n  color: inherit;\n  border: none;\n  padding: 0;\n  color: #006dc7; }\n  .wwt-cc-no-button:hover {\n    color: rgba(0, 109, 199, 0.7); }\n";
  styleInject(css_248z$2);

  var css_248z$1 = ".wwt-cc-banner {\n  position: fixed;\n  bottom: 0;\n  left: 0;\n  width: 100%;\n  background: #1d1e48;\n  color: #fff;\n  font-family: sans-serif;\n  z-index: 50; }\n\n.wwt-cc-banner-container {\n  max-width: 1200px;\n  margin: 0 auto;\n  padding: 1.5rem;\n  display: flex;\n  color: white; }\n  @media only screen and (max-width: 900px) {\n    .wwt-cc-banner-container {\n      flex-direction: column; } }\n  .wwt-cc-banner-container > section {\n    flex: 1; }\n  .wwt-cc-banner-container a {\n    color: #99cff7;\n    text-decoration: none; }\n    .wwt-cc-banner-container a:hover {\n      text-decoration: underline; }\n  .wwt-cc-banner-container h2 {\n    margin: 0;\n    font-size: 1.5rem;\n    font-weight: 600; }\n  .wwt-cc-banner-container p {\n    font-size: 1.125rem;\n    line-height: 1.5;\n    margin: 10px 0; }\n  .wwt-cc-banner-container .wwt-cc-banner-actions-wrapper {\n    display: flex;\n    justify-content: flex-end;\n    align-items: flex-end; }\n  .wwt-cc-banner-container .wwt-cc-banner-actions {\n    display: flex;\n    flex-direction: row-reverse; }\n    .wwt-cc-banner-container .wwt-cc-banner-actions > button {\n      margin-left: 25px; }\n  .wwt-cc-banner-container .wwt-cc-no-button {\n    color: #99cff7;\n    font-weight: normal; }\n    .wwt-cc-banner-container .wwt-cc-no-button:hover {\n      text-decoration: underline; }\n";
  styleInject(css_248z$1);

  var css_248z = ".wwt-cc-preferences-wrapper {\n  background: #32323287;\n  display: flex;\n  width: 100vw;\n  height: 100vh;\n  z-index: 99999999;\n  position: fixed;\n  top: 0;\n  left: 0;\n  justify-content: center;\n  align-items: center; }\n\n.wwt-cc-preferences {\n  font-family: sans-serif;\n  max-width: 560px;\n  position: fixed;\n  background: #fff;\n  overflow: auto;\n  color: #292940;\n  height: 650px;\n  width: 95%;\n  border-radius: 3px;\n  box-shadow: 0px 16px 48px rgba(0, 0, 0, 0.06), 0px 32px 64px rgba(28, 0, 135, 0.2);\n  height: 90vh;\n  max-height: 650px; }\n  .wwt-cc-preferences h2 {\n    display: block;\n    font-size: 16px;\n    margin: 0;\n    padding: 0;\n    padding-top: 1em; }\n  .wwt-cc-preferences p {\n    display: block;\n    font-size: 16px;\n    line-height: 20px;\n    margin: 0;\n    padding: 0;\n    padding-top: 1em; }\n\n.wwt-cc-preferences-body,\n.wwt-cc-preferences-footer {\n  padding: 0 20px; }\n\n.wwt-cc-preferences-footer {\n  position: sticky;\n  bottom: 0;\n  display: flex;\n  flex-direction: row-reverse;\n  background: #ffffffed;\n  border-top: 1px solid #ccc;\n  z-index: 2;\n  padding-top: 10px;\n  padding-bottom: 10px; }\n  .wwt-cc-preferences-footer button {\n    margin-left: 20px;\n    font-size: .875rem; }\n\n.wwt-cc-cookie {\n  border-bottom: 1px solid #ccc;\n  max-width: 500px;\n  font-size: 14px;\n  padding: 10px 0; }\n  .wwt-cc-cookie:last-child {\n    border-bottom: none; }\n\n.wwt-cc-preference-category {\n  border-bottom: 1px solid #ccc;\n  display: flex;\n  padding-bottom: 10px; }\n  .wwt-cc-preference-category:last-child {\n    border-bottom: none; }\n  .wwt-cc-preference-category .wwt-cc-no-button {\n    margin-top: 10px;\n    margin-bottom: 10px;\n    font-size: .875rem; }\n\n.wwt-cc-cookie-info-row {\n  display: flex;\n  padding: 5px 0; }\n  .wwt-cc-cookie-info-row > section {\n    flex: 1; }\n\n.wwt-cc-cookies-wrapper {\n  display: none; }\n  .wwt-cc-cookies-wrapper.wwt-cc-show {\n    display: block; }\n\n.wwt-cc-category-checkbox-wrapper {\n  margin-top: 13px;\n  margin-right: 15px;\n  display: flex;\n  align-items: center;\n  font-weight: 400;\n  gap: 0.5em;\n  line-height: 115%; }\n  .wwt-cc-category-checkbox-wrapper label {\n    font-weight: 400;\n    line-height: 1.5;\n    width: auto; }\n  .wwt-cc-category-checkbox-wrapper input {\n    -webkit-appearance: none;\n       -moz-appearance: none;\n            appearance: none;\n    border-radius: 0.125rem;\n    box-shadow: inset 0 0 0 0.125rem #0a0b19;\n    display: grid;\n    height: 1rem;\n    margin: 0;\n    place-content: center;\n    position: relative;\n    width: 1rem; }\n  .wwt-cc-category-checkbox-wrapper input::before {\n    box-shadow: #0086ea;\n    --filled-size: 1rem;\n    --check-fill-color: rgb(0, 134, 234);\n    content: '';\n    border-radius: 0.125rem;\n    box-shadow: inset var(--filled-size) var(--filled-size) var(--check-fill-color);\n    height: var(--filled-size);\n    visibility: hidden;\n    width: var(--filled-size); }\n  .wwt-cc-category-checkbox-wrapper input:checked::before {\n    visibility: visible; }\n  .wwt-cc-category-checkbox-wrapper input:disabled {\n    opacity: 0.4; }\n  .wwt-cc-category-checkbox-wrapper input::after {\n    border: solid #fff;\n    border-width: 0 0.125rem 0.125rem 0;\n    content: '';\n    height: 0.75em;\n    left: 50%;\n    position: absolute;\n    top: 50%;\n    transform-origin: center;\n    transform: translate(-50%, -60%) rotate(45deg);\n    visibility: hidden;\n    width: 0.375em; }\n  .wwt-cc-category-checkbox-wrapper input:checked::after {\n    visibility: visible; }\n";
  styleInject(css_248z);

  var cookieName = 'wwtCookiePrefs';
  var blockedScriptType = 'javascript/blocked';

  var config = {};
  function set(givenConfig) {
    config = givenConfig;
    return config;
  }
  function get() {
    return config;
  }

  var loggingIsEnabled = false;

  // todo: probably a better way to do this.
  var log$1 = {
    info: function info(message, obj) {
      if (loggingIsEnabled) console.info(message, obj);
      return;
    },
    warning: function warning(message, obj) {
      if (loggingIsEnabled) console.warning(message, obj);
      return;
    },
    error: function error(message, obj) {
      if (loggingIsEnabled) console.error(message, obj);
      return;
    }
  };
  function enableLogging() {
    loggingIsEnabled = true;
  }

  var cookieQueue = {};
  function addToQueue$1(key, value) {
    cookieQueue[key] = value;
  }
  function removeFromQueue$1(key) {
    delete cookieQueue[key];
  }
  function processQueue$2() {
    for (var key in cookieQueue) {
      document.cookie = cookieQueue[key];
    }
  }

  var scriptQueue = {};
  function addToQueue(key, value) {
    scriptQueue[key] = value;
  }
  function removeFromQueue(key) {
    delete scriptQueue[key];
  }
  function processQueue$1() {
    for (var key in scriptQueue) {
      // todo: add logic from preferences to check if we
      // should unblock
      unblockScript(scriptQueue[key]);
      removeFromQueue(key);
    }
  }
  function unblockScript(script) {
    var scriptNode = document.createElement('script');
    for (var i = 0; i < script.attributes.length; i++) {
      var attribute = script.attributes[i];
      if (attribute.name !== 'src' && attribute.name !== 'type') {
        scriptNode.setAttribute(attribute.name, script.attributes[i].value);
      }
    }
    scriptNode.setAttribute('src', script.src);
    scriptNode.setAttribute('type', 'application/javascript');
    document.head.appendChild(scriptNode);
  }

  function emitEvent(eventTitle) {
    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var event = new CustomEvent(eventTitle, {
      detail: data
    });
    window.dispatchEvent(event);
  }

  var prefs = {};
  function acceptAll() {
    prefs.rejectsAll = false;
    prefs.acceptsAll = true;
    var categoryTitles = getCategoryTitles();
    if (!prefs.categories) prefs.categories = {};
    var _iterator = _createForOfIteratorHelper(categoryTitles),
      _step;
    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var categoryTitle = _step.value;
        prefs.categories[categoryTitle] = 'accepted';
        emitEvent('wwt-cc-accepted-category', categoryTitle);
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
    updatePrefsCookie();
    emitEvent('wwt-cc-accepted-all');
    processQueue();
  }
  function getCategoryTitles() {
    var config = get();
    var categoryTitles = Object.keys(config.categories);
    return categoryTitles;
  }
  function acceptCategory(categoryTitle) {
    if (!prefs.categories) prefs.categories = {};
    prefs.rejectsAll = false;
    prefs.categories[categoryTitle] = 'accepted';
    updatePrefsCookie();
    emitEvent('wwt-cc-accepted-category', categoryTitle);
    processQueue();
  }
  function rejectCategory(categoryTitle) {
    if (!prefs.categories) prefs.categories = {};
    prefs.acceptsAll = false;
    prefs.categories[categoryTitle] = 'rejected';
    updatePrefsCookie();
    emitEvent('wwt-cc-rejected-category', categoryTitle);
    processQueue();
  }
  function rejectAll() {
    prefs.acceptsAll = false;
    prefs.rejectsAll = true;
    updatePrefsCookie();
    var categoryTitles = getCategoryTitles();
    if (!prefs.categories) prefs.categories = {};
    var _iterator2 = _createForOfIteratorHelper(categoryTitles),
      _step2;
    try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var categoryTitle = _step2.value;
        prefs.categories[categoryTitle] = 'rejected';
        emitEvent('wwt-cc-rejected-category', categoryTitle);
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }
    emitEvent('wwt-cc-rejected-all');
  }
  function setPreferences(givenPrefs) {
    prefs = getAndParseCookiePrefsCookie();
    return prefs;
  }
  function getPreferences() {
    return prefs;
  }
  function hasAcceptedAllCookies() {
    if (!prefs) return false;
    if (!prefs.acceptsAll) return false;
    return true;
  }
  function hasAcceptedCategory(categoryTitle) {
    if (hasAcceptedAllCookies()) return true;
    // todo: should target a flag like isRequired instead of the essential string
    if (categoryTitle === 'Essential') return true;
    if (prefs && prefs.categories && prefs.categories[categoryTitle] === 'accepted') return true;
    return false;
  }
  function hasAcceptedThisCookieType(cookieValueOrScriptDomain) {
    if (hasAcceptedAllCookies()) return true;
    if (!cookieValueOrScriptDomain) return true;
    var config = get();
    if (!hasSetPrefs() && config.mode === 'optOut') return true;

    // Find the known cookie and respect it's settings.
    var knownCookies = get().knownCookies;
    var knownCookie = null;
    for (var cookieKey in knownCookies) {
      var cookieRegexp = knownCookies[cookieKey].regexPattern ? new RegExp(knownCookies[cookieKey].regexPattern) : '';
      var scriptRegexp = knownCookies[cookieKey].scriptRegexPattern ? new RegExp(knownCookies[cookieKey].scriptRegexPattern) : '';
      if (cookieRegexp && cookieRegexp.test(cookieValueOrScriptDomain) || scriptRegexp && scriptRegexp.test(cookieValueOrScriptDomain)) {
        knownCookie = knownCookies[cookieKey];
        break;
      }
    }
    if (knownCookie && knownCookie.category) {
      // todo: should implement isRqequired flag rather than hardcoding for
      // the category called "Essential"
      if (knownCookie.category === 'Essential') return true;
      var categoryPref = prefs.categories ? prefs.categories[knownCookie.category] : '';
      return categoryPref && categoryPref === 'accepted';
    }
    if (!hasSetPrefs() && config.mode === 'optIn') return false;

    // todo: if the cookie is not known cookie, we should accept it and fire an
    // event that we'll log and alert on downstream so we can categorize it.
    emitEvent('wwt-cc-unknown-cookie-or-script-found', {
      cookieValueOrScriptDomain: cookieValueOrScriptDomain
    });
    return true;
  }
  function shouldAllowCookie(val) {
    return hasAcceptedAllCookies() || hasAcceptedThisCookieType(val);
  }
  function shouldAllowScript(val) {
    // The logic flow is the same as shouldAllowCookie(), but that will probably change
    // at some point.
    return shouldAllowCookie(val);
  }
  function hasSetPrefs() {
    return typeof prefs.acceptsAll !== 'undefined';
  }
  function getAndParseCookiePrefsCookie() {
    var cookie = document.cookie;
    if (!cookie) return {};
    cookie = cookie.split('; ');
    var cookiesAsObject = {};
    for (var i in cookie) {
      var cur = cookie[i].split('=');
      cookiesAsObject[cur[0]] = cur[1];
    }
    var cookiePrefsCookie = cookiesAsObject[cookieName];
    if (!cookiePrefsCookie) return {};
    try {
      return JSON.parse(atob(cookiePrefsCookie));
    } catch (err) {
      log$1.error('Error parsing cookie preferences', err);
    }
    return {};
  }
  function processQueue() {
    processQueue$1();
    processQueue$2();
  }
  function updatePrefsCookie() {
    document.cookie = "".concat(cookieName, "=").concat(btoa(JSON.stringify(prefs)), "; expires=").concat(new Date(new Date().getTime() + 1000 * 60 * 60 * 24 * 365).toGMTString(), "; path=/;");
    window.wwtCookieConsent.closeBanner();
    removeRejectedCookies();
  }
  function removeRejectedCookies() {
    var cookie = document.cookie;
    if (!cookie) return {};
    cookie = cookie.split('; ');
    var cookiesAsObject = {};
    for (var i in cookie) {
      var cur = cookie[i].split('=');
      cookiesAsObject[cur[0]] = cur[1];
    }
    for (var cookieKey in cookiesAsObject) {
      if (!hasAcceptedThisCookieType(cookieKey)) {
        // Delete cookie by setting it to expire in the past.
        // todo: This isn't deleting google analytics cookies.
        document.cookie = "".concat(cookieKey, "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;");
      }
    }
  }

  function patchCookie() {
    // We want to override the default cookie behavior so we can add logic before
    // creating cookies to make sure the cookies have been accepted. We can override
    // the document's cookie getters and setters, and use the original getters and setters
    // on the Document to do the actual getting and setting. If you're like me and hadn't really
    // considered the difference between Document and document...
    // https://stackoverflow.com/questions/23052135/what-is-the-difference-between-document-and-document
    var cookieDesc = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
    if (!cookieDesc) {
      // Fallback for older versions of Firefox
      cookieDesc = Object.getOwnPropertyDescriptor(HTMLDocument.prototype, 'cookie');
    }
    if (cookieDesc && cookieDesc.configurable) {
      Object.defineProperty(document, 'cookie', {
        get: function get() {
          return cookieDesc.get.call(document);
        },
        set: setCookie
      });
    }
  }
  function setCookie(val) {
    var cookieBits = val.split('=');
    if (!shouldAllowCookie(val)) {
      log$1.info('Queuing cookie:', val);
      addToQueue$1(cookieBits[0], val);
    } else {
      log$1.info('Setting cookie:', val);
      // Remove it from the queue if it's in there.
      removeFromQueue$1(cookieBits[0]);
      Object.getOwnPropertyDescriptor(Document.prototype, 'cookie').set.call(document, val);
    }
  }

  // The string being something like `<div>${variable}</div>`
  function interpolate(str, params) {
    var names = Object.keys(params);
    var vals = Object.values(params);
    return _construct(Function, names.concat(["return `".concat(str, "`;")])).apply(void 0, vals);
  }

  var bannerHtml = "<div class=\"wwt-cc-banner\">\n  <div class=\"wwt-cc-banner-container\">\n    <section>\n      ${bannerContent}\n    </section>\n\n    <section class=\"wwt-cc-banner-actions-wrapper\">\n      <div class=\"wwt-cc-banner-actions\">\n        <button class=\"wwt-cc-btn-primary\" onclick=\"window.wwtCookieConsent.acceptAll()\">${acceptButtonText}</button>\n        <button class=\"wwt-cc-btn-primary\" onclick=\"window.wwtCookieConsent.rejectAll()\">${rejectButtonText}</button>\n        <button class=\"wwt-cc-no-button\" onclick=\"window.wwtCookieConsent.openPreferences()\">${preferencesButtonText}</button>\n      </div>\n    </section>\n  </div>\n</div>";
  var bannerEl = null;
  function banner() {
    if (bannerEl) return bannerEl;
    var config = get();
    bannerEl = document.createElement('div');
    bannerEl.innerHTML = interpolate(bannerHtml, {
      bannerContent: config.bannerContent || 'Add banner content',
      acceptButtonText: config.acceptButtonText || 'Accept All',
      rejectButtonText: config.rejectButtonText || 'Decline Optional',
      preferencesButtonText: config.preferencesButtonText || 'Preferences'
    });
    document.body.appendChild(bannerEl);
    return bannerEl;
  }
  function closeBanner() {
    if (!bannerEl) return;
    bannerEl.remove();
  }

  var html$2 = "<div class=\"wwt-cc-cookie\">\n  <div class=\"wwt-cc-cookie-info-row\">\n    <section>Name</section>\n    <section>${name}</section>\n  </div>\n\n  <div class=\"wwt-cc-cookie-info-row\">\n    <section>Provider</section>\n    <section>${provider}</section>\n  </div>\n\n  <div class=\"wwt-cc-cookie-info-row\">\n    <section>Expiration</section>\n    <section>${expiration}</section>\n  </div>\n\n  <div class=\"wwt-cc-cookie-info-row\">\n    <section>Purpose</section>\n    <section>${purpose}</section>\n  </div>\n</div>";
  function cookie(data) {
    if (!data.name) data.name = '';
    if (!data.provider) data.provider = '';
    if (!data.expiration) data.expiration = '';
    if (!data.purpose) data.purpose = '';
    return interpolate(html$2, data);
  }

  var html$1 = "<div class=\"wwt-cc-preference-category\">\n  <section>\n    <div class=\"wwt-cc-category-checkbox-wrapper\">\n      <input type=\"checkbox\" id=\"wwt-cc-category-preference-${title}\" name=\"wwt-cc-category-preference-${title}\" ${disabledValue} ${checkedValue}>\n      <label for=\"wwt-cc-category-preference-${title}\">${title}</label>\n    </div>\n\n    <section style=\"margin-left: 25px;\">\n      <p>${description}</p>\n\n      <button class=\"wwt-cc-no-button\" style=\"${!cookies || !cookies.length ? 'display: none;' : ''}\" onclick=\"window.wwtCookieConsent.toggleShowCookiesForCategory('${title}', this)\">View Cookies</button>\n\n      <div class=\"wwt-cc-cookies-wrapper\" data-wwt-cc-cookies-wrapper-title=\"${title}\">\n        ${cookieMarkup}\n      </div>\n    </section>\n  </section>\n</div>";
  function category(categoryData) {
    categoryData.cookieMarkup = '';
    if (categoryData && categoryData.cookies && categoryData.cookies.length) {
      var _iterator = _createForOfIteratorHelper(categoryData.cookies),
        _step;
      try {
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
          var cookie$1 = _step.value;
          if (cookie$1 && cookie$1.disclose !== false) {
            categoryData.cookieMarkup += cookie(cookie$1);
          }
        }
      } catch (err) {
        _iterator.e(err);
      } finally {
        _iterator.f();
      }
    }

    // There is no such thing as checked="false". If the checked attribute exists
    // it means the box is checked. So we have to conditionally show the entire attribute
    // rather than just just it's value.
    categoryData.checkedValue = hasAcceptedCategory(categoryData.title) ? 'checked="checked"' : '';
    // todo: should queue off a flag like isRequired instead of this string.
    categoryData.disabledValue = categoryData.title === 'Essential' ? 'disabled="true"' : '';
    return interpolate(html$1, categoryData);
  }
  function toggleShowCookiesForCategory(categoryTitle, clickedEl) {
    var el = document.querySelector("[data-wwt-cc-cookies-wrapper-title=\"".concat(categoryTitle, "\"]"));
    if (el.classList.contains('wwt-cc-show')) return hideCookiesForCategory(el, clickedEl);
    return showCookiesForCategory(el, clickedEl);
  }
  function showCookiesForCategory(cookieListEl, clickedEl) {
    if (clickedEl) clickedEl.innerHTML = 'Hide Cookies';
    return cookieListEl.classList.add('wwt-cc-show');
  }
  function hideCookiesForCategory(cookieListEl, clickedEl) {
    if (clickedEl) clickedEl.innerHTML = 'View Cookies';
    return cookieListEl.classList.remove('wwt-cc-show');
  }

  var html = "<div id=\"wwt-cc-preferences-modal\" class=\"wwt-cc-preferences\">\n  <div class=\"wwt-cc-preferences-body\">\n    <button class=\"wwt-cc-no-button\" style=\"float: right; margin-top: 10px;\" onclick=\"window.wwtCookieConsent.closePreferences()\">X</button>\n\n    <h2>${preferencesTitle}</h2>\n\n    <p>${preferencesDescription}</p>\n\n    <div id=\"wwt-cc-preferences-category-list\"></div>\n    ${categoriesHtml}\n  </div>\n\n  <div class=\"wwt-cc-preferences-footer\">\n    <button class=\"wwt-cc-btn-primary\" onclick=\"window.wwtCookieConsent.savePreferenceChoices()\">Save</button>\n    <button class=\"wwt-cc-no-button\" onclick=\"window.wwtCookieConsent.closePreferences()\">Cancel</button>\n  </div>\n</div>";
  var clickOutsideListenerIsAttached = false;
  function preferencesPanel() {
    var config = get();
    var categoriesHtml = buildCategoryHtml();
    var el = document.createElement('div');
    el.classList.add('wwt-cc-preferences-wrapper');
    el.setAttribute('id', 'wwt-cc-preferences-panel');
    var preferencesTitle = config.preferencesTitle || 'Preferences';
    var preferencesDescription = config.preferencesDescription;
    el.innerHTML = interpolate(html, {
      categoriesHtml: categoriesHtml,
      preferencesTitle: preferencesTitle,
      preferencesDescription: preferencesDescription
    });
    document.body.appendChild(el);
  }
  function buildCategoryHtml() {
    var config = get();
    var categoriesHtml = '';
    // todo: should probably move more of this to category.js
    if (config.categories && Object.keys(config.categories).length) {
      document.getElementById('wwt-cc-preferences-category-list');
      for (var thisCategory in config.categories) {
        var formattedCategory = {
          title: thisCategory,
          description: config.categories[thisCategory] ? config.categories[thisCategory].description : '',
          cookies: []
        };
        if (config.knownCookies) {
          for (var key in config.knownCookies) {
            var cookie = config.knownCookies[key];
            if (cookie && cookie.category === thisCategory) {
              formattedCategory.cookies.push({
                name: cookie.title,
                description: cookie.description || '',
                provider: cookie.provider,
                expiration: cookie.expiration,
                purpose: cookie.purpose,
                disclose: cookie.disclose
              });
            }
          }
        }
        var categoryHtml = category(formattedCategory);
        categoriesHtml += categoryHtml;
      }
    }
    return categoriesHtml;
  }
  function openPreferences() {
    var el = preferencesPanel();
    // Need to wait for the element to be added to DOM
    // before attaching our listener or our listener could
    // pickup the click for opening the panel as a "click outside"
    // and immediately close it.
    setTimeout(attachClickOutsideListener, 50);
    return el;
  }
  function closePreferences() {
    var el = document.getElementById('wwt-cc-preferences-panel');
    removeClickOutsideListener();
    return el.remove();
  }
  function savePreferenceChoices() {
    var config = get();
    var categories = Object.keys(config.categories);
    for (var _i = 0, _categories = categories; _i < _categories.length; _i++) {
      var categoryTitle = _categories[_i];
      var checkboxEl = document.getElementById("wwt-cc-category-preference-".concat(categoryTitle));
      if (checkboxEl.checked) {
        acceptCategory(categoryTitle);
      } else {
        rejectCategory(categoryTitle);
      }
    }
    closePreferences();
  }
  function attachClickOutsideListener() {
    // Don't want to attach more than one listener.
    if (clickOutsideListenerIsAttached) return;
    document.addEventListener('click', clickOutsideListener);
    clickOutsideListenerIsAttached = true;
  }
  function removeClickOutsideListener() {
    document.removeEventListener('click', clickOutsideListener);
    clickOutsideListenerIsAttached = false;
  }
  function clickOutsideListener(e) {
    var prefsModel = document.getElementById('wwt-cc-preferences-modal');
    var targetEl = e.target;
    do {
      if (targetEl == prefsModel) return;
      // Go up the DOM
      targetEl = targetEl.parentNode;
    } while (targetEl);
    closePreferences();
  }

  // Setup a mutation observer to track DOM insertion
  var observer = new MutationObserver(function (mutations) {
    var _iterator = _createForOfIteratorHelper(mutations),
      _step;
    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var mutation = _step.value;
        var addedNodes = mutation.addedNodes;
        var _iterator2 = _createForOfIteratorHelper(addedNodes),
          _step2;
        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var node = _step2.value;
            processNewNode(node);
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
  });
  function processNewNode(node) {
    if (!node || node.nodeType !== 1 || node.tagName !== 'SCRIPT' || !node.src) return;
    if (!shouldBlockScript(node.src, node.type)) return;
    addToQueue(node.src, node);

    // Blocks inline script execution in Safari & Chrome
    node.type = blockedScriptType;

    // Firefox has this additional event which prevents scripts from being executed
    var beforeScriptExecuteListener = function beforeScriptExecuteListener(event) {
      // Prevent only marked scripts from executing
      if (node.getAttribute('type') === blockedScriptType) {
        event.preventDefault();
      }
      node.removeEventListener('beforescriptexecute', beforeScriptExecuteListener);
    };
    node.addEventListener('beforescriptexecute', beforeScriptExecuteListener);

    // Remove the node from the DOM
    node.parentElement && node.parentElement.removeChild(node);
  }
  function shouldBlockScript(src, type) {
    return !shouldAllowScript(src);
  }
  function observe() {
    observer.observe(document.documentElement, {
      childList: true,
      subtree: true
    });
  }

  var createElementBackup = document.createElement;
  var originalDescriptors = {
    src: Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'src'),
    type: Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, 'type')
  };

  // Patch the createElement method to prevent dynamic scripts from executing
  function patchCreateElement() {
    document.createElement = function () {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
      // If this is not a script tag, bypass
      if (!args || !args[0] || args[0].toLowerCase() !== 'script') {
        return createElementBackup.bind(document).apply(void 0, args);
      }
      var scriptElt = createElementBackup.bind(document).apply(void 0, args);

      // Define getters / setters to ensure that the script type is properly set
      try {
        Object.defineProperties(scriptElt, {
          'src': _objectSpread2(_objectSpread2({}, originalDescriptors.src), {}, {
            set: function set(value) {
              if (scriptElt.type === blockedScriptType || !shouldAllowScript(value)) {
                originalDescriptors.type.set.call(this, blockedScriptType);
              }
              originalDescriptors.src.set.call(this, value);
            }
          }),
          'type': _objectSpread2(_objectSpread2({}, originalDescriptors.type), {}, {
            get: function get() {
              var typeValue = originalDescriptors.type.get.call(this);
              if (typeValue === blockedScriptType || !shouldAllowScript(this.src)) {
                return null;
              }
              return typeValue;
            },
            set: function set(value) {
              var typeValue = scriptElt.type === blockedScriptType || !shouldAllowScript(scriptElt.src) ? blockedScriptType : value;
              originalDescriptors.type.set.call(this, typeValue);
            }
          })
        });

        // Monkey patch the setAttribute function so that the setter is called instead
        scriptElt.setAttribute = function (name, value) {
          if (name === 'type' || name === 'src') scriptElt[name] = value;else HTMLScriptElement.prototype.setAttribute.call(scriptElt, name, value);
        };
      } catch (error) {
        log.warn("Unable to prevent script execution for script src ".concat(scriptElt.src, "\n        A likely cause would be because you are using a third-party browser extension that patches the \"document.createElement\" function."));
      }
      return scriptElt;
    };
  }

  // eslint-disable-next-line
  window.initCookieConsent = init;
  function init(_x) {
    return _init.apply(this, arguments);
  }
  function _init() {
    _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(config) {
      var wwtCookieConsent;
      return _regeneratorRuntime().wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              if (config) {
                _context.next = 2;
                break;
              }
              throw new Error('A config is required to init WwtCookieConsent');
            case 2:
              if (!(config.enabled === false)) {
                _context.next = 4;
                break;
              }
              return _context.abrupt("return");
            case 4:
              if (config.enableLogging) enableLogging();
              wwtCookieConsent = {};
              addOurCookiesToConfig(config);
              set(config);
              setPreferences();
              if (config.patchCookieIsEnalbed !== false) patchCookie();
              if (config.observeScriptsIsEnabled !== false) observe();
              if (config.patchCreateElementIsEnabled !== false) patchCreateElement();
              wwtCookieConsent.mode = config.mode || 'optIn';
              if (!hasSetPrefs() && (wwtCookieConsent.mode === 'optIn' || config.showBannerInOptOut)) {
                if (document.readyState === 'interactive' || document.readyState === 'complete') {
                  banner();
                } else {
                  // If the document is not ready, we'll wait for it to be ready before
                  // loading the banner.
                  document.addEventListener('DOMContentLoaded', function () {
                    banner();
                  });
                }
              }

              // Exposing some methods directly on wwtCookieConsent makes them very simple
              // to target using the window object. Not sure yet if this is the right approach
              // but it feels better than adding listeners to click events or adding more
              // things to the global space.
              wwtCookieConsent.acceptAll = acceptAll;
              wwtCookieConsent.acceptCategory = acceptCategory;
              wwtCookieConsent.rejectAll = rejectAll;
              wwtCookieConsent.rejectCategory = rejectCategory;
              wwtCookieConsent.hasSetPrefs = hasSetPrefs;
              wwtCookieConsent.toggleShowCookiesForCategory = toggleShowCookiesForCategory;
              wwtCookieConsent.getPreferences = getPreferences;
              wwtCookieConsent.openPreferences = openPreferences;
              wwtCookieConsent.closePreferences = closePreferences;
              wwtCookieConsent.savePreferenceChoices = savePreferenceChoices;
              wwtCookieConsent.closeBanner = closeBanner;
              window.wwtCookieConsent = wwtCookieConsent;
              if (!hasSetPrefs() && wwtCookieConsent.mode === 'optOut') {
                // In opt out mode, we accept all cookies for the user by default.
                acceptAll();
              }
              log$1.info('WwtCookieConsent Loaded', wwtCookieConsent);
              emitEvent('wwt-cc-init-complete', window.wwtCookieConsent);
              return _context.abrupt("return", wwtCookieConsent);
            case 30:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));
    return _init.apply(this, arguments);
  }
  function addOurCookiesToConfig(config) {
    if (!config.knownCookies) config.knownCookies = {};
    config.knownCookies.wwtCookiePrefs = {
      regexPattern: '^wwtCookiePrefs',
      scriptRegexPattern: '',
      title: 'wwtCookiePrefs',
      category: 'Essential'
    };
    return config;
  }

})();