@jibb-open/jssdk 3.5.8 → 3.5.10

package/examples/browser/462.jibb.js

@@ -0,0 +1,306 @@
+"use strict";
+
+require("core-js/modules/es.global-this.js");
+require("core-js/modules/es.symbol.description.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.json.stringify.js");
+require("core-js/modules/es.object.assign.js");
+(globalThis.webpackChunkJIBB = globalThis.webpackChunkJIBB || []).push([[462], {
+  360: e => {
+    function r(e) {
+      return r = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (e) {
+        return typeof e;
+      } : function (e) {
+        return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+      }, r(e);
+    }
+    function t(e) {
+      try {
+        return JSON.stringify(e);
+      } catch (e) {
+        return '"[Circular]"';
+      }
+    }
+    e.exports = function (e, i, n) {
+      var s = n && n.stringify || t;
+      if ("object" === r(e) && null !== e) {
+        var l = i.length + 1;
+        if (1 === l) return e;
+        var o = new Array(l);
+        o[0] = s(e);
+        for (var a = 1; a < l; a++) o[a] = s(i[a]);
+        return o.join(" ");
+      }
+      if ("string" != typeof e) return e;
+      var f = i.length;
+      if (0 === f) return e;
+      for (var u = "", c = 0, v = -1, b = e && e.length || 0, h = 0; h < b;) {
+        if (37 === e.charCodeAt(h) && h + 1 < b) {
+          switch (v = v > -1 ? v : 0, e.charCodeAt(h + 1)) {
+            case 100:
+            case 102:
+              if (c >= f) break;
+              if (null == i[c]) break;
+              v < h && (u += e.slice(v, h)), u += Number(i[c]), v = h + 2, h++;
+              break;
+            case 105:
+              if (c >= f) break;
+              if (null == i[c]) break;
+              v < h && (u += e.slice(v, h)), u += Math.floor(Number(i[c])), v = h + 2, h++;
+              break;
+            case 79:
+            case 111:
+            case 106:
+              if (c >= f) break;
+              if (void 0 === i[c]) break;
+              v < h && (u += e.slice(v, h));
+              var g = r(i[c]);
+              if ("string" === g) {
+                u += "'" + i[c] + "'", v = h + 2, h++;
+                break;
+              }
+              if ("function" === g) {
+                u += i[c].name || "<anonymous>", v = h + 2, h++;
+                break;
+              }
+              u += s(i[c]), v = h + 2, h++;
+              break;
+            case 115:
+              if (c >= f) break;
+              v < h && (u += e.slice(v, h)), u += String(i[c]), v = h + 2, h++;
+              break;
+            case 37:
+              v < h && (u += e.slice(v, h)), u += "%", v = h + 2, h++, c--;
+          }
+          ++c;
+        }
+        ++h;
+      }
+      return -1 === v ? e : (v < b && (u += e.slice(v)), u);
+    };
+  },
+  462: (e, r, t) => {
+    t.r(r), t.d(r, {
+      logger: () => n
+    });
+    var i = t(288),
+      n = new (t.n(i)())({
+        browser: {
+          asObject: !1
+        },
+        timestamp: !1,
+        level: "warn"
+      });
+    n.setLevel = function (e) {
+      n.level = e;
+    };
+  },
+  288: (e, r, t) => {
+    function i(e) {
+      return i = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (e) {
+        return typeof e;
+      } : function (e) {
+        return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+      }, i(e);
+    }
+    var n = t(360);
+    e.exports = o;
+    var s = function () {
+        function e(e) {
+          return void 0 !== e && e;
+        }
+        try {
+          return "undefined" != typeof globalThis || Object.defineProperty(Object.prototype, "globalThis", {
+            get: function get() {
+              return delete Object.prototype.globalThis, this.globalThis = this;
+            },
+            configurable: !0
+          }), globalThis;
+        } catch (r) {
+          return e(self) || e(window) || e(this) || {};
+        }
+      }().console || {},
+      l = {
+        mapHttpRequest: g,
+        mapHttpResponse: g,
+        wrapRequestSerializer: m,
+        wrapResponseSerializer: m,
+        wrapErrorSerializer: m,
+        req: g,
+        res: g,
+        err: function err(e) {
+          var r = {
+            type: e.constructor.name,
+            msg: e.message,
+            stack: e.stack
+          };
+          for (var t in e) void 0 === r[t] && (r[t] = e[t]);
+          return r;
+        }
+      };
+    function o(e) {
+      (e = e || {}).browser = e.browser || {};
+      var r = e.browser.transmit;
+      if (r && "function" != typeof r.send) throw Error("pino: transmit option must have a send function");
+      var t = e.browser.write || s;
+      e.browser.write && (e.browser.asObject = !0);
+      var i = e.serializers || {},
+        n = function (e, r) {
+          return Array.isArray(e) ? e.filter(function (e) {
+            return "!stdSerializers.err" !== e;
+          }) : !0 === e && Object.keys(r);
+        }(e.browser.serialize, i),
+        l = e.browser.serialize;
+      Array.isArray(e.browser.serialize) && e.browser.serialize.indexOf("!stdSerializers.err") > -1 && (l = !1), "function" == typeof t && (t.error = t.fatal = t.warn = t.info = t.debug = t.trace = t), !1 === e.enabled && (e.level = "silent");
+      var f = e.level || "info",
+        v = Object.create(t);
+      v.log || (v.log = p), Object.defineProperty(v, "levelVal", {
+        get: function get() {
+          return "silent" === this.level ? 1 / 0 : this.levels.values[this.level];
+        }
+      }), Object.defineProperty(v, "level", {
+        get: function get() {
+          return this._level;
+        },
+        set: function set(e) {
+          if ("silent" !== e && !this.levels.values[e]) throw Error("unknown level " + e);
+          this._level = e, a(g, v, "error", "log"), a(g, v, "fatal", "error"), a(g, v, "warn", "error"), a(g, v, "info", "log"), a(g, v, "debug", "log"), a(g, v, "trace", "log");
+        }
+      });
+      var g = {
+        transmit: r,
+        serialize: n,
+        asObject: e.browser.asObject,
+        levels: ["error", "fatal", "warn", "info", "debug", "trace"],
+        timestamp: h(e)
+      };
+      return v.levels = o.levels, v.level = f, v.setMaxListeners = v.getMaxListeners = v.emit = v.addListener = v.on = v.prependListener = v.once = v.prependOnceListener = v.removeListener = v.removeAllListeners = v.listeners = v.listenerCount = v.eventNames = v.write = v.flush = p, v.serializers = i, v._serialize = n, v._stdErrSerialize = l, v.child = function (t, s) {
+        if (!t) throw new Error("missing bindings for child Pino");
+        s = s || {}, n && t.serializers && (s.serializers = t.serializers);
+        var l = s.serializers;
+        if (n && l) {
+          var o = Object.assign({}, i, l),
+            a = !0 === e.browser.serialize ? Object.keys(o) : n;
+          delete t.serializers, u([t], a, o, this._stdErrSerialize);
+        }
+        function f(e) {
+          this._childLevel = 1 + (0 | e._childLevel), this.error = c(e, t, "error"), this.fatal = c(e, t, "fatal"), this.warn = c(e, t, "warn"), this.info = c(e, t, "info"), this.debug = c(e, t, "debug"), this.trace = c(e, t, "trace"), o && (this.serializers = o, this._serialize = a), r && (this._logEvent = b([].concat(e._logEvent.bindings, t)));
+        }
+        return f.prototype = this, new f(this);
+      }, r && (v._logEvent = b()), v;
+    }
+    function a(e, r, t, i) {
+      var n = Object.getPrototypeOf(r);
+      r[t] = r.levelVal > r.levels.values[t] ? p : n[t] ? n[t] : s[t] || s[i] || p, function (e, r, t) {
+        var i;
+        (e.transmit || r[t] !== p) && (r[t] = (i = r[t], function () {
+          for (var n = e.timestamp(), l = new Array(arguments.length), a = Object.getPrototypeOf && Object.getPrototypeOf(this) === s ? s : this, c = 0; c < l.length; c++) l[c] = arguments[c];
+          if (e.serialize && !e.asObject && u(l, this._serialize, this.serializers, this._stdErrSerialize), e.asObject ? i.call(a, f(this, t, l, n)) : i.apply(a, l), e.transmit) {
+            var b = e.transmit.level || r.level,
+              h = o.levels.values[b],
+              g = o.levels.values[t];
+            if (g < h) return;
+            v(this, {
+              ts: n,
+              methodLevel: t,
+              methodValue: g,
+              transmitLevel: b,
+              transmitValue: o.levels.values[e.transmit.level || r.level],
+              send: e.transmit.send,
+              val: r.levelVal
+            }, l);
+          }
+        }));
+      }(e, r, t);
+    }
+    function f(e, r, t, s) {
+      e._serialize && u(t, e._serialize, e.serializers, e._stdErrSerialize);
+      var l = t.slice(),
+        a = l[0],
+        f = {};
+      s && (f.time = s), f.level = o.levels.values[r];
+      var c = 1 + (0 | e._childLevel);
+      if (c < 1 && (c = 1), null !== a && "object" === i(a)) {
+        for (; c-- && "object" === i(l[0]);) Object.assign(f, l.shift());
+        a = l.length ? n(l.shift(), l) : void 0;
+      } else "string" == typeof a && (a = n(l.shift(), l));
+      return void 0 !== a && (f.msg = a), f;
+    }
+    function u(e, r, t, n) {
+      for (var s in e) if (n && e[s] instanceof Error) e[s] = o.stdSerializers.err(e[s]);else if ("object" === i(e[s]) && !Array.isArray(e[s])) for (var l in e[s]) r && r.indexOf(l) > -1 && l in t && (e[s][l] = t[l](e[s][l]));
+    }
+    function c(e, r, t) {
+      return function () {
+        var i = new Array(1 + arguments.length);
+        i[0] = r;
+        for (var n = 1; n < i.length; n++) i[n] = arguments[n - 1];
+        return e[t].apply(this, i);
+      };
+    }
+    function v(e, r, t) {
+      var i = r.send,
+        n = r.ts,
+        s = r.methodLevel,
+        l = r.methodValue,
+        o = r.val,
+        a = e._logEvent.bindings;
+      u(t, e._serialize || Object.keys(e.serializers), e.serializers, void 0 === e._stdErrSerialize || e._stdErrSerialize), e._logEvent.ts = n, e._logEvent.messages = t.filter(function (e) {
+        return -1 === a.indexOf(e);
+      }), e._logEvent.level.label = s, e._logEvent.level.value = l, i(s, e._logEvent, o), e._logEvent = b(a);
+    }
+    function b(e) {
+      return {
+        ts: 0,
+        messages: [],
+        bindings: e || [],
+        level: {
+          label: "",
+          value: 0
+        }
+      };
+    }
+    function h(e) {
+      return "function" == typeof e.timestamp ? e.timestamp : !1 === e.timestamp ? d : y;
+    }
+    function g() {
+      return {};
+    }
+    function m(e) {
+      return e;
+    }
+    function p() {}
+    function d() {
+      return !1;
+    }
+    function y() {
+      return Date.now();
+    }
+    o.levels = {
+      values: {
+        fatal: 60,
+        error: 50,
+        warn: 40,
+        info: 30,
+        debug: 20,
+        trace: 10
+      },
+      labels: {
+        10: "trace",
+        20: "debug",
+        30: "info",
+        40: "warn",
+        50: "error",
+        60: "fatal"
+      }
+    }, o.stdSerializers = l, o.stdTimeFunctions = Object.assign({}, {
+      nullTime: d,
+      epochTime: y,
+      unixTime: function unixTime() {
+        return Math.round(Date.now() / 1e3);
+      },
+      isoTime: function isoTime() {
+        return new Date(Date.now()).toISOString();
+      }
+    });
+  }
+}]);