PageSourceSearch

https://amherstcopy.com/Scripts/backoffice.js

js amherstcopy.com collected 2026-10-05 18:43:40 UTC 125,341 bytes, 2,750 lines download raw bytes

1window.Aurigma = (function (t) {
2    var n = {};
3    function e(r) {
4        if (n[r]) return n[r].exports;
5        var i = (n[r] = { i: r, l: !1, exports: {} });
6        return t[r].call(i.exports, i, i.exports, e), (i.l = !0), i.exports;
7    }
8    return (
9        (e.m = t),
10        (e.c = n),
11        (e.d = function (t, n, r) {
12            e.o(t, n) || Object.defineProperty(t, n, { enumerable: !0, get: r });
13        }),
14        (e.r = function (t) {
15            "undefined" != typeof Symbol && Symbol.toStringTag && Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(t, "__esModule", { value: !0 });
16        }),
17        (e.t = function (t, n) {
18            if ((1 & n && (t = e(t)), 8 & n)) return t;
19            if (4 & n && "object" == typeof t && t && t.__esModule) return t;
20            var r = Object.create(null);
21            if ((e.r(r), Object.defineProperty(r, "default", { enumerable: !0, value: t }), 2 & n && "string" != typeof t))
22                for (var i in t)
23                    e.d(
24                        r,
25                        i,
26                        function (n) {
27                            return t[n];
28                        }.bind(null, i)
29                    );
30            return r;
31        }),
32        (e.n = function (t) {
33            var n =
34                t && t.__esModule
35                    ? function () {
36                        return t.default;
37                    }
38                    : function () {
39                        return t;
40                    };
41            return e.d(n, "a", n), n;
42        }),
43        (e.o = function (t, n) {
44            return Object.prototype.hasOwnProperty.call(t, n);
45        }),
46        (e.p = ""),
47        e((e.s = 41))
48    );
49})([
50    function (t, n, e) {
51        "use strict";
52        var r = e(5),
53            i = Object.prototype.toString;
54        function o(t) {
55            return "[object Array]" === i.call(t);
56        }
57        function s(t) {
58            return void 0 === t;
59        }
60        function u(t) {
61            return null !== t && "object" == typeof t;
62        }
63        function a(t) {
64            if ("[object Object]" !== i.call(t)) return !1;
65            var n = Object.getPrototypeOf(t);
66            return null === n || n === Object.prototype;
67        }
68        function c(t) {
69            return "[object Function]" === i.call(t);
70        }
71        function f(t, n) {
72            if (null != t)
73                if (("object" != typeof t && (t = [t]), o(t))) for (var e = 0, r = t.length; e < r; e++) n.call(null, t[e], e, t);
74                else for (var i in t) Object.prototype.hasOwnProperty.call(t, i) && n.call(null, t[i], i, t);
75        }
76        t.exports = {
77            isArray: o,
78            isArrayBuffer: function (t) {
79                return "[object ArrayBuffer]" === i.call(t);
80            },
81            isBuffer: function (t) {
82                return null !== t && !s(t) && null !== t.constructor && !s(t.constructor) && "function" == typeof t.constructor.isBuffer && t.constructor.isBuffer(t);
83            },
84            isFormData: function (t) {
85                return "undefined" != typeof FormData && t instanceof FormData;
86            },
87            isArrayBufferView: function (t) {
88                return "undefined" != typeof ArrayBuffer && ArrayBuffer.isView ? ArrayBuffer.isView(t) : t && t.buffer && t.buffer instanceof ArrayBuffer;
89            },
90            isString: function (t) {
91                return "string" == typeof t;
92            },
93            isNumber: function (t) {
94                return "number" == typeof t;
95            },
96            isObject: u,
97            isPlainObject: a,
98            isUndefined: s,
99            isDate: function (t) {
100                return "[object Date]" === i.call(t);
101            },
102            isFile: function (t) {
103                return "[object File]" === i.call(t);
104            },
105            isBlob: function (t) {
106                return "[object Blob]" === i.call(t);
107            },
108            isFunction: c,
109            isStream: function (t) {
110                return u(t) && c(t.pipe);
111            },
112            isURLSearchParams: function (t) {
113                return "undefined" != typeof URLSearchParams && t instanceof URLSearchParams;
114            },
115            isStandardBrowserEnv: function () {
116                return ("undefined" == typeof navigator || ("ReactNative" !== navigator.product && "NativeScript" !== navigator.product && "NS" !== navigator.product)) && "undefined" != typeof window && "undefined" != typeof document;
117            },
118            forEach: f,
119            merge: function t() {
120                var n = {};
121                function e(e, r) {
122                    a(n[r]) && a(e) ? (n[r] = t(n[r], e)) : a(e) ? (n[r] = t({}, e)) : o(e) ? (n[r] = e.slice()) : (n[r] = e);
123                }
124                for (var r = 0, i = arguments.length; r < i; r++) f(arguments[r], e);
125                return n;
126            },
127            extend: function (t, n, e) {
128                return (
129                    f(n, function (n, i) {
130                        t[i] = e && "function" == typeof n ? r(n, e) : n;
131                    }),
132                    t
133                );
134            },
135            trim: function (t) {
136                return t.replace(/^\s*/, "").replace(/\s*$/, "");
137            },
138            stripBOM: function (t) {
139                return 65279 === t.charCodeAt(0) && (t = t.slice(1)), t;
140            },
141        };
142    },
143    function (t, n, e) {
144        var r, i;
145        /**
146         * Monet.js 0.9.0-rc.1
147         *
148         * (c) 2012-2018 Chris Myers
149         * @license Monet.js may be freely distributed under the MIT license.
150         * For all details and documentation:
151         * https://monet.github.io/monet.js/
152         */ "undefined" != typeof self && self,
153            void 0 ===
154            (i =
155                "function" ==
156                    typeof (r = function () {
157                        "use strict";
158                        var t = {
159                            apply2: O,
160                            assign: b(Object.assign)
161                                ? Object.assign
162                                : function (t, n) {
163                                    for (var e in n) n.hasOwnProperty(e) && void 0 !== n[e] && (t[e] = n[e]);
164                                    return t;
165                                },
166                            compose: g,
167                            curry: v(L(v), [])([]),
168                            idFunction: w,
169                            isFunction: b,
170                            noop: m,
171                            swap: L,
172                        },
173                            n = "Identity",
174                            e = "Maybe",
175                            r = "Either",
176                            i = "Validation",
177                            o = "List",
178                            s = "NEL",
179                            u = "IO",
180                            a = "MonadT",
181                            c = "Reader",
182                            f = "Free";
183                        function p(t, n) {
184                            t["@@type"] = "monet.js/" + n;
185                        }
186                        function h(t) {
187                            return function (n) {
188                                return (n["@@type"] || n.constructor["@@type"]) === "monet.js/" + t;
189                            };
190                        }
191                        function l(t) {
192                            return function (n) {
193                                var e = n["@@type"] || (n.constructor && n.constructor["@@type"]);
194                                return Boolean(e) && e.length >= t.length && e.indexOf(t) === e.length - t.length;
195                            };
196                        }
197                        function d(t) {
198                            return null == t;
199                        }
200                        function m() { }
201                        function y(t) {
202                            return Array.prototype.slice.call(t);
203                        }
204                        function v(t, n) {
205                            return function () {
206                                var e = n.concat(y(arguments));
207                                return e.length >= t.length ? t.apply(null, e.slice(0, e.length)) : v(t, e);
208                            };
209                        }
210                        function g(t, n) {
211                            return function (e) {
212                                return t(n(e));
213                            };
214                        }
215                        function b(t) {
216                            return Boolean(t && t.constructor && t.call && t.apply);
217                        }
218                        function w(t) {
219                            return t;
220                        }
221                        function S(t, n) {
222                            return t === n || (t != t && n != n) || (!(!t || !n) && !(!b(t.equals) || !b(n.equals)) && t.equals(n));
223                        }
224                        function x(t) {
225                            return function (n) {
226                                return S(t, n);
227                            };
228                        }
229                        function E() {
230                            return !1;
231                        }
232                        function L(t) {
233                            return function (n, e) {
234                                return t(e, n);
235                            };
236                        }
237                        function O(t, n, e) {
238                            return n.ap(t.map(v(e, [])));
239                        }
240                        function _(t, n) {
241                            for (var e = t, r = n; !e.isNil && !r.isNil;) {
242                                if (!x(e.head())(r.head())) return !1;
243                                (e = e.tail()), (r = r.tail());
244                            }
245                            return e.isNil && r.isNil;
246                        }
247                        function j(t, n) {
248                            return (function t(n, e) {
249                                return e.isNil
250                                    ? rt(e)
251                                    : et(function () {
252                                        return t(n, e.tail());
253                                    }).map(v(A, [])(n(e.head())));
254                            })(t, n).run();
255                        }
256                        function N(t, n) {
257                            return t.foldRight(P)(function (t, e) {
258                                return n(t) ? A(t, e) : e;
259                            });
260                        }
261                        function T(t, n) {
262                            return (function t(n, e) {
263                                if (n.isNil) return rt(z());
264                                var r = n.head();
265                                return e(r)
266                                    ? rt($(r))
267                                    : et(function () {
268                                        return t(n.tail(), e);
269                                    });
270                            })(t, n).run();
271                        }
272                        function R(t, n) {
273                            return (function t(n, e) {
274                                return n.isNil
275                                    ? rt(!1)
276                                    : S(n.head(), e)
277                                        ? rt(!0)
278                                        : et(function () {
279                                            return t(n.tail(), e);
280                                        });
281                            })(t, n).run();
282                        }
283                        function A(t, n) {
284                            return n.cons(t);
285                        }
286                        function C() {
287                            switch (arguments.length) {
288                                case 0:
289                                    return new C.fn.init();
290                                case 1:
291                                    return new C.fn.init(arguments[0]);
292                                default:
293                                    return new C.fn.init(arguments[0], arguments[1]);
294                            }
295                        }
296                        t.List = C;
297                        var P,
298                            k = function (t, n) {
299                                n.isNil || (t(n.head()), k(t, n.tail()));
300                            },
301                            U = function (t, n, e) {
302                                return (function n(e, r) {
303                                    return r.isNil
304                                        ? rt(e)
305                                        : et(function () {
306                                            return n(t(e, r.head()), r.tail());
307                                        });
308                                })(n, e).run();
309                            },
310                            I = function (t, n, e) {
311                                return (function n(e, r) {
312                                    return e.isNil
313                                        ? rt(r)
314                                        : et(function () {
315                                            return n(e.tail(), r);
316                                        }).map(function (n) {
317                                            return t(e.head(), n);
318                                        });
319                                })(n, e).run();
320                            },
321                            D = function (t, n) {
322                                return (function t(n, e) {
323                                    return n.isNil
324                                        ? rt(e)
325                                        : et(function () {
326                                            return t(n.tail(), e).map(function (t) {
327                                                return t.cons(n.head());
328                                            });
329                                        });
330                                })(t, n).run();
331                            },
332                            M = function (t, n) {
333                                return t.foldRight(n.of(P))(n.map2(A));
334                            },
335                            B = function (t) {
336                                return t.foldLeft(P)(L(A));
337                            };
338                        function F(t) {
339                            return new Error("Cannot create an empty Non-Empty List. Passed head is " + t + ".");
340                        }
341                        function q(t, n) {
342                            if (d(t)) throw F(t);
343                            return new q.fn.init(t, n);
344                        }
345                        (C.fn = C.prototype = {
346                            init: function () {
347                                var t = arguments[0],
348                                    n = arguments[1];
349                                0 === arguments.length ? ((this.isNil = !0), (this.size_ = 0)) : ((this.isNil = !1), (this.head_ = t), (this.tail_ = n || P), (this.size_ = this.tail_.size() + 1)), p(this, o);
350                            },
351                            of: function (t) {
352                                return new C(t);
353                            },
354                            size: function () {
355                                return this.size_;
356                            },
357                            equals: function (t) {
358                                return (C.isOfType(t) || q.isOfType(t)) && _(this, t);
359                            },
360                            cons: function (t) {
361                                return C(t, this);
362                            },
363                            snoc: function (t) {
364                                return this.concat(C(t));
365                            },
366                            map: function (t) {
367                                return j(t, this);
368                            },
369                            toArray: function () {
370                                return U(
371                                    function (t, n) {
372                                        return t.push(n), t;
373                                    },
374                                    [],
375                                    this
376                                );
377                            },
378                            toSet: function () {
379                                return new Set(this);
380                            },
381                            foldLeft: function (t) {
382                                var n = this;
383                                return function (e) {
384                                    return U(e, t, n);
385                                };
386                            },
387                            foldRight: function (t) {
388                                var n = this;
389                                return function (e) {
390                                    return I(e, n, t);
391                                };
392                            },
393                            append: function (t) {
394                                return D(this, t);
395                            },
396                            filter: function (t) {
397                                return N(this, t);
398                            },
399                            find: function (t) {
400                                return T(this, t);
401                            },
402                            flatten: function () {
403                                return I(D, this, P);
404                            },
405                            flattenMaybe: function () {
406                                return this.flatMap(V.toList);
407                            },
408                            reverse: function () {
409                                return B(this);
410                            },
411                            bind: function (t) {
412                                return this.map(t).flatten();
413                            },
414                            forEach: function (t) {
415                                k(t, this);
416                            },
417                            contains: function (t) {
418                                return R(this, t);
419                            },
420                            sequenceMaybe: function () {
421                                return M(this, V);
422                            },
423                            sequenceValidation: function () {
424                                return this.foldLeft(J(P))(function (t, n) {
425                                    return t.ap(
426                                        n.map(function (t) {
427                                            return function (n) {
428                                                return A(t, n);
429                                            };
430                                        })
431                                    );
432                                }).map(B);
433                            },
434                            sequenceEither: function () {
435                                return M(this, Q);
436                            },
437                            sequenceIO: function () {
438                                return M(this, K);
439                            },
440                            sequenceReader: function () {
441                                return M(this, tt);
442                            },
443                            sequence: function (t) {
444                                return M(this, t);
445                            },
446                            head: function () {
447                                return this.head_;
448                            },
449                            headMaybe: function () {
450                                return this.isNil ? z() : $(this.head_);
451                            },
452                            tail: function () {
453                                return this.isNil ? P : this.tail_;
454                            },
455                            tails: function () {
456                                return this.isNil ? C(P, P) : this.tail().tails().cons(this);
457                            },
458                            ap: function (t) {
459                                return (
460                                    (n = t),
461                                    this.bind(function (t) {
462                                        return n.map(function (n) {
463                                            return n(t);
464                                        });
465                                    })
466                                );
467                                var n;
468                            },
469                            isNEL: E,
470                            toString: function () {
471                                return this.isNil ? "Nil" : "List(" + this.toArray().join(", ") + ")";
472                            },
473                            inspect: function () {
474                                return this.toString();
475                            },
476                        }),
477                            (C.fn.init.prototype = C.fn),
478                            p(C, o),
479                            p(C.fn.init, o),
480                            (C.isInstance = h(o)),
481                            (C.isOfType = l(o)),
482                            (C.prototype.empty = function () {
483                                return P;
484                            }),
485                            (C.fromArray = function (t) {
486                                return t.reduceRight(function (t, n) {
487                                    return t.cons(n);
488                                }, P);
489                            }),
490                            (C.from = function (t) {
491                                return C.fromArray(Array.from(t));
492                            }),
493                            (C.of = function (t) {
494                                return new C(t, P);
495                            }),
496                            (C.prototype.each = C.prototype.forEach),
497                            (P = t.Nil = new C.fn.init()),
498                            (t.NEL = t.NonEmptyList = q),
499                            (q.of = function (t) {
500                                return q(t, P);
501                            }),
502                            (q.fn = q.prototype = {
503                                init: function (t, n) {
504                                    if (d(t)) throw F(t);
505                                    (this.isNil = !1), (this.head_ = t), (this.tail_ = d(n) ? P : n), (this.size_ = this.tail_.size() + 1), p(this, s);
506                                },
507                                equals: function (t) {
508                                    return C.isOfType(t) || (q.isOfType(t) && _(this, t));
509                                },
510                                cons: function (t) {
511                                    return q(t, this.toList());
512                                },
513                                snoc: function (t) {
514                                    return this.concat(q(t));
515                                },
516                                map: function (t) {
517                                    return q(t(this.head_), j(t, this.tail_));
518                                },
519                                bind: function (t) {
520                                    var n = t(this.head_);
521                                    if (!n.isNEL()) throw new Error("NEL.fn.bind: Passed function must return a NonEmptyList.");
522                                    var e = this.tail().foldLeft(P.snoc(n.head()).append(n.tail()))(function (n, e) {
523                                        var r = t(e).toList();
524                                        return n.snoc(r.head()).append(r.tail());
525                                    });
526                                    return new q(e.head(), e.tail());
527                                },
528                                head: function () {
529                                    return this.head_;
530                                },
531                                tail: function () {
532                                    return this.tail_;
533                                },
534                                tails: function () {
535                                    var t = this.toList().tails().map(q.fromList).flattenMaybe();
536                                    return q(t.head(), t.tail());
537                                },
538                                toList: function () {
539                                    return C(this.head_, this.tail_);
540                                },
541                                reverse: function () {
542                                    if (this.tail().isNil) return this;
543                                    var t = this.tail().reverse();
544                                    return q(t.head(), t.tail().append(C(this.head())));
545                                },
546                                foldLeft: function (t) {
547                                    return this.toList().foldLeft(t);
548                                },
549                                foldRight: function (t) {
550                                    return this.toList().foldRight(t);
551                                },
552                                reduceLeft: function (t) {
553                                    return this.tail().foldLeft(this.head())(t);
554                                },
555                                filter: function (t) {
556                                    return N(this.toList(), t);
557                                },
558                                find: function (t) {
559                                    return T(this.toList(), t);
560                                },
561                                flatten: function () {
562                                    return I(
563                                        D,
564                                        this.toList().map(function (t) {
565                                            return t.isNEL() ? t.toList() : t;
566                                        }),
567                                        P
568                                    );
569                                },
570                                flattenMaybe: function () {
571                                    return this.toList().flatMap(V.toList);
572                                },
573                                contains: function (t) {
574                                    return R(this.toList(), t);
575                                },
576                                append: function (t) {
577                                    return q.fromList(this.toList().append(t.toList())).some();
578                                },
579                                cobind: function (t) {
580                                    return this.cojoin().map(t);
581                                },
582                                size: function () {
583                                    return this.size_;
584                                },
585                                forEach: function (t) {
586                                    return this.toList().forEach(t);
587                                },
588                                isNEL: function () {
589                                    return !0;
590                                },
591                                toString: function () {
592                                    return "NEL(" + this.toArray().join(", ") + ")";
593                                },
594                                inspect: function () {
595                                    return this.toString();
596                                },
597                            }),
598                            (q.fromList = function (t) {
599                                return t.isNil ? z() : $(q(t.head(), t.tail()));
600                            }),
601                            (q.fromArray = function (t) {
602                                return q.fromList(C.fromArray(t));
603                            }),
604                            (q.from = function (t) {
605                                return q.fromList(C.from(t));
606                            }),
607                            (q.fn.init.prototype = q.fn),
608                            p(q, s),
609                            p(q.fn.init, s),
610                            (q.isInstance = h(s)),
611                            (q.isOfType = l(s)),
612                            (q.prototype.toArray = C.prototype.toArray),
613                            (q.prototype.toSet = C.prototype.toSet),
614                            (q.prototype.extract = q.prototype.copure = q.prototype.head),
615                            (q.prototype.cojoin = q.prototype.tails),
616                            (q.prototype.coflatMap = q.prototype.mapTails = q.prototype.cobind),
617                            (q.prototype.ap = C.prototype.ap);
618                        var V = (t.Maybe = {});
619                        (V.fromFalsy = function (t) {
620                            return t ? V.Some(t) : V.None();
621                        }),
622                            (V.fromNull = function (t) {
623                                return d(t) ? V.None() : V.Some(t);
624                            }),
625                            (V.fromUndefined = function (t) {
626                                return void 0 === t ? V.None() : V.Some(t);
627                            }),
628                            (V.fromEmpty = function (t) {
629                                return d((n = t)) || "" === n || (Array.isArray(n) && 0 === n.length) || ("object" == typeof n && 0 === Object.keys(n).length) ? V.None() : V.Some(t);
630                                var n;
631                            }),
632                            (V.of = function (t) {
633                                return $(t);
634                            });
635                        var $ = (V.Just = V.Some = V.some = t.Some = t.Just = function (t) {
636                            return new V.fn.init(!0, t);
637                        }),
638                            z = (V.Nothing = V.None = V.none = t.None = t.Nothing = function () {
639                                return new V.fn.init(!1, null);
640                            });
641                        (V.toList = function (t) {
642                            return t.toList();
643                        }),
644                            (V.fn = V.prototype = {
645                                init: function (t, n) {
646                                    if (((this.isValue = t), t && d(n))) throw new Error("Can not create Some with illegal value: " + n + ".");
647                                    (this.val = n), p(this, e);
648                                },
649                                isSome: function () {
650                                    return this.isValue;
651                                },
652                                isNone: function () {
653                                    return !this.isSome();
654                                },
655                                bind: function (t) {
656                                    return this.isValue ? t(this.val) : this;
657                                },
658                                some: function () {
659                                    if (this.isValue) return this.val;
660                                    throw new Error("Cannot call .some() on a None.");
661                                },
662                                orSome: function (t) {
663                                    return this.isValue ? this.val : t;
664                                },
665                                orLazy: function (t) {
666                                    return this.cata(t, w);
667                                },
668                                orNull: function () {
669                                    return this.orSome(null);
670                                },
671                                orUndefined: function () {
672                                    return this.orSome(void 0);
673                                },
674                                orElse: function (t) {
675                                    return this.catchMap(function () {
676                                        return t;
677                                    });
678                                },
679                                ap: function (t) {
680                                    var n = this.val;
681                                    return this.isValue
682                                        ? t.map(function (t) {
683                                            return t(n);
684                                        })
685                                        : this;
686                                },
687                                equals: function (t) {
688                                    return (
689                                        V.isOfType(t) &&
690                                        this.cata(
691                                            function () {
692                                                return t.isNone();
693                                            },
694                                            function (n) {
695                                                return t.fold(!1)(x(n));
696                                            }
697                                        )
698                                    );
699                                },
700                                toArray: function () {
701                                    return this.map(function (t) {
702                                        return [t];
703                                    }).orLazy(function () {
704                                        return [];
705                                    });
706                                },
707                                toSet: function () {
708                                    return new Set(this);
709                                },
710                                toList: function () {
711                                    return this.map(C).orLazy(function () {
712                                        return P;
713                                    });
714                                },
715                                toEither: function (t) {
716                                    return this.isSome() ? Y(this.val) : Z(t);
717                                },
718                                toValidation: function (t) {
719                                    return this.isSome() ? J(this.val) : W(t);
720                                },
721                                fold: function (t) {
722                                    var n = this;
723                                    return function (e) {
724                                        return n.isSome() ? e(n.val) : t;
725                                    };
726                                },
727                                foldLeft: function (t) {
728                                    return this.toList().foldLeft(t);
729                                },
730                                foldRight: function (t) {
731                                    return this.toList().foldRight(t);
732                                },
733                                cata: function (t, n) {
734                                    return this.isSome() ? n(this.val) : t();
735                                },
736                                catchMap: function (t) {
737                                    return this.isSome() ? this 
737: t();
738                                },
739                                filter: function (t) {
740                                    var n = this;
741                                    return n.flatMap(function (e) {
742                                        return t(e) ? n : z();
743                                    });
744                                },
745                                orNoneIf: function (t) {
746                                    return t ? z() : this;
747                                },
748                                contains: function (t) {
749                                    return !!this.isSome() && S(this.val, t);
750                                },
751                                forEach: function (t) {
752                                    this.cata(m, t);
753                                },
754                                orElseRun: function (t) {
755                                    this.cata(t, m);
756                                },
757                                toString: function () {
758                                    return this.isSome() ? "Just(" + this.val + ")" : "Nothing";
759                                },
760                                inspect: function () {
761                                    return this.toString();
762                                },
763                            }),
764                            (V.prototype.orJust = V.prototype.getOrElse = V.prototype.orSome),
765                            (V.prototype.just = V.prototype.some),
766                            (V.prototype.isJust = V.prototype.isSome),
767                            (V.prototype.isNothing = V.prototype.isNone),
768                            (V.prototype.orNothingIf = V.prototype.orNoneIf),
769                            (V.fn.init.prototype = V.fn),
770                            p(V, e),
771                            p(V.fn.init, e),
772                            (V.isInstance = h(e)),
773                            (V.isOfType = l(e));
774                        var H = (t.Validation = {}),
775                            J = (H.Success = H.success = t.Success = function (t) {
776                                return new H.fn.init(t, !0);
777                            }),
778                            W = (H.Fail = H.fail = t.Fail = function (t) {
779                                return new H.fn.init(t, !1);
780                            });
781                        (H.of = function (t) {
782                            return J(t);
783                        }),
784                            (H.fn = H.prototype = {
785                                init: function (t, n) {
786                                    (this.val = t), (this.isSuccessValue = n), p(this, i);
787                                },
788                                success: function () {
789                                    if (this.isSuccess()) return this.val;
790                                    throw new Error("Cannot call success() on a Fail.");
791                                },
792                                isSuccess: function () {
793                                    return this.isSuccessValue;
794                                },
795                                isFail: function () {
796                                    return !this.isSuccessValue;
797                                },
798                                fail: function () {
799                                    if (this.isSuccess()) throw new Error("Cannot call fail() on a Success.");
800                                    return this.val;
801                                },
802                                bind: function (t) {
803                                    return this.isSuccess() ? t(this.val) : this;
804                                },
805                                ap: function (t) {
806                                    var n = this.val;
807                                    return this.isSuccess()
808                                        ? t.map(function (t) {
809                                            return t(n);
810                                        })
811                                        : t.isFail()
812                                            ? H.Fail(G.append(n, t.fail()))
813                                            : this;
814                                },
815                                acc: function () {
816                                    var t = function () {
817                                        return t;
818                                    };
819                                    return this.isSuccessValue ? H.success(t) : this;
820                                },
821                                foldLeft: function (t) {
822                                    return this.toMaybe().toList().foldLeft(t);
823                                },
824                                foldRight: function (t) {
825                                    return this.toMaybe().toList().foldRight(t);
826                                },
827                                cata: function (t, n) {
828                                    return this.isSuccessValue ? n(this.val) : t(this.val);
829                                },
830                                catchMap: function (t) {
831                                    return this.isSuccess() ? this 
831: t(this.val);
832                                },
833                                swap: function () {
834                                    return this.isSuccess() ? W(this.val) : J(this.val);
835                                },
836                                failMap: function (t) {
837                                    return this.isFail() ? W(t(this.val)) : this;
838                                },
839                                bimap: function (t, n) {
840                                    return this.isSuccessValue ? this.map(n) : this.failMap(t);
841                                },
842                                forEach: function (t) {
843                                    this.cata(m, t);
844                                },
845                                forEachFail: function (t) {
846                                    this.cata(t, m);
847                                },
848                                equals: function (t) {
849                                    return (
850                                        H.isOfType(t) &&
851                                        this.cata(
852                                            function (n) {
853                                                return t.cata(x(n), E);
854                                            },
855                                            function (n) {
856                                                return t.cata(E, x(n));
857                                            }
858                                        )
859                                    );
860                                },
861                                toMaybe: function () {
862                                    return this.isSuccess() ? $(this.val) : z();
863                                },
864                                toEither: function () {
865                                    return (this.isSuccess() ? Y : Z)(this.val);
866                                },
867                                toString: function () {
868                                    return (this.isSuccess() ? "Success(" : "Fail(") + this.val + ")";
869                                },
870                                inspect: function () {
871                                    return this.toString();
872                                },
873                            }),
874                            (H.prototype.fold = H.prototype.cata),
875                            (H.fn.init.prototype = H.fn),
876                            p(H, i),
877                            p(H.fn.init, i),
878                            (H.isInstance = h(i)),
879                            (H.isOfType = l(i));
880                        var G = (t.Semigroup = {
881                            append: function (t, n) {
882                                if (b(t.concat)) return t.concat(n);
883                                throw new Error("Couldn't find a semigroup appender in the environment, please specify your own append function");
884                            },
885                        }),
886                            X = (t.monadTransformer = t.MonadT = t.monadT = function (t) {
887                                return new X.fn.init(t);
888                            });
889                        (X.of = function (t) {
890                            return X(t);
891                        }),
892                            (X.fn = X.prototype = {
893                                init: function (t) {
894                                    (this.monad = t), p(H, a);
895                                },
896                                map: function (t) {
897                                    return X(
898                                        this.monad.map(function (n) {
899                                            return n.map(t);
900                                        })
901                                    );
902                                },
903                                bind: function (t) {
904                                    return X(
905                                        this.monad.map(function (n) {
906                                            return n.flatMap(t);
907                                        })
908                                    );
909                                },
910                                ap: function (t) {
911                                    return X(
912                                        this.monad.flatMap(function (n) {
913                                            return t.perform().map(function (t) {
914                                                return n.ap(t);
915                                            });
916                                        })
917                                    );
918                                },
919                                perform: function () {
920                                    return this.monad;
921                                },
922                            }),
923                            (X.fn.init.prototype = X.fn);
924                        var K = (t.IO = t.io = function (t) {
925                            return new K.fn.init(t);
926                        });
927                        (K.of = function (t) {
928                            return K(function () {
929                                return t;
930                            });
931                        }),
932                            (K.fn = K.prototype = {
933                                init: function (t) {
934                                    if (!b(t)) throw new Error("IO requires a function.");
935                                    (this.effectFn = t), p(this, u);
936                                },
937                                map: function (t) {
938                                    var n = this;
939                                    return K(function () {
940                                        return t(n.effectFn());
941                                    });
942                                },
943                                bind: function (t) {
944                                    var n = this;
945                                    return K(function () {
946                                        return t(n.effectFn()).run();
947                                    });
948                                },
949                                ap: function (t) {
950                                    var n = this;
951                                    return t.map(function (t) {
952                                        return t(n.effectFn());
953                                    });
954                                },
955                                run: function () {
956                                    return this.effectFn();
957                                },
958                            }),
959                            (K.fn.init.prototype = K.fn),
960                            p(K, u),
961                            p(K.fn.init, u),
962                            (K.isInstance = h(u)),
963                            (K.isOfType = l(u)),
964                            (K.prototype.perform = K.prototype.performUnsafeIO = K.prototype.run);
965                        var Q = (t.Either = {});
966                        (Q.of = function (t) {
967                            return Y(t);
968                        }),
969                            (Q.fromTry = function (t) {
970                                try {
971                                    return Q.right(t());
972                                } catch (t) {
973                                    return Q.left(t);
974                                }
975                            }),
976                            (Q.fromPromise = function (t) {
977                                return t.then(Q.Right, Q.Left);
978                            });
979                        var Y = (Q.Right = Q.right = t.Right = function (t) {
980                            return new Q.fn.init(t, !0);
981                        }),
982                            Z = (Q.Left = Q.left = t.Left = function (t) {
983                                return new Q.fn.init(t, !1);
984                            });
985                        (Q.fn = Q.prototype = {
986                            init: function (t, n) {
987                                (this.isRightValue = n), (this.value = t), p(this, r);
988                            },
989                            bind: function (t) {
990                                return this.isRightValue ? t(this.value) : this;
991                            },
992                            ap: function (t) {
993                                var n = this;
994                                return this.isRightValue
995                                    ? t.map(function (t) {
996                                        return t(n.value);
997                                    })
998                                    : this;
999                            },
1000                            leftMap: function (t) {
1001                                return this.isLeft() ? Z(t(this.value)) : this;
1002                            },
1003                            isRight: function () {
1004                                return this.isRightValue;
1005                            },
1006                            isLeft: function () {
1007                                return !this.isRight();
1008                            },
1009                            right: function () {
1010                                if (this.isRightValue) return this.value;
1011                                throw new Error("Cannot call right() on a Left.");
1012                            },
1013                            left: function () {
1014                                if (this.isRightValue) throw new Error("Cannot call left() on a Right.");
1015                                return this.value;
1016                            },
1017                            foldLeft: function (t) {
1018                                return this.toMaybe().toList().foldLeft(t);
1019                            },
1020                            foldRight: function (t) {
1021                                return this.toMaybe().toList().foldRight(t);
1022                            },
1023                            cata: function (t, n) {
1024                                return this.isRightValue ? n(this.value) : t(this.value);
1025                            },
1026                            catchMap: function (t) {
1027                                return this.isRight() ? this : t(this.value);
1028                            },
1029                            swap: function () {
1030                                return this.isRight() ? Z(this.value) : Y(this.value);
1031                            },
1032                            forEach: function (t) {
1033                                this.cata(m, t);
1034                            },
1035                            forEachLeft: function (t) {
1036                                this.cata(t, m);
1037                            },
1038                            equals: function (t) {
1039                                return (
1040                                    Q.isOfType(t) &&
1041                                    this.cata(
1042                                        function (n) {
1043                                            return t.cata(x(n), E);
1044                                        },
1045                                        function (n) {
1046                                            return t.cata(E, x(n));
1047                                        }
1048                                    )
1049                                );
1050                            },
1051                            bimap: function (t, n) {
1052                                return this.isRightValue ? this.map(n) : this.leftMap(t);
1053                            },
1054                            toMaybe: function () {
1055                                return this.isRight() ? $(this.value) : z();
1056                            },
1057                            toValidation: function () {
1058                                return this.isRight() ? J(this.value) : W(this.value);
1059                            },
1060                            toString: function () {
1061                                return this.cata(
1062                                    function (t) {
1063                                        return "Left(" + t + ")";
1064                                    },
1065                                    function (t) {
1066                                        return "Right(" + t + ")";
1067                                    }
1068                                );
1069                            },
1070                            toPromise: function () {
1071                                return this.cata(
1072                                    function (t) {
1073                                        return Promise.reject(t);
1074                                    },
1075                                    function (t) {
1076                                        return Promise.resolve(t);
1077                                    }
1078                                );
1079                            },
1080                            inspect: function () {
1081                                return this.toString();
1082                            },
1083                        }),
1084                            (Q.prototype.fold = Q.prototype.cata),
1085                            (Q.fn.init.prototype = Q.fn),
1086                            p(Q, r),
1087                            p(Q.fn.init, r),
1088                            (Q.isInstance = h(r)),
1089                            (Q.isOfType = l(r));
1090                        var tt = (t.Reader = function (t) {
1091                            return new tt.fn.init(t);
1092                        });
1093                        (tt.of = function (t) {
1094                            return tt(function (n) {
1095                                return t;
1096                            });
1097                        }),
1098                            (tt.ask = function () {
1099                                return tt(w);
1100                            }),
1101                            (tt.fn = tt.prototype = {
1102                                init: function (t) {
1103                                    (this.f = t), p(this, c);
1104                                },
1105                                run: function (t) {
1106                                    return this.f(t);
1107                                },
1108                                bind: function (t) {
1109                                    var n = this;
1110                                    return tt(function (e) {
1111                                        return t(n.run(e)).run(e);
1112                                    });
1113                                },
1114                                ap: function (t) {
1115                                    var n = this;
1116                                    return t.bind(function (t) {
1117                                        return tt(function (e) {
1118                                            return t(n.run(e));
1119                                        });
1120                                    });
1121                                },
1122                                map: function (t) {
1123                                    var n = this;
1124                                    return tt(function (e) {
1125                                        return t(n.run(e));
1126                                    });
1127                                },
1128                                local: function (t) {
1129                                    var n = this;
1130                                    return tt(function (e) {
1131                                        return n.run(t(e));
1132                                    });
1133                                },
1134                            }),
1135                            (tt.fn.init.prototype = tt.fn),
1136                            p(tt, c),
1137                            p(tt.fn.init, c),
1138                            (tt.isInstance = h(c)),
1139                            (tt.isOfType = l(c));
1140                        var nt = (t.Free = {}),
1141                            et = (nt.Suspend = t.Suspend = function (t) {
1142                                return new nt.fn.init(t, !0);
1143                            }),
1144                            rt = (nt.Return = t.Return = function (t) {
1145                                return new nt.fn.init(t, !1);
1146                            });
1147                        function it(t) {
1148                            return new it.fn.init(t);
1149                        }
1150                        function ot(t) {
1151                            !(function (t) {
1152                                (t.prototype.flatMap = t.prototype.chain = t.prototype.bind),
1153                                    (t.pure = t.unit = t.of),
1154                                    (t.prototype.of = t.of),
1155                                    b(t.prototype.append) && (t.prototype.concat = t.prototype.append),
1156                                    (t.prototype.point = t.prototype.pure = t.prototype.unit = t.prototype.of);
1157                            })(t),
1158                                (function (t) {
1159                                    b(t.prototype.filter) &&
1160                                        (t.prototype.filterNot = function (t) {
1161                                            return this.filter(function (n) {
1162                                                return !t(n);
1163                                            });
1164                                        });
1165                                })(t),
1166                                (function (t) {
1167                                    (t.prototype.join = function () {
1168                                        return this.flatMap(w);
1169                                    }),
1170                                        (t.map2 = function (t) {
1171                                            return function (n, e) {
1172                                                return n.flatMap(function (n) {
1173                                                    return e.map(function (e) {
1174                                                        return t(n, e);
1175                                                    });
1176                                                });
1177                                            };
1178                                        });
1179                                })(t),
1180                                (function (t) {
1181                                    b(t.prototype.map) ||
1182                                        (t.prototype.map = function (t) {
1183                                            return this.bind(g(this.of, t));
1184                                        });
1185                                })(t),
1186                                (function (t) {
1187                                    (t.prototype.takeLeft = function (t) {
1188                                        return O(this, t, function (t, n) {
1189                                            return t;
1190                                        });
1191                                    }),
1192                                        (t.prototype.takeRight = function (t) {
1193                                            return O(this, t, function (t, n) {
1194                                                return n;
1195                                            });
1196                                        });
1197                                })(t),
1198                                (function (t) {
1199                                    b(t.prototype.toArray) &&
1200                                        ((t.prototype.every = t.prototype.forall = function (t) {
1201                                            return this.toArray().every(t);
1202                                        }),
1203                                            (t.prototype.exists = function (t) {
1204                                                return this.toArray().some(t);
1205                                            }));
1206                                })(t),
1207                                (function (t) {
1208                                    ["equals", "map", "ap", "chain"]
1209                                        .filter(function (n) {
1210                                            return b(t.prototype[n]);
1211                                        })
1212                                        .forEach(function (n) {
1213                                            t.prototype["fantasy-land/" + n] = t.prototype[n];
1214                                        });
1215                                })(t),
1216                                (function (t) {
1217                                    b(t.prototype.toArray) &&
1218                                        (t.prototype[Symbol.iterator] = function () {
1219                                            return this.toArray()[Symbol.iterator]();
1220                                        });
1221                                })(t),
1222                                (function (t) {
1223                                    b(t.prototype.toArray) &&
1224                                        (t.prototype.to = function (t) {
1225                                            return t(this);
1226                                        });
1227                                })(t);
1228                        }
1229                        return (
1230                            (nt.of = function (t) {
1231                                return rt(t);
1232                            }),
1233                            (nt.liftF = function (t) {
1234                                return b(t) ? et(g(rt, t)) : et(t.map(rt));
1235                            }),
1236                            (nt.fn = nt.prototype = {
1237                                init: function (t, n) {
1238                                    (this.isSuspend = n), n ? (this.functor = t) : (this.val = t), p(this, f);
1239                                },
1240                                run: function () {
1241                                    return this.go(function (t) {
1242                                        return t();
1243                                    });
1244                                },
1245                                bind: function (t) {
1246                                    return this.isSuspend
1247                                        ? b(this.functor)
1248                                            ? et(
1249                                                g(function (n) {
1250                                                    return n.bind(t);
1251                                                }, this.functor)
1252                                            )
1253                                            : et(
1254                                                this.functor.map(function (n) {
1255                                                    return n.bind(t);
1256                                                })
1257                                            )
1258                                        : t(this.val);
1259                                },
1260                                ap: function (t) {
1261                                    return this.bind(function (n) {
1262                                        return t.map(function (t) {
1263                                            return t(n);
1264                                        });
1265                                    });
1266                                },
1267                                resume: function () {
1268                                    return this.isSuspend ? Z(this.functor) : Y(this.val);
1269                                },
1270                                go1: function (t) {
1271                                    return (function n(e) {
1272                                        return e.resume().cata(function (e) {
1273                                            return n(t(e));
1274                                        }, w);
1275                                    })(this);
1276                                },
1277                                go: function (t) {
1278                                    for (var n = this.resume(); n.isLeft();) {
1279                                        var e = t(n.left());
1280                                        n = e.resume();
1281                                    }
1282                                    return n.right();
1283                                },
1284                            }),
1285                            (nt.fn.init.prototype = nt.fn),
1286                            p(nt, f),
1287                            p(nt.fn.init, f),
1288                            (nt.isInstance = h(f)),
1289                            (nt.isOfType = l(f)),
1290                            (t.Identity = it),
1291                            (it.of = function (t) {
1292                                return new it(t);
1293                            }),
1294                            (it.fn = it.prototype = {
1295                                init: function (t) {
1296                                    (this.val = t), p(this, n);
1297                                },
1298                                bind: function (t) {
1299                                    return t(this.val);
1300                                },
1301                                get: function () {
1302                                    return this.val;
1303                                },
1304                                forEach: function (t) {
1305                                    t(this.val);
1306                                },
1307                                equals: function (t) {
1308                                    return it.isOfType(t) && x(this.get())(t.get());
1309                                },
1310                                contains: function (t) {
1311                                    return S(this.val, t);
1312                                },
1313                                toString: function () {
1314                                    return "Identity(" + this.val + ")";
1315                                },
1316                                inspect: function () {
1317                                    return this.toString();
1318                                },
1319                                ap: function (t) {
1320                                    var n = this.val;
1321                                    return t.map(function (t) {
1322                                        return t(n);
1323                                    });
1324                                },
1325                                toArray: function () {
1326                                    return [this.get()];
1327                                },
1328                                toList: function () {
1329                                    return C(this.get(), P);
1330                                },
1331                                toSet: function () {
1332                                    return new Set(this);
1333                                },
1334                            }),
1335                            (it.fn.init.prototype = it.fn),
1336                            p(it, n),
1337                            p(it.fn.init, n),
1338                            (it.isInstance = h(n)),
1339                            (it.isOfType = l(n)),
1340                            ot(X),
1341                            ot(Q),
1342                            ot(V),
1343                            ot(K),
1344                            ot(q),
1345                            ot(C),
1346                            ot(H),
1347                            ot(tt),
1348                            ot(nt),
1349                            ot(it),
1350                            t
1351                        );
1352                    })
1353                    ? r.call(n, e, n, t)
1354                    : r) || (t.exports = i);
1355    },
1356    function (t, n, e) {
1357        t.exports = e(17);
1358    },
1359    function (t, n, e) {
1360        "use strict";
1361        function r(t, n) {
1362            return "string" == typeof t ? i(t, n) : Promise.all(t.map((t) => i(t.importData, t.url, t.isDefault)));
1363        }
1364        function i(t, n, e = !1) {
1365            return new Promise((r, i) => {
1366                const o = "resolve_callback_" + Math.round(1e5 * Math.random());
1367                window[o] = (...n) => {
1368                    delete window[o], document.head.removeChild(s);
1369                    const e = Array.from(n);
1370                    let i = t.split(",");
1371                    i = i.map((t) => t.trim());
1372                    const u = e.reduce((t, n, e) => ((t[i[e]] = n), t), {});
1373                    r(u);
1374                };
1375                const s = document.createElement("script");
1376                (s.type = "module"),
1377                    (s.onerror = (t) => {
1378                        console.error("Failer load script from " + n
1378), console.error(t), i(t);
1379                    }),
1380                    (n += (n.indexOf("?") >= 0 ? "&" : "?") + "t=" + Date.now()),
1381                    (s.text = e ? `import ${t} from '${n}'; ${o}(${t}.default || ${t} );` : `import { ${t} } from '${n}'; ${o}(${t});`),
1382                    document.head.appendChild(s);
1383            });
1384        }
1385        e.d(n, "a", function () {
1386            return r;
1387        });
1388    },
1389    function (t, n, e) {
1390        "use strict";
1391        e.d(n, "a", function () {
1392            return r;
1393        });
1394        class r {
1395            constructor(t) {
1396                (this.getCookies = () => {
1397                    const t = this._doc.cookie;
1398                    console.log(t);
1399                    return t
1400                        ? t.split(";").reduce((t, n, e, r) => {
1401                            const i = n.split("=");
1402                            console.log(n);
1403                            if (2 !== i.length) throw new Error("Each cookie should be an equal sign separated string.");
1404                            return (t[i[0].trim()] = i[1]), t;
1405                        }, {})
1406                        : {};
1407                }),
1408                    (this._doc = t);
1409            }
1410            getLanguage() {
1411                const t = this._doc.querySelector("html").getAttribute("lang");
1412                return Boolean(t) ? t.substr(0, 2) : "EN";
1413            }
1414        }
1415    },
1416    function (t, n, e) {
1417        "use strict";
1418        t.exports = function (t, n) {
1419            return function () {
1420                for (var e = new Array(arguments.length), r = 0; r < e.length; r++) e[r] = arguments[r];
1421                return t.apply(n, e);
1422            };
1423        };
1424    },
1425    function (t, n, e) {
1426        "use strict";
1427        var r = e(0);
1428        function i(t) {
1429            return encodeURIComponent(t).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
1430        }
1431        t.exports = function (t, n, e) {
1432            if (!n) return t;
1433            var o;
1434            if (e) o = e(n);
1435            else if (r.isURLSearchParams(n)) o = n.toString();
1436            else {
1437                var s = [];
1438                r.forEach(n, function (t, n) {
1439                    null != t &&
1440                        (r.isArray(t) ? (n += "[]") : (t = [t]),
1441                            r.forEach(t, function (t) {
1442                                r.isDate(t) ? (t = t.toISOString()) : r.isObject(t) && (t = JSON.stringify(t)), s.push(i(n) + "=" + i(t));
1443                            }));
1444                }),
1445                    (o = s.join("&"));
1446            }
1447            if (o) {
1448                var u = t.indexOf("#");
1449                -1 !== u && (t = t.slice(0, u)), (t += (-1 === t.indexOf("?") ? "?" : "&") + o);
1450            }
1451            return t;
1452        };
1453    },
1454    function (t, n, e) {
1455        "use strict";
1456        t.exports = function (t) {
1457            return !(!t || !t.__CANCEL__);
1458        };
1459    },
1460    function (t, n, e) {
1461        "use strict";
1462        (function (n) {
1463            var r = e(0),
1464                i = e(23),
1465                o = { "Content-Type": "application/x-www-form-urlencoded" };
1466            function s(t, n) {
1467                !r.isUndefined(t) && r.isUndefined(t["Content-Type"]) && (t["Content-Type"] = n);
1468            }
1469            var u,
1470                a = {
1471                    adapter: (("undefined" != typeof XMLHttpRequest || (void 0 !== n && "[object process]" === Object.prototype.toString.call(n))) && (u = e(9)), u),
1472                    transformRequest: [
1473                        function (t, n) {
1474                            return (
1475                                i(n, "Accept"),
1476                                i(n, "Content-Type"),
1477                                r.isFormData(t) || r.isArrayBuffer(t) || r.isBuffer(t) || r.isStream(t) || r.isFile(t) || r.isBlob(t)
1478                                    ? t
1479                                    : r.isArrayBufferView(t)
1480                                        ? t.buffer
1481                                        : r.isURLSearchParams(t)
1482                                            ? (s(n, "application/x-www-form-urlencoded;charset=utf-8"), t.toString())
1483                                            : r.isObject(t)
1484                                                ? (s(n, "application/json;charset=utf-8"), JSON.stringify(t))
1485                                                : t
1486                            );
1487                        },
1488                    ],
1489                    transformResponse: [
1490                        function (t) {
1491                            if ("string" == typeof t)
1492                                try {
1493                                    t = JSON.parse(t);
1494                                } catch (t) { }
1495                            return t;
1496                        },
1497                    ],
1498                    timeout: 0,
1499                    xsrfCookieName: "XSRF-TOKEN",
1500                    xsrfHeaderName: "X-XSRF-TOKEN",
1501                    maxContentLength: -1,
1502                    maxBodyLength: -1,
1503                    validateStatus: function (t) {
1504                        return t >= 200 && t < 300;
1505                    },
1506                };
1507            (a.headers = { common: { Accept: "application/json, text/plain, */*" } }),
1508                r.forEach(["delete", "get", "head"], function (t) {
1509                    a.headers[t] = {};
1510                }),
1511                r.forEach(["post", "put", "patch"], function (t) {
1512                    a.headers[t] = r.merge(o);
1513                }),
1514                (t.exports = a);
1515        }.call(this, e(22)));
1516    },
1517    function (t, n, e) {
1518        "use strict";
1519        var r = e(0),
1520            i = e(24),
1521            o = e(26),
1522            s = e(6),
1523            u = e(27),
1524            a = e(30),
1525            c = e(31),
1526            f = e(10);
1527        t.exports = function (t) {
1528            return new Promise(function (n, e) {
1529                var p = t.data,
1530                    h = t.headers;
1531                r.isFormData(p) && delete h["Content-Type"], (r.isBlob(p) || r.isFile(p)) && p.type && delete h["Content-Type"];
1532                var l = new XMLHttpRequest();
1533                if (t.auth) {
1534                    var d = t.auth.username || "",
1535                        m = unescape(encodeURIComponent(t.auth.password)) || "";
1536                    h.Authorization = "Basic " + btoa(d + ":" + m);
1537                }
1538                var y = u(t.baseURL, t.url);
1539                if (
1540                    (l.open(t.method.toUpperCase(), s(y, t.params, t.paramsSerializer), !0),
1541                        (l.timeout = t.timeout),
1542                        (l.onreadystatechange = function () {
1543                            if (l && 4 === l.readyState && (0 !== l.status || (l.responseURL && 0 === l.responseURL.indexOf("file:")))) {
1544                                var r = "getAllResponseHeaders" in l ? a(l.getAllResponseHeaders()) : null,
1545                                    o = { data: t.responseType && "text" !== t.responseType ? l.response : l.responseText, status: l.status, statusText: l.statusText, headers: r, config: t, request: l };
1546                                i(n, e, o), (l = null);
1547                            }
1548                        }),
1549                        (l.onabort = function () {
1550                            l && (e(f("Request aborted", t, "ECONNABORTED", l)), (l = null));
1551                        }),
1552                        (l.onerror = function () {
1553                            e(f("Network Error", t, null, l)), (l = null);
1554                        }),
1555                        (l.ontimeout = function () {
1556                            var n = "timeout of " + t.timeout + "ms exceeded";
1557                            t.timeoutErrorMessage && (n = t.timeoutErrorMessage), e(f(n, t, "ECONNABORTED", l)), (l = null);
1558                        }),
1559                        r.isStandardBrowserEnv())
1560                ) {
1561                    var v = (t.withCredentials || c(y)) && t.xsrfCookieName ? o.read(t.xsrfCookieName) : void 0;
1562                    v && (h[t.xsrfHeaderName] = v);
1563                }
1564                if (
1565                    ("setRequestHeader" in l &&
1566                        r.forEach(h, function (t, n) {
1567                            void 0 === p && "content-type" === n.toLowerCase() ? delete h[n] : l.setRequestHeader(n, t);
1568                        }),
1569                        r.isUndefined(t.withCredentials) || (l.withCredentials = !!t.withCredentials),
1570                        t.responseType)
1571                )
1572                    try {
1573                        l.responseType = t.responseType;
1574                    } catch (n) {
1575                        if ("json" !== t.responseType) throw n;
1576                    }
1577                "function" == typeof t.onDownloadProgress && l.addEventListener("progress", t.onDownloadProgress),
1578                    "function" == typeof t.onUploadProgress && l.upload && l.upload.addEventListener("progress", t.onUploadProgress),
1579                    t.cancelToken &&
1580                    t.cancelToken.promise.then(function (t) {
1581                        l && (l.abort(), e(t), (l = null));
1582                    }),
1583                    p || (p = null),
1584                    l.send(p);
1585            });
1586        };
1587    },
1588    function (t, n, e) {
1589        "use strict";
1590        var r = e(25);
1591        t.exports = function (t, n, e, i, o) {
1592            var s = new Error(t);
1593            return r(s, n, e, i, o);
1594        };
1595    },
1596    function (t, n, e) {
1597        "use strict";
1598        var r = e(0);
1599        t.exports = function (t, n) {
1600            n = n || {};
1601            var e = {},
1602                i = ["url", "method", "data"],
1603                o = ["headers", "auth", "proxy", "params"],
1604                s = [
1605                    "baseURL",
1606                    "transformRequest",
1607                    "transformResponse",
1608                    "paramsSerializer",
1609                    "timeout",
1610                    "timeoutMessage",
1611                    "withCredentials",
1612                    "adapter",
1613                    "responseType",
1614                    "xsrfCookieName",
1615                    "xsrfHeaderName",
1616                    "onUploadProgress",
1617                    "onDownloadProgress",
1618                    "decompress",
1619                    "maxContentLength",
1620                    "maxBodyLength",
1621                    "maxRedirects",
1622                    "transport",
1623                    "httpAgent",
1624                    "httpsAgent",
1625                    "cancelToken",
1626                    "socketPath",
1627                    "responseEncoding",
1628                ],
1629                u = ["validateStatus"];
1630            function a(t, n) {
1631                return r.isPlainObject(t) && r.isPlainObject(n) ? r.merge(t, n) : r.isPlainObject(n) ? r.merge({}, n) : r.isArray(n) ? n.slice() : n;
1632            }
1633            function c(i) {
1634                r.isUndefined(n[i]) ? r.isUndefined(t[i]) || (e[i] = a(void 0, t[i])) : (e[i] = a(t[i], n[i]));
1635            }
1636            r.forEach(i, function (t) {
1637                r.isUndefined(n[t]) || (e[t] = a(void 0, n[t]));
1638            }),
1639                r.forEach(o, c),
1640                r.forEach(s, function (i) {
1641                    r.isUndefined(n[i]) ? r.isUndefined(t[i]) || (e[i] = a(void 0, t[i])) : (e[i] = a(void 0, n[i]));
1642                }),
1643                r.forEach(u, function (r) {
1644                    r in n ? (e[r] = a(t[r], n[r])) : r in t && (e[r] = a(void 0, t[r]));
1645                });
1646            var f = i.concat(o).concat(s).concat(u),
1647                p = Object.keys(t)
1648                    .concat(Object.keys(n))
1649                    .filter(function (t) {
1650                        return -1 === f.indexOf(t);
1651                    });
1652            return r.forEach(p, c), e;
1653        };
1654    },
1655    function (t, n, e) {
1656        "use strict";
1657        function r(t) {
1658            this.message = t;
1659        }
1660        (r.prototype.toString = function () {
1661            return "Cancel" + (this.message ? ": " + this.message : "");
1662        }),
1663            (r.prototype.__CANCEL__ = !0),
1664            (t.exports = r);
1665    },
1666    function (t, n, e) {
1667        "use strict";
1668        e.d(n, "a", function () {
1669            return o;
1670        });
1671        var r = e(2),
1672            i = e.n(r);
1673        class o {
1674            constructor(t) {
1675                (this.apiUrl = null != t ? t : "https://customerscanvashub.com/"), (this.http = i.a.create({ baseURL: null != t ? t : "https://customerscanvashub.com/", validateStatus: (t) => t >= 200 && t < 300 }));
1676            }
1677            async getIntegrationInfo(t, n) {
1678                const e = await this.http.get(`/api/v1/tenants/${t}/integrations/${n}`);
1679                return this.getDataFrom(e);
1680            }
1681            async getTemplateIntegrationInfo(t, n) {
1682                const e = await this.http.get(`/api/v1/tenants/${t}/integrations/template/${n}`);
1683                return this.getDataFrom(e);
1684            }
1685            async getToken(t, n, e) {
1686                const r = await this.http.post(`/api/v1/tenants/${t}/integrations/gettoken`, { userGuid: n, ecommerceDomain: e, origin: window.location.origin });
1687                return this.getDataFrom(r);
1688            }
1689            async getTokenAndUserId(t, n, e) {
1690                const r = await this.http.post(`/api/v1/tenants/${t}/integrations/getusertoken`, { userGuid: n, ecommerceDomain: e, origin: window.location.origin });
1691                return this.getDataFrom(r);
1692            }
1693            async getCcToken(t, n, e) {
1694                const r = await this.http.post(`/api/v1/tenants/${t}/integrations/getcctoken`, { userGuid: n, ecommerceDomain: e, origin: window.location.origin });
1695                return this.getDataFrom(r);
1696            }
1697            getDataFrom(t) {
1698                if (!this.http.defaults.validateStatus(t.status) || !t.data.success) throw new Error(`HTTP ${t.status} ${t.statusText}. ${JSON.stringify(t.data)}`);
1699                return t.data.result;
1700            }
1701        }
1702    },
1703    function (t, n, e) {
1704        "use strict";
1705        e.d(n, "a", function () {
1706            return o;
1707        });
1708        var r = e(2),
1709            i = e.n(r);
1710        class o {
1711            constructor({ url: t, tenantId: n, http: e }) {
1712                (this.apiUrl = t), (this.tenantId = n), (this.http = null != e ? e : i.a);
1713            }
1714            async warmUp(t, n, e) {
1715                for (let r = 0; r < t; r++) {
1716                    const i = await this.http.get(this.apiUrl + "/ping");
1717                    switch (i.status) {
1718                        case 200:
1719                        case 201:
1720                        case 204:
1721                            return !0;
1722                        case 503:
1723                            if (r < t - 1) {
1724                                const t = new Promise((t) => setTimeout(t, 1e3 * n));
1725                                Boolean(e) && e(), await t;
1726                            }
1727                            break;
1728                        default:
1729                            throw new Error(`Unexpected response from service: HTTP ${i.status} ${i.statusText}`);
1730                    }
1731                }
1732                return !1;
1733            }
1734            async post(t) {
1735                return (await this.http.post(`${this.apiUrl}/tenants/${this.tenantId}/projects/create`, t, { headers: { "Content-Type": "application/json" } })).data;
1736            }
1737        }
1738    },
1739    function (t, n, e) {
1740        "use strict";
1741        Object.defineProperty(n, "__esModule", { value: !0 }), (n.SignalList = n.SignalHandlingBase = n.SignalDispatcher = void 0);
1742        var r = e(36);
1743        Object.defineProperty(n, "SignalDispatcher", {
1744            enumerable: !0,
1745            get: function () {
1746                return r.SignalDispatcher;
1747            },
1748        }),
1749            Object.defineProperty(n, "SignalHandlingBase", {
1750                enumerable: !0,
1751                get: function () {
1752                    return r.SignalHandlingBase;
1753                },
1754            }),
1755            Object.defineProperty(n, "SignalList", {
1756                enumerable: !0,
1757                get: function () {
1758                    return r.SignalList;
1759                },
1760            });
1761    },
1762    function (t, n, e) {
1763        "use strict";
1764        function r() {
1765            var t;
1766            let n = new Date().getTime(),
1767                e = null !== (t = performance && performance.now && 1e3 * performance.now()) && void 0 !== t ? t : 0;
1768            return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (t) => {
1769                var r = 16 * Math.random();
1770                return n > 0 ? ((r = (n + r) % 16 | 0), (n = Math.floor(n / 16))) : ((r = (e + r) % 16 | 0), (e = Math.floor(e / 16))
1770), ("x" === t ? r : (3 & r) | 8).toString(16);
1771            });
1772        }
1773        function i(t) {
1774            return t.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
1775        }
1776        e.d(n, "a", function () {
1777            return r;
1778        }),
1779            e.d(n, "b", function () {
1780                return i;
1781            });
1782    },
1783    function (t, n, e) {
1784        "use strict";
1785        var r = e(0),
1786            i = e(5),
1787            o = e(18),
1788            s = e(11);
1789        function u(t) {
1790            var n = new o(t),
1791                e = i(o.prototype.request, n);
1792            return r.extend(e, o.prototype, n), r.extend(e, n), e;
1793        }
1794        var a = u(e(8));
1795        (a.Axios = o),
1796            (a.create = function (t) {
1797                return u(s(a.defaults, t));
1798            }),
1799            (a.Cancel = e(12)),
1800            (a.CancelToken = e(32)),
1801            (a.isCancel = e(7)),
1802            (a.all = function (t) {
1803                return Promise.all(t);
1804            }),
1805            (a.spread = e(33)),
1806            (t.exports = a),
1807            (t.exports.default = a);
1808    },
1809    function (t, n, e) {
1810        "use strict";
1811        var r = e(0),
1812            i = e(6),
1813            o = e(19),
1814            s = e(20),
1815            u = e(11);
1816        function a(t) {
1817            (this.defaults = t), (this.interceptors = { request: new o(), response: new o() });
1818        }
1819        (a.prototype.request = function (t) {
1820            "string" == typeof t ? ((t = arguments[1] || {}).url = arguments[0]) : (t = t || {}),
1821                (t = u(this.defaults, t)).method ? (t.method = t.method.toLowerCase()) : this.defaults.method ? (t.method = this.defaults.method.toLowerCase()) : (t.method = "get");
1822            var n = [s, void 0],
1823                e = Promise.resolve(t);
1824            for (
1825                this.interceptors.request.forEach(function (t) {
1826                    n.unshift(t.fulfilled, t.rejected);
1827                }),
1828                this.interceptors.response.forEach(function (t) {
1829                    n.push(t.fulfilled, t.rejected);
1830                });
1831                n.length;
1832
1833            )
1834                e = e.then(n.shift(), n.shift());
1835            return e;
1836        }),
1837            (a.prototype.getUri = function (t) {
1838                return (t = u(this.defaults, t)), i(t.url, t.params, t.paramsSerializer).replace(/^\?/, "");
1839            }),
1840            r.forEach(["delete", "get", "head", "options"], function (t) {
1841                a.prototype[t] = function (n, e) {
1842                    return this.request(u(e || {}, { method: t, url: n }));
1843                };
1844            }),
1845            r.forEach(["post", "put", "patch"], function (t) {
1846                a.prototype[t] = function (n, e, r) {
1847                    return this.request(u(r || {}, { method: t, url: n, data: e }));
1848                };
1849            }),
1850            (t.exports = a);
1851    },
1852    function (t, n, e) {
1853        "use strict";
1854        var r = e(0);
1855        function i() {
1856            this.handlers = [];
1857        }
1858        (i.prototype.use = function (t, n) {
1859            return this.handlers.push({ fulfilled: t, rejected: n }), this.handlers.length - 1;
1860        }),
1861            (i.prototype.eject = function (t) {
1862                this.handlers[t] && (this.handlers[t] = null);
1863            }),
1864            (i.prototype.forEach = function (t) {
1865                r.forEach(this.handlers, function (n) {
1866                    null !== n && t(n);
1867                });
1868            }),
1869            (t.exports = i);
1870    },
1871    function (t, n, e) {
1872        "use strict";
1873        var r = e(0),
1874            i = e(21),
1875            o = e(7),
1876            s = e(8);
1877        function u(t) {
1878            t.cancelToken && t.cancelToken.throwIfRequested();
1879        }
1880        t.exports = function (t) {
1881            return (
1882                u(t),
1883                (t.headers = t.headers || {}),
1884                (t.data = i(t.data, t.headers, t.transformRequest)),
1885                (t.headers = r.merge(t.headers.common || {}, t.headers[t.method] || {}, t.headers)),
1886                r.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function (n) {
1887                    delete t.headers[n];
1888                }),
1889                (t.adapter || s.adapter)(t).then(
1890                    function (n) {
1891                        return u(t), (n.data = i(n.data, n.headers, t.transformResponse)), n;
1892                    },
1893                    function (n) {
1894                        return o(n) || (u(t), n && n.response && (n.response.data = i(n.response.data, n.response.headers, t.transformResponse))), Promise.reject(n);
1895                    }
1896                )
1897            );
1898        };
1899    },
1900    function (t, n, e) {
1901        "use strict";
1902        var r = e(0);
1903        t.exports = function (t, n, e) {
1904            return (
1905                r.forEach(e, function (e) {
1906                    t = e(t, n);
1907                }),
1908                t
1909            );
1910        };
1911    },
1912    function (t, n) {
1913        var e,
1914            r,
1915            i = (t.exports = {});
1916        function o() {
1917            throw new Error("setTimeout has not been defined");
1918        }
1919        function s() {
1920            throw new Error("clearTimeout has not been defined");
1921        }
1922        function u(t) {
1923            if (e === setTimeout) return setTimeout(t, 0);
1924            if ((e === o || !e) && setTimeout) return (e = setTimeout), setTimeout(t, 0);
1925            try {
1926                return e(t, 0);
1927            } catch (n) {
1928                try {
1929                    return e.call(null, t, 0);
1930                } catch (n) {
1931                    return e.call(this, t, 0);
1932                }
1933            }
1934        }
1935        !(function () {
1936            try {
1937                e = "function" == typeof setTimeout ? setTimeout : o;
1938            } catch (t) {
1939                e = o;
1940            }
1941            try {
1942                r = "function" == typeof clearTimeout ? clearTimeout : s;
1943            } catch (t) {
1944                r = s;
1945            }
1946        })();
1947        var a,
1948            c = [],
1949            f = !1,
1950            p = -1;
1951        function h() {
1952            f && a && ((f = !1), a.length ? (c = a.concat(c)) : (p = -1), c.length && l());
1953        }
1954        function l() {
1955            if (!f) {
1956                var t = u(h);
1957                f = !0;
1958                for (var n = c.length; n;) {
1959                    for (a = c, c = []; ++p < n;) a && a[p].run();
1960                    (p = -1), (n = c.length);
1961                }
1962                (a = null),
1963                    (f = !1),
1964                    (function (t) {
1965                        if (r === clearTimeout) return clearTimeout(t);
1966                        if ((r === s || !r) && clearTimeout) return (r = clearTimeout), clearTimeout(t);
1967                        try {
1968                            r(t);
1969                        } catch (n) {
1970                            try {
1971                                return r.call(null, t);
1972                            } catch (n) {
1973                                return r.call(this, t);
1974                            }
1975                        }
1976                    })(t);
1977            }
1978        }
1979        function d(t, n) {
1980            (this.fun = t), (this.array = n);
1981        }
1982        function m() { }
1983        (i.nextTick = function (t) {
1984            var n = new Array(arguments.length - 1);
1985            if (arguments.length > 1) for (var e = 1; e < arguments.length; e++) n[e - 1] = arguments[e];
1986            c.push(new d(t, n)), 1 !== c.length || f || u(l);
1987        }),
1988            (d.prototype.run = function () {
1989                this.fun.apply(null, this.array);
1990            }),
1991            (i.title = "browser"),
1992            (i.browser = !0),
1993            (i.env = {}),
1994            (i.argv = []),
1995            (i.version = ""),
1996            (i.versions = {}),
1997            (i.on = m),
1998            (i.addListener = m),
1999            (i.once = m),
2000            (i.off = m),
2001            (i.removeListener = m),
2002            (i.removeAllListeners = m),
2003            (i.emit = m),
2004            (i.prependListener = m),
2005            (i.prependOnceListener = m),
2006            (i.listeners = function (t) {
2007                return [];
2008            }),
2009            (i.binding = function (t) {
2010                throw new Error("process.binding is not supported");
2011            }),
2012            (i.cwd = function () {
2013                return "/";
2014            }),
2015            (i.chdir = function (t) {
2016                throw new Error("process.chdir is not supported");
2017            }),
2018            (i.umask = function () {
2019                return 0;
2020            });
2021    },
2022    function (t, n, e) {
2023        "use strict";
2024        var r = e(0);
2025        t.exports = function (t, n) {
2026            r.forEach(t, function (e, r) {
2027                r !== n && r.toUpperCase() === n.toUpperCase() && ((t[n] = e), delete t[r]);
2028            });
2029        };
2030    },
2031    function (t, n, e) {
2032        "use strict";
2033        var r = e(10);
2034        t.exports = function (t, n, e) {
2035            var i = e.config.validateStatus;
2036            e.status && i && !i(e.status) ? n(r("Request failed with status code " + e.status, e.config, null, e.request, e)) : t(e);
2037        };
2038    },
2039    function (t, n, e) {
2040        "use strict";
2041        t.exports = function (t, n, e, r, i) {
2042            return (
2043                (t.config = n),
2044                e && (t.code = e),
2045                (t.request = r),
2046                (t.response = i),
2047                (t.isAxiosError = !0),
2048                (t.toJSON = function () {
2049                    return {
2050                        message: this.message,
2051                        name: this.name,
2052                        description: this.description,
2053                        number: this.number,
2054                        fileName: this.fileName,
2055                        lineNumber: this.lineNumber,
2056                        columnNumber: this.columnNumber,
2057                        stack: this.stack,
2058                        config: this.config,
2059                        code: this.code,
2060                    };
2061                }),
2062                t
2063            );
2064        };
2065    },
2066    function (t, n, e) {
2067        "use strict";
2068        var r = e(0);
2069
2070        function escapeRegex(str) {
2071            return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
2072        }
2073
2074        function getCookieValue(t) {
2075            const escapedName = escapeRegex(t);
2076            var n = document.cookie.match(new RegExp("(^|;\\s*)" + escapedName + "=([^;]*)"));
2077            return n ? decodeURIComponent(n[2]) : null;
2078        }
2079        
2080        t.exports = r.isStandardBrowserEnv()
2081            ? {
2082                write: function (t, n, e, i, o, s) {
2083                    var u = [];
2084                    u.push(t + "=" + encodeURIComponent(n)),
2085                        r.isNumber(e) && u.push("expires=" + new Date(e).toGMTString()),
2086                        r.isString(i) && u.push("path=" + i),
2087                        r.isString(o) && u.push("domain=" + o),
2088                        !0 === s && u.push("secure"),
2089                        (document.cookie = u.join("; "));
2090                },
2091                read: function (t) {
2092                    return getCookieValue(t);
2093                },
2094                remove: function (t) {
2095                    this.write(t, "", Date.now() - 864e5);
2096                },
2097            }
2098            : {
2099                write: function () { },
2100                read: function () {
2101                    return null;
2102                },
2103                remove: function () { },
2104            };
2105    },
2106    function (t, n, e) {
2107        "use strict";
2108        var r = e(28),
2109            i = e(29);
2110        t.exports = function (t, n) {
2111            return t && !r(n) ? i(t, n) : n;
2112        };
2113    },
2114    function (t, n, e) {
2115        "use strict";
2116        t.exports = function (t) {
2117            return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(t);
2118        };
2119    },
2120    function (t, n, e) {
2121        "use strict";
2122        t.exports = function (t, n) {
2123            return n ? t.replace(/\/+$/, "") + "/" + n.replace(/^\/+/, "") : t;
2124        };
2125    },
2126    function (t, n, e) {
2127        "use strict";
2128        var r = e(0),
2129            i = [
2130                "age",
2131                "authorization",
2132                "content-length",
2133                "content-type",
2134                "etag",
2135                "expires",
2136                "from",
2137                "host",
2138                "if-modified-since",
2139                "if-unmodified-since",
2140                "last-modified",
2141                "location",
2142                "max-forwards",
2143                "proxy-authorization",
2144                "referer",
2145                "retry-after",
2146                "user-agent",
2147            ];
2148        t.exports = function (t) {
2149            var n,
2150                e,
2151                o,
2152                s = {};
2153            return t
2154                ? (r.forEach(t.split("\n"), function (t) {
2155                    if (((o = t.indexOf(":")), (n = r.trim(t.substr(0, o)).toLowerCase()), (e = r.trim(t.substr(o + 1))), n)) {
2156                        if (s[n] && i.indexOf(n) >= 0) return;
2157                        s[n] = "set-cookie" === n ? (s[n] ? s[n] : []).concat([e]) : s[n] ? s[n] + ", " + e : e;
2158                    }
2159                }),
2160                    s)
2161                : s;
2162        };
2163    },
2164    function (t, n, e) {
2165        "use strict";
2166        var r = e(0);
2167        t.exports = r.isStandardBrowserEnv()
2168            ? (function () {
2169                var t,
2170                    n = /(msie|trident)/i.test(navigator.userAgent),
2171                    e = document.createElement("a");
2172                function i(t) {
2173                    var r = t;
2174                    return (
2175                        n && (e.setAttribute("href", r), (r = e.href)),
2176                        e.setAttribute("href", r),
2177                        {
2178                            href: e.href,
2179                            protocol: e.protocol ? e.protocol.replace(/:$/, "") : "",
2180                            host: e.host,
2181                            search: e.search ? e.search.replace(/^\?/, "") : "",
2182                            hash: e.hash ? e.hash.replace(/^#/, "") : "",
2183                            hostname: e.hostname,
2184                            port: e.port,
2185                            pathname: "/" === e.pathname.charAt(0) ? e.pathname : "/" + e.pathname,
2186                        }
2187                    );
2188                }
2189                return (
2190                    (t = i(window.location.href)),
2191                    function (n) {
2192                        var e = r.isString(n) ? i(n) : n;
2193                        return e.protocol === t.protocol && e.host === t.host;
2194                    }
2195                );
2196            })()
2197            : function () {
2198                return !0;
2199            };
2200    },
2201    function (t, n, e) {
2202        "use strict";
2203        var r = e(12);
2204        function i(t) {
2205            if ("function" != typeof t) throw new TypeError("executor must be a function.");
2206            var n;
2207            this.promise = new Promise(function (t) {
2208                n = t;
2209            });
2210            var e = this;
2211            t(function (t) {
2212                e.reason || ((e.reason = new r(t)), n(e.reason));
2213            });
2214        }
2215        (i.prototype.throwIfRequested = function () {
2216            if (this.reason) throw this.reason;
2217        }),
2218            (i.source = function () {
2219                var t;
2220                return {
2221                    token: new i(function (n) {
2222                        t = n;
2223                    }),
2224                    cancel: t,
2225                };
2226            }),
2227            (t.exports = i);
2228    },
2229    function (t, n, e) {
2230        "use strict";
2231        t.exports = function (t) {
2232            return function (n) {
2233                return t.apply(null, n);
2234            };
2235        };
2236    },
2237    function (t, n, e) {
2238        "use strict";
2239        Object.defineProperty(n, "__esModule", { value: !0 }), (n.Subscription = void 0);
2240        var r = (function () {
2241            function t(t, n) {
2242                (this.handler = t), (this.isOnce = n), (this.isExecuted = !1);
2243            }
2244            return (
2245                (t.prototype.execute = function (t, n, e) {
2246                    if (!this.isOnce || !this.isExecuted) {
2247                        this.isExecuted = !0;
2248                        var r = this.handler;
2249                        t
2250                            ? setTimeout(function () {
2251                                r.apply(n, e);
2252                            }, 1)
2253                            : r.apply(n, e);
2254                    }
2255                }),
2256                t
2257            );
2258        })();
2259        n.Subscription = r;
2260    },
2261    function (t, n, e) {
2262        "use strict";
2263        var r = e(13),
2264            i = e(3),
2265            o = e(14);
2266        class s {
2267            static process(t) {
2268                switch (typeof t) {
2269                    case "string":
2270                        try {
2271                            return JSON.parse(t);
2272                        } catch (n) {
2273                            return t;
2274                        }
2275                    case "object":
2276                        const n = {};
2277                        for (const [e, r] of Object.entries(t)) n[e] = s.process(r);
2278                        return n;
2279                    default:
2280                        return t;
2281                }
2282            }
2283        }
2284        class u {
2285            constructor(t) {
2286                Object.assign(this, t);
2287            }
2288        }
2289        class a {
2290            constructor(t, n, e) {
2291                (this.ecommerceService = n), (this.driverLoader = e), (this.input = t);
2292            }
2293            async getDriver() {
2294                return await this.prepareDriver();
2295            }
2296            async prepareDriver() {
2297                const [t, n] = this.prepareSettings(),
2298                    e = (await Object(i.a)([{ importData: "editor", url: this.input.uiFrameworkUrl + "/editor.js", isDefault: !0 }]))[0].editor,
2299                    r = this.ecommerceService.getUser();
2300                r.tokenId = this.input.ccToken;
2301                const o = await this.driverLoader.init(this.ecommerceService.productModel, e, n, t, this.ecommerceService.getBackToEditorData().orNull(), this.ecommerceService.quantity, r, this.ecommerceService.backOffice),
2302                    u = this.input.attributes.map((t) => ({ name: t.name, value: s.process(t.value) }));
2303                return o.products.current.attributes.push(...u), o;
2304            }
2305            prepareSettings() {
2306                var t;
2307                const n = this.ecommerceService.getPluginSettings();
2308                (n.token = this.input.token),
2309                    (n.tenantId = this.input.tenantId),
2310                    (n.editorUrl = this.input.customersCanvasUrl),
2311                    (n.customersCanvasBaseUrl = this.input.customersCanvasUrl),
2312                    (n.customersCanvasUrl = this.input.customersCanvasUrl);
2313                const e = Object.assign({}, this.input.config);
2314                return (
2315                    (null !== (t = e.vars) && void 0 !== t) || (e.vars = {}),
2316                    (e.vars.backOfficeUserId = this.input.tokenUserId),
2317                    (e.vars.token = this.input.token),
2318                    (e.vars.unitId = this.input.tenantId),
2319                    (e.vars.tenantId = this.input.tenantId),
2320                    [n, e]
2321                );
2322            }
2323        }
2324        var c = e(15);
2325        e.d(n, "a", function () {
2326            return f;
2327        });
2328        class f {
2329            constructor({ container: t, ecommerceService: n }) {
2330                (this.container = t), (this.ecommerceService = n), (this.driver = null), (this.projectBuffer = null), (this.onCreating = new c.SignalDispatcher()), (this.onCreated = new c.SignalDispatcher());
2331            }
2332            async create(t = !0) {
2333                this.onCreating.dispatch();
2334                const [n, e] = await (async function (t, n = !0) {
2335                    const e = new r.a(t.backofficeUrl),
2336                        s = await e.getIntegrationInfo(t.tenantId, String(t.getProductId())),
2337                        c = new o.a({ url: s.projectsBufferUrl, tenantId: t.tenantId });
2338                    !1 !== n &&
2339                        c
2340                            .warmUp(5, 3, () => console.warn("Cannot ping project buffer... Retrying in 3 seconds."))
2341                            .then((t) => {
2342                                t || console.warn("Project buffer was not warmed up.");
2343                            });
2344                    const f = (await Object(i.a)("ecommerceDriver", `${s.uiFrameworkUrl}/drivers/${t.driverFilename}`)).ecommerceDriver,
2345                        p = await e.getTokenAndUserId(t.tenantId, t.customerAuth.id, t.domain),
2346                        h = new u({
2347                            attributes: s.templateAttributes.slice(),
2348                            config: ((l = JSON.parse(s.config)), null !== (d = l.config) && void 0 !== d ? d : l),
2349                            customersCanvasUrl: s.customerCanvasUrl,
2350                            uiFrameworkUrl: s.uiFrameworkUrl,
2351                            tenantId: t.tenantId,
2352                            token: p.token,
2353                            tokenUserId: p.userId,
2354                            ccToken: await e.getCcToken(t.tenantId, t.getUser().id, t.domain || window.location.origin),
2355                        });
2356                    t.backOffice = {
2357                        storefrontId: s.ecommerceSystemId || "",
2358                        apiGatewayUrl: s.apiGatewayUrl || "",
2359                        backOfficeUrl: t.backofficeUrl || "https://customerscanvashub.com/",
2360                        assetStorageUrl: s.assetStorageUrl,
2361                        assetProcessorUrl: s.assetProcessorUrl,
2362                        designAtomsApiUrl: s.designAtomsApiUrl,
2363                        userId: p.userId,
2364                        token: p.token,
2365                        tenantId: t.tenantId
2366                    };
2367                    var l, d;
2368                    const m = new a(h, t, f);
2369                    return [await m.getDriver(), c];
2370                })(this.ecommerceService, t);
2371                return (this.driver = n), (this.projectBuffer = e), this.ecommerceService.addEditorExitHandler(this), await this.renderEditor(), this.onCreated.dispatch(), this.driver;
2372            }
2373            async addProjectHandler(t) {
2374                this.ecommerceService.addProjectHandler(t);
2375            }
2376            async renderEditor() {
2377                const t = document.createElement("div");
2378                return (
2379                    (t.style.height = "100%"),
2380                    this.container.appendChild(t),
2381                    this.driver.products.current.renderEditor(t),
2382                    this.syncronizeOptions(),
2383                    new Promise((t, n) => {
2384                        this.container.addEventListener("load", t), this.container.addEventListener("error", n);
2385                    })
2386                );
2387            }
2388            syncronizeOptions() {
2389                this.driver.orders.current.quantity = this.ecommerceService.quantity;
2390                this.ecommerceService.getSelectedVariantId().isJust() && "function" == typeof this.driver.orders.current.updateVariant && this.driver.orders.current.updateVariant(this.ecommerceService.getSelectedVariantId().just());
2391            }
2392        }
2393    },
2394    function (t, n, e) {
2395        "use strict";
2396        var r,
2397            i =
2398                (this && this.__extends) ||
2399                ((r = function (t, n) {
2400                    return (r =
2401                        Object.setPrototypeOf ||
2402                        ({ __proto__: [] } instanceof Array &&
2403                            function (t, n) {
2404                                t.__proto__ = n;
2405                            }) ||
2406                        function (t, n) {
2407                            for (var e in n) Object.prototype.hasOwnProperty.call(n, e) && (t[e] = n[e]);
2408                        })(t, n);
2409                }),
2410                    function (t, n) {
2411                        function e() {
2412                            this.constructor = t;
2413                        }
2414                        r(t, n), (t.prototype = null === n ? Object.create(n) : ((e.prototype = n.prototype), new e()));
2415                    });
2416        Object.defineProperty(n, "__esModule", { value: !0 }), (n.SignalHandlingBase = n.SignalList = n.SignalDispatcher = void 0);
2417        var o = e(37),
2418            s = (function (t) {
2419                function n() {
2420                    return t.call(this) || this;
2421                }
2422                return (
2423                    i(n, t),
2424                    (n.prototype.dispatch = function () {
2425                        this._dispatch(!1, this, arguments);
2426                    }),
2427                    (n.prototype.dispatchAsync = function () {
2428                        this._dispatch(!0, this, arguments);
2429                    }),
2430                    (n.prototype.asEvent = function () {
2431                        return t.prototype.asEvent.call(this);
2432                    }),
2433                    n
2434                );
2435            })(o.DispatcherBase);
2436        n.SignalDispatcher = s;
2437        var u = (function (t) {
2438            function n() {
2439                return t.call(this) || this;
2440            }
2441            return (
2442                i(n, t),
2443                (n.prototype.createDispatcher = function () {
2444                    return new s();
2445                }),
2446                n
2447            );
2448        })(o.EventListBase);
2449        n.SignalList = u;
2450        var a = (function () {
2451            function t() {
2452                this._events = new u();
2453            }
2454            return (
2455                Object.defineProperty(t.prototype, "events", {
2456                    get: function () {
2457                        return this._events;
2458                    },
2459                    enumerable: !1,
2460                    configurable: !0,
2461                }),
2462                (t.prototype.one = function (t, n) {
2463                    this._events.get(t).one(n);
2464                }),
2465                (t.prototype.has = function (t, n) {
2466                    return this._events.get(t).has(n);
2467                }),
2468                (t.prototype.subscribe = function (t, n) {
2469                    this._events.get(t).subscribe(n);
2470                }),
2471                (t.prototype.sub = function (t, n) {
2472                    this.subscribe(t, n);
2473                }),
2474                (t.prototype.unsubscribe = function (t, n) {
2475                    this._events.get(t).unsubscribe(n);
2476                }),
2477                (t.prototype.unsub = function (t, n) {
2478                    this.unsubscribe(t, n);
2479                }),
2480                t
2481            );
2482        })();
2483        n.SignalHandlingBase = a;
2484    },
2485    function (t, n, e) {
2486        "use strict";
2487        /*!
2488         * Strongly Typed Events for TypeScript - Core
2489         * https://github.com/KeesCBakker/StronlyTypedEvents/
2490         * http://keestalkstech.com
2491         *
2492         * Copyright Kees C. Bakker / KeesTalksTech
2493         * Released under the MIT license
2494         */ Object.defineProperty(n, "__esModule", { value: !0 }), (n.Subscription = n.EventListBase = n.DispatcherWrapper = n.DispatcherBase = void 0);
2495        var r = e(38);
2496        Object.defineProperty(n, "DispatcherBase", {
2497            enumerable: !0,
2498            get: function () {
2499                return r.DispatcherBase;
2500            },
2501        }),
2502            Object.defineProperty(n, "DispatcherWrapper", {
2503                enumerable: !0,
2504                get: function () {
2505                    return r.DispatcherWrapper;
2506                },
2507            }),
2508            Object.defineProperty(n, "EventListBase", {
2509                enumerable: !0,
2510                get: function () {
2511                    return r.EventListBase;
2512                },
2513            });
2514        var i = e(34);
2515        Object.defineProperty(n, "Subscription", {
2516            enumerable: !0,
2517            get: function () {
2518                return i.Subscription;
2519            },
2520        });
2521    },
2522    function (t, n, e) {
2523        "use strict";
2524        var r =
2525            (this && this.__spreadArrays) ||
2526            function () {
2527                for (var t = 0, n = 0, e = arguments.length; n < e; n++) t += arguments[n].length;
2528                var r = Array(t),
2529                    i = 0;
2530                for (n = 0; n < e; n++) for (var o = arguments[n], s = 0, u = o.length; s < u; s++, i++) r[i] = o[s];
2531                return r;
2532            };
2533        Object.defineProperty(n, "__esModule", { value: !0 }), (n.DispatcherWrapper = n.EventListBase = n.DispatcherBase = void 0);
2534        var i = e(39),
2535            o = e(34),
2536            s = (function () {
2537                function t() {
2538                    (this._wrap = new a(this)), (this._subscriptions = new Array());
2539                }
2540                return (
2541                    Object.defineProperty(t.prototype, "count", {
2542                        get: function () {
2543                            return this._subscriptions.length;
2544                        },
2545                        enumerable: !1,
2546                        configurable: !0,
2547                    }),
2548                    (t.prototype.subscribe = function (t) {
2549                        var n = this;
2550                        return (
2551                            t && this._subscriptions.push(new o.Subscription(t, !1)),
2552                            function () {
2553                                n.unsubscribe(t);
2554                            }
2555                        );
2556                    }),
2557                    (t.prototype.sub = function (t) {
2558                        return this.subscribe(t);
2559                    }),
2560                    (t.prototype.one = function (t) {
2561                        var n = this;
2562                        return (
2563                            t && this._subscriptions.push(new o.Subscription(t, !0)),
2564                            function () {
2565                                n.unsubscribe(t);
2566                            }
2567                        );
2568                    }),
2569                    (t.prototype.has = function (t) {
2570                        return (
2571                            !!t &&
2572                            this._subscriptions.some(function (n) {
2573                                return n.handler == t;
2574                            })
2575                        );
2576                    }),
2577                    (t.prototype.unsubscribe = function (t) {
2578                        if (t)
2579                            for (var n = 0; n < this._subscriptions.length; n++)
2580                                if (this._subscriptions[n].handler == t) {
2581                                    this._subscriptions.splice(n, 1);
2582                                    break;
2583                                }
2584                    }),
2585                    (t.prototype.unsub = function (t) {
2586                        this.unsubscribe(t);
2587                    }),
2588                    (t.prototype._dispatch = function (t, n, e) {
2589                        for (
2590                            var o = this,
2591                            s = function (r) {
2592                                var s = new i.EventManagement(function () {
2593                                    return o.unsub(r.handler);
2594                                }),
2595                                    a = Array.prototype.slice.call(e);
2596                                if ((a.push(s), r.execute(t, n, a), u.cleanup(r), !t && s.propagationStopped)) return "break";
2597                            },
2598                            u = this,
2599                            a = 0,
2600                            c = r(this._subscriptions);
2601                            a < c.length;
2602                            a++
2603                        ) {
2604                            if ("break" === s(c[a])) break;
2605                        }
2606                    }),
2607                    (t.prototype.cleanup = function (t) {
2608                        if (t.isOnce && t.isExecuted) {
2609                            var n = this._subscriptions.indexOf(t);
2610                            n > -1 && this._subscriptions.splice(n, 1);
2611                        }
2612                    }),
2613                    (t.prototype.asEvent = function () {
2614                        return this._wrap;
2615                    }),
2616                    (t.prototype.clear = function () {
2617                        this._subscriptions.splice(0, this._subscriptions.length);
2618                    }),
2619                    t
2620                );
2621            })();
2622        n.DispatcherBase = s;
2623        var u = (function () {
2624            function t() {
2625                this._events = {};
2626            }
2627            return (
2628                (t.prototype.get = function (t) {
2629                    var n = this._events[t];
2630                    return n || ((n = this.createDispatcher()), (this._events[t] = n), n);
2631                }),
2632                (t.prototype.remove = function (t) {
2633                    delete this._events[t];
2634                }),
2635                t
2636            );
2637        })();
2638        n.EventListBase = u;
2639        var a = (function () {
2640            function t(t) {
2641                (this._subscribe = function (n) {
2642                    return t.subscribe(n);
2643                }),
2644                    (this._unsubscribe = function (n) {
2645                        return t.unsubscribe(n);
2646                    }),
2647                    (this._one = function (n) {
2648                        return t.one(n);
2649                    }),
2650                    (this._has = function (n) {
2651                        return t.has(n);
2652                    }),
2653                    (this._clear = function () {
2654                        return t.clear();
2655                    }),
2656                    (this._count = function () {
2657                        return t.count;
2658                    });
2659            }
2660            return (
2661                Object.defineProperty(t.prototype, "count", {
2662                    get: function () {
2663                        return this._count();
2664                    },
2665                    enumerable: !1,
2666                    configurable: !0,
2667                }),
2668                (t.prototype.subscribe = function (t) {
2669                    return this._subscribe(t);
2670                }),
2671                (t.prototype.sub = function (t) {
2672                    return this.subscribe(t);
2673                }),
2674                (t.prototype.unsubscribe = function (t) {
2675                    this._unsubscribe(t);
2676                }),
2677                (t.prototype.unsub = function (t) {
2678                    this.unsubscribe(t);
2679                }),
2680                (t.prototype.one = function (t) {
2681                    return this._one(t);
2682                }),
2683                (t.prototype.has = function (t) {
2684                    return this._has(t);
2685                }),
2686                (t.prototype.clear = function () {
2687                    this._clear();
2688                }),
2689                t
2690            );
2691        })();
2692        n.DispatcherWrapper = a;
2693    },
2694    function (t, n, e) {
2695        "use strict";
2696        Object.defineProperty(n, "__esModule", { value: !0 }), (n.EventManagement = void 0);
2697        var r = (function () {
2698            function t(t) {
2699                (this.unsub = t), (this.propagationStopped = !1);
2700            }
2701            return (
2702                (t.prototype.stopPropagation = function () {
2703                    this.propagationStopped = !0;
2704                }),
2705                t
2706            );
2707        })();
2708        n.EventManagement = r;
2709    },
2710    function (t, n, e) {
2711        "use strict";
2712        function r(t, n) {
2713            return t.endsWith(n) ? t : t + n;
2714        }
2715        e.d(n, "a", function () {
2716            return r;
2717        });
2718    },
2719    function (t, n, e) {
2720        "use strict";
2721        e.r(n);
2722        var r = e(35);
2723        e.d(n, "UIFrameworkEditor", function () {
2724            return r.a;
2725        });
2726        var i = e(1);
2727        for (var o in i)
2728            ["UIFrameworkEditor", "default"].indexOf(o) < 0 &&
2729                (function (t) {
2730                    e.d(n, t, function () {
2731                        return i[t];
2732                    });
2733                })(o);
2734        var s = e(16);
2735        e.d(n, "Guid", function () {
2736            return s.a;
2737        }),
2738            e.d(n, "isGuid", function () {
2739                return s.b;
2740            });
2741        var u = e(40);
2742        e.d(n, "ensureEndsWith", function () {
2743            return u.a;
2744        });
2745        var a = e(4);
2746        e.d(n, "DocumentService", function () {
2747            return a.a;
2748        });
2749    },
2750]);

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.