@senx/warpview-editor
Version:
WarpView Editor Elements
1,336 lines (1,321 loc) • 158 kB
JavaScript
/******/ (function() { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 70173:
/*!****************************************************************************!*\
!*** ./node_modules/@webcomponents/custom-elements/custom-elements.min.js ***!
\****************************************************************************/
/***/ (function() {
(function () {
/*
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at
http://polymer.github.io/LICENSE.txt The complete set of authors may be found
at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
Google as part of the polymer project is also subject to an additional IP
rights grant found at http://polymer.github.io/PATENTS.txt
*/
'use strict';
var n = window.Document.prototype.createElement,
p = window.Document.prototype.createElementNS,
aa = window.Document.prototype.importNode,
ba = window.Document.prototype.prepend,
ca = window.Document.prototype.append,
da = window.DocumentFragment.prototype.prepend,
ea = window.DocumentFragment.prototype.append,
q = window.Node.prototype.cloneNode,
r = window.Node.prototype.appendChild,
t = window.Node.prototype.insertBefore,
u = window.Node.prototype.removeChild,
v = window.Node.prototype.replaceChild,
w = Object.getOwnPropertyDescriptor(window.Node.prototype, "textContent"),
y = window.Element.prototype.attachShadow,
z = Object.getOwnPropertyDescriptor(window.Element.prototype, "innerHTML"),
A = window.Element.prototype.getAttribute,
B = window.Element.prototype.setAttribute,
C = window.Element.prototype.removeAttribute,
D = window.Element.prototype.toggleAttribute,
E = window.Element.prototype.getAttributeNS,
F = window.Element.prototype.setAttributeNS,
G = window.Element.prototype.removeAttributeNS,
H = window.Element.prototype.insertAdjacentElement,
fa = window.Element.prototype.insertAdjacentHTML,
ha = window.Element.prototype.prepend,
ia = window.Element.prototype.append,
ja = window.Element.prototype.before,
ka = window.Element.prototype.after,
la = window.Element.prototype.replaceWith,
ma = window.Element.prototype.remove,
na = window.HTMLElement,
I = Object.getOwnPropertyDescriptor(window.HTMLElement.prototype, "innerHTML"),
oa = window.HTMLElement.prototype.insertAdjacentElement,
pa = window.HTMLElement.prototype.insertAdjacentHTML;
var qa = new Set();
"annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph".split(" ").forEach(function (a) {
return qa.add(a);
});
function ra(a) {
var b = qa.has(a);
a = /^[a-z][.0-9_a-z]*-[-.0-9_a-z]*$/.test(a);
return !b && a;
}
var sa = document.contains ? document.contains.bind(document) : document.documentElement.contains.bind(document.documentElement);
function J(a) {
var b = a.isConnected;
if (void 0 !== b) return b;
if (sa(a)) return !0;
for (; a && !(a.__CE_isImportDocument || a instanceof Document);) a = a.parentNode || (window.ShadowRoot && a instanceof ShadowRoot ? a.host : void 0);
return !(!a || !(a.__CE_isImportDocument || a instanceof Document));
}
function K(a) {
var b = a.children;
if (b) return Array.prototype.slice.call(b);
b = [];
for (a = a.firstChild; a; a = a.nextSibling) a.nodeType === Node.ELEMENT_NODE && b.push(a);
return b;
}
function L(a, b) {
for (; b && b !== a && !b.nextSibling;) b = b.parentNode;
return b && b !== a ? b.nextSibling : null;
}
function M(a, b, d) {
for (var f = a; f;) {
if (f.nodeType === Node.ELEMENT_NODE) {
var c = f;
b(c);
var e = c.localName;
if ("link" === e && "import" === c.getAttribute("rel")) {
f = c.import;
void 0 === d && (d = new Set());
if (f instanceof Node && !d.has(f)) for (d.add(f), f = f.firstChild; f; f = f.nextSibling) M(f, b, d);
f = L(a, c);
continue;
} else if ("template" === e) {
f = L(a, c);
continue;
}
if (c = c.__CE_shadowRoot) for (c = c.firstChild; c; c = c.nextSibling) M(c, b, d);
}
f = f.firstChild ? f.firstChild : L(a, f);
}
}
;
function N() {
var a = !(null === O || void 0 === O || !O.noDocumentConstructionObserver),
b = !(null === O || void 0 === O || !O.shadyDomFastWalk);
this.m = [];
this.g = [];
this.j = !1;
this.shadyDomFastWalk = b;
this.I = !a;
}
function P(a, b, d, f) {
var c = window.ShadyDOM;
if (a.shadyDomFastWalk && c && c.inUse) {
if (b.nodeType === Node.ELEMENT_NODE && d(b), b.querySelectorAll) for (a = c.nativeMethods.querySelectorAll.call(b, "*"), b = 0; b < a.length; b++) d(a[b]);
} else M(b, d, f);
}
function ta(a, b) {
a.j = !0;
a.m.push(b);
}
function ua(a, b) {
a.j = !0;
a.g.push(b);
}
function Q(a, b) {
a.j && P(a, b, function (d) {
return R(a, d);
});
}
function R(a, b) {
if (a.j && !b.__CE_patched) {
b.__CE_patched = !0;
for (var d = 0; d < a.m.length; d++) a.m[d](b);
for (d = 0; d < a.g.length; d++) a.g[d](b);
}
}
function S(a, b) {
var d = [];
P(a, b, function (c) {
return d.push(c);
});
for (b = 0; b < d.length; b++) {
var f = d[b];
1 === f.__CE_state ? a.connectedCallback(f) : T(a, f);
}
}
function U(a, b) {
var d = [];
P(a, b, function (c) {
return d.push(c);
});
for (b = 0; b < d.length; b++) {
var f = d[b];
1 === f.__CE_state && a.disconnectedCallback(f);
}
}
function V(a, b, d) {
d = void 0 === d ? {} : d;
var f = d.J,
c = d.upgrade || function (g) {
return T(a, g);
},
e = [];
P(a, b, function (g) {
a.j && R(a, g);
if ("link" === g.localName && "import" === g.getAttribute("rel")) {
var h = g.import;
h instanceof Node && (h.__CE_isImportDocument = !0, h.__CE_registry = document.__CE_registry);
h && "complete" === h.readyState ? h.__CE_documentLoadHandled = !0 : g.addEventListener("load", function () {
var k = g.import;
if (!k.__CE_documentLoadHandled) {
k.__CE_documentLoadHandled = !0;
var l = new Set();
f && (f.forEach(function (m) {
return l.add(m);
}), l.delete(k));
V(a, k, {
J: l,
upgrade: c
});
}
});
} else e.push(g);
}, f);
for (b = 0; b < e.length; b++) c(e[b]);
}
function T(a, b) {
try {
var d = b.ownerDocument,
f = d.__CE_registry;
var c = f && (d.defaultView || d.__CE_isImportDocument) ? W(f, b.localName) : void 0;
if (c && void 0 === b.__CE_state) {
c.constructionStack.push(b);
try {
try {
if (new c.constructorFunction() !== b) throw Error("The custom element constructor did not produce the element being upgraded.");
} finally {
c.constructionStack.pop();
}
} catch (k) {
throw b.__CE_state = 2, k;
}
b.__CE_state = 1;
b.__CE_definition = c;
if (c.attributeChangedCallback && b.hasAttributes()) {
var e = c.observedAttributes;
for (c = 0; c < e.length; c++) {
var g = e[c],
h = b.getAttribute(g);
null !== h && a.attributeChangedCallback(b, g, null, h, null);
}
}
J(b) && a.connectedCallback(b);
}
} catch (k) {
X(k);
}
}
N.prototype.connectedCallback = function (a) {
var b = a.__CE_definition;
if (b.connectedCallback) try {
b.connectedCallback.call(a);
} catch (d) {
X(d);
}
};
N.prototype.disconnectedCallback = function (a) {
var b = a.__CE_definition;
if (b.disconnectedCallback) try {
b.disconnectedCallback.call(a);
} catch (d) {
X(d);
}
};
N.prototype.attributeChangedCallback = function (a, b, d, f, c) {
var e = a.__CE_definition;
if (e.attributeChangedCallback && -1 < e.observedAttributes.indexOf(b)) try {
e.attributeChangedCallback.call(a, b, d, f, c);
} catch (g) {
X(g);
}
};
function va(a, b, d, f) {
var c = b.__CE_registry;
if (c && (null === f || "http://www.w3.org/1999/xhtml" === f) && (c = W(c, d))) try {
var e = new c.constructorFunction();
if (void 0 === e.__CE_state || void 0 === e.__CE_definition) throw Error("Failed to construct '" + d + "': The returned value was not constructed with the HTMLElement constructor.");
if ("http://www.w3.org/1999/xhtml" !== e.namespaceURI) throw Error("Failed to construct '" + d + "': The constructed element's namespace must be the HTML namespace.");
if (e.hasAttributes()) throw Error("Failed to construct '" + d + "': The constructed element must not have any attributes.");
if (null !== e.firstChild) throw Error("Failed to construct '" + d + "': The constructed element must not have any children.");
if (null !== e.parentNode) throw Error("Failed to construct '" + d + "': The constructed element must not have a parent node.");
if (e.ownerDocument !== b) throw Error("Failed to construct '" + d + "': The constructed element's owner document is incorrect.");
if (e.localName !== d) throw Error("Failed to construct '" + d + "': The constructed element's local name is incorrect.");
return e;
} catch (g) {
return X(g), b = null === f ? n.call(b, d) : p.call(b, f, d), Object.setPrototypeOf(b, HTMLUnknownElement.prototype), b.__CE_state = 2, b.__CE_definition = void 0, R(a, b), b;
}
b = null === f ? n.call(b, d) : p.call(b, f, d);
R(a, b);
return b;
}
function X(a) {
var b = "",
d = "",
f = 0,
c = 0;
a instanceof Error ? (b = a.message, d = a.sourceURL || a.fileName || "", f = a.line || a.lineNumber || 0, c = a.column || a.columnNumber || 0) : b = "Uncaught " + String(a);
var e = void 0;
void 0 === ErrorEvent.prototype.initErrorEvent ? e = new ErrorEvent("error", {
cancelable: !0,
message: b,
filename: d,
lineno: f,
colno: c,
error: a
}) : (e = document.createEvent("ErrorEvent"), e.initErrorEvent("error", !1, !0, b, d, f), e.preventDefault = function () {
Object.defineProperty(this, "defaultPrevented", {
configurable: !0,
get: function get() {
return !0;
}
});
});
void 0 === e.error && Object.defineProperty(e, "error", {
configurable: !0,
enumerable: !0,
get: function get() {
return a;
}
});
window.dispatchEvent(e);
e.defaultPrevented || console.error(a);
}
;
function wa() {
var a = this;
this.g = void 0;
this.F = new Promise(function (b) {
a.l = b;
});
}
wa.prototype.resolve = function (a) {
if (this.g) throw Error("Already resolved.");
this.g = a;
this.l(a);
};
function xa(a) {
var b = document;
this.l = void 0;
this.h = a;
this.g = b;
V(this.h, this.g);
"loading" === this.g.readyState && (this.l = new MutationObserver(this.G.bind(this)), this.l.observe(this.g, {
childList: !0,
subtree: !0
}));
}
function ya(a) {
a.l && a.l.disconnect();
}
xa.prototype.G = function (a) {
var b = this.g.readyState;
"interactive" !== b && "complete" !== b || ya(this);
for (b = 0; b < a.length; b++) for (var d = a[b].addedNodes, f = 0; f < d.length; f++) V(this.h, d[f]);
};
function Y(a) {
this.s = new Map();
this.u = new Map();
this.C = new Map();
this.A = !1;
this.B = new Map();
this.o = function (b) {
return b();
};
this.i = !1;
this.v = [];
this.h = a;
this.D = a.I ? new xa(a) : void 0;
}
Y.prototype.H = function (a, b) {
var d = this;
if (!(b instanceof Function)) throw new TypeError("Custom element constructor getters must be functions.");
za(this, a);
this.s.set(a, b);
this.v.push(a);
this.i || (this.i = !0, this.o(function () {
return Aa(d);
}));
};
Y.prototype.define = function (a, b) {
var d = this;
if (!(b instanceof Function)) throw new TypeError("Custom element constructors must be functions.");
za(this, a);
Ba(this, a, b);
this.v.push(a);
this.i || (this.i = !0, this.o(function () {
return Aa(d);
}));
};
function za(a, b) {
if (!ra(b)) throw new SyntaxError("The element name '" + b + "' is not valid.");
if (W(a, b)) throw Error("A custom element with name '" + (b + "' has already been defined."));
if (a.A) throw Error("A custom element is already being defined.");
}
function Ba(a, b, d) {
a.A = !0;
var f;
try {
var c = d.prototype;
if (!(c instanceof Object)) throw new TypeError("The custom element constructor's prototype is not an object.");
var e = function e(m) {
var x = c[m];
if (void 0 !== x && !(x instanceof Function)) throw Error("The '" + m + "' callback must be a function.");
return x;
};
var g = e("connectedCallback");
var h = e("disconnectedCallback");
var k = e("adoptedCallback");
var l = (f = e("attributeChangedCallback")) && d.observedAttributes || [];
} catch (m) {
throw m;
} finally {
a.A = !1;
}
d = {
localName: b,
constructorFunction: d,
connectedCallback: g,
disconnectedCallback: h,
adoptedCallback: k,
attributeChangedCallback: f,
observedAttributes: l,
constructionStack: []
};
a.u.set(b, d);
a.C.set(d.constructorFunction, d);
return d;
}
Y.prototype.upgrade = function (a) {
V(this.h, a);
};
function Aa(a) {
if (!1 !== a.i) {
a.i = !1;
for (var b = [], d = a.v, f = new Map(), c = 0; c < d.length; c++) f.set(d[c], []);
V(a.h, document, {
upgrade: function upgrade(k) {
if (void 0 === k.__CE_state) {
var l = k.localName,
m = f.get(l);
m ? m.push(k) : a.u.has(l) && b.push(k);
}
}
});
for (c = 0; c < b.length; c++) T(a.h, b[c]);
for (c = 0; c < d.length; c++) {
for (var e = d[c], g = f.get(e), h = 0; h < g.length; h++) T(a.h, g[h]);
(e = a.B.get(e)) && e.resolve(void 0);
}
d.length = 0;
}
}
Y.prototype.get = function (a) {
if (a = W(this, a)) return a.constructorFunction;
};
Y.prototype.whenDefined = function (a) {
if (!ra(a)) return Promise.reject(new SyntaxError("'" + a + "' is not a valid custom element name."));
var b = this.B.get(a);
if (b) return b.F;
b = new wa();
this.B.set(a, b);
var d = this.u.has(a) || this.s.has(a);
a = -1 === this.v.indexOf(a);
d && a && b.resolve(void 0);
return b.F;
};
Y.prototype.polyfillWrapFlushCallback = function (a) {
this.D && ya(this.D);
var b = this.o;
this.o = function (d) {
return a(function () {
return b(d);
});
};
};
function W(a, b) {
var d = a.u.get(b);
if (d) return d;
if (d = a.s.get(b)) {
a.s.delete(b);
try {
return Ba(a, b, d());
} catch (f) {
X(f);
}
}
}
Y.prototype.define = Y.prototype.define;
Y.prototype.upgrade = Y.prototype.upgrade;
Y.prototype.get = Y.prototype.get;
Y.prototype.whenDefined = Y.prototype.whenDefined;
Y.prototype.polyfillDefineLazy = Y.prototype.H;
Y.prototype.polyfillWrapFlushCallback = Y.prototype.polyfillWrapFlushCallback;
function Z(a, b, d) {
function f(c) {
return function (e) {
for (var g = [], h = 0; h < arguments.length; ++h) g[h] = arguments[h];
h = [];
for (var k = [], l = 0; l < g.length; l++) {
var m = g[l];
m instanceof Element && J(m) && k.push(m);
if (m instanceof DocumentFragment) for (m = m.firstChild; m; m = m.nextSibling) h.push(m);else h.push(m);
}
c.apply(this, g);
for (g = 0; g < k.length; g++) U(a, k[g]);
if (J(this)) for (g = 0; g < h.length; g++) k = h[g], k instanceof Element && S(a, k);
};
}
void 0 !== d.prepend && (b.prepend = f(d.prepend));
void 0 !== d.append && (b.append = f(d.append));
}
;
function Ca(a) {
Document.prototype.createElement = function (b) {
return va(a, this, b, null);
};
Document.prototype.importNode = function (b, d) {
b = aa.call(this, b, !!d);
this.__CE_registry ? V(a, b) : Q(a, b);
return b;
};
Document.prototype.createElementNS = function (b, d) {
return va(a, this, d, b);
};
Z(a, Document.prototype, {
prepend: ba,
append: ca
});
}
;
function Da(a) {
function b(f) {
return function (c) {
for (var e = [], g = 0; g < arguments.length; ++g) e[g] = arguments[g];
g = [];
for (var h = [], k = 0; k < e.length; k++) {
var l = e[k];
l instanceof Element && J(l) && h.push(l);
if (l instanceof DocumentFragment) for (l = l.firstChild; l; l = l.nextSibling) g.push(l);else g.push(l);
}
f.apply(this, e);
for (e = 0; e < h.length; e++) U(a, h[e]);
if (J(this)) for (e = 0; e < g.length; e++) h = g[e], h instanceof Element && S(a, h);
};
}
var d = Element.prototype;
void 0 !== ja && (d.before = b(ja));
void 0 !== ka && (d.after = b(ka));
void 0 !== la && (d.replaceWith = function (f) {
for (var c = [], e = 0; e < arguments.length; ++e) c[e] = arguments[e];
e = [];
for (var g = [], h = 0; h < c.length; h++) {
var k = c[h];
k instanceof Element && J(k) && g.push(k);
if (k instanceof DocumentFragment) for (k = k.firstChild; k; k = k.nextSibling) e.push(k);else e.push(k);
}
h = J(this);
la.apply(this, c);
for (c = 0; c < g.length; c++) U(a, g[c]);
if (h) for (U(a, this), c = 0; c < e.length; c++) g = e[c], g instanceof Element && S(a, g);
});
void 0 !== ma && (d.remove = function () {
var f = J(this);
ma.call(this);
f && U(a, this);
});
}
;
function Ea(a) {
function b(c, e) {
Object.defineProperty(c, "innerHTML", {
enumerable: e.enumerable,
configurable: !0,
get: e.get,
set: function set(g) {
var h = this,
k = void 0;
J(this) && (k = [], P(a, this, function (x) {
x !== h && k.push(x);
}));
e.set.call(this, g);
if (k) for (var l = 0; l < k.length; l++) {
var m = k[l];
1 === m.__CE_state && a.disconnectedCallback(m);
}
this.ownerDocument.__CE_registry ? V(a, this) : Q(a, this);
return g;
}
});
}
function d(c, e) {
c.insertAdjacentElement = function (g, h) {
var k = J(h);
g = e.call(this, g, h);
k && U(a, h);
J(g) && S(a, h);
return g;
};
}
function f(c, e) {
function g(h, k) {
for (var l = []; h !== k; h = h.nextSibling) l.push(h);
for (k = 0; k < l.length; k++) V(a, l[k]);
}
c.insertAdjacentHTML = function (h, k) {
h = h.toLowerCase();
if ("beforebegin" === h) {
var l = this.previousSibling;
e.call(this, h, k);
g(l || this.parentNode.firstChild, this);
} else if ("afterbegin" === h) l = this.firstChild, e.call(this, h, k), g(this.firstChild, l);else if ("beforeend" === h) l = this.lastChild, e.call(this, h, k), g(l || this.firstChild, null);else if ("afterend" === h) l = this.nextSibling, e.call(this, h, k), g(this.nextSibling, l);else throw new SyntaxError("The value provided (" + String(h) + ") is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'.");
};
}
y && (Element.prototype.attachShadow = function (c) {
c = y.call(this, c);
if (a.j && !c.__CE_patched) {
c.__CE_patched = !0;
for (var e = 0; e < a.m.length; e++) a.m[e](c);
}
return this.__CE_shadowRoot = c;
});
z && z.get ? b(Element.prototype, z) : I && I.get ? b(HTMLElement.prototype, I) : ua(a, function (c) {
b(c, {
enumerable: !0,
configurable: !0,
get: function get() {
return q.call(this, !0).innerHTML;
},
set: function set(e) {
var g = "template" === this.localName,
h = g ? this.content : this,
k = p.call(document, this.namespaceURI, this.localName);
for (k.innerHTML = e; 0 < h.childNodes.length;) u.call(h, h.childNodes[0]);
for (e = g ? k.content : k; 0 < e.childNodes.length;) r.call(h, e.childNodes[0]);
}
});
});
Element.prototype.setAttribute = function (c, e) {
if (1 !== this.__CE_state) return B.call(this, c, e);
var g = A.call(this, c);
B.call(this, c, e);
e = A.call(this, c);
a.attributeChangedCallback(this, c, g, e, null);
};
Element.prototype.setAttributeNS = function (c, e, g) {
if (1 !== this.__CE_state) return F.call(this, c, e, g);
var h = E.call(this, c, e);
F.call(this, c, e, g);
g = E.call(this, c, e);
a.attributeChangedCallback(this, e, h, g, c);
};
Element.prototype.removeAttribute = function (c) {
if (1 !== this.__CE_state) return C.call(this, c);
var e = A.call(this, c);
C.call(this, c);
null !== e && a.attributeChangedCallback(this, c, e, null, null);
};
D && (Element.prototype.toggleAttribute = function (c, e) {
if (1 !== this.__CE_state) return D.call(this, c, e);
var g = A.call(this, c),
h = null !== g;
e = D.call(this, c, e);
h !== e && a.attributeChangedCallback(this, c, g, e ? "" : null, null);
return e;
});
Element.prototype.removeAttributeNS = function (c, e) {
if (1 !== this.__CE_state) return G.call(this, c, e);
var g = E.call(this, c, e);
G.call(this, c, e);
var h = E.call(this, c, e);
g !== h && a.attributeChangedCallback(this, e, g, h, c);
};
oa ? d(HTMLElement.prototype, oa) : H && d(Element.prototype, H);
pa ? f(HTMLElement.prototype, pa) : fa && f(Element.prototype, fa);
Z(a, Element.prototype, {
prepend: ha,
append: ia
});
Da(a);
}
;
var Fa = {};
function Ga(a) {
function b() {
var d = this.constructor;
var f = document.__CE_registry.C.get(d);
if (!f) throw Error("Failed to construct a custom element: The constructor was not registered with `customElements`.");
var c = f.constructionStack;
if (0 === c.length) return c = n.call(document, f.localName), Object.setPrototypeOf(c, d.prototype), c.__CE_state = 1, c.__CE_definition = f, R(a, c), c;
var e = c.length - 1,
g = c[e];
if (g === Fa) throw Error("Failed to construct '" + f.localName + "': This element was already constructed.");
c[e] = Fa;
Object.setPrototypeOf(g, d.prototype);
R(a, g);
return g;
}
b.prototype = na.prototype;
Object.defineProperty(HTMLElement.prototype, "constructor", {
writable: !0,
configurable: !0,
enumerable: !1,
value: b
});
window.HTMLElement = b;
}
;
function Ha(a) {
function b(d, f) {
Object.defineProperty(d, "textContent", {
enumerable: f.enumerable,
configurable: !0,
get: f.get,
set: function set(c) {
if (this.nodeType === Node.TEXT_NODE) f.set.call(this, c);else {
var e = void 0;
if (this.firstChild) {
var g = this.childNodes,
h = g.length;
if (0 < h && J(this)) {
e = Array(h);
for (var k = 0; k < h; k++) e[k] = g[k];
}
}
f.set.call(this, c);
if (e) for (c = 0; c < e.length; c++) U(a, e[c]);
}
}
});
}
Node.prototype.insertBefore = function (d, f) {
if (d instanceof DocumentFragment) {
var c = K(d);
d = t.call(this, d, f);
if (J(this)) for (f = 0; f < c.length; f++) S(a, c[f]);
return d;
}
c = d instanceof Element && J(d);
f = t.call(this, d, f);
c && U(a, d);
J(this) && S(a, d);
return f;
};
Node.prototype.appendChild = function (d) {
if (d instanceof DocumentFragment) {
var f = K(d);
d = r.call(this, d);
if (J(this)) for (var c = 0; c < f.length; c++) S(a, f[c]);
return d;
}
f = d instanceof Element && J(d);
c = r.call(this, d);
f && U(a, d);
J(this) && S(a, d);
return c;
};
Node.prototype.cloneNode = function (d) {
d = q.call(this, !!d);
this.ownerDocument.__CE_registry ? V(a, d) : Q(a, d);
return d;
};
Node.prototype.removeChild = function (d) {
var f = d instanceof Element && J(d),
c = u.call(this, d);
f && U(a, d);
return c;
};
Node.prototype.replaceChild = function (d, f) {
if (d instanceof DocumentFragment) {
var c = K(d);
d = v.call(this, d, f);
if (J(this)) for (U(a, f), f = 0; f < c.length; f++) S(a, c[f]);
return d;
}
c = d instanceof Element && J(d);
var e = v.call(this, d, f),
g = J(this);
g && U(a, f);
c && U(a, d);
g && S(a, d);
return e;
};
w && w.get ? b(Node.prototype, w) : ta(a, function (d) {
b(d, {
enumerable: !0,
configurable: !0,
get: function get() {
for (var f = [], c = this.firstChild; c; c = c.nextSibling) c.nodeType !== Node.COMMENT_NODE && f.push(c.textContent);
return f.join("");
},
set: function set(f) {
for (; this.firstChild;) u.call(this, this.firstChild);
null != f && "" !== f && r.call(this, document.createTextNode(f));
}
});
});
}
;
var O = window.customElements;
function Ia() {
var a = new N();
Ga(a);
Ca(a);
Z(a, DocumentFragment.prototype, {
prepend: da,
append: ea
});
Ha(a);
Ea(a);
window.CustomElementRegistry = Y;
a = new Y(a);
document.__CE_registry = a;
Object.defineProperty(window, "customElements", {
configurable: !0,
enumerable: !0,
value: a
});
}
O && !O.forcePolyfill && "function" == typeof O.define && "function" == typeof O.get || Ia();
window.__CE_installPolyfill = Ia;
}).call(self);
//# sourceMappingURL=custom-elements.min.js.map
/***/ }),
/***/ 148:
/*!************************************************************************!*\
!*** ./node_modules/@webcomponents/custom-elements/src/native-shim.js ***!
\************************************************************************/
/***/ (function() {
"use strict";
/**
* @license
* Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
* This code may only be used under the BSD style license found at
* http://polymer.github.io/LICENSE.txt The complete set of authors may be found
* at http://polymer.github.io/AUTHORS.txt The complete set of contributors may
* be found at http://polymer.github.io/CONTRIBUTORS.txt Code distributed by
* Google as part of the polymer project is also subject to an additional IP
* rights grant found at http://polymer.github.io/PATENTS.txt
*/
/**
* This shim allows elements written in, or compiled to, ES5 to work on native
* implementations of Custom Elements v1. It sets new.target to the value of
* this.constructor so that the native HTMLElement constructor can access the
* current under-construction element's definition.
*/
(function () {
if (
// No Reflect, no classes, no need for shim because native custom elements
// require ES2015 classes or Reflect.
window.Reflect === undefined || window.customElements === undefined ||
// The webcomponentsjs custom elements polyfill doesn't require
// ES2015-compatible construction (`super()` or `Reflect.construct`).
window.customElements.polyfillWrapFlushCallback) {
return;
}
var BuiltInHTMLElement = HTMLElement;
/**
* With jscompiler's RECOMMENDED_FLAGS the function name will be optimized away.
* However, if we declare the function as a property on an object literal, and
* use quotes for the property name, then closure will leave that much intact,
* which is enough for the JS VM to correctly set Function.prototype.name.
*/
var wrapperForTheName = {
'HTMLElement': function HTMLElement() {
return Reflect.construct(BuiltInHTMLElement, [], this.constructor);
}
};
window.HTMLElement = wrapperForTheName['HTMLElement'];
HTMLElement.prototype = BuiltInHTMLElement.prototype;
HTMLElement.prototype.constructor = HTMLElement;
Object.setPrototypeOf(HTMLElement, BuiltInHTMLElement);
})();
//# sourceMappingURL=native-shim.js.map
/***/ }),
/***/ 88583:
/*!***********************************************!*\
!*** ./node_modules/zone.js/fesm2015/zone.js ***!
\***********************************************/
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
/**
* @license Angular v<unknown>
* (c) 2010-2022 Google LLC. https://angular.io/
* License: MIT
*/
var _objectSpread = (__webpack_require__(/*! ./node_modules/@babel/runtime/helpers/objectSpread2.js */ 81109)["default"]);
var _createForOfIteratorHelper = (__webpack_require__(/*! ./node_modules/@babel/runtime/helpers/createForOfIteratorHelper.js */ 43269)["default"]);
var _classCallCheck = (__webpack_require__(/*! ./node_modules/@babel/runtime/helpers/classCallCheck.js */ 34575)["default"]);
var _createClass = (__webpack_require__(/*! ./node_modules/@babel/runtime/helpers/createClass.js */ 93913)["default"]);
(function (global) {
var performance = global['performance'];
function mark(name) {
performance && performance['mark'] && performance['mark'](name);
}
function performanceMeasure(name, label) {
performance && performance['measure'] && performance['measure'](name, label);
}
mark('Zone');
// Initialize before it's accessed below.
// __Zone_symbol_prefix global can be used to override the default zone
// symbol prefix with a custom one if needed.
var symbolPrefix = global['__Zone_symbol_prefix'] || '__zone_symbol__';
function __symbol__(name) {
return symbolPrefix + name;
}
var checkDuplicate = global[__symbol__('forceDuplicateZoneCheck')] === true;
if (global['Zone']) {
// if global['Zone'] already exists (maybe zone.js was already loaded or
// some other lib also registered a global object named Zone), we may need
// to throw an error, but sometimes user may not want this error.
// For example,
// we have two web pages, page1 includes zone.js, page2 doesn't.
// and the 1st time user load page1 and page2, everything work fine,
// but when user load page2 again, error occurs because global['Zone'] already exists.
// so we add a flag to let user choose whether to throw this error or not.
// By default, if existing Zone is from zone.js, we will not throw the error.
if (checkDuplicate || typeof global['Zone'].__symbol__ !== 'function') {
throw new Error('Zone already loaded.');
} else {
return global['Zone'];
}
}
var Zone = /*#__PURE__*/function () {
function Zone(parent, zoneSpec) {
_classCallCheck(this, Zone);
this._parent = parent;
this._name = zoneSpec ? zoneSpec.name || 'unnamed' : '<root>';
this._properties = zoneSpec && zoneSpec.properties || {};
this._zoneDelegate = new _ZoneDelegate(this, this._parent && this._parent._zoneDelegate, zoneSpec);
}
_createClass(Zone, [{
key: "parent",
get: function get() {
return this._parent;
}
}, {
key: "name",
get: function get() {
return this._name;
}
}, {
key: "get",
value: function get(key) {
var zone = this.getZoneWith(key);
if (zone) return zone._properties[key];
}
}, {
key: "getZoneWith",
value: function getZoneWith(key) {
var current = this;
while (current) {
if (current._properties.hasOwnProperty(key)) {
return current;
}
current = current._parent;
}
return null;
}
}, {
key: "fork",
value: function fork(zoneSpec) {
if (!zoneSpec) throw new Error('ZoneSpec required!');
return this._zoneDelegate.fork(this, zoneSpec);
}
}, {
key: "wrap",
value: function wrap(callback, source) {
if (typeof callback !== 'function') {
throw new Error('Expecting function got: ' + callback);
}
var _callback = this._zoneDelegate.intercept(this, callback, source);
var zone = this;
return function () {
return zone.runGuarded(_callback, this, arguments, source);
};
}
}, {
key: "run",
value: function run(callback, applyThis, applyArgs, source) {
_currentZoneFrame = {
parent: _currentZoneFrame,
zone: this
};
try {
return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
} finally {
_currentZoneFrame = _currentZoneFrame.parent;
}
}
}, {
key: "runGuarded",
value: function runGuarded(callback) {
var applyThis = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
var applyArgs = arguments.length > 2 ? arguments[2] : undefined;
var source = arguments.length > 3 ? arguments[3] : undefined;
_currentZoneFrame = {
parent: _currentZoneFrame,
zone: this
};
try {
try {
return this._zoneDelegate.invoke(this, callback, applyThis, applyArgs, source);
} catch (error) {
if (this._zoneDelegate.handleError(this, error)) {
throw error;
}
}
} finally {
_currentZoneFrame = _currentZoneFrame.parent;
}
}
}, {
key: "runTask",
value: function runTask(task, applyThis, applyArgs) {
if (task.zone != this) {
throw new Error('A task can only be run in the zone of creation! (Creation: ' + (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
}
// https://github.com/angular/zone.js/issues/778, sometimes eventTask
// will run in notScheduled(canceled) state, we should not try to
// run such kind of task but just return
if (task.state === notScheduled && (task.type === eventTask || task.type === macroTask)) {
return;
}
var reEntryGuard = task.state != running;
reEntryGuard && task._transitionTo(running, scheduled);
task.runCount++;
var previousTask = _currentTask;
_currentTask = task;
_currentZoneFrame = {
parent: _currentZoneFrame,
zone: this
};
try {
if (task.type == macroTask && task.data && !task.data.isPeriodic) {
task.cancelFn = undefined;
}
try {
return this._zoneDelegate.invokeTask(this, task, applyThis, applyArgs);
} catch (error) {
if (this._zoneDelegate.handleError(this, error)) {
throw error;
}
}
} finally {
// if the task's state is notScheduled or unknown, then it has already been cancelled
// we should not reset the state to scheduled
if (task.state !== notScheduled && task.state !== unknown) {
if (task.type == eventTask || task.data && task.data.isPeriodic) {
reEntryGuard && task._transitionTo(scheduled, running);
} else {
task.runCount = 0;
this._updateTaskCount(task, -1);
reEntryGuard && task._transitionTo(notScheduled, running, notScheduled);
}
}
_currentZoneFrame = _currentZoneFrame.parent;
_currentTask = previousTask;
}
}
}, {
key: "scheduleTask",
value: function scheduleTask(task) {
if (task.zone && task.zone !== this) {
// check if the task was rescheduled, the newZone
// should not be the children of the original zone
var newZone = this;
while (newZone) {
if (newZone === task.zone) {
throw Error("can not reschedule task to ".concat(this.name, " which is descendants of the original zone ").concat(task.zone.name));
}
newZone = newZone.parent;
}
}
task._transitionTo(scheduling, notScheduled);
var zoneDelegates = [];
task._zoneDelegates = zoneDelegates;
task._zone = this;
try {
task = this._zoneDelegate.scheduleTask(this, task);
} catch (err) {
// should set task's state to unknown when scheduleTask throw error
// because the err may from reschedule, so the fromState maybe notScheduled
task._transitionTo(unknown, scheduling, notScheduled);
// TODO: @JiaLiPassion, should we check the result from handleError?
this._zoneDelegate.handleError(this, err);
throw err;
}
if (task._zoneDelegates === zoneDelegates) {
// we have to check because internally the delegate can reschedule the task.
this._updateTaskCount(task, 1);
}
if (task.state == scheduling) {
task._transitionTo(scheduled, scheduling);
}
return task;
}
}, {
key: "scheduleMicroTask",
value: function scheduleMicroTask(source, callback, data, customSchedule) {
return this.scheduleTask(new ZoneTask(microTask, source, callback, data, customSchedule, undefined));
}
}, {
key: "scheduleMacroTask",
value: function scheduleMacroTask(source, callback, data, customSchedule, customCancel) {
return this.scheduleTask(new ZoneTask(macroTask, source, callback, data, customSchedule, customCancel));
}
}, {
key: "scheduleEventTask",
value: function scheduleEventTask(source, callback, data, customSchedule, customCancel) {
return this.scheduleTask(new ZoneTask(eventTask, source, callback, data, customSchedule, customCancel));
}
}, {
key: "cancelTask",
value: function cancelTask(task) {
if (task.zone != this) throw new Error('A task can only be cancelled in the zone of creation! (Creation: ' + (task.zone || NO_ZONE).name + '; Execution: ' + this.name + ')');
if (task.state !== scheduled && task.state !== running) {
return;
}
task._transitionTo(canceling, scheduled, running);
try {
this._zoneDelegate.cancelTask(this, task);
} catch (err) {
// if error occurs when cancelTask, transit the state to unknown
task._transitionTo(unknown, canceling);
this._zoneDelegate.handleError(this, err);
throw err;
}
this._updateTaskCount(task, -1);
task._transitionTo(notScheduled, canceling);
task.runCount = 0;
return task;
}
}, {
key: "_updateTaskCount",
value: function _updateTaskCount(task, count) {
var zoneDelegates = task._zoneDelegates;
if (count == -1) {
task._zoneDelegates = null;
}
for (var i = 0; i < zoneDelegates.length; i++) {
zoneDelegates[i]._updateTaskCount(task.type, count);
}
}
}], [{
key: "assertZonePatched",
value: function assertZonePatched() {
if (global['Promise'] !== patches['ZoneAwarePromise']) {
throw new Error('Zone.js has detected that ZoneAwarePromise `(window|global).Promise` ' + 'has been overwritten.\n' + 'Most likely cause is that a Promise polyfill has been loaded ' + 'after Zone.js (Polyfilling Promise api is not necessary when zone.js is loaded. ' + 'If you must load one, do so before loading zone.js.)');
}
}
}, {
key: "root",
get: function get() {
var zone = Zone.current;
while (zone.parent) {
zone = zone.parent;
}
return zone;
}
}, {
key: "current",
get: function get() {
return _currentZoneFrame.zone;
}
}, {
key: "currentTask",
get: function get() {
return _currentTask;
}
// tslint:disable-next-line:require-internal-with-underscore
}, {
key: "__load_patch",
value: function __load_patch(name, fn) {
var ignoreDuplicate = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
if (patches.hasOwnProperty(name)) {
// `checkDuplicate` option is defined from global variable
// so it works for all modules.
// `ignoreDuplicate` can work for the specified module
if (!ignoreDuplicate && checkDuplicate) {
throw Error('Already loaded patch: ' + name);
}
} else if (!global['__Zone_disable_' + name]) {
var perfName = 'Zone:' + name;
mark(perfName);
patches[name] = fn(global, Zone, _api);
performanceMeasure(perfName, perfName);
}
}
}]);
return Zone;
}(); // tslint:disable-next-line:require-internal-with-underscore
Zone.__symbol__ = __symbol__;
var DELEGATE_ZS = {
name: '',
onHasTask: function onHasTask(delegate, _, target, hasTaskState) {
return delegate.hasTask(target, hasTaskState);
},
onScheduleTask: function onScheduleTask(delegate, _, target, task) {
return delegate.scheduleTask(target, task);
},
onInvokeTask: function onInvokeTask(delegate, _, target, task, applyThis, applyArgs) {
return delegate.invokeTask(target, task, applyThis, applyArgs);
},
onCancelTask: function onCancelTask(delegate, _, target, task) {
return delegate.cancelTask(target, task);
}
};
var _ZoneDelegate = /*#__PURE__*/function () {
function _ZoneDelegate(zone, parentDelegate, zoneSpec) {
_classCallCheck(this, _ZoneDelegate);
this._taskCounts = {
'microTask': 0,
'macroTask': 0,
'eventTask': 0
};
this.zone = zone;
this._parentDelegate = parentDelegate;
this._forkZS = zoneSpec && (zoneSpec && zoneSpec.onFork ? zoneSpec : parentDelegate._forkZS);
this._forkDlgt = zoneSpec && (zoneSpec.onFork ? parentDelegate : parentDelegate._forkDlgt);
this._forkCurrZone = zoneSpec && (zoneSpec.onFork ? this.zone : parentDelegate._forkCurrZone);
this._interceptZS = zoneSpec && (zoneSpec.onIntercept ? zoneSpec : parentDelegate._interceptZS);
this._interceptDlgt = zoneSpec && (zoneSpec.onIntercept ? parentDelegate : parentDelegate._interceptDlgt);
this._interceptCurrZone = zoneSpec && (zoneSpec.onIntercept ? this.zone : parentDelegate._interceptCurrZone);
this._invokeZS = zoneSpec && (zoneSpec.onInvoke ? zoneSpec : parentDelegate._invokeZS);
this._invokeDlgt = zoneSpec && (zoneSpec.onInvoke ? parentDelegate : parentDelegate._invokeDlgt);
this._invokeCurrZone = zoneSpec && (zoneSpec.onInvoke ? this.zone : parentDelegate._invokeCurrZone);
this._handleErrorZS = zoneSpec && (zoneSpec.onHandleError ? zoneSpec : parentDelegate._handleErrorZS);
this._handleErrorDlgt = zoneSpec && (zoneSpec.onHandleError ? parentDelegate : parentDelegate._handleErrorDlgt);
this._handleErrorCurrZone = zoneSpec && (zoneSpec.onHandleError ? this.zone : parentDelegate._handleErrorCurrZone);
this._scheduleTaskZS = zoneSpec && (zoneSpec.onScheduleTask ? zoneSpec : parentDelegate._scheduleTaskZS);
this._scheduleTaskDlgt = zoneSpec && (zoneSpec.onScheduleTask ? parentDelegate : parentDelegate._scheduleTaskDlgt);
this._scheduleTaskCurrZone = zoneSpec && (zoneSpec.onScheduleTask ? this.zone : parentDelegate._scheduleTaskCurrZone);
this._invokeTaskZS = zoneSpec && (zoneSpec.onInvokeTask ? zoneSpec : parentDelegate._invokeTaskZS);
this._invokeTaskDlgt = zoneSpec && (zoneSpec.onInvokeTask ? parentDelegate : parentDelegate._invokeTaskDlgt);
this._invokeTaskCurrZone = zoneSpec && (zoneSpec.onInvokeTask ? this.zone : parentDelegate._invokeTaskCurrZone);
this._cancelTaskZS = zoneSpec && (zoneSpec.onCancelTask ? zoneSpec : parentDelegate._cancelTaskZS);
this._cancelTaskDlgt = zoneSpec && (zoneSpec.onCancelTask ? parentDelegate : parentDelegate._cancelTaskDlgt);
this._cancelTaskCurrZone = zoneSpec && (zoneSpec.onCancelTask ? this.zone : parentDelegate._cancelTaskCurrZone);
this._hasTaskZS = null;
this._hasTaskDlgt = null;
this._hasTaskDlgtOwner = null;
this._hasTaskCurrZone = null;
var zoneSpecHasTask = zoneSpec && zoneSpec.onHasTask;
var parentHasTask = parentDelegate && parentDelegate._hasTaskZS;
if (zoneSpecHasTask || parentHasTask) {
// If we need to report hasTask, than this ZS needs to do ref counting on tasks. In such
// a case all task related interceptors must go through this ZD. We can't short circuit it.
this._hasTaskZS = zoneSpecHasTask ? zoneSpec : DELEGATE_ZS;
this._hasTaskDlgt = parentDelegate;
this._hasTaskDlgtOwner = this;
this._hasTaskCurrZone = zone;
if (!zoneSpec.onScheduleTask) {
this._scheduleTaskZS = DELEGATE_ZS;
this._scheduleTaskDlgt = parentDelegate;
this._scheduleTaskCurrZone = this.zone;
}
if (!zoneSpec.onInvokeTask) {
this._invokeTaskZS = DELEGATE_ZS;
this._invokeTaskDlgt = parentDelegate;
this._invokeTaskCurrZone = this.zone;
}
if (!zoneSpec.onCancelTask) {
this._cancelTaskZS = DELEGATE_ZS;
this._cancelTaskDlgt = parentDelegate;
this._cancelTaskCurrZone = this.zone;
}
}
}
_createClass(_ZoneDelegate, [{
key: "fork",
value: function fork(targetZone, zoneSpec) {
return this._forkZS ? this._forkZS.onFork(this._forkDlgt, this.zone, targetZone, zoneSpec) : new Zone(targetZone, zoneSpec);
}
}, {
key: "intercept",
value: function intercept(targetZone, callback, source) {
return this._interceptZS ? this._interceptZS.onIntercept(this._interceptDlgt, this._interceptCurrZone, targetZone, callback, source) : callback;
}
}, {
key: "invoke",
value: function invoke(targetZone, callback, applyThis, applyArgs, source) {
return this._invokeZS ? this._invokeZS.onInvoke(this._invokeDlgt, this._invokeCurrZone, targetZone, callback, applyThis, applyArgs, source) : callback.apply(applyThis, applyArgs);
}
}, {
key: "handleError",
value: function handleError(targetZone, error) {
return this._handleErrorZS ? this._handleErrorZS.onHandleError(this._handleErrorDlgt, this._handleErrorCurrZone, targetZone, error) : true;
}
}, {
key: "scheduleTask",
value: function scheduleTask(targetZone, task) {
var returnTask = task;
if (this._scheduleTaskZS) {
if (this._hasTaskZS) {
returnTask._zoneDelegates.push(this._hasTaskDlgtOwner);
}
// clang-format off
returnTask = this._scheduleTaskZS.onScheduleTask(this._scheduleTaskDlgt, this._scheduleTaskCurrZone, targetZone, task);
// clang-format on
if (!returnTask) returnTask = task;
} else {
if (task.scheduleFn) {
task.scheduleFn(task);
} else if (task.type == microTask) {
scheduleMicroTask(task);
} else {
throw new Error('Task is missing scheduleFn.');
}
}
return returnTask;
}
}, {
key: "invokeTask",
value: function invokeTask(targetZone, task, applyThis, applyArgs) {
return this._invokeTaskZS ? this._invokeTaskZS.onInvokeTask(this._invokeTaskDlgt, this._invokeTaskCurrZone, targetZone, task, applyThis, applyArgs) : task.callback.apply(applyThis, applyArgs);
}
}, {
key: "cancelTask",
value: function cancelTask(targetZone, task) {
var value;
if (this._cancelTaskZS) {
value = this._cancelTaskZS.onCancelTask(this._cancelTaskDlgt, this._cancelTaskCurrZone, targetZone, task);
} else {
if (!task.cancelFn) {
throw Error('Task is not cancelable');
}
value = task.cancelFn(task);
}
return value;
}
}, {
key: "hasTask",
value: function hasTask(targetZone, isEmpty) {
// hasTask should not throw error so other ZoneDelegate
// can still trigger hasTask callback
try {
this._hasTaskZS && this._hasTaskZS.onHasTask(this._hasTaskDlgt, this._hasTaskCurrZone, targetZone, isEmpty);
} catch (err) {
this.handleError(targetZone, err);
}
}
// tslint:disable-next-line:require-internal-with-underscore
}, {
key: "_updateTaskCount",
value: function _updateTaskCount(type, count) {
var counts = this._taskCounts;
var prev = counts[type];
var next = counts[type] = prev + count;
if (next < 0) {
throw