@genesislcap/foundation-errors 9.0.1-alpha-b5c5eb7.0

package/dist/foundation-errors.js

@@ -0,0 +1,1240 @@
+var ErrorBoundaryEvent;
+(function (ErrorBoundaryEvent) {
+  ErrorBoundaryEvent["ERROR_BOUNDARY_EVENT"] = "error-boundary-event";
+})(ErrorBoundaryEvent || (ErrorBoundaryEvent = {}));
+
+const LogLevel = {};
+LogLevel[LogLevel.Fatal = 0] = 'Fatal';
+LogLevel[LogLevel.Error = 0] = 'Error';
+LogLevel[LogLevel.Warn = 1] = 'Warn';
+LogLevel[LogLevel.Log = 2] = 'Log';
+LogLevel[LogLevel.Info = 3] = 'Info';
+LogLevel[LogLevel.Success = 3] = 'Success';
+LogLevel[LogLevel.Debug = 4] = 'Debug';
+LogLevel[LogLevel.Trace = 5] = 'Trace';
+LogLevel[LogLevel.Silent = -Infinity] = 'Silent';
+LogLevel[LogLevel.Verbose = Infinity] = 'Verbose';
+
+var Types = {
+  // Silent
+  silent: {
+    level: -1
+  },
+  // Level 0
+  fatal: {
+    level: LogLevel.Fatal
+  },
+  error: {
+    level: LogLevel.Error
+  },
+  // Level 1
+  warn: {
+    level: LogLevel.Warn
+  },
+  // Level 2
+  log: {
+    level: LogLevel.Log
+  },
+  // Level 3
+  info: {
+    level: LogLevel.Info
+  },
+  success: {
+    level: LogLevel.Success
+  },
+  // Level 4
+  debug: {
+    level: LogLevel.Debug
+  },
+  // Level 5
+  trace: {
+    level: LogLevel.Trace
+  },
+  // Verbose
+  verbose: {
+    level: LogLevel.Trace
+  },
+  // Legacy
+  ready: {
+    level: LogLevel.Info
+  },
+  start: {
+    level: LogLevel.Info
+  }
+};
+
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]';
+}
+
+// TODO: remove for consola@3
+function isLogObj(arg) {
+  // Should be plain object
+  if (!isPlainObject(arg)) {
+    return false;
+  }
+
+  // Should contains either 'message' or 'args' field
+  if (!arg.message && !arg.args) {
+    return false;
+  }
+
+  // Handle non-standard error objects
+  if (arg.stack) {
+    return false;
+  }
+  return true;
+}
+
+let paused = false;
+const queue = [];
+class Consola {
+  constructor(options = {}) {
+    this._reporters = options.reporters || [];
+    this._types = options.types || Types;
+    this.level = options.level !== undefined ? options.level : 3;
+    this._defaults = options.defaults || {};
+    this._async = options.async !== undefined ? options.async : undefined;
+    this._stdout = options.stdout;
+    this._stderr = options.stderr;
+    this._mockFn = options.mockFn;
+    this._throttle = options.throttle || 1000;
+    this._throttleMin = options.throttleMin || 5;
+
+    // Create logger functions for current instance
+    for (const type in this._types) {
+      const defaults = {
+        type,
+        ...this._types[type],
+        ...this._defaults
+      };
+      this[type] = this._wrapLogFn(defaults);
+      this[type].raw = this._wrapLogFn(defaults, true);
+    }
+
+    // Use _mockFn if is set
+    if (this._mockFn) {
+      this.mockTypes();
+    }
+
+    // Keep serialized version of last log
+    this._lastLogSerialized = undefined;
+    this._lastLog = undefined;
+    this._lastLogTime = undefined;
+    this._lastLogCount = 0;
+    this._throttleTimeout = undefined;
+  }
+  get stdout() {
+    return this._stdout || console._stdout; // eslint-disable-line no-console
+  }
+
+  get stderr() {
+    return this._stderr || console._stderr; // eslint-disable-line no-console
+  }
+
+  create(options) {
+    return new Consola(Object.assign({
+      reporters: this._reporters,
+      level: this.level,
+      types: this._types,
+      defaults: this._defaults,
+      stdout: this._stdout,
+      stderr: this._stderr,
+      mockFn: this._mockFn
+    }, options));
+  }
+  withDefaults(defaults) {
+    return this.create({
+      defaults: Object.assign({}, this._defaults, defaults)
+    });
+  }
+  withTag(tag) {
+    return this.withDefaults({
+      tag: this._defaults.tag ? this._defaults.tag + ':' + tag : tag
+    });
+  }
+  addReporter(reporter) {
+    this._reporters.push(reporter);
+    return this;
+  }
+  removeReporter(reporter) {
+    if (reporter) {
+      const i = this._reporters.indexOf(reporter);
+      if (i >= 0) {
+        return this._reporters.splice(i, 1);
+      }
+    } else {
+      this._reporters.splice(0);
+    }
+    return this;
+  }
+  setReporters(reporters) {
+    this._reporters = Array.isArray(reporters) ? reporters : [reporters];
+    return this;
+  }
+  wrapAll() {
+    this.wrapConsole();
+    this.wrapStd();
+  }
+  restoreAll() {
+    this.restoreConsole();
+    this.restoreStd();
+  }
+  wrapConsole() {
+    for (const type in this._types) {
+      // Backup original value
+      if (!console['__' + type]) {
+        // eslint-disable-line no-console
+        console['__' + type] = console[type]; // eslint-disable-line no-console
+      }
+      // Override
+      console[type] = this[type].raw; // eslint-disable-line no-console
+    }
+  }
+
+  restoreConsole() {
+    for (const type in this._types) {
+      // Restore if backup is available
+      if (console['__' + type]) {
+        // eslint-disable-line no-console
+        console[type] = console['__' + type]; // eslint-disable-line no-console
+        delete console['__' + type]; // eslint-disable-line no-console
+      }
+    }
+  }
+
+  wrapStd() {
+    this._wrapStream(this.stdout, 'log');
+    this._wrapStream(this.stderr, 'log');
+  }
+  _wrapStream(stream, type) {
+    if (!stream) {
+      return;
+    }
+
+    // Backup original value
+    if (!stream.__write) {
+      stream.__write = stream.write;
+    }
+
+    // Override
+    stream.write = data => {
+      this[type].raw(String(data).trim());
+    };
+  }
+  restoreStd() {
+    this._restoreStream(this.stdout);
+    this._restoreStream(this.stderr);
+  }
+  _restoreStream(stream) {
+    if (!stream) {
+      return;
+    }
+    if (stream.__write) {
+      stream.write = stream.__write;
+      delete stream.__write;
+    }
+  }
+  pauseLogs() {
+    paused = true;
+  }
+  resumeLogs() {
+    paused = false;
+
+    // Process queue
+    const _queue = queue.splice(0);
+    for (const item of _queue) {
+      item[0]._logFn(item[1], item[2]);
+    }
+  }
+  mockTypes(mockFn) {
+    this._mockFn = mockFn || this._mockFn;
+    if (typeof this._mockFn !== 'function') {
+      return;
+    }
+    for (const type in this._types) {
+      this[type] = this._mockFn(type, this._types[type]) || this[type];
+      this[type].raw = this[type];
+    }
+  }
+  _wrapLogFn(defaults, isRaw) {
+    return (...args) => {
+      if (paused) {
+        queue.push([this, defaults, args, isRaw]);
+        return;
+      }
+      return this._logFn(defaults, args, isRaw);
+    };
+  }
+  _logFn(defaults, args, isRaw) {
+    if (defaults.level > this.level) {
+      return this._async ? Promise.resolve(false) : false;
+    }
+
+    // Construct a new log object
+    const logObj = Object.assign({
+      date: new Date(),
+      args: []
+    }, defaults);
+
+    // Consume arguments
+    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
+      Object.assign(logObj, args[0]);
+    } else {
+      logObj.args = Array.from(args);
+    }
+
+    // Aliases
+    if (logObj.message) {
+      logObj.args.unshift(logObj.message);
+      delete logObj.message;
+    }
+    if (logObj.additional) {
+      if (!Array.isArray(logObj.additional)) {
+        logObj.additional = logObj.additional.split('\n');
+      }
+      logObj.args.push('\n' + logObj.additional.join('\n'));
+      delete logObj.additional;
+    }
+
+    // Normalize type and tag to lowercase
+    logObj.type = typeof logObj.type === 'string' ? logObj.type.toLowerCase() : '';
+    logObj.tag = typeof logObj.tag === 'string' ? logObj.tag.toLowerCase() : '';
+
+    // Resolve log
+    /**
+     * @param newLog false if the throttle expired and
+     *  we don't want to log a duplicate
+     */
+    const resolveLog = (newLog = false) => {
+      const repeated = this._lastLogCount - this._throttleMin;
+      if (this._lastLog && repeated > 0) {
+        const args = [...this._lastLog.args];
+        if (repeated > 1) {
+          args.push(`(repeated ${repeated} times)`);
+        }
+        this._log({
+          ...this._lastLog,
+          args
+        });
+        this._lastLogCount = 1;
+      }
+
+      // Log
+      if (newLog) {
+        this._lastLog = logObj;
+        if (this._async) {
+          return this._logAsync(logObj);
+        } else {
+          this._log(logObj);
+        }
+      }
+    };
+
+    // Throttle
+    clearTimeout(this._throttleTimeout);
+    const diffTime = this._lastLogTime ? logObj.date - this._lastLogTime : 0;
+    this._lastLogTime = logObj.date;
+    if (diffTime < this._throttle) {
+      try {
+        const serializedLog = JSON.stringify([logObj.type, logObj.tag, logObj.args]);
+        const isSameLog = this._lastLogSerialized === serializedLog;
+        this._lastLogSerialized = serializedLog;
+        if (isSameLog) {
+          this._lastLogCount++;
+          if (this._lastLogCount > this._throttleMin) {
+            // Auto-resolve when throttle is timed out
+            this._throttleTimeout = setTimeout(resolveLog, this._throttle);
+            return; // SPAM!
+          }
+        }
+      } catch (_) {
+        // Circular References
+      }
+    }
+    resolveLog(true);
+  }
+  _log(logObj) {
+    for (const reporter of this._reporters) {
+      reporter.log(logObj, {
+        async: false,
+        stdout: this.stdout,
+        stderr: this.stderr
+      });
+    }
+  }
+  _logAsync(logObj) {
+    return Promise.all(this._reporters.map(reporter => reporter.log(logObj, {
+      async: true,
+      stdout: this.stdout,
+      stderr: this.stderr
+    })));
+  }
+}
+
+// Legacy support
+Consola.prototype.add = Consola.prototype.addReporter;
+Consola.prototype.remove = Consola.prototype.removeReporter;
+Consola.prototype.clear = Consola.prototype.removeReporter;
+Consola.prototype.withScope = Consola.prototype.withTag;
+Consola.prototype.mock = Consola.prototype.mockTypes;
+Consola.prototype.pause = Consola.prototype.pauseLogs;
+Consola.prototype.resume = Consola.prototype.resumeLogs;
+
+class BrowserReporter {
+  constructor(options) {
+    this.options = Object.assign({}, options);
+    this.defaultColor = '#7f8c8d'; // Gray
+    this.levelColorMap = {
+      0: '#c0392b',
+      // Red
+      1: '#f39c12',
+      // Yellow
+      3: '#00BCD4' // Cyan
+    };
+
+    this.typeColorMap = {
+      success: '#2ecc71' // Green
+    };
+  }
+
+  log(logObj) {
+    const consoleLogFn = logObj.level < 1
+    // eslint-disable-next-line no-console
+    ? console.__error || console.error
+    // eslint-disable-next-line no-console
+    : logObj.level === 1 && console.warn ? console.__warn || console.warn : console.__log || console.log;
+
+    // Type
+    const type = logObj.type !== 'log' ? logObj.type : '';
+
+    // Tag
+    const tag = logObj.tag ? logObj.tag : '';
+
+    // Styles
+    const color = this.typeColorMap[logObj.type] || this.levelColorMap[logObj.level] || this.defaultColor;
+    const style = `
+      background: ${color};
+      border-radius: 0.5em;
+      color: white;
+      font-weight: bold;
+      padding: 2px 0.5em;
+    `;
+    const badge = `%c${[tag, type].filter(Boolean).join(':')}`;
+
+    // Log to the console
+    if (typeof logObj.args[0] === 'string') {
+      consoleLogFn(`${badge}%c ${logObj.args[0]}`, style,
+      // Empty string as style resets to default console style
+      '', ...logObj.args.slice(1));
+    } else {
+      consoleLogFn(badge, style, ...logObj.args);
+    }
+  }
+}
+
+function createConsola() {
+  const consola = new Consola({
+    reporters: [new BrowserReporter()]
+  });
+
+  // Expose constructors
+  consola.Consola = Consola;
+  consola.LogLevel = LogLevel;
+  consola.BrowserReporter = BrowserReporter;
+  return consola;
+}
+var consola = typeof window !== 'undefined' && window.consola || createConsola();
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var consola_browser = {
+  exports: {}
+};
+
+(function (module, exports) {
+  !function (t, e) {
+    module.exports = e() ;
+  }(commonjsGlobal, function () {
+
+    function t(t, e) {
+      if (!(t instanceof e)) throw new TypeError("Cannot call a class as a function");
+    }
+    function e(t, e) {
+      for (var r = 0; r < e.length; r++) {
+        var o = e[r];
+        o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(t, o.key, o);
+      }
+    }
+    function r(t, r, o) {
+      return r && e(t.prototype, r), o && e(t, o), t;
+    }
+    function o(t, e, r) {
+      return e in t ? Object.defineProperty(t, e, {
+        value: r,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      }) : t[e] = r, t;
+    }
+    function n(t, e) {
+      var r = Object.keys(t);
+      if (Object.getOwnPropertySymbols) {
+        var o = Object.getOwnPropertySymbols(t);
+        e && (o = o.filter(function (e) {
+          return Object.getOwnPropertyDescriptor(t, e).enumerable;
+        })), r.push.apply(r, o);
+      }
+      return r;
+    }
+    function s(t) {
+      for (var e = 1; e < arguments.length; e++) {
+        var r = null != arguments[e] ? arguments[e] : {};
+        e % 2 ? n(Object(r), !0).forEach(function (e) {
+          o(t, e, r[e]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) : n(Object(r)).forEach(function (e) {
+          Object.defineProperty(t, e, Object.getOwnPropertyDescriptor(r, e));
+        });
+      }
+      return t;
+    }
+    function i(t) {
+      return function (t) {
+        if (Array.isArray(t)) return l(t);
+      }(t) || function (t) {
+        if ("undefined" != typeof Symbol && Symbol.iterator in Object(t)) return Array.from(t);
+      }(t) || a(t) || function () {
+        throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+      }();
+    }
+    function a(t, e) {
+      if (t) {
+        if ("string" == typeof t) return l(t, e);
+        var r = Object.prototype.toString.call(t).slice(8, -1);
+        return "Object" === r && t.constructor && (r = t.constructor.name), "Map" === r || "Set" === r ? Array.from(t) : "Arguments" === r || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? l(t, e) : void 0;
+      }
+    }
+    function l(t, e) {
+      (null == e || e > t.length) && (e = t.length);
+      for (var r = 0, o = new Array(e); r < e; r++) o[r] = t[r];
+      return o;
+    }
+    function u(t) {
+      if ("undefined" == typeof Symbol || null == t[Symbol.iterator]) {
+        if (Array.isArray(t) || (t = a(t))) {
+          var e = 0,
+            r = function () {};
+          return {
+            s: r,
+            n: function () {
+              return e >= t.length ? {
+                done: !0
+              } : {
+                done: !1,
+                value: t[e++]
+              };
+            },
+            e: function (t) {
+              throw t;
+            },
+            f: r
+          };
+        }
+        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 o,
+        n,
+        s = !0,
+        i = !1;
+      return {
+        s: function () {
+          o = t[Symbol.iterator]();
+        },
+        n: function () {
+          var t = o.next();
+          return s = t.done, t;
+        },
+        e: function (t) {
+          i = !0, n = t;
+        },
+        f: function () {
+          try {
+            s || null == o.return || o.return();
+          } finally {
+            if (i) throw n;
+          }
+        }
+      };
+    }
+    var c = {};
+    c[c.Fatal = 0] = "Fatal", c[c.Error = 0] = "Error", c[c.Warn = 1] = "Warn", c[c.Log = 2] = "Log", c[c.Info = 3] = "Info", c[c.Success = 3] = "Success", c[c.Debug = 4] = "Debug", c[c.Trace = 5] = "Trace", c[c.Silent = -1 / 0] = "Silent", c[c.Verbose = 1 / 0] = "Verbose";
+    var f = {
+      silent: {
+        level: -1
+      },
+      fatal: {
+        level: c.Fatal
+      },
+      error: {
+        level: c.Error
+      },
+      warn: {
+        level: c.Warn
+      },
+      log: {
+        level: c.Log
+      },
+      info: {
+        level: c.Info
+      },
+      success: {
+        level: c.Success
+      },
+      debug: {
+        level: c.Debug
+      },
+      trace: {
+        level: c.Trace
+      },
+      verbose: {
+        level: c.Trace
+      },
+      ready: {
+        level: c.Info
+      },
+      start: {
+        level: c.Info
+      }
+    };
+    function h(t) {
+      return e = t, "[object Object]" === Object.prototype.toString.call(e) && !(!t.message && !t.args) && !t.stack;
+      var e;
+    }
+    var p = !1,
+      y = [],
+      d = function () {
+        function e() {
+          var r = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : {};
+          for (var o in t(this, e), this._reporters = r.reporters || [], this._types = r.types || f, this.level = void 0 !== r.level ? r.level : 3, this._defaults = r.defaults || {}, this._async = void 0 !== r.async ? r.async : void 0, this._stdout = r.stdout, this._stderr = r.stderr, this._mockFn = r.mockFn, this._throttle = r.throttle || 1e3, this._throttleMin = r.throttleMin || 5, this._types) {
+            var n = s(s({
+              type: o
+            }, this._types[o]), this._defaults);
+            this[o] = this._wrapLogFn(n), this[o].raw = this._wrapLogFn(n, !0);
+          }
+          this._mockFn && this.mockTypes(), this._lastLogSerialized = void 0, this._lastLog = void 0, this._lastLogTime = void 0, this._lastLogCount = 0, this._throttleTimeout = void 0;
+        }
+        return r(e, [{
+          key: "create",
+          value: function (t) {
+            return new e(Object.assign({
+              reporters: this._reporters,
+              level: this.level,
+              types: this._types,
+              defaults: this._defaults,
+              stdout: this._stdout,
+              stderr: this._stderr,
+              mockFn: this._mockFn
+            }, t));
+          }
+        }, {
+          key: "withDefaults",
+          value: function (t) {
+            return this.create({
+              defaults: Object.assign({}, this._defaults, t)
+            });
+          }
+        }, {
+          key: "withTag",
+          value: function (t) {
+            return this.withDefaults({
+              tag: this._defaults.tag ? this._defaults.tag + ":" + t : t
+            });
+          }
+        }, {
+          key: "addReporter",
+          value: function (t) {
+            return this._reporters.push(t), this;
+          }
+        }, {
+          key: "removeReporter",
+          value: function (t) {
+            if (t) {
+              var e = this._reporters.indexOf(t);
+              if (e >= 0) return this._reporters.splice(e, 1);
+            } else this._reporters.splice(0);
+            return this;
+          }
+        }, {
+          key: "setReporters",
+          value: function (t) {
+            return this._reporters = Array.isArray(t) ? t : [t], this;
+          }
+        }, {
+          key: "wrapAll",
+          value: function () {
+            this.wrapConsole(), this.wrapStd();
+          }
+        }, {
+          key: "restoreAll",
+          value: function () {
+            this.restoreConsole(), this.restoreStd();
+          }
+        }, {
+          key: "wrapConsole",
+          value: function () {
+            for (var t in this._types) console["__" + t] || (console["__" + t] = console[t]), console[t] = this[t].raw;
+          }
+        }, {
+          key: "restoreConsole",
+          value: function () {
+            for (var t in this._types) console["__" + t] && (console[t] = console["__" + t], delete console["__" + t]);
+          }
+        }, {
+          key: "wrapStd",
+          value: function () {
+            this._wrapStream(this.stdout, "log"), this._wrapStream(this.stderr, "log");
+          }
+        }, {
+          key: "_wrapStream",
+          value: function (t, e) {
+            var r = this;
+            t && (t.__write || (t.__write = t.write), t.write = function (t) {
+              r[e].raw(String(t).trim());
+            });
+          }
+        }, {
+          key: "restoreStd",
+          value: function () {
+            this._restoreStream(this.stdout), this._restoreStream(this.stderr);
+          }
+        }, {
+          key: "_restoreStream",
+          value: function (t) {
+            t && t.__write && (t.write = t.__write, delete t.__write);
+          }
+        }, {
+          key: "pauseLogs",
+          value: function () {
+            p = !0;
+          }
+        }, {
+          key: "resumeLogs",
+          value: function () {
+            p = !1;
+            var t,
+              e = u(y.splice(0));
+            try {
+              for (e.s(); !(t = e.n()).done;) {
+                var r = t.value;
+                r[0]._logFn(r[1], r[2]);
+              }
+            } catch (t) {
+              e.e(t);
+            } finally {
+              e.f();
+            }
+          }
+        }, {
+          key: "mockTypes",
+          value: function (t) {
+            if (this._mockFn = t || this._mockFn, "function" == typeof this._mockFn) for (var e in this._types) this[e] = this._mockFn(e, this._types[e]) || this[e], this[e].raw = this[e];
+          }
+        }, {
+          key: "_wrapLogFn",
+          value: function (t, e) {
+            var r = this;
+            return function () {
+              for (var o = arguments.length, n = new Array(o), s = 0; s < o; s++) n[s] = arguments[s];
+              if (!p) return r._logFn(t, n, e);
+              y.push([r, t, n, e]);
+            };
+          }
+        }, {
+          key: "_logFn",
+          value: function (t, e, r) {
+            var o = this;
+            if (t.level > this.level) return !!this._async && Promise.resolve(!1);
+            var n = Object.assign({
+              date: new Date(),
+              args: []
+            }, t);
+            !r && 1 === e.length && h(e[0]) ? Object.assign(n, e[0]) : n.args = Array.from(e), n.message && (n.args.unshift(n.message), delete n.message), n.additional && (Array.isArray(n.additional) || (n.additional = n.additional.split("\n")), n.args.push("\n" + n.additional.join("\n")), delete n.additional), n.type = "string" == typeof n.type ? n.type.toLowerCase() : "", n.tag = "string" == typeof n.tag ? n.tag.toLowerCase() : "";
+            var a = function () {
+              var t = arguments.length > 0 && void 0 !== arguments[0] && arguments[0],
+                e = o._lastLogCount - o._throttleMin;
+              if (o._lastLog && e > 0) {
+                var r = i(o._lastLog.args);
+                e > 1 && r.push("(repeated ".concat(e, " times)")), o._log(s(s({}, o._lastLog), {}, {
+                  args: r
+                })), o._lastLogCount = 1;
+              }
+              if (t) {
+                if (o._lastLog = n, o._async) return o._logAsync(n);
+                o._log(n);
+              }
+            };
+            clearTimeout(this._throttleTimeout);
+            var l = this._lastLogTime ? n.date - this._lastLogTime : 0;
+            if (this._lastLogTime = n.date, l < this._throttle) try {
+              var u = JSON.stringify([n.type, n.tag, n.args]),
+                c = this._lastLogSerialized === u;
+              if (this._lastLogSerialized = u, c && (this._lastLogCount++, this._lastLogCount > this._throttleMin)) return void (this._throttleTimeout = setTimeout(a, this._throttle));
+            } catch (t) {}
+            a(!0);
+          }
+        }, {
+          key: "_log",
+          value: function (t) {
+            var e,
+              r = u(this._reporters);
+            try {
+              for (r.s(); !(e = r.n()).done;) {
+                e.value.log(t, {
+                  async: !1,
+                  stdout: this.stdout,
+                  stderr: this.stderr
+                });
+              }
+            } catch (t) {
+              r.e(t);
+            } finally {
+              r.f();
+            }
+          }
+        }, {
+          key: "_logAsync",
+          value: function (t) {
+            var e = this;
+            return Promise.all(this._reporters.map(function (r) {
+              return r.log(t, {
+                async: !0,
+                stdout: e.stdout,
+                stderr: e.stderr
+              });
+            }));
+          }
+        }, {
+          key: "stdout",
+          get: function () {
+            return this._stdout || console._stdout;
+          }
+        }, {
+          key: "stderr",
+          get: function () {
+            return this._stderr || console._stderr;
+          }
+        }]), e;
+      }();
+    d.prototype.add = d.prototype.addReporter, d.prototype.remove = d.prototype.removeReporter, d.prototype.clear = d.prototype.removeReporter, d.prototype.withScope = d.prototype.withTag, d.prototype.mock = d.prototype.mockTypes, d.prototype.pause = d.prototype.pauseLogs, d.prototype.resume = d.prototype.resumeLogs;
+    var v,
+      g = function () {
+        function e(r) {
+          t(this, e), this.options = Object.assign({}, r), this.defaultColor = "#7f8c8d", this.levelColorMap = {
+            0: "#c0392b",
+            1: "#f39c12",
+            3: "#00BCD4"
+          }, this.typeColorMap = {
+            success: "#2ecc71"
+          };
+        }
+        return r(e, [{
+          key: "log",
+          value: function (t) {
+            var e = t.level < 1 ? console.__error || console.error : 1 === t.level && console.warn ? console.__warn || console.warn : console.__log || console.log,
+              r = "log" !== t.type ? t.type : "",
+              o = t.tag ? t.tag : "",
+              n = this.typeColorMap[t.type] || this.levelColorMap[t.level] || this.defaultColor,
+              s = "\n      background: ".concat(n, ";\n      border-radius: 0.5em;\n      color: white;\n      font-weight: bold;\n      padding: 2px 0.5em;\n    "),
+              a = "%c".concat([o, r].filter(Boolean).join(":"));
+            "string" == typeof t.args[0] ? e.apply(void 0, ["".concat(a, "%c ").concat(t.args[0]), s, ""].concat(i(t.args.slice(1)))) : e.apply(void 0, [a, s].concat(i(t.args)));
+          }
+        }]), e;
+      }();
+    return "undefined" != typeof window && window.consola || ((v = new d({
+      reporters: [new g()]
+    })).Consola = d, v.LogLevel = c, v.BrowserReporter = g, v);
+  });
+})(consola_browser);
+
+const logLevelDebug = 4;
+const defaultLoggerOptions = {
+  level: logLevelDebug
+};
+function createLogger(name, options = defaultLoggerOptions) {
+  const baseLogger = consola.create(options);
+  const logger = baseLogger.withTag(name);
+  return logger;
+}
+
+class ErrorBuilder {
+  withTitle(title) {
+    this.title = title;
+    return this;
+  }
+  withErrorDetails(errorDetails) {
+    this.errorDetails = errorDetails;
+    return this;
+  }
+  withLogLevel(logLevel) {
+    this.logLevel = logLevel;
+    return this;
+  }
+  withAlert(alert) {
+    this.alert = alert;
+    return this;
+  }
+  withNotification(notification) {
+    this.notification = notification;
+    return this;
+  }
+  withBanner(banner) {
+    this.banner = banner;
+    return this;
+  }
+  withSnackbar(snackbar) {
+    this.snackbar = snackbar;
+    return this;
+  }
+  withDialog(dialog) {
+    this.dialog = dialog;
+    return this;
+  }
+  build() {
+    if (!this.title) {
+      throw new Error('Title is required');
+    }
+    if (!this.errorDetails) {
+      throw new Error(`Missing required param 'errorDetails'`);
+    }
+    let errorStructure = {
+      title: this.title,
+      errorDetails: this.errorDetails
+    };
+    let config = {};
+    if (this.logLevel in consola_browser.exports.LogLevel) {
+      errorStructure = Object.assign({
+        logLevel: this.logLevel
+      }, errorStructure);
+    }
+    if (this.alert) {
+      config = Object.assign({
+        alert: this.alert
+      }, config);
+      errorStructure = Object.assign({
+        config
+      }, errorStructure);
+    }
+    if (this.notification) {
+      config = Object.assign({
+        notification: this.notification
+      }, config);
+      errorStructure = Object.assign({
+        config
+      }, errorStructure);
+    }
+    if (this.banner) {
+      config = Object.assign({
+        banner: this.banner
+      }, config);
+      errorStructure = Object.assign({
+        config
+      }, errorStructure);
+    }
+    if (this.snackbar) {
+      config = Object.assign({
+        snackbar: this.snackbar
+      }, config);
+      errorStructure = Object.assign({
+        config
+      }, errorStructure);
+    }
+    if (this.dialog) {
+      config = Object.assign({
+        dialog: this.dialog
+      }, config);
+      errorStructure = Object.assign({
+        config
+      }, errorStructure);
+    }
+    return errorStructure;
+  }
+}
+const getErrorBuilder = () => new ErrorBuilder();
+
+class NotificationBuilder {
+  withAutoClose(autoClose) {
+    this.autoClose = autoClose;
+    return this;
+  }
+  withCloseTimeout(closeTimeout) {
+    this.closeTimeout = closeTimeout;
+    return this;
+  }
+  withType(type) {
+    this.type = type;
+    return this;
+  }
+  build() {
+    let notification = {};
+    if (this.autoClose) {
+      notification = Object.assign({
+        autoClose: this.autoClose
+      }, notification);
+    }
+    if (this.closeTimeout) {
+      notification = Object.assign({
+        closeTimeout: this.closeTimeout
+      }, notification);
+    }
+    if (this.type) {
+      notification = Object.assign({
+        type: this.type
+      }, notification);
+    }
+    return notification;
+  }
+}
+const getNotificationBuilder = () => new NotificationBuilder();
+
+/**
+ * Retrieves the error details from an ErrorStructure object
+ * @public
+ * @param details - The ErrorStructure object
+ * @returns The title and error details concatenated as a string, or default values ('Error: Something went wrong') if not present
+ */
+const getErrorDetails = details => {
+  var _a, _b;
+  const title = (_a = details === null || details === void 0 ? void 0 : details.title) !== null && _a !== void 0 ? _a : 'Error';
+  const errorDetails = (_b = details === null || details === void 0 ? void 0 : details.errorDetails) !== null && _b !== void 0 ? _b : 'Something went wrong';
+  return `${title}: ${errorDetails}`;
+};
+/**
+ * Retrieves the log level from an ErrorStructure object
+ * @public
+ * @param details - The ErrorStructure object
+ * @returns The log level or the default value (LogLevel.Error) if not present
+ */
+const getLoglevel = details => {
+  var _a;
+  return (details === null || details === void 0 ? void 0 : details.logLevel) || ((_a = details === null || details === void 0 ? void 0 : details.config) === null || _a === void 0 ? void 0 : _a.logLevel) || consola_browser.exports.LogLevel.Error;
+};
+/**
+ * Get/Create the error container in the DOM
+ * @public
+ * @param id - The id of the container
+ * @param tagName - The tag name to create prefix for the design system provider
+ * @returns
+ */
+const getErrorContainer = (id, tagName) => {
+  const tagPrefix = tagName.split('-')[0];
+  let container = document.querySelector(`#${id}`);
+  if (!container) {
+    container = document.createElement('div');
+    container.setAttribute('id', id);
+    const dsProvider = document.createElement(`${tagPrefix}-design-system-provider`);
+    dsProvider.appendChild(container);
+    document.body.appendChild(dsProvider);
+  }
+  return container;
+};
+
+/**
+ * Shows the error notification
+ * @public
+ * @param error - The ErrorStructure object
+ * @param tagName - The tag name to create prefix for the design system provider & error component
+ * @returns
+ * */
+const showNotification = (error, tagName) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+  const tagPrefix = tagName.split('-')[0];
+  const container = getErrorContainer('notify-container', tagName);
+  if (container) {
+    container.style.position = 'fixed';
+    container.style.top = '0';
+    container.style.right = '0';
+  }
+  const toastNotify = document.createElement(`${tagPrefix}-toast`);
+  const errorTitle = document.createElement('div');
+  errorTitle.setAttribute('slot', 'top');
+  errorTitle.textContent = (_a = error.title) !== null && _a !== void 0 ? _a : 'Error';
+  const errorDetails = document.createElement('div');
+  errorDetails.setAttribute('slot', 'content');
+  errorDetails.textContent = (error === null || error === void 0 ? void 0 : error.errorDetails) || '';
+  const errorDate = document.createElement('div');
+  errorDate.setAttribute('slot', 'date');
+  errorDate.textContent = new Date().toLocaleTimeString();
+  toastNotify.setAttribute('notify', ((_c = (_b = error === null || error === void 0 ? void 0 : error.config) === null || _b === void 0 ? void 0 : _b.notification) === null || _c === void 0 ? void 0 : _c.type) || '');
+  ((_e = (_d = error === null || error === void 0 ? void 0 : error.config) === null || _d === void 0 ? void 0 : _d.notification) === null || _e === void 0 ? void 0 : _e.autoClose) ? toastNotify.setAttribute('auto-close', `${(_g = (_f = error === null || error === void 0 ? void 0 : error.config) === null || _f === void 0 ? void 0 : _f.notification) === null || _g === void 0 ? void 0 : _g.autoClose}`) : '';
+  ((_j = (_h = error === null || error === void 0 ? void 0 : error.config) === null || _h === void 0 ? void 0 : _h.notification) === null || _j === void 0 ? void 0 : _j.closeTimeout) ? toastNotify.setAttribute('close-timeout', `${(_l = (_k = error === null || error === void 0 ? void 0 : error.config) === null || _k === void 0 ? void 0 : _k.notification) === null || _l === void 0 ? void 0 : _l.closeTimeout}`) : '';
+  toastNotify.appendChild(errorTitle);
+  toastNotify.appendChild(errorDetails);
+  toastNotify.appendChild(errorDate);
+  container.appendChild(toastNotify);
+};
+
+class ErrorBannerBuilder {
+  withDismissingAction(dismissingAction) {
+    this.dismissingAction = dismissingAction;
+    return this;
+  }
+  withConfirmingAction(confirmingAction) {
+    if (!this.confirmingActions) {
+      this.confirmingActions = [];
+    }
+    this.confirmingActions.push(confirmingAction);
+    return this;
+  }
+  build() {
+    let errorBanner = {};
+    if (this.dismissingAction) {
+      errorBanner = Object.assign({
+        dismissingAction: this.dismissingAction
+      }, errorBanner);
+    }
+    if (this.confirmingActions) {
+      errorBanner = Object.assign({
+        confirmingActions: this.confirmingActions
+      }, errorBanner);
+    }
+    return errorBanner;
+  }
+}
+const getErrorBannerBuilder = () => new ErrorBannerBuilder();
+
+class ErrorDialogBuilder {
+  withDismissingAction(dismissingAction) {
+    this.dismissingAction = dismissingAction;
+    return this;
+  }
+  withConfirmingAction(confirmingAction) {
+    if (!this.confirmingActions) {
+      this.confirmingActions = [];
+    }
+    this.confirmingActions.push(confirmingAction);
+    return this;
+  }
+  build() {
+    let errorDialog = {};
+    if (this.dismissingAction) {
+      errorDialog = Object.assign({
+        dismissingAction: this.dismissingAction
+      }, errorDialog);
+    }
+    if (this.confirmingActions) {
+      errorDialog = Object.assign({
+        confirmingActions: this.confirmingActions
+      }, errorDialog);
+    }
+    return errorDialog;
+  }
+}
+const getErrorDialogBuilder = () => new ErrorDialogBuilder();
+
+/**
+ * Shows the error dialog
+ * @public
+ * @param error - The ErrorStructure object
+ * @param tagName - The tag name to create prefix for the design system provider & error component
+ * @returns
+ * */
+const showDialog = (error, tagName) => {
+  const tagPrefix = tagName.split('-')[0];
+  const dialog = document.createElement(`${tagPrefix}-error-dialog`);
+  const container = getErrorContainer('dialog-container', tagName);
+  container.appendChild(dialog);
+  dialog.error = error;
+  dialog.show();
+};
+
+class SnackbarBuilder {
+  /**
+   * Add type to snackbar
+   * @public
+   * @param type
+   * @returns
+   */
+  withType(type) {
+    this.type = type;
+    return this;
+  }
+  /**
+   * Add confirming action to snackbar
+   * @public
+   * @param confirmingAction
+   * @returns
+   * */
+  withConfirmingAction(confirmingAction) {
+    if (!this.confirmingActions) {
+      this.confirmingActions = [];
+    }
+    this.confirmingActions.push(confirmingAction);
+    return this;
+  }
+  /**
+   * Build snackbar
+   * @public
+   * @returns Snackbar
+   * */
+  build() {
+    let snackbar = {};
+    if (this.confirmingActions) {
+      snackbar = Object.assign({
+        confirmingActions: this.confirmingActions
+      }, snackbar);
+    }
+    if (this.type !== undefined) {
+      snackbar = Object.assign({
+        type: this.type
+      }, snackbar);
+    }
+    return snackbar;
+  }
+}
+const getSnackbarBuilder = () => new SnackbarBuilder();
+
+/**
+ * Shows the snackbar
+ * @public
+ * @param error - The ErrorStructure object
+ * @param tagName - The tag name to create prefix for the design system provider & error component
+ * @returns
+ * */
+const showSnackbar = (error, tagName) => {
+  const tagPrefix = tagName.split('-')[0];
+  const snackbar = document.createElement(`${tagPrefix}-snackbar`);
+  const container = getErrorContainer('snack-container', tagName);
+  container.appendChild(snackbar);
+  snackbar.error = error;
+};
+
+const logger = createLogger('foundation-error');
+const errorTypeToComponentMap = {
+  alert: error => {
+    alert(getErrorDetails(error));
+  },
+  notification: showNotification,
+  dialog: showDialog,
+  snackbar: showSnackbar
+};
+/**
+ * Shows the error in the appropriate component
+ * @public
+ * @param error - The ErrorStructure object
+ * @param tagName - The tag name to create prefix for the design system provider *
+ * @returns
+ * */
+const showError = (error, tagName) => {
+  logger.log({
+    message: getErrorDetails(error),
+    level: getLoglevel(error)
+  });
+  const keys = Object.keys((error === null || error === void 0 ? void 0 : error.config) || {});
+  keys.forEach(key => {
+    if (errorTypeToComponentMap[key]) {
+      errorTypeToComponentMap[key](error, tagName);
+    }
+  });
+};
+
+export { ErrorBannerBuilder, ErrorBoundaryEvent, ErrorBuilder, ErrorDialogBuilder, NotificationBuilder, SnackbarBuilder, getErrorBannerBuilder, getErrorBuilder, getErrorContainer, getErrorDetails, getErrorDialogBuilder, getLoglevel, getNotificationBuilder, getSnackbarBuilder, showDialog, showError, showNotification, showSnackbar };