Created
February 25, 2025 07:44
-
-
Save MarvinXu/0988e151ce016962f202e840baafa0fb to your computer and use it in GitHub Desktop.
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| "use strict"; | |
| (self.webpackChunkpolyhedron_canvas = self.webpackChunkpolyhedron_canvas || []).push([[179], { | |
| 739: () => { | |
| function Ye(n) { | |
| return "function" == typeof n | |
| } | |
| function is(n) { | |
| const t = n(r => { | |
| Error.call(r), | |
| r.stack = (new Error).stack | |
| } | |
| ); | |
| return t.prototype = Object.create(Error.prototype), | |
| t.prototype.constructor = t, | |
| t | |
| } | |
| const La = is(n => function(t) { | |
| n(this), | |
| this.message = t ? `${t.length} errors occurred during unsubscription:\n${t.map( (r, i) => `${i + 1}) ${r.toString()}`).join("\n ")}` : "", | |
| this.name = "UnsubscriptionError", | |
| this.errors = t | |
| } | |
| ); | |
| function Yi(n, e) { | |
| if (n) { | |
| const t = n.indexOf(e); | |
| 0 <= t && n.splice(t, 1) | |
| } | |
| } | |
| class mn { | |
| constructor(e) { | |
| this.initialTeardown = e, | |
| this.closed = !1, | |
| this._parentage = null, | |
| this._finalizers = null | |
| } | |
| unsubscribe() { | |
| let e; | |
| if (!this.closed) { | |
| this.closed = !0; | |
| const {_parentage: t} = this; | |
| if (t) | |
| if (this._parentage = null, | |
| Array.isArray(t)) | |
| for (const o of t) | |
| o.remove(this); | |
| else | |
| t.remove(this); | |
| const {initialTeardown: r} = this; | |
| if (Ye(r)) | |
| try { | |
| r() | |
| } catch (o) { | |
| e = o instanceof La ? o.errors : [o] | |
| } | |
| const {_finalizers: i} = this; | |
| if (i) { | |
| this._finalizers = null; | |
| for (const o of i) | |
| try { | |
| Sg(o) | |
| } catch (s) { | |
| e = null != e ? e : [], | |
| s instanceof La ? e = [...e, ...s.errors] : e.push(s) | |
| } | |
| } | |
| if (e) | |
| throw new La(e) | |
| } | |
| } | |
| add(e) { | |
| var t; | |
| if (e && e !== this) | |
| if (this.closed) | |
| Sg(e); | |
| else { | |
| if (e instanceof mn) { | |
| if (e.closed || e._hasParent(this)) | |
| return; | |
| e._addParent(this) | |
| } | |
| (this._finalizers = null !== (t = this._finalizers) && void 0 !== t ? t : []).push(e) | |
| } | |
| } | |
| _hasParent(e) { | |
| const {_parentage: t} = this; | |
| return t === e || Array.isArray(t) && t.includes(e) | |
| } | |
| _addParent(e) { | |
| const {_parentage: t} = this; | |
| this._parentage = Array.isArray(t) ? (t.push(e), | |
| t) : t ? [t, e] : e | |
| } | |
| _removeParent(e) { | |
| const {_parentage: t} = this; | |
| t === e ? this._parentage = null : Array.isArray(t) && Yi(t, e) | |
| } | |
| remove(e) { | |
| const {_finalizers: t} = this; | |
| t && Yi(t, e), | |
| e instanceof mn && e._removeParent(this) | |
| } | |
| } | |
| mn.EMPTY = ( () => { | |
| const n = new mn; | |
| return n.closed = !0, | |
| n | |
| } | |
| )(); | |
| const Ag = mn.EMPTY; | |
| function Ig(n) { | |
| return n instanceof mn || n && "closed"in n && Ye(n.remove) && Ye(n.add) && Ye(n.unsubscribe) | |
| } | |
| function Sg(n) { | |
| Ye(n) ? n() : n.unsubscribe() | |
| } | |
| const bi = { | |
| onUnhandledError: null, | |
| onStoppedNotification: null, | |
| Promise: void 0, | |
| useDeprecatedSynchronousErrorHandling: !1, | |
| useDeprecatedNextContext: !1 | |
| } | |
| , Va = { | |
| setTimeout(n, e, ...t) { | |
| const {delegate: r} = Va; | |
| return null != r && r.setTimeout ? r.setTimeout(n, e, ...t) : setTimeout(n, e, ...t) | |
| }, | |
| clearTimeout(n) { | |
| const {delegate: e} = Va; | |
| return ((null == e ? void 0 : e.clearTimeout) || clearTimeout)(n) | |
| }, | |
| delegate: void 0 | |
| }; | |
| function xg(n) { | |
| Va.setTimeout( () => { | |
| const {onUnhandledError: e} = bi; | |
| if (!e) | |
| throw n; | |
| e(n) | |
| } | |
| ) | |
| } | |
| function bu() {} | |
| const DD = Cu("C", void 0, void 0); | |
| function Cu(n, e, t) { | |
| return { | |
| kind: n, | |
| value: e, | |
| error: t | |
| } | |
| } | |
| let Ci = null; | |
| function Ba(n) { | |
| if (bi.useDeprecatedSynchronousErrorHandling) { | |
| const e = !Ci; | |
| if (e && (Ci = { | |
| errorThrown: !1, | |
| error: null | |
| }), | |
| n(), | |
| e) { | |
| const {errorThrown: t, error: r} = Ci; | |
| if (Ci = null, | |
| t) | |
| throw r | |
| } | |
| } else | |
| n() | |
| } | |
| class Tu extends mn { | |
| constructor(e) { | |
| super(), | |
| this.isStopped = !1, | |
| e ? (this.destination = e, | |
| Ig(e) && e.add(this)) : this.destination = FD | |
| } | |
| static create(e, t, r) { | |
| return new os(e,t,r) | |
| } | |
| next(e) { | |
| this.isStopped ? wu(function AD(n) { | |
| return Cu("N", n, void 0) | |
| }(e), this) : this._next(e) | |
| } | |
| error(e) { | |
| this.isStopped ? wu(function MD(n) { | |
| return Cu("E", void 0, n) | |
| }(e), this) : (this.isStopped = !0, | |
| this._error(e)) | |
| } | |
| complete() { | |
| this.isStopped ? wu(DD, this) : (this.isStopped = !0, | |
| this._complete()) | |
| } | |
| unsubscribe() { | |
| this.closed || (this.isStopped = !0, | |
| super.unsubscribe(), | |
| this.destination = null) | |
| } | |
| _next(e) { | |
| this.destination.next(e) | |
| } | |
| _error(e) { | |
| try { | |
| this.destination.error(e) | |
| } finally { | |
| this.unsubscribe() | |
| } | |
| } | |
| _complete() { | |
| try { | |
| this.destination.complete() | |
| } finally { | |
| this.unsubscribe() | |
| } | |
| } | |
| } | |
| const SD = Function.prototype.bind; | |
| function Eu(n, e) { | |
| return SD.call(n, e) | |
| } | |
| class xD { | |
| constructor(e) { | |
| this.partialObserver = e | |
| } | |
| next(e) { | |
| const {partialObserver: t} = this; | |
| if (t.next) | |
| try { | |
| t.next(e) | |
| } catch (r) { | |
| Ua(r) | |
| } | |
| } | |
| error(e) { | |
| const {partialObserver: t} = this; | |
| if (t.error) | |
| try { | |
| t.error(e) | |
| } catch (r) { | |
| Ua(r) | |
| } | |
| else | |
| Ua(e) | |
| } | |
| complete() { | |
| const {partialObserver: e} = this; | |
| if (e.complete) | |
| try { | |
| e.complete() | |
| } catch (t) { | |
| Ua(t) | |
| } | |
| } | |
| } | |
| class os extends Tu { | |
| constructor(e, t, r) { | |
| let i; | |
| if (super(), | |
| Ye(e) || !e) | |
| i = { | |
| next: null != e ? e : void 0, | |
| error: null != t ? t : void 0, | |
| complete: null != r ? r : void 0 | |
| }; | |
| else { | |
| let o; | |
| this && bi.useDeprecatedNextContext ? (o = Object.create(e), | |
| o.unsubscribe = () => this.unsubscribe(), | |
| i = { | |
| next: e.next && Eu(e.next, o), | |
| error: e.error && Eu(e.error, o), | |
| complete: e.complete && Eu(e.complete, o) | |
| }) : i = e | |
| } | |
| this.destination = new xD(i) | |
| } | |
| } | |
| function Ua(n) { | |
| bi.useDeprecatedSynchronousErrorHandling ? function ID(n) { | |
| bi.useDeprecatedSynchronousErrorHandling && Ci && (Ci.errorThrown = !0, | |
| Ci.error = n) | |
| }(n) : xg(n) | |
| } | |
| function wu(n, e) { | |
| const {onStoppedNotification: t} = bi; | |
| t && Va.setTimeout( () => t(n, e)) | |
| } | |
| const FD = { | |
| closed: !0, | |
| next: bu, | |
| error: function RD(n) { | |
| throw n | |
| }, | |
| complete: bu | |
| } | |
| , Du = "function" == typeof Symbol && Symbol.observable || "@@observable"; | |
| function qr(n) { | |
| return n | |
| } | |
| function Rg(n) { | |
| return 0 === n.length ? qr : 1 === n.length ? n[0] : function(t) { | |
| return n.reduce( (r, i) => i(r), t) | |
| } | |
| } | |
| let vt = ( () => { | |
| class n { | |
| constructor(t) { | |
| t && (this._subscribe = t) | |
| } | |
| lift(t) { | |
| const r = new n; | |
| return r.source = this, | |
| r.operator = t, | |
| r | |
| } | |
| subscribe(t, r, i) { | |
| const o = function ND(n) { | |
| return n && n instanceof Tu || function OD(n) { | |
| return n && Ye(n.next) && Ye(n.error) && Ye(n.complete) | |
| }(n) && Ig(n) | |
| }(t) ? t : new os(t,r,i); | |
| return Ba( () => { | |
| const {operator: s, source: a} = this; | |
| o.add(s ? s.call(o, a) : a ? this._subscribe(o) : this._trySubscribe(o)) | |
| } | |
| ), | |
| o | |
| } | |
| _trySubscribe(t) { | |
| try { | |
| return this._subscribe(t) | |
| } catch (r) { | |
| t.error(r) | |
| } | |
| } | |
| forEach(t, r) { | |
| return new (r = Fg(r))( (i, o) => { | |
| const s = new os({ | |
| next: a => { | |
| try { | |
| t(a) | |
| } catch (l) { | |
| o(l), | |
| s.unsubscribe() | |
| } | |
| } | |
| , | |
| error: o, | |
| complete: i | |
| }); | |
| this.subscribe(s) | |
| } | |
| ) | |
| } | |
| _subscribe(t) { | |
| var r; | |
| return null === (r = this.source) || void 0 === r ? void 0 : r.subscribe(t) | |
| } | |
| [Du]() { | |
| return this | |
| } | |
| pipe(...t) { | |
| return Rg(t)(this) | |
| } | |
| toPromise(t) { | |
| return new (t = Fg(t))( (r, i) => { | |
| let o; | |
| this.subscribe(s => o = s, s => i(s), () => r(o)) | |
| } | |
| ) | |
| } | |
| } | |
| return n.create = e => new n(e), | |
| n | |
| } | |
| )(); | |
| function Fg(n) { | |
| var e; | |
| return null !== (e = null != n ? n : bi.Promise) && void 0 !== e ? e : Promise | |
| } | |
| const kD = is(n => function() { | |
| n(this), | |
| this.name = "ObjectUnsubscribedError", | |
| this.message = "object unsubscribed" | |
| } | |
| ); | |
| let un = ( () => { | |
| class n extends vt { | |
| constructor() { | |
| super(), | |
| this.closed = !1, | |
| this.currentObservers = null, | |
| this.observers = [], | |
| this.isStopped = !1, | |
| this.hasError = !1, | |
| this.thrownError = null | |
| } | |
| lift(t) { | |
| const r = new Pg(this,this); | |
| return r.operator = t, | |
| r | |
| } | |
| _throwIfClosed() { | |
| if (this.closed) | |
| throw new kD | |
| } | |
| next(t) { | |
| Ba( () => { | |
| if (this._throwIfClosed(), | |
| !this.isStopped) { | |
| this.currentObservers || (this.currentObservers = Array.from(this.observers)); | |
| for (const r of this.currentObservers) | |
| r.next(t) | |
| } | |
| } | |
| ) | |
| } | |
| error(t) { | |
| Ba( () => { | |
| if (this._throwIfClosed(), | |
| !this.isStopped) { | |
| this.hasError = this.isStopped = !0, | |
| this.thrownError = t; | |
| const {observers: r} = this; | |
| for (; r.length; ) | |
| r.shift().error(t) | |
| } | |
| } | |
| ) | |
| } | |
| complete() { | |
| Ba( () => { | |
| if (this._throwIfClosed(), | |
| !this.isStopped) { | |
| this.isStopped = !0; | |
| const {observers: t} = this; | |
| for (; t.length; ) | |
| t.shift().complete() | |
| } | |
| } | |
| ) | |
| } | |
| unsubscribe() { | |
| this.isStopped = this.closed = !0, | |
| this.observers = this.currentObservers = null | |
| } | |
| get observed() { | |
| var t; | |
| return (null === (t = this.observers) || void 0 === t ? void 0 : t.length) > 0 | |
| } | |
| _trySubscribe(t) { | |
| return this._throwIfClosed(), | |
| super._trySubscribe(t) | |
| } | |
| _subscribe(t) { | |
| return this._throwIfClosed(), | |
| this._checkFinalizedStatuses(t), | |
| this._innerSubscribe(t) | |
| } | |
| _innerSubscribe(t) { | |
| const {hasError: r, isStopped: i, observers: o} = this; | |
| return r || i ? Ag : (this.currentObservers = null, | |
| o.push(t), | |
| new mn( () => { | |
| this.currentObservers = null, | |
| Yi(o, t) | |
| } | |
| )) | |
| } | |
| _checkFinalizedStatuses(t) { | |
| const {hasError: r, thrownError: i, isStopped: o} = this; | |
| r ? t.error(i) : o && t.complete() | |
| } | |
| asObservable() { | |
| const t = new vt; | |
| return t.source = this, | |
| t | |
| } | |
| } | |
| return n.create = (e, t) => new Pg(e,t), | |
| n | |
| } | |
| )(); | |
| class Pg extends un { | |
| constructor(e, t) { | |
| super(), | |
| this.destination = e, | |
| this.source = t | |
| } | |
| next(e) { | |
| var t, r; | |
| null === (r = null === (t = this.destination) || void 0 === t ? void 0 : t.next) || void 0 === r || r.call(t, e) | |
| } | |
| error(e) { | |
| var t, r; | |
| null === (r = null === (t = this.destination) || void 0 === t ? void 0 : t.error) || void 0 === r || r.call(t, e) | |
| } | |
| complete() { | |
| var e, t; | |
| null === (t = null === (e = this.destination) || void 0 === e ? void 0 : e.complete) || void 0 === t || t.call(e) | |
| } | |
| _subscribe(e) { | |
| var t, r; | |
| return null !== (r = null === (t = this.source) || void 0 === t ? void 0 : t.subscribe(e)) && void 0 !== r ? r : Ag | |
| } | |
| } | |
| function Og(n) { | |
| return Ye(null == n ? void 0 : n.lift) | |
| } | |
| function bt(n) { | |
| return e => { | |
| if (Og(e)) | |
| return e.lift(function(t) { | |
| try { | |
| return n(t, this) | |
| } catch (r) { | |
| this.error(r) | |
| } | |
| }); | |
| throw new TypeError("Unable to lift unknown Observable type") | |
| } | |
| } | |
| function pt(n, e, t, r, i) { | |
| return new LD(n,e,t,r,i) | |
| } | |
| class LD extends Tu { | |
| constructor(e, t, r, i, o, s) { | |
| super(e), | |
| this.onFinalize = o, | |
| this.shouldUnsubscribe = s, | |
| this._next = t ? function(a) { | |
| try { | |
| t(a) | |
| } catch (l) { | |
| e.error(l) | |
| } | |
| } | |
| : super._next, | |
| this._error = i ? function(a) { | |
| try { | |
| i(a) | |
| } catch (l) { | |
| e.error(l) | |
| } finally { | |
| this.unsubscribe() | |
| } | |
| } | |
| : super._error, | |
| this._complete = r ? function() { | |
| try { | |
| r() | |
| } catch (a) { | |
| e.error(a) | |
| } finally { | |
| this.unsubscribe() | |
| } | |
| } | |
| : super._complete | |
| } | |
| unsubscribe() { | |
| var e; | |
| if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) { | |
| const {closed: t} = this; | |
| super.unsubscribe(), | |
| !t && (null === (e = this.onFinalize) || void 0 === e || e.call(this)) | |
| } | |
| } | |
| } | |
| function Fe(n, e) { | |
| return bt( (t, r) => { | |
| let i = 0; | |
| t.subscribe(pt(r, o => { | |
| r.next(n.call(e, o, i++)) | |
| } | |
| )) | |
| } | |
| ) | |
| } | |
| function Ht(n, e, t, r) { | |
| return new (t || (t = Promise))(function(o, s) { | |
| function a(u) { | |
| try { | |
| c(r.next(u)) | |
| } catch (d) { | |
| s(d) | |
| } | |
| } | |
| function l(u) { | |
| try { | |
| c(r.throw(u)) | |
| } catch (d) { | |
| s(d) | |
| } | |
| } | |
| function c(u) { | |
| u.done ? o(u.value) : function i(o) { | |
| return o instanceof t ? o : new t(function(s) { | |
| s(o) | |
| } | |
| ) | |
| }(u.value).then(a, l) | |
| } | |
| c((r = r.apply(n, e || [])).next()) | |
| } | |
| ) | |
| } | |
| function Kr(n) { | |
| return this instanceof Kr ? (this.v = n, | |
| this) : new Kr(n) | |
| } | |
| function kg(n, e, t) { | |
| if (!Symbol.asyncIterator) | |
| throw new TypeError("Symbol.asyncIterator is not defined."); | |
| var i, r = t.apply(n, e || []), o = []; | |
| return i = {}, | |
| s("next"), | |
| s("throw"), | |
| s("return"), | |
| i[Symbol.asyncIterator] = function() { | |
| return this | |
| } | |
| , | |
| i; | |
| function s(h) { | |
| r[h] && (i[h] = function(f) { | |
| return new Promise(function(p, _) { | |
| o.push([h, f, p, _]) > 1 || a(h, f) | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| function a(h, f) { | |
| try { | |
| !function l(h) { | |
| h.value instanceof Kr ? Promise.resolve(h.value.v).then(c, u) : d(o[0][2], h) | |
| }(r[h](f)) | |
| } catch (p) { | |
| d(o[0][3], p) | |
| } | |
| } | |
| function c(h) { | |
| a("next", h) | |
| } | |
| function u(h) { | |
| a("throw", h) | |
| } | |
| function d(h, f) { | |
| h(f), | |
| o.shift(), | |
| o.length && a(o[0][0], o[0][1]) | |
| } | |
| } | |
| function Lg(n) { | |
| if (!Symbol.asyncIterator) | |
| throw new TypeError("Symbol.asyncIterator is not defined."); | |
| var t, e = n[Symbol.asyncIterator]; | |
| return e ? e.call(n) : (n = function Su(n) { | |
| var e = "function" == typeof Symbol && Symbol.iterator | |
| , t = e && n[e] | |
| , r = 0; | |
| if (t) | |
| return t.call(n); | |
| if (n && "number" == typeof n.length) | |
| return { | |
| next: function() { | |
| return n && r >= n.length && (n = void 0), | |
| { | |
| value: n && n[r++], | |
| done: !n | |
| } | |
| } | |
| }; | |
| throw new TypeError(e ? "Object is not iterable." : "Symbol.iterator is not defined.") | |
| }(n), | |
| t = {}, | |
| r("next"), | |
| r("throw"), | |
| r("return"), | |
| t[Symbol.asyncIterator] = function() { | |
| return this | |
| } | |
| , | |
| t); | |
| function r(o) { | |
| t[o] = n[o] && function(s) { | |
| return new Promise(function(a, l) { | |
| !function i(o, s, a, l) { | |
| Promise.resolve(l).then(function(c) { | |
| o({ | |
| value: c, | |
| done: a | |
| }) | |
| }, s) | |
| }(a, l, (s = n[o](s)).done, s.value) | |
| } | |
| ) | |
| } | |
| } | |
| } | |
| "function" == typeof SuppressedError && SuppressedError; | |
| const Vg = n => n && "number" == typeof n.length && "function" != typeof n; | |
| function Bg(n) { | |
| return Ye(null == n ? void 0 : n.then) | |
| } | |
| function Ug(n) { | |
| return Ye(n[Du]) | |
| } | |
| function jg(n) { | |
| return Symbol.asyncIterator && Ye(null == n ? void 0 : n[Symbol.asyncIterator]) | |
| } | |
| function Hg(n) { | |
| return new TypeError(`You provided ${null !== n && "object" == typeof n ? "an invalid object" : `'${n}'`} where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.`) | |
| } | |
| const zg = function oM() { | |
| return "function" == typeof Symbol && Symbol.iterator ? Symbol.iterator : "@@iterator" | |
| }(); | |
| function $g(n) { | |
| return Ye(null == n ? void 0 : n[zg]) | |
| } | |
| function Wg(n) { | |
| return kg(this, arguments, function*() { | |
| const t = n.getReader(); | |
| try { | |
| for (; ; ) { | |
| const {value: r, done: i} = yield Kr(t.read()); | |
| if (i) | |
| return yield Kr(void 0); | |
| yield yield Kr(r) | |
| } | |
| } finally { | |
| t.releaseLock() | |
| } | |
| }) | |
| } | |
| function Gg(n) { | |
| return Ye(null == n ? void 0 : n.getReader) | |
| } | |
| function _n(n) { | |
| if (n instanceof vt) | |
| return n; | |
| if (null != n) { | |
| if (Ug(n)) | |
| return function sM(n) { | |
| return new vt(e => { | |
| const t = n[Du](); | |
| if (Ye(t.subscribe)) | |
| return t.subscribe(e); | |
| throw new TypeError("Provided object does not correctly implement Symbol.observable") | |
| } | |
| ) | |
| }(n); | |
| if (Vg(n)) | |
| return function aM(n) { | |
| return new vt(e => { | |
| for (let t = 0; t < n.length && !e.closed; t++) | |
| e.next(n[t]); | |
| e.complete() | |
| } | |
| ) | |
| }(n); | |
| if (Bg(n)) | |
| return function lM(n) { | |
| return new vt(e => { | |
| n.then(t => { | |
| e.closed || (e.next(t), | |
| e.complete()) | |
| } | |
| , t => e.error(t)).then(null, xg) | |
| } | |
| ) | |
| }(n); | |
| if (jg(n)) | |
| return qg(n); | |
| if ($g(n)) | |
| return function cM(n) { | |
| return new vt(e => { | |
| for (const t of n) | |
| if (e.next(t), | |
| e.closed) | |
| return; | |
| e.complete() | |
| } | |
| ) | |
| }(n); | |
| if (Gg(n)) | |
| return function uM(n) { | |
| return qg(Wg(n)) | |
| }(n) | |
| } | |
| throw Hg(n) | |
| } | |
| function qg(n) { | |
| return new vt(e => { | |
| (function dM(n, e) { | |
| var t, r, i, o; | |
| return Ht(this, void 0, void 0, function*() { | |
| try { | |
| for (t = Lg(n); !(r = yield t.next()).done; ) | |
| if (e.next(r.value), | |
| e.closed) | |
| return | |
| } catch (s) { | |
| i = { | |
| error: s | |
| } | |
| } finally { | |
| try { | |
| r && !r.done && (o = t.return) && (yield o.call(t)) | |
| } finally { | |
| if (i) | |
| throw i.error | |
| } | |
| } | |
| e.complete() | |
| }) | |
| } | |
| )(n, e).catch(t => e.error(t)) | |
| } | |
| ) | |
| } | |
| function Cr(n, e, t, r=0, i=!1) { | |
| const o = e.schedule(function() { | |
| t(), | |
| i ? n.add(this.schedule(null, r)) : this.unsubscribe() | |
| }, r); | |
| if (n.add(o), | |
| !i) | |
| return o | |
| } | |
| function Lt(n, e, t=1 / 0) { | |
| return Ye(e) ? Lt( (r, i) => Fe( (o, s) => e(r, o, i, s))(_n(n(r, i))), t) : ("number" == typeof e && (t = e), | |
| bt( (r, i) => function hM(n, e, t, r, i, o, s, a) { | |
| const l = []; | |
| let c = 0 | |
| , u = 0 | |
| , d = !1; | |
| const h = () => { | |
| d && !l.length && !c && e.complete() | |
| } | |
| , f = _ => c < r ? p(_) : l.push(_) | |
| , p = _ => { | |
| o && e.next(_), | |
| c++; | |
| let C = !1; | |
| _n(t(_, u++)).subscribe(pt(e, S => { | |
| null == i || i(S), | |
| o ? f(S) : e.next(S) | |
| } | |
| , () => { | |
| C = !0 | |
| } | |
| , void 0, () => { | |
| if (C) | |
| try { | |
| for (c--; l.length && c < r; ) { | |
| const S = l.shift(); | |
| s ? Cr(e, s, () => p(S)) : p(S) | |
| } | |
| h() | |
| } catch (S) { | |
| e.error(S) | |
| } | |
| } | |
| )) | |
| } | |
| ; | |
| return n.subscribe(pt(e, f, () => { | |
| d = !0, | |
| h() | |
| } | |
| )), | |
| () => { | |
| null == a || a() | |
| } | |
| }(r, i, n, t))) | |
| } | |
| function Zi(n=1 / 0) { | |
| return Lt(qr, n) | |
| } | |
| const Tr = new vt(n => n.complete()); | |
| function xu(n) { | |
| return n[n.length - 1] | |
| } | |
| function Kg(n) { | |
| return Ye(xu(n)) ? n.pop() : void 0 | |
| } | |
| function ss(n) { | |
| return function pM(n) { | |
| return n && Ye(n.schedule) | |
| }(xu(n)) ? n.pop() : void 0 | |
| } | |
| function Qg(n, e=0) { | |
| return bt( (t, r) => { | |
| t.subscribe(pt(r, i => Cr(r, n, () => r.next(i), e), () => Cr(r, n, () => r.complete(), e), i => Cr(r, n, () => r.error(i), e))) | |
| } | |
| ) | |
| } | |
| function Yg(n, e=0) { | |
| return bt( (t, r) => { | |
| r.add(n.schedule( () => t.subscribe(r), e)) | |
| } | |
| ) | |
| } | |
| function Zg(n, e) { | |
| if (!n) | |
| throw new Error("Iterable cannot be null"); | |
| return new vt(t => { | |
| Cr(t, e, () => { | |
| const r = n[Symbol.asyncIterator](); | |
| Cr(t, e, () => { | |
| r.next().then(i => { | |
| i.done ? t.complete() : t.next(i.value) | |
| } | |
| ) | |
| } | |
| , 0, !0) | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| function wt(n, e) { | |
| return e ? function CM(n, e) { | |
| if (null != n) { | |
| if (Ug(n)) | |
| return function mM(n, e) { | |
| return _n(n).pipe(Yg(e), Qg(e)) | |
| }(n, e); | |
| if (Vg(n)) | |
| return function yM(n, e) { | |
| return new vt(t => { | |
| let r = 0; | |
| return e.schedule(function() { | |
| r === n.length ? t.complete() : (t.next(n[r++]), | |
| t.closed || this.schedule()) | |
| }) | |
| } | |
| ) | |
| }(n, e); | |
| if (Bg(n)) | |
| return function _M(n, e) { | |
| return _n(n).pipe(Yg(e), Qg(e)) | |
| }(n, e); | |
| if (jg(n)) | |
| return Zg(n, e); | |
| if ($g(n)) | |
| return function vM(n, e) { | |
| return new vt(t => { | |
| let r; | |
| return Cr(t, e, () => { | |
| r = n[zg](), | |
| Cr(t, e, () => { | |
| let i, o; | |
| try { | |
| ({value: i, done: o} = r.next()) | |
| } catch (s) { | |
| return void t.error(s) | |
| } | |
| o ? t.complete() : t.next(i) | |
| } | |
| , 0, !0) | |
| } | |
| ), | |
| () => Ye(null == r ? void 0 : r.return) && r.return() | |
| } | |
| ) | |
| }(n, e); | |
| if (Gg(n)) | |
| return function bM(n, e) { | |
| return Zg(Wg(n), e) | |
| }(n, e) | |
| } | |
| throw Hg(n) | |
| }(n, e) : _n(n) | |
| } | |
| function Ru(n, e, ...t) { | |
| if (!0 === e) | |
| return void n(); | |
| if (!1 === e) | |
| return; | |
| const r = new os({ | |
| next: () => { | |
| r.unsubscribe(), | |
| n() | |
| } | |
| }); | |
| return _n(e(...t)).subscribe(r) | |
| } | |
| function We(n) { | |
| for (let e in n) | |
| if (n[e] === We) | |
| return e; | |
| throw Error("Could not find renamed property on target object.") | |
| } | |
| function Fu(n, e) { | |
| for (const t in e) | |
| e.hasOwnProperty(t) && !n.hasOwnProperty(t) && (n[t] = e[t]) | |
| } | |
| function Ge(n) { | |
| if ("string" == typeof n) | |
| return n; | |
| if (Array.isArray(n)) | |
| return "[" + n.map(Ge).join(", ") + "]"; | |
| if (null == n) | |
| return "" + n; | |
| if (n.overriddenName) | |
| return `${n.overriddenName}`; | |
| if (n.name) | |
| return `${n.name}`; | |
| const e = n.toString(); | |
| if (null == e) | |
| return "" + e; | |
| const t = e.indexOf("\n"); | |
| return -1 === t ? e : e.substring(0, t) | |
| } | |
| function Pu(n, e) { | |
| return null == n || "" === n ? null === e ? "" : e : null == e || "" === e ? n : n + " " + e | |
| } | |
| const wM = We({ | |
| __forward_ref__: We | |
| }); | |
| function qe(n) { | |
| return n.__forward_ref__ = qe, | |
| n.toString = function() { | |
| return Ge(this()) | |
| } | |
| , | |
| n | |
| } | |
| function ge(n) { | |
| return Ou(n) ? n() : n | |
| } | |
| function Ou(n) { | |
| return "function" == typeof n && n.hasOwnProperty(wM) && n.__forward_ref__ === qe | |
| } | |
| class U extends Error { | |
| constructor(e, t) { | |
| super(function ja(n, e) { | |
| return `NG0${Math.abs(n)}${e ? ": " + e.trim() : ""}` | |
| }(e, t)), | |
| this.code = e | |
| } | |
| } | |
| function ye(n) { | |
| return "string" == typeof n ? n : null == n ? "" : String(n) | |
| } | |
| function Ha(n, e) { | |
| throw new U(-201,!1) | |
| } | |
| function vn(n, e) { | |
| null == n && function Be(n, e, t, r) { | |
| throw new Error(`ASSERTION ERROR: ${n}` + (null == r ? "" : ` [Expected=> ${t} ${r} ${e} <=Actual]`)) | |
| }(e, n, null, "!=") | |
| } | |
| function se(n) { | |
| return { | |
| token: n.token, | |
| providedIn: n.providedIn || null, | |
| factory: n.factory, | |
| value: void 0 | |
| } | |
| } | |
| function lt(n) { | |
| return { | |
| providers: n.providers || [], | |
| imports: n.imports || [] | |
| } | |
| } | |
| function za(n) { | |
| return Xg(n, $a) || Xg(n, em) | |
| } | |
| function Xg(n, e) { | |
| return n.hasOwnProperty(e) ? n[e] : null | |
| } | |
| function Jg(n) { | |
| return n && (n.hasOwnProperty(Nu) || n.hasOwnProperty(PM)) ? n[Nu] : null | |
| } | |
| const $a = We({ | |
| \u0275prov: We | |
| }) | |
| , Nu = We({ | |
| \u0275inj: We | |
| }) | |
| , em = We({ | |
| ngInjectableDef: We | |
| }) | |
| , PM = We({ | |
| ngInjectorDef: We | |
| }); | |
| var he = ( () => ((he = he || {})[he.Default = 0] = "Default", | |
| he[he.Host = 1] = "Host", | |
| he[he.Self = 2] = "Self", | |
| he[he.SkipSelf = 4] = "SkipSelf", | |
| he[he.Optional = 8] = "Optional", | |
| he))(); | |
| let ku; | |
| function Rn(n) { | |
| const e = ku; | |
| return ku = n, | |
| e | |
| } | |
| function tm(n, e, t) { | |
| const r = za(n); | |
| return r && "root" == r.providedIn ? void 0 === r.value ? r.value = r.factory() : r.value : t & he.Optional ? null : void 0 !== e ? e : void Ha(Ge(n)) | |
| } | |
| function Qr(n) { | |
| return { | |
| toString: n | |
| }.toString() | |
| } | |
| var Wn = ( () => ((Wn = Wn || {})[Wn.OnPush = 0] = "OnPush", | |
| Wn[Wn.Default = 1] = "Default", | |
| Wn))() | |
| , Gn = ( () => { | |
| return (n = Gn || (Gn = {}))[n.Emulated = 0] = "Emulated", | |
| n[n.None = 2] = "None", | |
| n[n.ShadowDom = 3] = "ShadowDom", | |
| Gn; | |
| var n | |
| } | |
| )(); | |
| const Ze = ( () => "undefined" != typeof globalThis && globalThis || "undefined" != typeof global && global || "undefined" != typeof window && window || "undefined" != typeof self && "undefined" != typeof WorkerGlobalScope && self instanceof WorkerGlobalScope && self)() | |
| , Xi = {} | |
| , Ne = [] | |
| , Wa = We({ | |
| \u0275cmp: We | |
| }) | |
| , Lu = We({ | |
| \u0275dir: We | |
| }) | |
| , Vu = We({ | |
| \u0275pipe: We | |
| }) | |
| , nm = We({ | |
| \u0275mod: We | |
| }) | |
| , wr = We({ | |
| \u0275fac: We | |
| }) | |
| , as = We({ | |
| __NG_ELEMENT_ID__: We | |
| }); | |
| let NM = 0; | |
| function dn(n) { | |
| return Qr( () => { | |
| const t = !0 === n.standalone | |
| , r = {} | |
| , i = { | |
| type: n.type, | |
| providersResolver: null, | |
| decls: n.decls, | |
| vars: n.vars, | |
| factory: null, | |
| template: n.template || null, | |
| consts: n.consts || null, | |
| ngContentSelectors: n.ngContentSelectors, | |
| hostBindings: n.hostBindings || null, | |
| hostVars: n.hostVars || 0, | |
| hostAttrs: n.hostAttrs || null, | |
| contentQueries: n.contentQueries || null, | |
| declaredInputs: r, | |
| inputs: null, | |
| outputs: null, | |
| exportAs: n.exportAs || null, | |
| onPush: n.changeDetection === Wn.OnPush, | |
| directiveDefs: null, | |
| pipeDefs: null, | |
| standalone: t, | |
| dependencies: t && n.dependencies || null, | |
| getStandaloneInjector: null, | |
| selectors: n.selectors || Ne, | |
| viewQuery: n.viewQuery || null, | |
| features: n.features || null, | |
| data: n.data || {}, | |
| encapsulation: n.encapsulation || Gn.Emulated, | |
| id: "c" + NM++, | |
| styles: n.styles || Ne, | |
| _: null, | |
| setInput: null, | |
| schemas: n.schemas || null, | |
| tView: null | |
| } | |
| , o = n.dependencies | |
| , s = n.features; | |
| return i.inputs = om(n.inputs, r), | |
| i.outputs = om(n.outputs), | |
| s && s.forEach(a => a(i)), | |
| i.directiveDefs = o ? () => ("function" == typeof o ? o() : o).map(rm).filter(im) : null, | |
| i.pipeDefs = o ? () => ("function" == typeof o ? o() : o).map(Xt).filter(im) : null, | |
| i | |
| } | |
| ) | |
| } | |
| function rm(n) { | |
| return ze(n) || Zt(n) | |
| } | |
| function im(n) { | |
| return null !== n | |
| } | |
| function gt(n) { | |
| return Qr( () => ({ | |
| type: n.type, | |
| bootstrap: n.bootstrap || Ne, | |
| declarations: n.declarations || Ne, | |
| imports: n.imports || Ne, | |
| exports: n.exports || Ne, | |
| transitiveCompileScopes: null, | |
| schemas: n.schemas || null, | |
| id: n.id || null | |
| })) | |
| } | |
| function om(n, e) { | |
| if (null == n) | |
| return Xi; | |
| const t = {}; | |
| for (const r in n) | |
| if (n.hasOwnProperty(r)) { | |
| let i = n[r] | |
| , o = i; | |
| Array.isArray(i) && (o = i[1], | |
| i = i[0]), | |
| t[i] = r, | |
| e && (e[i] = o) | |
| } | |
| return t | |
| } | |
| const ue = dn; | |
| function ze(n) { | |
| return n[Wa] || null | |
| } | |
| function Zt(n) { | |
| return n[Lu] || null | |
| } | |
| function Xt(n) { | |
| return n[Vu] || null | |
| } | |
| function bn(n, e) { | |
| const t = n[nm] || null; | |
| if (!t && !0 === e) | |
| throw new Error(`Type ${Ge(n)} does not have '\u0275mod' property.`); | |
| return t | |
| } | |
| function fn(n) { | |
| return Array.isArray(n) && "object" == typeof n[1] | |
| } | |
| function Kn(n) { | |
| return Array.isArray(n) && !0 === n[1] | |
| } | |
| function ju(n) { | |
| return 0 != (8 & n.flags) | |
| } | |
| function Qa(n) { | |
| return 2 == (2 & n.flags) | |
| } | |
| function Ya(n) { | |
| return 1 == (1 & n.flags) | |
| } | |
| function Qn(n) { | |
| return null !== n.template | |
| } | |
| function jM(n) { | |
| return 0 != (256 & n[2]) | |
| } | |
| function Mi(n, e) { | |
| return n.hasOwnProperty(wr) ? n[wr] : null | |
| } | |
| class $M { | |
| constructor(e, t, r) { | |
| this.previousValue = e, | |
| this.currentValue = t, | |
| this.firstChange = r | |
| } | |
| isFirstChange() { | |
| return this.firstChange | |
| } | |
| } | |
| function Tn() { | |
| return lm | |
| } | |
| function lm(n) { | |
| return n.type.prototype.ngOnChanges && (n.setInput = GM), | |
| WM | |
| } | |
| function WM() { | |
| const n = um(this) | |
| , e = null == n ? void 0 : n.current; | |
| if (e) { | |
| const t = n.previous; | |
| if (t === Xi) | |
| n.previous = e; | |
| else | |
| for (let r in e) | |
| t[r] = e[r]; | |
| n.current = null, | |
| this.ngOnChanges(e) | |
| } | |
| } | |
| function GM(n, e, t, r) { | |
| const i = um(n) || function qM(n, e) { | |
| return n[cm] = e | |
| }(n, { | |
| previous: Xi, | |
| current: null | |
| }) | |
| , o = i.current || (i.current = {}) | |
| , s = i.previous | |
| , a = this.declaredInputs[t] | |
| , l = s[a]; | |
| o[a] = new $M(l && l.currentValue,e,s === Xi), | |
| n[r] = e | |
| } | |
| Tn.ngInherit = !0; | |
| const cm = "__ngSimpleChanges__"; | |
| function um(n) { | |
| return n[cm] || null | |
| } | |
| function Dt(n) { | |
| for (; Array.isArray(n); ) | |
| n = n[0]; | |
| return n | |
| } | |
| function Za(n, e) { | |
| return Dt(e[n]) | |
| } | |
| function En(n, e) { | |
| return Dt(e[n.index]) | |
| } | |
| function Gu(n, e) { | |
| return n.data[e] | |
| } | |
| function wn(n, e) { | |
| const t = e[n]; | |
| return fn(t) ? t : t[0] | |
| } | |
| function Xa(n) { | |
| return 64 == (64 & n[2]) | |
| } | |
| function Yr(n, e) { | |
| return null == e ? null : n[e] | |
| } | |
| function dm(n) { | |
| n[18] = 0 | |
| } | |
| function qu(n, e) { | |
| n[5] += e; | |
| let t = n | |
| , r = n[3]; | |
| for (; null !== r && (1 === e && 1 === t[5] || -1 === e && 0 === t[5]); ) | |
| r[5] += e, | |
| t = r, | |
| r = r[3] | |
| } | |
| const me = { | |
| lFrame: Cm(null), | |
| bindingsEnabled: !0 | |
| }; | |
| function fm() { | |
| return me.bindingsEnabled | |
| } | |
| function H() { | |
| return me.lFrame.lView | |
| } | |
| function Pe() { | |
| return me.lFrame.tView | |
| } | |
| function Ue(n) { | |
| return me.lFrame.contextLView = n, | |
| n[8] | |
| } | |
| function je(n) { | |
| return me.lFrame.contextLView = null, | |
| n | |
| } | |
| function St() { | |
| let n = pm(); | |
| for (; null !== n && 64 === n.type; ) | |
| n = n.parent; | |
| return n | |
| } | |
| function pm() { | |
| return me.lFrame.currentTNode | |
| } | |
| function lr(n, e) { | |
| const t = me.lFrame; | |
| t.currentTNode = n, | |
| t.isParent = e | |
| } | |
| function Ku() { | |
| return me.lFrame.isParent | |
| } | |
| function Qu() { | |
| me.lFrame.isParent = !1 | |
| } | |
| function io() { | |
| return me.lFrame.bindingIndex++ | |
| } | |
| function lA(n, e) { | |
| const t = me.lFrame; | |
| t.bindingIndex = t.bindingRootIndex = n, | |
| Yu(e) | |
| } | |
| function Yu(n) { | |
| me.lFrame.currentDirectiveIndex = n | |
| } | |
| function ym() { | |
| return me.lFrame.currentQueryIndex | |
| } | |
| function Xu(n) { | |
| me.lFrame.currentQueryIndex = n | |
| } | |
| function uA(n) { | |
| const e = n[1]; | |
| return 2 === e.type ? e.declTNode : 1 === e.type ? n[6] : null | |
| } | |
| function vm(n, e, t) { | |
| if (t & he.SkipSelf) { | |
| let i = e | |
| , o = n; | |
| for (; !(i = i.parent, | |
| null !== i || t & he.Host || (i = uA(o), | |
| null === i || (o = o[15], | |
| 10 & i.type))); ) | |
| ; | |
| if (null === i) | |
| return !1; | |
| e = i, | |
| n = o | |
| } | |
| const r = me.lFrame = bm(); | |
| return r.currentTNode = e, | |
| r.lView = n, | |
| !0 | |
| } | |
| function Ju(n) { | |
| const e = bm() | |
| , t = n[1]; | |
| me.lFrame = e, | |
| e.currentTNode = t.firstChild, | |
| e.lView = n, | |
| e.tView = t, | |
| e.contextLView = n, | |
| e.bindingIndex = t.bindingStartIndex, | |
| e.inI18n = !1 | |
| } | |
| function bm() { | |
| const n = me.lFrame | |
| , e = null === n ? null : n.child; | |
| return null === e ? Cm(n) : e | |
| } | |
| function Cm(n) { | |
| const e = { | |
| currentTNode: null, | |
| isParent: !0, | |
| lView: null, | |
| tView: null, | |
| selectedIndex: -1, | |
| contextLView: null, | |
| elementDepthCount: 0, | |
| currentNamespace: null, | |
| currentDirectiveIndex: -1, | |
| bindingRootIndex: -1, | |
| bindingIndex: -1, | |
| currentQueryIndex: 0, | |
| parent: n, | |
| child: null, | |
| inI18n: !1 | |
| }; | |
| return null !== n && (n.child = e), | |
| e | |
| } | |
| function Tm() { | |
| const n = me.lFrame; | |
| return me.lFrame = n.parent, | |
| n.currentTNode = null, | |
| n.lView = null, | |
| n | |
| } | |
| const Em = Tm; | |
| function ed() { | |
| const n = Tm(); | |
| n.isParent = !0, | |
| n.tView = null, | |
| n.selectedIndex = -1, | |
| n.contextLView = null, | |
| n.elementDepthCount = 0, | |
| n.currentDirectiveIndex = -1, | |
| n.currentNamespace = null, | |
| n.bindingRootIndex = -1, | |
| n.bindingIndex = -1, | |
| n.currentQueryIndex = 0 | |
| } | |
| function en() { | |
| return me.lFrame.selectedIndex | |
| } | |
| function Zr(n) { | |
| me.lFrame.selectedIndex = n | |
| } | |
| function ct() { | |
| const n = me.lFrame; | |
| return Gu(n.tView, n.selectedIndex) | |
| } | |
| function Ja(n, e) { | |
| for (let t = e.directiveStart, r = e.directiveEnd; t < r; t++) { | |
| const o = n.data[t].type.prototype | |
| , {ngAfterContentInit: s, ngAfterContentChecked: a, ngAfterViewInit: l, ngAfterViewChecked: c, ngOnDestroy: u} = o; | |
| s && (n.contentHooks || (n.contentHooks = [])).push(-t, s), | |
| a && ((n.contentHooks || (n.contentHooks = [])).push(t, a), | |
| (n.contentCheckHooks || (n.contentCheckHooks = [])).push(t, a)), | |
| l && (n.viewHooks || (n.viewHooks = [])).push(-t, l), | |
| c && ((n.viewHooks || (n.viewHooks = [])).push(t, c), | |
| (n.viewCheckHooks || (n.viewCheckHooks = [])).push(t, c)), | |
| null != u && (n.destroyHooks || (n.destroyHooks = [])).push(t, u) | |
| } | |
| } | |
| function el(n, e, t) { | |
| wm(n, e, 3, t) | |
| } | |
| function tl(n, e, t, r) { | |
| (3 & n[2]) === t && wm(n, e, t, r) | |
| } | |
| function td(n, e) { | |
| let t = n[2]; | |
| (3 & t) === e && (t &= 2047, | |
| t += 1, | |
| n[2] = t) | |
| } | |
| function wm(n, e, t, r) { | |
| const o = null != r ? r : -1 | |
| , s = e.length - 1; | |
| let a = 0; | |
| for (let l = void 0 !== r ? 65535 & n[18] : 0; l < s; l++) | |
| if ("number" == typeof e[l + 1]) { | |
| if (a = e[l], | |
| null != r && a >= r) | |
| break | |
| } else | |
| e[l] < 0 && (n[18] += 65536), | |
| (a < o || -1 == o) && (vA(n, t, e, l), | |
| n[18] = (4294901760 & n[18]) + l + 2), | |
| l++ | |
| } | |
| function vA(n, e, t, r) { | |
| const i = t[r] < 0 | |
| , o = t[r + 1] | |
| , a = n[i ? -t[r] : t[r]]; | |
| if (i) { | |
| if (n[2] >> 11 < n[18] >> 16 && (3 & n[2]) === e) { | |
| n[2] += 2048; | |
| try { | |
| o.call(a) | |
| } finally {} | |
| } | |
| } else | |
| try { | |
| o.call(a) | |
| } finally {} | |
| } | |
| class fs { | |
| constructor(e, t, r) { | |
| this.factory = e, | |
| this.resolving = !1, | |
| this.canSeeViewProviders = t, | |
| this.injectImpl = r | |
| } | |
| } | |
| function nl(n, e, t) { | |
| let r = 0; | |
| for (; r < t.length; ) { | |
| const i = t[r]; | |
| if ("number" == typeof i) { | |
| if (0 !== i) | |
| break; | |
| r++; | |
| const o = t[r++] | |
| , s = t[r++] | |
| , a = t[r++]; | |
| n.setAttribute(e, s, a, o) | |
| } else { | |
| const o = i | |
| , s = t[++r]; | |
| Mm(o) ? n.setProperty(e, o, s) : n.setAttribute(e, o, s), | |
| r++ | |
| } | |
| } | |
| return r | |
| } | |
| function Dm(n) { | |
| return 3 === n || 4 === n || 6 === n | |
| } | |
| function Mm(n) { | |
| return 64 === n.charCodeAt(0) | |
| } | |
| function rl(n, e) { | |
| if (null !== e && 0 !== e.length) | |
| if (null === n || 0 === n.length) | |
| n = e.slice(); | |
| else { | |
| let t = -1; | |
| for (let r = 0; r < e.length; r++) { | |
| const i = e[r]; | |
| "number" == typeof i ? t = i : 0 === t || Am(n, t, i, null, -1 === t || 2 === t ? e[++r] : null) | |
| } | |
| } | |
| return n | |
| } | |
| function Am(n, e, t, r, i) { | |
| let o = 0 | |
| , s = n.length; | |
| if (-1 === e) | |
| s = -1; | |
| else | |
| for (; o < n.length; ) { | |
| const a = n[o++]; | |
| if ("number" == typeof a) { | |
| if (a === e) { | |
| s = -1; | |
| break | |
| } | |
| if (a > e) { | |
| s = o - 1; | |
| break | |
| } | |
| } | |
| } | |
| for (; o < n.length; ) { | |
| const a = n[o]; | |
| if ("number" == typeof a) | |
| break; | |
| if (a === t) { | |
| if (null === r) | |
| return void (null !== i && (n[o + 1] = i)); | |
| if (r === n[o + 1]) | |
| return void (n[o + 2] = i) | |
| } | |
| o++, | |
| null !== r && o++, | |
| null !== i && o++ | |
| } | |
| -1 !== s && (n.splice(s, 0, e), | |
| o = s + 1), | |
| n.splice(o++, 0, t), | |
| null !== r && n.splice(o++, 0, r), | |
| null !== i && n.splice(o++, 0, i) | |
| } | |
| function Im(n) { | |
| return -1 !== n | |
| } | |
| function oo(n) { | |
| return 32767 & n | |
| } | |
| function so(n, e) { | |
| let t = function wA(n) { | |
| return n >> 16 | |
| }(n) | |
| , r = e; | |
| for (; t > 0; ) | |
| r = r[15], | |
| t--; | |
| return r | |
| } | |
| let rd = !0; | |
| function il(n) { | |
| const e = rd; | |
| return rd = n, | |
| e | |
| } | |
| let DA = 0; | |
| const cr = {}; | |
| function gs(n, e) { | |
| const t = od(n, e); | |
| if (-1 !== t) | |
| return t; | |
| const r = e[1]; | |
| r.firstCreatePass && (n.injectorIndex = e.length, | |
| id(r.data, n), | |
| id(e, null), | |
| id(r.blueprint, null)); | |
| const i = ol(n, e) | |
| , o = n.injectorIndex; | |
| if (Im(i)) { | |
| const s = oo(i) | |
| , a = so(i, e) | |
| , l = a[1].data; | |
| for (let c = 0; c < 8; c++) | |
| e[o + c] = a[s + c] | l[s + c] | |
| } | |
| return e[o + 8] = i, | |
| o | |
| } | |
| function id(n, e) { | |
| n.push(0, 0, 0, 0, 0, 0, 0, 0, e) | |
| } | |
| function od(n, e) { | |
| return -1 === n.injectorIndex || n.parent && n.parent.injectorIndex === n.injectorIndex || null === e[n.injectorIndex + 8] ? -1 : n.injectorIndex | |
| } | |
| function ol(n, e) { | |
| if (n.parent && -1 !== n.parent.injectorIndex) | |
| return n.parent.injectorIndex; | |
| let t = 0 | |
| , r = null | |
| , i = e; | |
| for (; null !== i; ) { | |
| if (r = Lm(i), | |
| null === r) | |
| return -1; | |
| if (t++, | |
| i = i[15], | |
| -1 !== r.injectorIndex) | |
| return r.injectorIndex | t << 16 | |
| } | |
| return -1 | |
| } | |
| function sl(n, e, t) { | |
| !function MA(n, e, t) { | |
| let r; | |
| "string" == typeof t ? r = t.charCodeAt(0) || 0 : t.hasOwnProperty(as) && (r = t[as]), | |
| null == r && (r = t[as] = DA++); | |
| const i = 255 & r; | |
| e.data[n + (i >> 5)] |= 1 << i | |
| }(n, e, t) | |
| } | |
| function Rm(n, e, t) { | |
| if (t & he.Optional || void 0 !== n) | |
| return n; | |
| Ha() | |
| } | |
| function Fm(n, e, t, r) { | |
| if (t & he.Optional && void 0 === r && (r = null), | |
| 0 == (t & (he.Self | he.Host))) { | |
| const i = n[9] | |
| , o = Rn(void 0); | |
| try { | |
| return i ? i.get(e, r, t & he.Optional) : tm(e, r, t & he.Optional) | |
| } finally { | |
| Rn(o) | |
| } | |
| } | |
| return Rm(r, 0, t) | |
| } | |
| function Pm(n, e, t, r=he.Default, i) { | |
| if (null !== n) { | |
| if (1024 & e[2]) { | |
| const s = function RA(n, e, t, r, i) { | |
| let o = n | |
| , s = e; | |
| for (; null !== o && null !== s && 1024 & s[2] && !(256 & s[2]); ) { | |
| const a = Om(o, s, t, r | he.Self, cr); | |
| if (a !== cr) | |
| return a; | |
| let l = o.parent; | |
| if (!l) { | |
| const c = s[21]; | |
| if (c) { | |
| const u = c.get(t, cr, r); | |
| if (u !== cr) | |
| return u | |
| } | |
| l = Lm(s), | |
| s = s[15] | |
| } | |
| o = l | |
| } | |
| return i | |
| }(n, e, t, r, cr); | |
| if (s !== cr) | |
| return s | |
| } | |
| const o = Om(n, e, t, r, cr); | |
| if (o !== cr) | |
| return o | |
| } | |
| return Fm(e, t, r, i) | |
| } | |
| function Om(n, e, t, r, i) { | |
| const o = function SA(n) { | |
| if ("string" == typeof n) | |
| return n.charCodeAt(0) || 0; | |
| const e = n.hasOwnProperty(as) ? n[as] : void 0; | |
| return "number" == typeof e ? e >= 0 ? 255 & e : xA : e | |
| }(t); | |
| if ("function" == typeof o) { | |
| if (!vm(e, n, r)) | |
| return r & he.Host ? Rm(i, 0, r) : Fm(e, t, r, i); | |
| try { | |
| const s = o(r); | |
| if (null != s || r & he.Optional) | |
| return s; | |
| Ha() | |
| } finally { | |
| Em() | |
| } | |
| } else if ("number" == typeof o) { | |
| let s = null | |
| , a = od(n, e) | |
| , l = -1 | |
| , c = r & he.Host ? e[16][6] : null; | |
| for ((-1 === a || r & he.SkipSelf) && (l = -1 === a ? ol(n, e) : e[a + 8], | |
| -1 !== l && km(r, !1) ? (s = e[1], | |
| a = oo(l), | |
| e = so(l, e)) : a = -1); -1 !== a; ) { | |
| const u = e[1]; | |
| if (Nm(o, a, u.data)) { | |
| const d = IA(a, e, t, s, r, c); | |
| if (d !== cr) | |
| return d | |
| } | |
| l = e[a + 8], | |
| -1 !== l && km(r, e[1].data[a + 8] === c) && Nm(o, a, e) ? (s = u, | |
| a = oo(l), | |
| e = so(l, e)) : a = -1 | |
| } | |
| } | |
| return i | |
| } | |
| function IA(n, e, t, r, i, o) { | |
| const s = e[1] | |
| , a = s.data[n + 8] | |
| , u = al(a, s, t, null == r ? Qa(a) && rd : r != s && 0 != (3 & a.type), i & he.Host && o === a); | |
| return null !== u ? ms(e, s, u, a) : cr | |
| } | |
| function al(n, e, t, r, i) { | |
| const o = n.providerIndexes | |
| , s = e.data | |
| , a = 1048575 & o | |
| , l = n.directiveStart | |
| , u = o >> 20 | |
| , h = i ? a + u : n.directiveEnd; | |
| for (let f = r ? a : a + u; f < h; f++) { | |
| const p = s[f]; | |
| if (f < l && t === p || f >= l && p.type === t) | |
| return f | |
| } | |
| if (i) { | |
| const f = s[l]; | |
| if (f && Qn(f) && f.type === t) | |
| return l | |
| } | |
| return null | |
| } | |
| function ms(n, e, t, r) { | |
| let i = n[t]; | |
| const o = e.data; | |
| if (function bA(n) { | |
| return n instanceof fs | |
| }(i)) { | |
| const s = i; | |
| s.resolving && function DM(n, e) { | |
| const t = e ? `. Dependency path: ${e.join(" > ")} > ${n}` : ""; | |
| throw new U(-200,`Circular dependency in DI detected for ${n}${t}`) | |
| }(function Oe(n) { | |
| return "function" == typeof n ? n.name || n.toString() : "object" == typeof n && null != n && "function" == typeof n.type ? n.type.name || n.type.toString() : ye(n) | |
| }(o[t])); | |
| const a = il(s.canSeeViewProviders); | |
| s.resolving = !0; | |
| const l = s.injectImpl ? Rn(s.injectImpl) : null; | |
| vm(n, r, he.Default); | |
| try { | |
| i = n[t] = s.factory(void 0, o, n, r), | |
| e.firstCreatePass && t >= r.directiveStart && function yA(n, e, t) { | |
| const {ngOnChanges: r, ngOnInit: i, ngDoCheck: o} = e.type.prototype; | |
| if (r) { | |
| const s = lm(e); | |
| (t.preOrderHooks || (t.preOrderHooks = [])).push(n, s), | |
| (t.preOrderCheckHooks || (t.preOrderCheckHooks = [])).push(n, s) | |
| } | |
| i && (t.preOrderHooks || (t.preOrderHooks = [])).push(0 - n, i), | |
| o && ((t.preOrderHooks || (t.preOrderHooks = [])).push(n, o), | |
| (t.preOrderCheckHooks || (t.preOrderCheckHooks = [])).push(n, o)) | |
| }(t, o[t], e) | |
| } finally { | |
| null !== l && Rn(l), | |
| il(a), | |
| s.resolving = !1, | |
| Em() | |
| } | |
| } | |
| return i | |
| } | |
| function Nm(n, e, t) { | |
| return !!(t[e + (n >> 5)] & 1 << n) | |
| } | |
| function km(n, e) { | |
| return !(n & he.Self || n & he.Host && e) | |
| } | |
| class ao { | |
| constructor(e, t) { | |
| this._tNode = e, | |
| this._lView = t | |
| } | |
| get(e, t, r) { | |
| return Pm(this._tNode, this._lView, e, r, t) | |
| } | |
| } | |
| function xA() { | |
| return new ao(St(),H()) | |
| } | |
| function sd(n) { | |
| return Ou(n) ? () => { | |
| const e = sd(ge(n)); | |
| return e && e() | |
| } | |
| : Mi(n) | |
| } | |
| function Lm(n) { | |
| const e = n[1] | |
| , t = e.type; | |
| return 2 === t ? e.declTNode : 1 === t ? n[6] : null | |
| } | |
| function lo(n) { | |
| return function AA(n, e) { | |
| if ("class" === e) | |
| return n.classes; | |
| if ("style" === e) | |
| return n.styles; | |
| const t = n.attrs; | |
| if (t) { | |
| const r = t.length; | |
| let i = 0; | |
| for (; i < r; ) { | |
| const o = t[i]; | |
| if (Dm(o)) | |
| break; | |
| if (0 === o) | |
| i += 2; | |
| else if ("number" == typeof o) | |
| for (i++; i < r && "string" == typeof t[i]; ) | |
| i++; | |
| else { | |
| if (o === e) | |
| return t[i + 1]; | |
| i += 2 | |
| } | |
| } | |
| } | |
| return null | |
| }(St(), n) | |
| } | |
| const uo = "__parameters__"; | |
| function fo(n, e, t) { | |
| return Qr( () => { | |
| const r = function ad(n) { | |
| return function(...t) { | |
| if (n) { | |
| const r = n(...t); | |
| for (const i in r) | |
| this[i] = r[i] | |
| } | |
| } | |
| }(e); | |
| function i(...o) { | |
| if (this instanceof i) | |
| return r.apply(this, o), | |
| this; | |
| const s = new i(...o); | |
| return a.annotation = s, | |
| a; | |
| function a(l, c, u) { | |
| const d = l.hasOwnProperty(uo) ? l[uo] : Object.defineProperty(l, uo, { | |
| value: [] | |
| })[uo]; | |
| for (; d.length <= u; ) | |
| d.push(null); | |
| return (d[u] = d[u] || []).push(s), | |
| l | |
| } | |
| } | |
| return t && (i.prototype = Object.create(t.prototype)), | |
| i.prototype.ngMetadataName = n, | |
| i.annotationCls = i, | |
| i | |
| } | |
| ) | |
| } | |
| class ee { | |
| constructor(e, t) { | |
| this._desc = e, | |
| this.ngMetadataName = "InjectionToken", | |
| this.\u0275prov = void 0, | |
| "number" == typeof t ? this.__NG_ELEMENT_ID__ = t : void 0 !== t && (this.\u0275prov = se({ | |
| token: this, | |
| providedIn: t.providedIn || "root", | |
| factory: t.factory | |
| })) | |
| } | |
| get multi() { | |
| return this | |
| } | |
| toString() { | |
| return `InjectionToken ${this._desc}` | |
| } | |
| } | |
| function Dn(n, e) { | |
| void 0 === e && (e = n); | |
| for (let t = 0; t < n.length; t++) { | |
| let r = n[t]; | |
| Array.isArray(r) ? (e === n && (e = n.slice(0, t)), | |
| Dn(r, e)) : e !== n && e.push(r) | |
| } | |
| return e | |
| } | |
| function Ar(n, e) { | |
| n.forEach(t => Array.isArray(t) ? Ar(t, e) : e(t)) | |
| } | |
| function Bm(n, e, t) { | |
| e >= n.length ? n.push(t) : n.splice(e, 0, t) | |
| } | |
| function ll(n, e) { | |
| return e >= n.length - 1 ? n.pop() : n.splice(e, 1)[0] | |
| } | |
| function vs(n, e) { | |
| const t = []; | |
| for (let r = 0; r < n; r++) | |
| t.push(e); | |
| return t | |
| } | |
| function Mn(n, e, t) { | |
| let r = po(n, e); | |
| return r >= 0 ? n[1 | r] = t : (r = ~r, | |
| function NA(n, e, t, r) { | |
| let i = n.length; | |
| if (i == e) | |
| n.push(t, r); | |
| else if (1 === i) | |
| n.push(r, n[0]), | |
| n[0] = t; | |
| else { | |
| for (i--, | |
| n.push(n[i - 1], n[i]); i > e; ) | |
| n[i] = n[i - 2], | |
| i--; | |
| n[e] = t, | |
| n[e + 1] = r | |
| } | |
| }(n, r, e, t)), | |
| r | |
| } | |
| function cd(n, e) { | |
| const t = po(n, e); | |
| if (t >= 0) | |
| return n[1 | t] | |
| } | |
| function po(n, e) { | |
| return function Hm(n, e, t) { | |
| let r = 0 | |
| , i = n.length >> t; | |
| for (; i !== r; ) { | |
| const o = r + (i - r >> 1) | |
| , s = n[o << t]; | |
| if (e === s) | |
| return o << t; | |
| s > e ? i = o : r = o + 1 | |
| } | |
| return ~(i << t) | |
| }(n, e, 1) | |
| } | |
| const bs = {} | |
| , dd = "__NG_DI_FLAG__" | |
| , ul = "ngTempTokenPath" | |
| , zA = /\n/gm | |
| , zm = "__source"; | |
| let Cs; | |
| function go(n) { | |
| const e = Cs; | |
| return Cs = n, | |
| e | |
| } | |
| function WA(n, e=he.Default) { | |
| if (void 0 === Cs) | |
| throw new U(-203,!1); | |
| return null === Cs ? tm(n, void 0, e) : Cs.get(n, e & he.Optional ? null : void 0, e) | |
| } | |
| function Q(n, e=he.Default) { | |
| return (function OM() { | |
| return ku | |
| }() || WA)(ge(n), e) | |
| } | |
| function ot(n, e=he.Default) { | |
| return "number" != typeof e && (e = 0 | (e.optional && 8) | (e.host && 1) | (e.self && 2) | (e.skipSelf && 4)), | |
| Q(n, e) | |
| } | |
| function hd(n) { | |
| const e = []; | |
| for (let t = 0; t < n.length; t++) { | |
| const r = ge(n[t]); | |
| if (Array.isArray(r)) { | |
| if (0 === r.length) | |
| throw new U(900,!1); | |
| let i, o = he.Default; | |
| for (let s = 0; s < r.length; s++) { | |
| const a = r[s] | |
| , l = GA(a); | |
| "number" == typeof l ? -1 === l ? i = a.token : o |= l : i = a | |
| } | |
| e.push(Q(i, o)) | |
| } else | |
| e.push(Q(r)) | |
| } | |
| return e | |
| } | |
| function Ts(n, e) { | |
| return n[dd] = e, | |
| n.prototype[dd] = e, | |
| n | |
| } | |
| function GA(n) { | |
| return n[dd] | |
| } | |
| const Es = Ts(fo("Optional"), 8) | |
| , ws = Ts(fo("SkipSelf"), 4); | |
| var pn = ( () => ((pn = pn || {})[pn.Important = 1] = "Important", | |
| pn[pn.DashCase = 2] = "DashCase", | |
| pn))(); | |
| const _d = new Map; | |
| let uI = 0; | |
| const vd = "__ngContext__"; | |
| function Gt(n, e) { | |
| fn(e) ? (n[vd] = e[20], | |
| function hI(n) { | |
| _d.set(n[20], n) | |
| }(e)) : n[vd] = e | |
| } | |
| function Cd(n, e) { | |
| return undefined(n, e) | |
| } | |
| function Is(n) { | |
| const e = n[3]; | |
| return Kn(e) ? e[3] : e | |
| } | |
| function Td(n) { | |
| return u_(n[13]) | |
| } | |
| function Ed(n) { | |
| return u_(n[4]) | |
| } | |
| function u_(n) { | |
| for (; null !== n && !Kn(n); ) | |
| n = n[4]; | |
| return n | |
| } | |
| function _o(n, e, t, r, i) { | |
| if (null != r) { | |
| let o, s = !1; | |
| Kn(r) ? o = r : fn(r) && (s = !0, | |
| r = r[0]); | |
| const a = Dt(r); | |
| 0 === n && null !== t ? null == i ? m_(e, t, a) : Ai(e, t, a, i || null, !0) : 1 === n && null !== t ? Ai(e, t, a, i || null, !0) : 2 === n ? function xd(n, e, t) { | |
| const r = fl(n, e); | |
| r && function OI(n, e, t, r) { | |
| n.removeChild(e, t, r) | |
| }(n, r, e, t) | |
| }(e, a, s) : 3 === n && e.destroyNode(a), | |
| null != o && function LI(n, e, t, r, i) { | |
| const o = t[7]; | |
| o !== Dt(t) && _o(e, n, r, o, i); | |
| for (let a = 10; a < t.length; a++) { | |
| const l = t[a]; | |
| Ss(l[1], l, n, e, r, o) | |
| } | |
| }(e, n, o, t, i) | |
| } | |
| } | |
| function Dd(n, e, t) { | |
| return n.createElement(e, t) | |
| } | |
| function h_(n, e) { | |
| const t = n[9] | |
| , r = t.indexOf(e) | |
| , i = e[3]; | |
| 512 & e[2] && (e[2] &= -513, | |
| qu(i, -1)), | |
| t.splice(r, 1) | |
| } | |
| function Md(n, e) { | |
| if (n.length <= 10) | |
| return; | |
| const t = 10 + e | |
| , r = n[t]; | |
| if (r) { | |
| const i = r[17]; | |
| null !== i && i !== n && h_(i, r), | |
| e > 0 && (n[t - 1][4] = r[4]); | |
| const o = ll(n, 10 + e); | |
| !function MI(n, e) { | |
| Ss(n, e, e[11], 2, null, null), | |
| e[0] = null, | |
| e[6] = null | |
| }(r[1], r); | |
| const s = o[19]; | |
| null !== s && s.detachView(o[1]), | |
| r[3] = null, | |
| r[4] = null, | |
| r[2] &= -65 | |
| } | |
| return r | |
| } | |
| function f_(n, e) { | |
| if (!(128 & e[2])) { | |
| const t = e[11]; | |
| t.destroyNode && Ss(n, e, t, 3, null, null), | |
| function SI(n) { | |
| let e = n[13]; | |
| if (!e) | |
| return Ad(n[1], n); | |
| for (; e; ) { | |
| let t = null; | |
| if (fn(e)) | |
| t = e[13]; | |
| else { | |
| const r = e[10]; | |
| r && (t = r) | |
| } | |
| if (!t) { | |
| for (; e && !e[4] && e !== n; ) | |
| fn(e) && Ad(e[1], e), | |
| e = e[3]; | |
| null === e && (e = n), | |
| fn(e) && Ad(e[1], e), | |
| t = e && e[4] | |
| } | |
| e = t | |
| } | |
| }(e) | |
| } | |
| } | |
| function Ad(n, e) { | |
| if (!(128 & e[2])) { | |
| e[2] &= -65, | |
| e[2] |= 128, | |
| function PI(n, e) { | |
| let t; | |
| if (null != n && null != (t = n.destroyHooks)) | |
| for (let r = 0; r < t.length; r += 2) { | |
| const i = e[t[r]]; | |
| if (!(i instanceof fs)) { | |
| const o = t[r + 1]; | |
| if (Array.isArray(o)) | |
| for (let s = 0; s < o.length; s += 2) { | |
| const a = i[o[s]] | |
| , l = o[s + 1]; | |
| try { | |
| l.call(a) | |
| } finally {} | |
| } | |
| else | |
| try { | |
| o.call(i) | |
| } finally {} | |
| } | |
| } | |
| }(n, e), | |
| function FI(n, e) { | |
| const t = n.cleanup | |
| , r = e[7]; | |
| let i = -1; | |
| if (null !== t) | |
| for (let o = 0; o < t.length - 1; o += 2) | |
| if ("string" == typeof t[o]) { | |
| const s = t[o + 1] | |
| , a = "function" == typeof s ? s(e) : Dt(e[s]) | |
| , l = r[i = t[o + 2]] | |
| , c = t[o + 3]; | |
| "boolean" == typeof c ? a.removeEventListener(t[o], l, c) : c >= 0 ? r[i = c]() : r[i = -c].unsubscribe(), | |
| o += 2 | |
| } else { | |
| const s = r[i = t[o + 1]]; | |
| t[o].call(s) | |
| } | |
| if (null !== r) { | |
| for (let o = i + 1; o < r.length; o++) | |
| (0, | |
| r[o])(); | |
| e[7] = null | |
| } | |
| }(n, e), | |
| 1 === e[1].type && e[11].destroy(); | |
| const t = e[17]; | |
| if (null !== t && Kn(e[3])) { | |
| t !== e[3] && h_(t, e); | |
| const r = e[19]; | |
| null !== r && r.detachView(n) | |
| } | |
| !function fI(n) { | |
| _d.delete(n[20]) | |
| }(e) | |
| } | |
| } | |
| function p_(n, e, t) { | |
| return function g_(n, e, t) { | |
| let r = e; | |
| for (; null !== r && 40 & r.type; ) | |
| r = (e = r).parent; | |
| if (null === r) | |
| return t[0]; | |
| if (2 & r.flags) { | |
| const i = n.data[r.directiveStart].encapsulation; | |
| if (i === Gn.None || i === Gn.Emulated) | |
| return null | |
| } | |
| return En(r, t) | |
| }(n, e.parent, t) | |
| } | |
| function Ai(n, e, t, r, i) { | |
| n.insertBefore(e, t, r, i) | |
| } | |
| function m_(n, e, t) { | |
| n.appendChild(e, t) | |
| } | |
| function __(n, e, t, r, i) { | |
| null !== r ? Ai(n, e, t, r, i) : m_(n, e, t) | |
| } | |
| function fl(n, e) { | |
| return n.parentNode(e) | |
| } | |
| function y_(n, e, t) { | |
| return b_(n, e, t) | |
| } | |
| let Od, b_ = function v_(n, e, t) { | |
| return 40 & n.type ? En(n, t) : null | |
| }; | |
| function pl(n, e, t, r) { | |
| const i = p_(n, r, e) | |
| , o = e[11] | |
| , a = y_(r.parent || e[6], r, e); | |
| if (null != i) | |
| if (Array.isArray(t)) | |
| for (let l = 0; l < t.length; l++) | |
| __(o, i, t[l], a, !1); | |
| else | |
| __(o, i, t, a, !1) | |
| } | |
| function gl(n, e) { | |
| if (null !== e) { | |
| const t = e.type; | |
| if (3 & t) | |
| return En(e, n); | |
| if (4 & t) | |
| return Sd(-1, n[e.index]); | |
| if (8 & t) { | |
| const r = e.child; | |
| if (null !== r) | |
| return gl(n, r); | |
| { | |
| const i = n[e.index]; | |
| return Kn(i) ? Sd(-1, i) : Dt(i) | |
| } | |
| } | |
| if (32 & t) | |
| return Cd(e, n)() || Dt(n[e.index]); | |
| { | |
| const r = T_(n, e); | |
| return null !== r ? Array.isArray(r) ? r[0] : gl(Is(n[16]), r) : gl(n, e.next) | |
| } | |
| } | |
| return null | |
| } | |
| function T_(n, e) { | |
| return null !== e ? n[16][6].projection[e.projection] : null | |
| } | |
| function Sd(n, e) { | |
| const t = 10 + n + 1; | |
| if (t < e.length) { | |
| const r = e[t] | |
| , i = r[1].firstChild; | |
| if (null !== i) | |
| return gl(r, i) | |
| } | |
| return e[7] | |
| } | |
| function Rd(n, e, t, r, i, o, s) { | |
| for (; null != t; ) { | |
| const a = r[t.index] | |
| , l = t.type; | |
| if (s && 0 === e && (a && Gt(Dt(a), r), | |
| t.flags |= 4), | |
| 64 != (64 & t.flags)) | |
| if (8 & l) | |
| Rd(n, e, t.child, r, i, o, !1), | |
| _o(e, n, i, a, o); | |
| else if (32 & l) { | |
| const c = Cd(t, r); | |
| let u; | |
| for (; u = c(); ) | |
| _o(e, n, i, u, o); | |
| _o(e, n, i, a, o) | |
| } else | |
| 16 & l ? E_(n, e, r, t, i, o) : _o(e, n, i, a, o); | |
| t = s ? t.projectionNext : t.next | |
| } | |
| } | |
| function Ss(n, e, t, r, i, o) { | |
| Rd(t, r, n.firstChild, e, i, o, !1) | |
| } | |
| function E_(n, e, t, r, i, o) { | |
| const s = t[16] | |
| , l = s[6].projection[r.projection]; | |
| if (Array.isArray(l)) | |
| for (let c = 0; c < l.length; c++) | |
| _o(e, n, i, l[c], o); | |
| else | |
| Rd(n, e, l, s[3], i, o, !0) | |
| } | |
| function w_(n, e, t) { | |
| n.setAttribute(e, "style", t) | |
| } | |
| function Fd(n, e, t) { | |
| "" === t ? n.removeAttribute(e, "class") : n.setAttribute(e, "class", t) | |
| } | |
| class S_ { | |
| constructor(e) { | |
| this.changingThisBreaksApplicationSecurity = e | |
| } | |
| toString() { | |
| return `SafeValue must use [property]=binding: ${this.changingThisBreaksApplicationSecurity} (see https://g.co/ng/security#xss)` | |
| } | |
| } | |
| function Jr(n) { | |
| return n instanceof S_ ? n.changingThisBreaksApplicationSecurity : n | |
| } | |
| const XI = /^(?:(?:https?|mailto|data|ftp|tel|file|sms):|[^&:/?#]*(?:[/?#]|$))/gi; | |
| var Mt = ( () => ((Mt = Mt || {})[Mt.NONE = 0] = "NONE", | |
| Mt[Mt.HTML = 1] = "HTML", | |
| Mt[Mt.STYLE = 2] = "STYLE", | |
| Mt[Mt.SCRIPT = 3] = "SCRIPT", | |
| Mt[Mt.URL = 4] = "URL", | |
| Mt[Mt.RESOURCE_URL = 5] = "RESOURCE_URL", | |
| Mt))(); | |
| function ei(n) { | |
| const e = function Fs() { | |
| const n = H(); | |
| return n && n[12] | |
| }(); | |
| return e ? e.sanitize(Mt.URL, n) || "" : function xs(n, e) { | |
| const t = function KI(n) { | |
| return n instanceof S_ && n.getTypeName() || null | |
| }(n); | |
| if (null != t && t !== e) { | |
| if ("ResourceURL" === t && "URL" === e) | |
| return !0; | |
| throw new Error(`Required a safe ${e}, got a ${t} (see https://g.co/ng/security#xss)`) | |
| } | |
| return t === e | |
| }(n, "URL") ? Jr(n) : function kd(n) { | |
| return (n = String(n)).match(XI) ? n : "unsafe:" + n | |
| }(ye(n)) | |
| } | |
| const Ud = new ee("ENVIRONMENT_INITIALIZER") | |
| , L_ = new ee("INJECTOR",-1) | |
| , V_ = new ee("INJECTOR_DEF_TYPES"); | |
| class B_ { | |
| get(e, t=bs) { | |
| if (t === bs) { | |
| const r = new Error(`NullInjectorError: No provider for ${Ge(e)}!`); | |
| throw r.name = "NullInjectorError", | |
| r | |
| } | |
| return t | |
| } | |
| } | |
| function hS(...n) { | |
| return { | |
| \u0275providers: U_(0, n) | |
| } | |
| } | |
| function U_(n, ...e) { | |
| const t = [] | |
| , r = new Set; | |
| let i; | |
| return Ar(e, o => { | |
| const s = o; | |
| jd(s, t, [], r) && (i || (i = []), | |
| i.push(s)) | |
| } | |
| ), | |
| void 0 !== i && j_(i, t), | |
| t | |
| } | |
| function j_(n, e) { | |
| for (let t = 0; t < n.length; t++) { | |
| const {providers: i} = n[t]; | |
| Ar(i, o => { | |
| e.push(o) | |
| } | |
| ) | |
| } | |
| } | |
| function jd(n, e, t, r) { | |
| if (!(n = ge(n))) | |
| return !1; | |
| let i = null | |
| , o = Jg(n); | |
| const s = !o && ze(n); | |
| if (o || s) { | |
| if (s && !s.standalone) | |
| return !1; | |
| i = n | |
| } else { | |
| const l = n.ngModule; | |
| if (o = Jg(l), | |
| !o) | |
| return !1; | |
| i = l | |
| } | |
| const a = r.has(i); | |
| if (s) { | |
| if (a) | |
| return !1; | |
| if (r.add(i), | |
| s.dependencies) { | |
| const l = "function" == typeof s.dependencies ? s.dependencies() : s.dependencies; | |
| for (const c of l) | |
| jd(c, e, t, r) | |
| } | |
| } else { | |
| if (!o) | |
| return !1; | |
| { | |
| if (null != o.imports && !a) { | |
| let c; | |
| r.add(i); | |
| try { | |
| Ar(o.imports, u => { | |
| jd(u, e, t, r) && (c || (c = []), | |
| c.push(u)) | |
| } | |
| ) | |
| } finally {} | |
| void 0 !== c && j_(c, e) | |
| } | |
| if (!a) { | |
| const c = Mi(i) || ( () => new i); | |
| e.push({ | |
| provide: i, | |
| useFactory: c, | |
| deps: Ne | |
| }, { | |
| provide: V_, | |
| useValue: i, | |
| multi: !0 | |
| }, { | |
| provide: Ud, | |
| useValue: () => Q(i), | |
| multi: !0 | |
| }) | |
| } | |
| const l = o.providers; | |
| null == l || a || Ar(l, u => { | |
| e.push(u) | |
| } | |
| ) | |
| } | |
| } | |
| return i !== n && void 0 !== n.providers | |
| } | |
| const fS = We({ | |
| provide: String, | |
| useValue: We | |
| }); | |
| function Hd(n) { | |
| return null !== n && "object" == typeof n && fS in n | |
| } | |
| function Si(n) { | |
| return "function" == typeof n | |
| } | |
| const zd = new ee("Set Injector scope.") | |
| , vl = {} | |
| , gS = {}; | |
| let $d; | |
| function bl() { | |
| return void 0 === $d && ($d = new B_), | |
| $d | |
| } | |
| class ti { | |
| } | |
| class $_ extends ti { | |
| constructor(e, t, r, i) { | |
| super(), | |
| this.parent = t, | |
| this.source = r, | |
| this.scopes = i, | |
| this.records = new Map, | |
| this._ngOnDestroyHooks = new Set, | |
| this._onDestroyHooks = [], | |
| this._destroyed = !1, | |
| Gd(e, s => this.processProvider(s)), | |
| this.records.set(L_, yo(void 0, this)), | |
| i.has("environment") && this.records.set(ti, yo(void 0, this)); | |
| const o = this.records.get(zd); | |
| null != o && "string" == typeof o.value && this.scopes.add(o.value), | |
| this.injectorDefTypes = new Set(this.get(V_.multi, Ne, he.Self)) | |
| } | |
| get destroyed() { | |
| return this._destroyed | |
| } | |
| destroy() { | |
| this.assertNotDestroyed(), | |
| this._destroyed = !0; | |
| try { | |
| for (const e of this._ngOnDestroyHooks) | |
| e.ngOnDestroy(); | |
| for (const e of this._onDestroyHooks) | |
| e() | |
| } finally { | |
| this.records.clear(), | |
| this._ngOnDestroyHooks.clear(), | |
| this.injectorDefTypes.clear(), | |
| this._onDestroyHooks.length = 0 | |
| } | |
| } | |
| onDestroy(e) { | |
| this._onDestroyHooks.push(e) | |
| } | |
| runInContext(e) { | |
| this.assertNotDestroyed(); | |
| const t = go(this) | |
| , r = Rn(void 0); | |
| try { | |
| return e() | |
| } finally { | |
| go(t), | |
| Rn(r) | |
| } | |
| } | |
| get(e, t=bs, r=he.Default) { | |
| this.assertNotDestroyed(); | |
| const i = go(this) | |
| , o = Rn(void 0); | |
| try { | |
| if (!(r & he.SkipSelf)) { | |
| let a = this.records.get(e); | |
| if (void 0 === a) { | |
| const l = function bS(n) { | |
| return "function" == typeof n || "object" == typeof n && n instanceof ee | |
| }(e) && za(e); | |
| a = l && this.injectableDefInScope(l) ? yo(Wd(e), vl) : null, | |
| this.records.set(e, a) | |
| } | |
| if (null != a) | |
| return this.hydrate(e, a) | |
| } | |
| return (r & he.Self ? bl() : this.parent).get(e, t = r & he.Optional && t === bs ? null : t) | |
| } catch (s) { | |
| if ("NullInjectorError" === s.name) { | |
| if ((s[ul] = s[ul] || []).unshift(Ge(e)), | |
| i) | |
| throw s; | |
| return function qA(n, e, t, r) { | |
| const i = n[ul]; | |
| throw e[zm] && i.unshift(e[zm]), | |
| n.message = function KA(n, e, t, r=null) { | |
| n = n && "\n" === n.charAt(0) && "\u0275" == n.charAt(1) ? n.slice(2) : n; | |
| let i = Ge(e); | |
| if (Array.isArray(e)) | |
| i = e.map(Ge).join(" -> "); | |
| else if ("object" == typeof e) { | |
| let o = []; | |
| for (let s in e) | |
| if (e.hasOwnProperty(s)) { | |
| let a = e[s]; | |
| o.push(s + ":" + ("string" == typeof a ? JSON.stringify(a) : Ge(a))) | |
| } | |
| i = `{${o.join(", ")}}` | |
| } | |
| return `${t}${r ? "(" + r + ")" : ""}[${i}]: ${n.replace(zA, "\n ")}` | |
| }("\n" + n.message, i, t, r), | |
| n.ngTokenPath = i, | |
| n[ul] = null, | |
| n | |
| }(s, e, "R3InjectorError", this.source) | |
| } | |
| throw s | |
| } finally { | |
| Rn(o), | |
| go(i) | |
| } | |
| } | |
| resolveInjectorInitializers() { | |
| const e = go(this) | |
| , t = Rn(void 0); | |
| try { | |
| const r = this.get(Ud.multi, Ne, he.Self); | |
| for (const i of r) | |
| i() | |
| } finally { | |
| go(e), | |
| Rn(t) | |
| } | |
| } | |
| toString() { | |
| const e = [] | |
| , t = this.records; | |
| for (const r of t.keys()) | |
| e.push(Ge(r)); | |
| return `R3Injector[${e.join(", ")}]` | |
| } | |
| assertNotDestroyed() { | |
| if (this._destroyed) | |
| throw new U(205,!1) | |
| } | |
| processProvider(e) { | |
| let t = Si(e = ge(e)) ? e : ge(e && e.provide); | |
| const r = function _S(n) { | |
| return Hd(n) ? yo(void 0, n.useValue) : yo(W_(n), vl) | |
| }(e); | |
| if (Si(e) || !0 !== e.multi) | |
| this.records.get(t); | |
| else { | |
| let i = this.records.get(t); | |
| i || (i = yo(void 0, vl, !0), | |
| i.factory = () => hd(i.multi), | |
| this.records.set(t, i)), | |
| t = e, | |
| i.multi.push(e) | |
| } | |
| this.records.set(t, r) | |
| } | |
| hydrate(e, t) { | |
| return t.value === vl && (t.value = gS, | |
| t.value = t.factory()), | |
| "object" == typeof t.value && t.value && function vS(n) { | |
| return null !== n && "object" == typeof n && "function" == typeof n.ngOnDestroy | |
| }(t.value) && this._ngOnDestroyHooks.add(t.value), | |
| t.value | |
| } | |
| injectableDefInScope(e) { | |
| if (!e.providedIn) | |
| return !1; | |
| const t = ge(e.providedIn); | |
| return "string" == typeof t ? "any" === t || this.scopes.has(t) : this.injectorDefTypes.has(t) | |
| } | |
| } | |
| function Wd(n) { | |
| const e = za(n) | |
| , t = null !== e ? e.factory : Mi(n); | |
| if (null !== t) | |
| return t; | |
| if (n instanceof ee) | |
| throw new U(204,!1); | |
| if (n instanceof Function) | |
| return function mS(n) { | |
| const e = n.length; | |
| if (e > 0) | |
| throw vs(e, "?"), | |
| new U(204,!1); | |
| const t = function RM(n) { | |
| const e = n && (n[$a] || n[em]); | |
| if (e) { | |
| const t = function FM(n) { | |
| if (n.hasOwnProperty("name")) | |
| return n.name; | |
| const e = ("" + n).match(/^function\s*([^\s(]+)/); | |
| return null === e ? "" : e[1] | |
| }(n); | |
| return console.warn(`DEPRECATED: DI is instantiating a token "${t}" that inherits its @Injectable decorator but does not provide one itself.\nThis will become an error in a future version of Angular. Please add @Injectable() to the "${t}" class.`), | |
| e | |
| } | |
| return null | |
| }(n); | |
| return null !== t ? () => t.factory(n) : () => new n | |
| }(n); | |
| throw new U(204,!1) | |
| } | |
| function W_(n, e, t) { | |
| let r; | |
| if (Si(n)) { | |
| const i = ge(n); | |
| return Mi(i) || Wd(i) | |
| } | |
| if (Hd(n)) | |
| r = () => ge(n.useValue); | |
| else if (function z_(n) { | |
| return !(!n || !n.useFactory) | |
| }(n)) | |
| r = () => n.useFactory(...hd(n.deps || [])); | |
| else if (function H_(n) { | |
| return !(!n || !n.useExisting) | |
| }(n)) | |
| r = () => Q(ge(n.useExisting)); | |
| else { | |
| const i = ge(n && (n.useClass || n.provide)); | |
| if (!function yS(n) { | |
| return !!n.deps | |
| }(n)) | |
| return Mi(i) || Wd(i); | |
| r = () => new i(...hd(n.deps)) | |
| } | |
| return r | |
| } | |
| function yo(n, e, t=!1) { | |
| return { | |
| factory: n, | |
| value: e, | |
| multi: t ? [] : void 0 | |
| } | |
| } | |
| function CS(n) { | |
| return !!n.\u0275providers | |
| } | |
| function Gd(n, e) { | |
| for (const t of n) | |
| Array.isArray(t) ? Gd(t, e) : CS(t) ? Gd(t.\u0275providers, e) : e(t) | |
| } | |
| class G_ { | |
| } | |
| class wS { | |
| resolveComponentFactory(e) { | |
| throw function ES(n) { | |
| const e = Error(`No component factory found for ${Ge(n)}. Did you add it to @NgModule.entryComponents?`); | |
| return e.ngComponent = n, | |
| e | |
| }(e) | |
| } | |
| } | |
| let Ps = ( () => { | |
| class n { | |
| } | |
| return n.NULL = new wS, | |
| n | |
| } | |
| )(); | |
| function DS() { | |
| return vo(St(), H()) | |
| } | |
| function vo(n, e) { | |
| return new Vt(En(n, e)) | |
| } | |
| let Vt = ( () => { | |
| class n { | |
| constructor(t) { | |
| this.nativeElement = t | |
| } | |
| } | |
| return n.__NG_ELEMENT_ID__ = DS, | |
| n | |
| } | |
| )(); | |
| function MS(n) { | |
| return n instanceof Vt ? n.nativeElement : n | |
| } | |
| class Os { | |
| } | |
| let Sr = ( () => { | |
| class n { | |
| } | |
| return n.__NG_ELEMENT_ID__ = () => function AS() { | |
| const n = H() | |
| , t = wn(St().index, n); | |
| return (fn(t) ? t : n)[11] | |
| }(), | |
| n | |
| } | |
| )() | |
| , IS = ( () => { | |
| class n { | |
| } | |
| return n.\u0275prov = se({ | |
| token: n, | |
| providedIn: "root", | |
| factory: () => null | |
| }), | |
| n | |
| } | |
| )(); | |
| class xi { | |
| constructor(e) { | |
| this.full = e, | |
| this.major = e.split(".")[0], | |
| this.minor = e.split(".")[1], | |
| this.patch = e.split(".").slice(2).join(".") | |
| } | |
| } | |
| const SS = new xi("14.3.0") | |
| , qd = {}; | |
| function Qd(n) { | |
| return n.ngOriginalError | |
| } | |
| class bo { | |
| constructor() { | |
| this._console = console | |
| } | |
| handleError(e) { | |
| const t = this._findOriginalError(e); | |
| this._console.error("ERROR", e), | |
| t && this._console.error("ORIGINAL ERROR", t) | |
| } | |
| _findOriginalError(e) { | |
| let t = e && Qd(e); | |
| for (; t && Qd(t); ) | |
| t = Qd(t); | |
| return t || null | |
| } | |
| } | |
| function K_(n) { | |
| return n.ownerDocument.defaultView | |
| } | |
| function Q_(n) { | |
| return n.ownerDocument | |
| } | |
| function xr(n) { | |
| return n instanceof Function ? n() : n | |
| } | |
| function Z_(n, e, t) { | |
| let r = n.length; | |
| for (; ; ) { | |
| const i = n.indexOf(e, t); | |
| if (-1 === i) | |
| return i; | |
| if (0 === i || n.charCodeAt(i - 1) <= 32) { | |
| const o = e.length; | |
| if (i + o === r || n.charCodeAt(i + o) <= 32) | |
| return i | |
| } | |
| t = i + 1 | |
| } | |
| } | |
| const X_ = "ng-template"; | |
| function VS(n, e, t) { | |
| let r = 0; | |
| for (; r < n.length; ) { | |
| let i = n[r++]; | |
| if (t && "class" === i) { | |
| if (i = n[r], | |
| -1 !== Z_(i.toLowerCase(), e, 0)) | |
| return !0 | |
| } else if (1 === i) { | |
| for (; r < n.length && "string" == typeof (i = n[r++]); ) | |
| if (i.toLowerCase() === e) | |
| return !0; | |
| return !1 | |
| } | |
| } | |
| return !1 | |
| } | |
| function J_(n) { | |
| return 4 === n.type && n.value !== X_ | |
| } | |
| function BS(n, e, t) { | |
| return e === (4 !== n.type || t ? n.value : X_) | |
| } | |
| function US(n, e, t) { | |
| let r = 4; | |
| const i = n.attrs || [] | |
| , o = function zS(n) { | |
| for (let e = 0; e < n.length; e++) | |
| if (Dm(n[e])) | |
| return e; | |
| return n.length | |
| }(i); | |
| let s = !1; | |
| for (let a = 0; a < e.length; a++) { | |
| const l = e[a]; | |
| if ("number" != typeof l) { | |
| if (!s) | |
| if (4 & r) { | |
| if (r = 2 | 1 & r, | |
| "" !== l && !BS(n, l, t) || "" === l && 1 === e.length) { | |
| if (Yn(r)) | |
| return !1; | |
| s = !0 | |
| } | |
| } else { | |
| const c = 8 & r ? l : e[++a]; | |
| if (8 & r && null !== n.attrs) { | |
| if (!VS(n.attrs, c, t)) { | |
| if (Yn(r)) | |
| return !1; | |
| s = !0 | |
| } | |
| continue | |
| } | |
| const d = jS(8 & r ? "class" : l, i, J_(n), t); | |
| if (-1 === d) { | |
| if (Yn(r)) | |
| return !1; | |
| s = !0; | |
| continue | |
| } | |
| if ("" !== c) { | |
| let h; | |
| h = d > o ? "" : i[d + 1].toLowerCase(); | |
| const f = 8 & r ? h : null; | |
| if (f && -1 !== Z_(f, c, 0) || 2 & r && c !== h) { | |
| if (Yn(r)) | |
| return !1; | |
| s = !0 | |
| } | |
| } | |
| } | |
| } else { | |
| if (!s && !Yn(r) && !Yn(l)) | |
| return !1; | |
| if (s && Yn(l)) | |
| continue; | |
| s = !1, | |
| r = l | 1 & r | |
| } | |
| } | |
| return Yn(r) || s | |
| } | |
| function Yn(n) { | |
| return 0 == (1 & n) | |
| } | |
| function jS(n, e, t, r) { | |
| if (null === e) | |
| return -1; | |
| let i = 0; | |
| if (r || !t) { | |
| let o = !1; | |
| for (; i < e.length; ) { | |
| const s = e[i]; | |
| if (s === n) | |
| return i; | |
| if (3 === s || 6 === s) | |
| o = !0; | |
| else { | |
| if (1 === s || 2 === s) { | |
| let a = e[++i]; | |
| for (; "string" == typeof a; ) | |
| a = e[++i]; | |
| continue | |
| } | |
| if (4 === s) | |
| break; | |
| if (0 === s) { | |
| i += 4; | |
| continue | |
| } | |
| } | |
| i += o ? 1 : 2 | |
| } | |
| return -1 | |
| } | |
| return function $S(n, e) { | |
| let t = n.indexOf(4); | |
| if (t > -1) | |
| for (t++; t < n.length; ) { | |
| const r = n[t]; | |
| if ("number" == typeof r) | |
| return -1; | |
| if (r === e) | |
| return t; | |
| t++ | |
| } | |
| return -1 | |
| }(e, n) | |
| } | |
| function ey(n, e, t=!1) { | |
| for (let r = 0; r < e.length; r++) | |
| if (US(n, e[r], t)) | |
| return !0; | |
| return !1 | |
| } | |
| function WS(n, e) { | |
| e: for (let t = 0; t < e.length; t++) { | |
| const r = e[t]; | |
| if (n.length === r.length) { | |
| for (let i = 0; i < n.length; i++) | |
| if (n[i] !== r[i]) | |
| continue e; | |
| return !0 | |
| } | |
| } | |
| return !1 | |
| } | |
| function ty(n, e) { | |
| return n ? ":not(" + e.trim() + ")" : e | |
| } | |
| function GS(n) { | |
| let e = n[0] | |
| , t = 1 | |
| , r = 2 | |
| , i = "" | |
| , o = !1; | |
| for (; t < n.length; ) { | |
| let s = n[t]; | |
| if ("string" == typeof s) | |
| if (2 & r) { | |
| const a = n[++t]; | |
| i += "[" + s + (a.length > 0 ? '="' + a + '"' : "") + "]" | |
| } else | |
| 8 & r ? i += "." + s : 4 & r && (i += " " + s); | |
| else | |
| "" !== i && !Yn(s) && (e += ty(o, i), | |
| i = ""), | |
| r = s, | |
| o = o || !Yn(r); | |
| t++ | |
| } | |
| return "" !== i && (e += ty(o, i)), | |
| e | |
| } | |
| const ve = {}; | |
| function Ee(n) { | |
| ny(Pe(), H(), en() + n, !1) | |
| } | |
| function ny(n, e, t, r) { | |
| if (!r) | |
| if (3 == (3 & e[2])) { | |
| const o = n.preOrderCheckHooks; | |
| null !== o && el(e, o, t) | |
| } else { | |
| const o = n.preOrderHooks; | |
| null !== o && tl(e, o, 0, t) | |
| } | |
| Zr(t) | |
| } | |
| function sy(n, e=null, t=null, r) { | |
| const i = ay(n, e, t, r); | |
| return i.resolveInjectorInitializers(), | |
| i | |
| } | |
| function ay(n, e=null, t=null, r, i=new Set) { | |
| const o = [t || Ne, hS(n)]; | |
| return r = r || ("object" == typeof n ? void 0 : Ge(n)), | |
| new $_(o,e || bl(),r || null,i) | |
| } | |
| let On = ( () => { | |
| class n { | |
| static create(t, r) { | |
| var i; | |
| if (Array.isArray(t)) | |
| return sy({ | |
| name: "" | |
| }, r, t, ""); | |
| { | |
| const o = null !== (i = t.name) && void 0 !== i ? i : ""; | |
| return sy({ | |
| name: o | |
| }, t.parent, t.providers, o) | |
| } | |
| } | |
| } | |
| return n.THROW_IF_NOT_FOUND = bs, | |
| n.NULL = new B_, | |
| n.\u0275prov = se({ | |
| token: n, | |
| providedIn: "any", | |
| factory: () => Q(L_) | |
| }), | |
| n.__NG_ELEMENT_ID__ = -1, | |
| n | |
| } | |
| )(); | |
| function B(n, e=he.Default) { | |
| const t = H(); | |
| return null === t ? Q(n, e) : Pm(St(), t, ge(n), e) | |
| } | |
| function eh() { | |
| throw new Error("invalid") | |
| } | |
| function Tl(n, e) { | |
| return n << 17 | e << 2 | |
| } | |
| function Zn(n) { | |
| return n >> 17 & 32767 | |
| } | |
| function th(n) { | |
| return 2 | n | |
| } | |
| function Rr(n) { | |
| return (131068 & n) >> 2 | |
| } | |
| function nh(n, e) { | |
| return -131069 & n | e << 2 | |
| } | |
| function rh(n) { | |
| return 1 | n | |
| } | |
| function wy(n, e) { | |
| const t = n.contentQueries; | |
| if (null !== t) | |
| for (let r = 0; r < t.length; r += 2) { | |
| const i = t[r] | |
| , o = t[r + 1]; | |
| if (-1 !== o) { | |
| const s = n.data[o]; | |
| Xu(i), | |
| s.contentQueries(2, e[o], o) | |
| } | |
| } | |
| } | |
| function Dl(n, e, t, r, i, o, s, a, l, c, u) { | |
| const d = e.blueprint.slice(); | |
| return d[0] = i, | |
| d[2] = 76 | r, | |
| (null !== u || n && 1024 & n[2]) && (d[2] |= 1024), | |
| dm(d), | |
| d[3] = d[15] = n, | |
| d[8] = t, | |
| d[10] = s || n && n[10], | |
| d[11] = a || n && n[11], | |
| d[12] = l || n && n[12] || null, | |
| d[9] = c || n && n[9] || null, | |
| d[6] = o, | |
| d[20] = function dI() { | |
| return uI++ | |
| }(), | |
| d[21] = u, | |
| d[16] = 2 == e.type ? n[16] : d, | |
| d | |
| } | |
| function Eo(n, e, t, r, i) { | |
| let o = n.data[e]; | |
| if (null === o) | |
| o = function dh(n, e, t, r, i) { | |
| const o = pm() | |
| , s = Ku() | |
| , l = n.data[e] = function Ix(n, e, t, r, i, o) { | |
| return { | |
| type: t, | |
| index: r, | |
| insertBeforeIndex: null, | |
| injectorIndex: e ? e.injectorIndex : -1, | |
| directiveStart: -1, | |
| directiveEnd: -1, | |
| directiveStylingLast: -1, | |
| propertyBindings: null, | |
| flags: 0, | |
| providerIndexes: 0, | |
| value: i, | |
| attrs: o, | |
| mergedAttrs: null, | |
| localNames: null, | |
| initialInputs: void 0, | |
| inputs: null, | |
| outputs: null, | |
| tViews: null, | |
| next: null, | |
| projectionNext: null, | |
| child: null, | |
| parent: e, | |
| projection: null, | |
| styles: null, | |
| stylesWithoutHost: null, | |
| residualStyles: void 0, | |
| classes: null, | |
| classesWithoutHost: null, | |
| residualClasses: void 0, | |
| classBindings: 0, | |
| styleBindings: 0 | |
| } | |
| }(0, s ? o : o && o.parent, t, e, r, i); | |
| return null === n.firstChild && (n.firstChild = l), | |
| null !== o && (s ? null == o.child && null !== l.parent && (o.child = l) : null === o.next && (o.next = l)), | |
| l | |
| }(n, e, t, r, i), | |
| function aA() { | |
| return me.lFrame.inI18n | |
| }() && (o.flags |= 64); | |
| else if (64 & o.type) { | |
| o.type = t, | |
| o.value = r, | |
| o.attrs = i; | |
| const s = function hs() { | |
| const n = me.lFrame | |
| , e = n.currentTNode; | |
| return n.isParent ? e : e.parent | |
| }(); | |
| o.injectorIndex = null === s ? -1 : s.injectorIndex | |
| } | |
| return lr(o, !0), | |
| o | |
| } | |
| function wo(n, e, t, r) { | |
| if (0 === t) | |
| return -1; | |
| const i = e.length; | |
| for (let o = 0; o < t; o++) | |
| e.push(r), | |
| n.blueprint.push(r), | |
| n.data.push(null); | |
| return i | |
| } | |
| function hh(n, e, t) { | |
| Ju(e); | |
| try { | |
| const r = n.viewQuery; | |
| null !== r && bh(1, r, t); | |
| const i = n.template; | |
| null !== i && Dy(n, e, i, 1, t), | |
| n.firstCreatePass && (n.firstCreatePass = !1), | |
| n.staticContentQueries && wy(n, e), | |
| n.staticViewQueries && bh(2, n.viewQuery, t); | |
| const o = n.components; | |
| null !== o && function Dx(n, e) { | |
| for (let t = 0; t < e.length; t++) | |
| $x(n, e[t]) | |
| }(e, o) | |
| } catch (r) { | |
| throw n.firstCreatePass && (n.incompleteFirstPass = !0, | |
| n.firstCreatePass = !1), | |
| r | |
| } finally { | |
| e[2] &= -5, | |
| ed() | |
| } | |
| } | |
| function Ml(n, e, t, r) { | |
| const i = e[2]; | |
| if (128 != (128 & i)) { | |
| Ju(e); | |
| try { | |
| dm(e), | |
| function mm(n) { | |
| return me.lFrame.bindingIndex = n | |
| }(n.bindingStartIndex), | |
| null !== t && Dy(n, e, t, 2, r); | |
| const s = 3 == (3 & i); | |
| if (s) { | |
| const c = n.preOrderCheckHooks; | |
| null !== c && el(e, c, null) | |
| } else { | |
| const c = n.preOrderHooks; | |
| null !== c && tl(e, c, 0, null), | |
| td(e, 0) | |
| } | |
| if (function Hx(n) { | |
| for (let e = Td(n); null !== e; e = Ed(e)) { | |
| if (!e[2]) | |
| continue; | |
| const t = e[9]; | |
| for (let r = 0; r < t.length; r++) { | |
| const i = t[r] | |
| , o = i[3]; | |
| 0 == (512 & i[2]) && qu(o, 1), | |
| i[2] |= 512 | |
| } | |
| } | |
| }(e), | |
| function jx(n) { | |
| for (let e = Td(n); null !== e; e = Ed(e)) | |
| for (let t = 10; t < e.length; t++) { | |
| const r = e[t] | |
| , i = r[1]; | |
| Xa(r) && Ml(i, r, i.template, r[8]) | |
| } | |
| }(e), | |
| null !== n.contentQueries && wy(n, e), | |
| s) { | |
| const c = n.contentCheckHooks; | |
| null !== c && el(e, c) | |
| } else { | |
| const c = n.contentHooks; | |
| null !== c && tl(e, c, 1), | |
| td(e, 1) | |
| } | |
| !function Ex(n, e) { | |
| const t = n.hostBindingOpCodes; | |
| if (null !== t) | |
| try { | |
| for (let r = 0; r < t.length; r++) { | |
| const i = t[r]; | |
| if (i < 0) | |
| Zr(~i); | |
| else { | |
| const o = i | |
| , s = t[++r] | |
| , a = t[++r]; | |
| lA(s, o), | |
| a(2, e[o]) | |
| } | |
| } | |
| } finally { | |
| Zr(-1) | |
| } | |
| }(n, e); | |
| const a = n.components; | |
| null !== a && function wx(n, e) { | |
| for (let t = 0; t < e.length; t++) | |
| zx(n, e[t]) | |
| }(e, a); | |
| const l = n.viewQuery; | |
| if (null !== l && bh(2, l, r), | |
| s) { | |
| const c = n.viewCheckHooks; | |
| null !== c && el(e, c) | |
| } else { | |
| const c = n.viewHooks; | |
| null !== c && tl(e, c, 2), | |
| td(e, 2) | |
| } | |
| !0 === n.firstUpdatePass && (n.firstUpdatePass = !1), | |
| e[2] &= -41, | |
| 512 & e[2] && (e[2] &= -513, | |
| qu(e[3], -1)) | |
| } finally { | |
| ed() | |
| } | |
| } | |
| } | |
| function Dy(n, e, t, r, i) { | |
| const o = en() | |
| , s = 2 & r; | |
| try { | |
| Zr(-1), | |
| s && e.length > 22 && ny(n, e, 22, !1), | |
| t(r, i) | |
| } finally { | |
| Zr(o) | |
| } | |
| } | |
| function My(n, e, t) { | |
| if (ju(e)) { | |
| const i = e.directiveEnd; | |
| for (let o = e.directiveStart; o < i; o++) { | |
| const s = n.data[o]; | |
| s.contentQueries && s.contentQueries(1, t[o], o) | |
| } | |
| } | |
| } | |
| function fh(n, e, t) { | |
| !fm() || (function Px(n, e, t, r) { | |
| const i = t.directiveStart | |
| , o = t.directiveEnd; | |
| n.firstCreatePass || gs(t, e), | |
| Gt(r, e); | |
| const s = t.initialInputs; | |
| for (let a = i; a < o; a++) { | |
| const l = n.data[a] | |
| , c = Qn(l); | |
| c && Vx(e, t, l); | |
| const u = ms(e, n, a, t); | |
| Gt(u, e), | |
| null !== s && Bx(0, a - i, u, l, 0, s), | |
| c && (wn(t.index, e)[8] = u) | |
| } | |
| }(n, e, t, En(t, e)), | |
| 128 == (128 & t.flags) && function Ox(n, e, t) { | |
| const r = t.directiveStart | |
| , i = t.directiveEnd | |
| , o = t.index | |
| , s = function cA() { | |
| return me.lFrame.currentDirectiveIndex | |
| }(); | |
| try { | |
| Zr(o); | |
| for (let a = r; a < i; a++) { | |
| const l = n.data[a] | |
| , c = e[a]; | |
| Yu(a), | |
| (null !== l.hostBindings || 0 !== l.hostVars || null !== l.hostAttrs) && Py(l, c) | |
| } | |
| } finally { | |
| Zr(-1), | |
| Yu(s) | |
| } | |
| }(n, e, t)) | |
| } | |
| function ph(n, e, t=En) { | |
| const r = e.localNames; | |
| if (null !== r) { | |
| let i = e.index + 1; | |
| for (let o = 0; o < r.length; o += 2) { | |
| const s = r[o + 1] | |
| , a = -1 === s ? t(e, n) : n[s]; | |
| n[i++] = a | |
| } | |
| } | |
| } | |
| function Ay(n) { | |
| const e = n.tView; | |
| return null === e || e.incompleteFirstPass ? n.tView = gh(1, null, n.template, n.decls, n.vars, n.directiveDefs, n.pipeDefs, n.viewQuery, n.schemas, n.consts) : e | |
| } | |
| function gh(n, e, t, r, i, o, s, a, l, c) { | |
| const u = 22 + r | |
| , d = u + i | |
| , h = function Mx(n, e) { | |
| const t = []; | |
| for (let r = 0; r < e; r++) | |
| t.push(r < n ? null : ve); | |
| return t | |
| }(u, d) | |
| , f = "function" == typeof c ? c() : c; | |
| return h[1] = { | |
| type: n, | |
| blueprint: h, | |
| template: t, | |
| queries: null, | |
| viewQuery: a, | |
| declTNode: e, | |
| data: h.slice().fill(null, u), | |
| bindingStartIndex: u, | |
| expandoStartIndex: d, | |
| hostBindingOpCodes: null, | |
| firstCreatePass: !0, | |
| firstUpdatePass: !0, | |
| staticViewQueries: !1, | |
| staticContentQueries: !1, | |
| preOrderHooks: null, | |
| preOrderCheckHooks: null, | |
| contentHooks: null, | |
| contentCheckHooks: null, | |
| viewHooks: null, | |
| viewCheckHooks: null, | |
| destroyHooks: null, | |
| cleanup: null, | |
| contentQueries: null, | |
| components: null, | |
| directiveRegistry: "function" == typeof o ? o() : o, | |
| pipeRegistry: "function" == typeof s ? s() : s, | |
| firstChild: null, | |
| schemas: l, | |
| consts: f, | |
| incompleteFirstPass: !1 | |
| } | |
| } | |
| function Iy(n, e, t, r) { | |
| const i = Vy(e); | |
| null === t ? i.push(r) : (i.push(t), | |
| n.firstCreatePass && By(n).push(r, i.length - 1)) | |
| } | |
| function Sy(n, e, t) { | |
| for (let r in n) | |
| if (n.hasOwnProperty(r)) { | |
| const i = n[r]; | |
| (t = null === t ? {} : t).hasOwnProperty(r) ? t[r].push(e, i) : t[r] = [e, i] | |
| } | |
| return t | |
| } | |
| function xy(n, e) { | |
| const r = e.directiveEnd | |
| , i = n.data | |
| , o = e.attrs | |
| , s = []; | |
| let a = null | |
| , l = null; | |
| for (let c = e.directiveStart; c < r; c++) { | |
| const u = i[c] | |
| , d = u.inputs | |
| , h = null === o || J_(e) ? null : Ux(d, o); | |
| s.push(h), | |
| a = Sy(d, c, a), | |
| l = Sy(u.outputs, c, l) | |
| } | |
| null !== a && (a.hasOwnProperty("class") && (e.flags |= 16), | |
| a.hasOwnProperty("style") && (e.flags |= 32)), | |
| e.initialInputs = s, | |
| e.inputs = a, | |
| e.outputs = l | |
| } | |
| function Ry(n, e) { | |
| const t = wn(e, n); | |
| 16 & t[2] || (t[2] |= 32) | |
| } | |
| function mh(n, e, t, r) { | |
| let i = !1; | |
| if (fm()) { | |
| const o = function Nx(n, e, t) { | |
| const r = n.directiveRegistry; | |
| let i = null; | |
| if (r) | |
| for (let o = 0; o < r.length; o++) { | |
| const s = r[o]; | |
| ey(t, s.selectors, !1) && (i || (i = []), | |
| sl(gs(t, e), n, s.type), | |
| Qn(s) ? (Oy(n, t), | |
| i.unshift(s)) : i.push(s)) | |
| } | |
| return i | |
| }(n, e, t) | |
| , s = null === r ? null : { | |
| "": -1 | |
| }; | |
| if (null !== o) { | |
| i = !0, | |
| Ny(t, n.data.length, o.length); | |
| for (let u = 0; u < o.length; u++) { | |
| const d = o[u]; | |
| d.providersResolver && d.providersResolver(d) | |
| } | |
| let a = !1 | |
| , l = !1 | |
| , c = wo(n, e, o.length, null); | |
| for (let u = 0; u < o.length; u++) { | |
| const d = o[u]; | |
| t.mergedAttrs = rl(t.mergedAttrs, d.hostAttrs), | |
| ky(n, t, e, c, d), | |
| Lx(c, d, s), | |
| null !== d.contentQueries && (t.flags |= 8), | |
| (null !== d.hostBindings || null !== d.hostAttrs || 0 !== d.hostVars) && (t.flags |= 128); | |
| const h = d.type.prototype; | |
| !a && (h.ngOnChanges || h.ngOnInit || h.ngDoCheck) && ((n.preOrderHooks || (n.preOrderHooks = [])).push(t.index), | |
| a = !0), | |
| !l && (h.ngOnChanges || h.ngDoCheck) && ((n.preOrderCheckHooks || (n.preOrderCheckHooks = [])).push(t.index), | |
| l = !0), | |
| c++ | |
| } | |
| xy(n, t) | |
| } | |
| s && function kx(n, e, t) { | |
| if (e) { | |
| const r = n.localNames = []; | |
| for (let i = 0; i < e.length; i += 2) { | |
| const o = t[e[i + 1]]; | |
| if (null == o) | |
| throw new U(-301,!1); | |
| r.push(e[i], o) | |
| } | |
| } | |
| }(t, r, s) | |
| } | |
| return t.mergedAttrs = rl(t.mergedAttrs, t.attrs), | |
| i | |
| } | |
| function Fy(n, e, t, r, i, o) { | |
| const s = o.hostBindings; | |
| if (s) { | |
| let a = n.hostBindingOpCodes; | |
| null === a && (a = n.hostBindingOpCodes = []); | |
| const l = ~e.index; | |
| (function Fx(n) { | |
| let e = n.length; | |
| for (; e > 0; ) { | |
| const t = n[--e]; | |
| if ("number" == typeof t && t < 0) | |
| return t | |
| } | |
| return 0 | |
| } | |
| )(a) != l && a.push(l), | |
| a.push(r, i, s) | |
| } | |
| } | |
| function Py(n, e) { | |
| null !== n.hostBindings && n.hostBindings(1, e) | |
| } | |
| function Oy(n, e) { | |
| e.flags |= 2, | |
| (n.components || (n.components = [])).push(e.index) | |
| } | |
| function Lx(n, e, t) { | |
| if (t) { | |
| if (e.exportAs) | |
| for (let r = 0; r < e.exportAs.length; r++) | |
| t[e.exportAs[r]] = n; | |
| Qn(e) && (t[""] = n) | |
| } | |
| } | |
| function Ny(n, e, t) { | |
| n.flags |= 1, | |
| n.directiveStart = e, | |
| n.directiveEnd = e + t, | |
| n.providerIndexes = e | |
| } | |
| function ky(n, e, t, r, i) { | |
| n.data[r] = i; | |
| const o = i.factory || (i.factory = Mi(i.type)) | |
| , s = new fs(o,Qn(i),B); | |
| n.blueprint[r] = s, | |
| t[r] = s, | |
| Fy(n, e, 0, r, wo(n, t, i.hostVars, ve), i) | |
| } | |
| function Vx(n, e, t) { | |
| const r = En(e, n) | |
| , i = Ay(t) | |
| , o = n[10] | |
| , s = Al(n, Dl(n, i, null, t.onPush ? 32 : 16, r, e, o, o.createRenderer(r, t), null, null, null)); | |
| n[e.index] = s | |
| } | |
| function ur(n, e, t, r, i, o) { | |
| const s = En(n, e); | |
| !function _h(n, e, t, r, i, o, s) { | |
| if (null == o) | |
| n.removeAttribute(e, i, t); | |
| else { | |
| const a = null == s ? ye(o) : s(o, r || "", i); | |
| n.setAttribute(e, i, a, t) | |
| } | |
| }(e[11], s, o, n.value, t, r, i) | |
| } | |
| function Bx(n, e, t, r, i, o) { | |
| const s = o[e]; | |
| if (null !== s) { | |
| const a = r.setInput; | |
| for (let l = 0; l < s.length; ) { | |
| const c = s[l++] | |
| , u = s[l++] | |
| , d = s[l++]; | |
| null !== a ? r.setInput(t, d, c, u) : t[u] = d | |
| } | |
| } | |
| } | |
| function Ux(n, e) { | |
| let t = null | |
| , r = 0; | |
| for (; r < e.length; ) { | |
| const i = e[r]; | |
| if (0 !== i) | |
| if (5 !== i) { | |
| if ("number" == typeof i) | |
| break; | |
| n.hasOwnProperty(i) && (null === t && (t = []), | |
| t.push(i, n[i], e[r + 1])), | |
| r += 2 | |
| } else | |
| r += 2; | |
| else | |
| r += 4 | |
| } | |
| return t | |
| } | |
| function Ly(n, e, t, r) { | |
| return new Array(n,!0,!1,e,null,0,r,t,null,null) | |
| } | |
| function zx(n, e) { | |
| const t = wn(e, n); | |
| if (Xa(t)) { | |
| const r = t[1]; | |
| 48 & t[2] ? Ml(r, t, r.template, t[8]) : t[5] > 0 && yh(t) | |
| } | |
| } | |
| function yh(n) { | |
| for (let r = Td(n); null !== r; r = Ed(r)) | |
| for (let i = 10; i < r.length; i++) { | |
| const o = r[i]; | |
| if (Xa(o)) | |
| if (512 & o[2]) { | |
| const s = o[1]; | |
| Ml(s, o, s.template, o[8]) | |
| } else | |
| o[5] > 0 && yh(o) | |
| } | |
| const t = n[1].components; | |
| if (null !== t) | |
| for (let r = 0; r < t.length; r++) { | |
| const i = wn(t[r], n); | |
| Xa(i) && i[5] > 0 && yh(i) | |
| } | |
| } | |
| function $x(n, e) { | |
| const t = wn(e, n) | |
| , r = t[1]; | |
| (function Wx(n, e) { | |
| for (let t = e.length; t < n.blueprint.length; t++) | |
| e.push(n.blueprint[t]) | |
| } | |
| )(r, t), | |
| hh(r, t, t[8]) | |
| } | |
| function Al(n, e) { | |
| return n[13] ? n[14][4] = e : n[13] = e, | |
| n[14] = e, | |
| e | |
| } | |
| function vh(n) { | |
| for (; n; ) { | |
| n[2] |= 32; | |
| const e = Is(n); | |
| if (jM(n) && !e) | |
| return n; | |
| n = e | |
| } | |
| return null | |
| } | |
| function Il(n, e, t, r=!0) { | |
| const i = e[10]; | |
| i.begin && i.begin(); | |
| try { | |
| Ml(n, e, n.template, t) | |
| } catch (s) { | |
| throw r && jy(e, s), | |
| s | |
| } finally { | |
| i.end && i.end() | |
| } | |
| } | |
| function bh(n, e, t) { | |
| Xu(0), | |
| e(n, t) | |
| } | |
| function Vy(n) { | |
| return n[7] || (n[7] = []) | |
| } | |
| function By(n) { | |
| return n.cleanup || (n.cleanup = []) | |
| } | |
| function jy(n, e) { | |
| const t = n[9] | |
| , r = t ? t.get(bo, null) : null; | |
| r && r.handleError(e) | |
| } | |
| function Ch(n, e, t, r, i) { | |
| for (let o = 0; o < t.length; ) { | |
| const s = t[o++] | |
| , a = t[o++] | |
| , l = e[s] | |
| , c = n.data[s]; | |
| null !== c.setInput ? c.setInput(l, i, r, a) : l[a] = i | |
| } | |
| } | |
| function Sl(n, e, t) { | |
| let r = t ? n.styles : null | |
| , i = t ? n.classes : null | |
| , o = 0; | |
| if (null !== e) | |
| for (let s = 0; s < e.length; s++) { | |
| const a = e[s]; | |
| "number" == typeof a ? o = a : 1 == o ? i = Pu(i, a) : 2 == o && (r = Pu(r, a + ": " + e[++s] + ";")) | |
| } | |
| t ? n.styles = r : n.stylesWithoutHost = r, | |
| t ? n.classes = i : n.classesWithoutHost = i | |
| } | |
| function xl(n, e, t, r, i=!1) { | |
| for (; null !== t; ) { | |
| const o = e[t.index]; | |
| if (null !== o && r.push(Dt(o)), | |
| Kn(o)) | |
| for (let a = 10; a < o.length; a++) { | |
| const l = o[a] | |
| , c = l[1].firstChild; | |
| null !== c && xl(l[1], l, c, r) | |
| } | |
| const s = t.type; | |
| if (8 & s) | |
| xl(n, e, t.child, r); | |
| else if (32 & s) { | |
| const a = Cd(t, e); | |
| let l; | |
| for (; l = a(); ) | |
| r.push(l) | |
| } else if (16 & s) { | |
| const a = T_(e, t); | |
| if (Array.isArray(a)) | |
| r.push(...a); | |
| else { | |
| const l = Is(e[16]); | |
| xl(l[1], l, a, r, !0) | |
| } | |
| } | |
| t = i ? t.projectionNext : t.next | |
| } | |
| return r | |
| } | |
| class Ns { | |
| constructor(e, t) { | |
| this._lView = e, | |
| this._cdRefInjectingView = t, | |
| this._appRef = null, | |
| this._attachedToViewContainer = !1 | |
| } | |
| get rootNodes() { | |
| const e = this._lView | |
| , t = e[1]; | |
| return xl(t, e, t.firstChild, []) | |
| } | |
| get context() { | |
| return this._lView[8] | |
| } | |
| set context(e) { | |
| this._lView[8] = e | |
| } | |
| get destroyed() { | |
| return 128 == (128 & this._lView[2]) | |
| } | |
| destroy() { | |
| if (this._appRef) | |
| this._appRef.detachView(this); | |
| else if (this._attachedToViewContainer) { | |
| const e = this._lView[3]; | |
| if (Kn(e)) { | |
| const t = e[8] | |
| , r = t ? t.indexOf(this) : -1; | |
| r > -1 && (Md(e, r), | |
| ll(t, r)) | |
| } | |
| this._attachedToViewContainer = !1 | |
| } | |
| f_(this._lView[1], this._lView) | |
| } | |
| onDestroy(e) { | |
| Iy(this._lView[1], this._lView, null, e) | |
| } | |
| markForCheck() { | |
| vh(this._cdRefInjectingView || this._lView) | |
| } | |
| detach() { | |
| this._lView[2] &= -65 | |
| } | |
| reattach() { | |
| this._lView[2] |= 64 | |
| } | |
| detectChanges() { | |
| Il(this._lView[1], this._lView, this.context) | |
| } | |
| checkNoChanges() {} | |
| attachToViewContainerRef() { | |
| if (this._appRef) | |
| throw new U(902,!1); | |
| this._attachedToViewContainer = !0 | |
| } | |
| detachFromAppRef() { | |
| this._appRef = null, | |
| function II(n, e) { | |
| Ss(n, e, e[11], 2, null, null) | |
| }(this._lView[1], this._lView) | |
| } | |
| attachToAppRef(e) { | |
| if (this._attachedToViewContainer) | |
| throw new U(902,!1); | |
| this._appRef = e | |
| } | |
| } | |
| class Gx extends Ns { | |
| constructor(e) { | |
| super(e), | |
| this._view = e | |
| } | |
| detectChanges() { | |
| const e = this._view; | |
| Il(e[1], e, e[8], !1) | |
| } | |
| checkNoChanges() {} | |
| get context() { | |
| return null | |
| } | |
| } | |
| class Th extends Ps { | |
| constructor(e) { | |
| super(), | |
| this.ngModule = e | |
| } | |
| resolveComponentFactory(e) { | |
| const t = ze(e); | |
| return new ks(t,this.ngModule) | |
| } | |
| } | |
| function Hy(n) { | |
| const e = []; | |
| for (let t in n) | |
| n.hasOwnProperty(t) && e.push({ | |
| propName: n[t], | |
| templateName: t | |
| }); | |
| return e | |
| } | |
| class Kx { | |
| constructor(e, t) { | |
| this.injector = e, | |
| this.parentInjector = t | |
| } | |
| get(e, t, r) { | |
| const i = this.injector.get(e, qd, r); | |
| return i !== qd || t === qd ? i : this.parentInjector.get(e, t, r) | |
| } | |
| } | |
| class ks extends G_ { | |
| constructor(e, t) { | |
| super(), | |
| this.componentDef = e, | |
| this.ngModule = t, | |
| this.componentType = e.type, | |
| this.selector = function qS(n) { | |
| return n.map(GS).join(",") | |
| }(e.selectors), | |
| this.ngContentSelectors = e.ngContentSelectors ? e.ngContentSelectors : [], | |
| this.isBoundToModule = !!t | |
| } | |
| get inputs() { | |
| return Hy(this.componentDef.inputs) | |
| } | |
| get outputs() { | |
| return Hy(this.componentDef.outputs) | |
| } | |
| create(e, t, r, i) { | |
| let o = (i = i || this.ngModule)instanceof ti ? i : null == i ? void 0 : i.injector; | |
| o && null !== this.componentDef.getStandaloneInjector && (o = this.componentDef.getStandaloneInjector(o) || o); | |
| const s = o ? new Kx(e,o) : e | |
| , a = s.get(Os, null); | |
| if (null === a) | |
| throw new U(407,!1); | |
| const l = s.get(IS, null) | |
| , c = a.createRenderer(null, this.componentDef) | |
| , u = this.componentDef.selectors[0][0] || "div" | |
| , d = r ? function Ax(n, e, t) { | |
| return n.selectRootElement(e, t === Gn.ShadowDom) | |
| }(c, r, this.componentDef.encapsulation) : Dd(c, u, function qx(n) { | |
| const e = n.toLowerCase(); | |
| return "svg" === e ? "svg" : "math" === e ? "math" : null | |
| }(u)) | |
| , h = this.componentDef.onPush ? 288 : 272 | |
| , f = gh(0, null, null, 1, 0, null, null, null, null, null) | |
| , p = Dl(null, f, null, h, null, null, a, c, l, s, null); | |
| let _, C; | |
| Ju(p); | |
| try { | |
| const S = function Zx(n, e, t, r, i, o) { | |
| const s = t[1]; | |
| t[22] = n; | |
| const l = Eo(s, 22, 2, "#host", null) | |
| , c = l.mergedAttrs = e.hostAttrs; | |
| null !== c && (Sl(l, c, !0), | |
| null !== n && (nl(i, n, c), | |
| null !== l.classes && Fd(i, n, l.classes), | |
| null !== l.styles && w_(i, n, l.styles))); | |
| const u = r.createRenderer(n, e) | |
| , d = Dl(t, Ay(e), null, e.onPush ? 32 : 16, t[22], l, r, u, o || null, null, null); | |
| return s.firstCreatePass && (sl(gs(l, t), s, e.type), | |
| Oy(s, l), | |
| Ny(l, t.length, 1)), | |
| Al(t, d), | |
| t[22] = d | |
| }(d, this.componentDef, p, a, c); | |
| if (d) | |
| if (r) | |
| nl(c, d, ["ng-version", SS.full]); | |
| else { | |
| const {attrs: R, classes: v} = function KS(n) { | |
| const e = [] | |
| , t = []; | |
| let r = 1 | |
| , i = 2; | |
| for (; r < n.length; ) { | |
| let o = n[r]; | |
| if ("string" == typeof o) | |
| 2 === i ? "" !== o && e.push(o, n[++r]) : 8 === i && t.push(o); | |
| else { | |
| if (!Yn(i)) | |
| break; | |
| i = o | |
| } | |
| r++ | |
| } | |
| return { | |
| attrs: e, | |
| classes: t | |
| } | |
| }(this.componentDef.selectors[0]); | |
| R && nl(c, d, R), | |
| v && v.length > 0 && Fd(c, d, v.join(" ")) | |
| } | |
| if (C = Gu(f, 22), | |
| void 0 !== t) { | |
| const R = C.projection = []; | |
| for (let v = 0; v < this.ngContentSelectors.length; v++) { | |
| const O = t[v]; | |
| R.push(null != O ? Array.from(O) : null) | |
| } | |
| } | |
| _ = function Xx(n, e, t, r) { | |
| const i = t[1] | |
| , o = function Rx(n, e, t) { | |
| const r = St(); | |
| n.firstCreatePass && (t.providersResolver && t.providersResolver(t), | |
| ky(n, r, e, wo(n, e, 1, null), t), | |
| xy(n, r)); | |
| const i = ms(e, n, r.directiveStart, r); | |
| Gt(i, e); | |
| const o = En(r, e); | |
| return o && Gt(o, e), | |
| i | |
| }(i, t, e); | |
| if (n[8] = t[8] = o, | |
| null !== r) | |
| for (const a of r) | |
| a(o, e); | |
| if (e.contentQueries) { | |
| const a = St(); | |
| e.contentQueries(1, o, a.directiveStart) | |
| } | |
| const s = St(); | |
| return !i.firstCreatePass || null === e.hostBindings && null === e.hostAttrs || (Zr(s.index), | |
| Fy(t[1], s, 0, s.directiveStart, s.directiveEnd, e), | |
| Py(e, o)), | |
| o | |
| }(S, this.componentDef, p, [Jx]), | |
| hh(f, p, null) | |
| } finally { | |
| ed() | |
| } | |
| return new Yx(this.componentType,_,vo(C, p),p,C) | |
| } | |
| } | |
| class Yx extends class TS { | |
| } | |
| { | |
| constructor(e, t, r, i, o) { | |
| super(), | |
| this.location = r, | |
| this._rootLView = i, | |
| this._tNode = o, | |
| this.instance = t, | |
| this.hostView = this.changeDetectorRef = new Gx(i), | |
| this.componentType = e | |
| } | |
| setInput(e, t) { | |
| const r = this._tNode.inputs; | |
| let i; | |
| if (null !== r && (i = r[e])) { | |
| const o = this._rootLView; | |
| Ch(o[1], o, i, e, t), | |
| Ry(o, this._tNode.index) | |
| } | |
| } | |
| get injector() { | |
| return new ao(this._tNode,this._rootLView) | |
| } | |
| destroy() { | |
| this.hostView.destroy() | |
| } | |
| onDestroy(e) { | |
| this.hostView.onDestroy(e) | |
| } | |
| } | |
| function Jx() { | |
| const n = St(); | |
| Ja(H()[1], n) | |
| } | |
| function ke(n) { | |
| let e = function zy(n) { | |
| return Object.getPrototypeOf(n.prototype).constructor | |
| }(n.type) | |
| , t = !0; | |
| const r = [n]; | |
| for (; e; ) { | |
| let i; | |
| if (Qn(n)) | |
| i = e.\u0275cmp || e.\u0275dir; | |
| else { | |
| if (e.\u0275cmp) | |
| throw new U(903,!1); | |
| i = e.\u0275dir | |
| } | |
| if (i) { | |
| if (t) { | |
| r.push(i); | |
| const s = n; | |
| s.inputs = Eh(n.inputs), | |
| s.declaredInputs = Eh(n.declaredInputs), | |
| s.outputs = Eh(n.outputs); | |
| const a = i.hostBindings; | |
| a && rR(n, a); | |
| const l = i.viewQuery | |
| , c = i.contentQueries; | |
| if (l && tR(n, l), | |
| c && nR(n, c), | |
| Fu(n.inputs, i.inputs), | |
| Fu(n.declaredInputs, i.declaredInputs), | |
| Fu(n.outputs, i.outputs), | |
| Qn(i) && i.data.animation) { | |
| const u = n.data; | |
| u.animation = (u.animation || []).concat(i.data.animation) | |
| } | |
| } | |
| const o = i.features; | |
| if (o) | |
| for (let s = 0; s < o.length; s++) { | |
| const a = o[s]; | |
| a && a.ngInherit && a(n), | |
| a === ke && (t = !1) | |
| } | |
| } | |
| e = Object.getPrototypeOf(e) | |
| } | |
| !function eR(n) { | |
| let e = 0 | |
| , t = null; | |
| for (let r = n.length - 1; r >= 0; r--) { | |
| const i = n[r]; | |
| i.hostVars = e += i.hostVars, | |
| i.hostAttrs = rl(i.hostAttrs, t = rl(t, i.hostAttrs)) | |
| } | |
| }(r) | |
| } | |
| function Eh(n) { | |
| return n === Xi ? {} : n === Ne ? [] : n | |
| } | |
| function tR(n, e) { | |
| const t = n.viewQuery; | |
| n.viewQuery = t ? (r, i) => { | |
| e(r, i), | |
| t(r, i) | |
| } | |
| : e | |
| } | |
| function nR(n, e) { | |
| const t = n.contentQueries; | |
| n.contentQueries = t ? (r, i, o) => { | |
| e(r, i, o), | |
| t(r, i, o) | |
| } | |
| : e | |
| } | |
| function rR(n, e) { | |
| const t = n.hostBindings; | |
| n.hostBindings = t ? (r, i) => { | |
| e(r, i), | |
| t(r, i) | |
| } | |
| : e | |
| } | |
| let Rl = null; | |
| function Ri() { | |
| if (!Rl) { | |
| const n = Ze.Symbol; | |
| if (n && n.iterator) | |
| Rl = n.iterator; | |
| else { | |
| const e = Object.getOwnPropertyNames(Map.prototype); | |
| for (let t = 0; t < e.length; ++t) { | |
| const r = e[t]; | |
| "entries" !== r && "size" !== r && Map.prototype[r] === Map.prototype.entries && (Rl = r) | |
| } | |
| } | |
| } | |
| return Rl | |
| } | |
| function Ls(n) { | |
| return !!wh(n) && (Array.isArray(n) || !(n instanceof Map) && Ri()in n) | |
| } | |
| function wh(n) { | |
| return null !== n && ("function" == typeof n || "object" == typeof n) | |
| } | |
| function qt(n, e, t) { | |
| return !Object.is(n[e], t) && (n[e] = t, | |
| !0) | |
| } | |
| function In(n, e, t, r) { | |
| const i = H(); | |
| return qt(i, io(), e) && (Pe(), | |
| ur(ct(), i, n, e, t, r)), | |
| In | |
| } | |
| function Ke(n, e, t, r, i, o, s, a) { | |
| const l = H() | |
| , c = Pe() | |
| , u = n + 22 | |
| , d = c.firstCreatePass ? function dR(n, e, t, r, i, o, s, a, l) { | |
| const c = e.consts | |
| , u = Eo(e, n, 4, s || null, Yr(c, a)); | |
| mh(e, t, u, Yr(c, l)), | |
| Ja(e, u); | |
| const d = u.tViews = gh(2, u, r, i, o, e.directiveRegistry, e.pipeRegistry, null, e.schemas, c); | |
| return null !== e.queries && (e.queries.template(e, u), | |
| d.queries = e.queries.embeddedTView(u)), | |
| u | |
| }(u, c, l, e, t, r, i, o, s) : c.data[u]; | |
| lr(d, !1); | |
| const h = l[11].createComment(""); | |
| pl(c, l, h, d), | |
| Gt(h, l), | |
| Al(l, l[u] = Ly(h, l, h, d)), | |
| Ya(d) && fh(c, l, d), | |
| null != s && ph(l, d, a) | |
| } | |
| function kn(n) { | |
| return function ro(n, e) { | |
| return n[e] | |
| }(function sA() { | |
| return me.lFrame.contextLView | |
| }(), 22 + n) | |
| } | |
| function Ae(n, e, t) { | |
| const r = H(); | |
| return qt(r, io(), e) && function An(n, e, t, r, i, o, s, a) { | |
| const l = En(e, t); | |
| let u, c = e.inputs; | |
| !a && null != c && (u = c[r]) ? (Ch(n, t, u, r, i), | |
| Qa(e) && Ry(t, e.index)) : 3 & e.type && (r = function Sx(n) { | |
| return "class" === n ? "className" : "for" === n ? "htmlFor" : "formaction" === n ? "formAction" : "innerHtml" === n ? "innerHTML" : "readonly" === n ? "readOnly" : "tabindex" === n ? "tabIndex" : n | |
| }(r), | |
| i = null != s ? s(i, e.value || "", r) : i, | |
| o.setProperty(l, r, i)) | |
| }(Pe(), ct(), r, n, e, r[11], t, !1), | |
| Ae | |
| } | |
| function Dh(n, e, t, r, i) { | |
| const s = i ? "class" : "style"; | |
| Ch(n, t, e.inputs[s], s, r) | |
| } | |
| function re(n, e, t, r) { | |
| const i = H() | |
| , o = Pe() | |
| , s = 22 + n | |
| , a = i[11] | |
| , l = i[s] = Dd(a, e, function _A() { | |
| return me.lFrame.currentNamespace | |
| }()) | |
| , c = o.firstCreatePass ? function fR(n, e, t, r, i, o, s) { | |
| const a = e.consts | |
| , c = Eo(e, n, 2, i, Yr(a, o)); | |
| return mh(e, t, c, Yr(a, s)), | |
| null !== c.attrs && Sl(c, c.attrs, !1), | |
| null !== c.mergedAttrs && Sl(c, c.mergedAttrs, !0), | |
| null !== e.queries && e.queries.elementStart(e, c), | |
| c | |
| }(s, o, i, 0, e, t, r) : o.data[s]; | |
| lr(c, !0); | |
| const u = c.mergedAttrs; | |
| null !== u && nl(a, l, u); | |
| const d = c.classes; | |
| null !== d && Fd(a, l, d); | |
| const h = c.styles; | |
| return null !== h && w_(a, l, h), | |
| 64 != (64 & c.flags) && pl(o, i, l, c), | |
| 0 === function tA() { | |
| return me.lFrame.elementDepthCount | |
| }() && Gt(l, i), | |
| function nA() { | |
| me.lFrame.elementDepthCount++ | |
| }(), | |
| Ya(c) && (fh(o, i, c), | |
| My(o, c, i)), | |
| null !== r && ph(i, c), | |
| re | |
| } | |
| function oe() { | |
| let n = St(); | |
| Ku() ? Qu() : (n = n.parent, | |
| lr(n, !1)); | |
| const e = n; | |
| !function rA() { | |
| me.lFrame.elementDepthCount-- | |
| }(); | |
| const t = Pe(); | |
| return t.firstCreatePass && (Ja(t, n), | |
| ju(n) && t.queries.elementEnd(n)), | |
| null != e.classesWithoutHost && function TA(n) { | |
| return 0 != (16 & n.flags) | |
| }(e) && Dh(t, e, H(), e.classesWithoutHost, !0), | |
| null != e.stylesWithoutHost && function EA(n) { | |
| return 0 != (32 & n.flags) | |
| }(e) && Dh(t, e, H(), e.stylesWithoutHost, !1), | |
| oe | |
| } | |
| function Ct(n, e, t, r) { | |
| return re(n, e, t, r), | |
| oe(), | |
| Ct | |
| } | |
| function Pi(n, e, t) { | |
| const r = H() | |
| , i = Pe() | |
| , o = n + 22 | |
| , s = i.firstCreatePass ? function pR(n, e, t, r, i) { | |
| const o = e.consts | |
| , s = Yr(o, r) | |
| , a = Eo(e, n, 8, "ng-container", s); | |
| return null !== s && Sl(a, s, !0), | |
| mh(e, t, a, Yr(o, i)), | |
| null !== e.queries && e.queries.elementStart(e, a), | |
| a | |
| }(o, i, r, e, t) : i.data[o]; | |
| lr(s, !0); | |
| const a = r[o] = r[11].createComment(""); | |
| return pl(i, r, a, s), | |
| Gt(a, r), | |
| Ya(s) && (fh(i, r, s), | |
| My(i, s, r)), | |
| null != t && ph(r, s), | |
| Pi | |
| } | |
| function Oi() { | |
| let n = St(); | |
| const e = Pe(); | |
| return Ku() ? Qu() : (n = n.parent, | |
| lr(n, !1)), | |
| e.firstCreatePass && (Ja(e, n), | |
| ju(n) && e.queries.elementEnd(n)), | |
| Oi | |
| } | |
| function Ln() { | |
| return H() | |
| } | |
| function Bs(n) { | |
| return !!n && "function" == typeof n.then | |
| } | |
| const Mh = function ev(n) { | |
| return !!n && "function" == typeof n.subscribe | |
| }; | |
| function _e(n, e, t, r) { | |
| const i = H() | |
| , o = Pe() | |
| , s = St(); | |
| return function nv(n, e, t, r, i, o, s, a) { | |
| const l = Ya(r) | |
| , u = n.firstCreatePass && By(n) | |
| , d = e[8] | |
| , h = Vy(e); | |
| let f = !0; | |
| if (3 & r.type || a) { | |
| const C = En(r, e) | |
| , S = a ? a(C) : C | |
| , R = h.length | |
| , v = a ? M => a(Dt(M[r.index])) : r.index; | |
| let O = null; | |
| if (!a && l && (O = function gR(n, e, t, r) { | |
| const i = n.cleanup; | |
| if (null != i) | |
| for (let o = 0; o < i.length - 1; o += 2) { | |
| const s = i[o]; | |
| if (s === t && i[o + 1] === r) { | |
| const a = e[7] | |
| , l = i[o + 2]; | |
| return a.length > l ? a[l] : null | |
| } | |
| "string" == typeof s && (o += 2) | |
| } | |
| return null | |
| }(n, e, i, r.index)), | |
| null !== O) | |
| (O.__ngLastListenerFn__ || O).__ngNextListenerFn__ = o, | |
| O.__ngLastListenerFn__ = o, | |
| f = !1; | |
| else { | |
| o = iv(r, e, d, o, !1); | |
| const M = t.listen(S, i, o); | |
| h.push(o, M), | |
| u && u.push(i, v, R, R + 1) | |
| } | |
| } else | |
| o = iv(r, e, d, o, !1); | |
| const p = r.outputs; | |
| let _; | |
| if (f && null !== p && (_ = p[i])) { | |
| const C = _.length; | |
| if (C) | |
| for (let S = 0; S < C; S += 2) { | |
| const N = e[_[S]][_[S + 1]].subscribe(o) | |
| , F = h.length; | |
| h.push(o, N), | |
| u && u.push(i, r.index, F, -(F + 1)) | |
| } | |
| } | |
| }(o, i, i[11], s, n, e, 0, r), | |
| _e | |
| } | |
| function rv(n, e, t, r) { | |
| try { | |
| return !1 !== t(r) | |
| } catch (i) { | |
| return jy(n, i), | |
| !1 | |
| } | |
| } | |
| function iv(n, e, t, r, i) { | |
| return function o(s) { | |
| if (s === Function) | |
| return r; | |
| vh(2 & n.flags ? wn(n.index, e) : e); | |
| let l = rv(e, 0, r, s) | |
| , c = o.__ngNextListenerFn__; | |
| for (; c; ) | |
| l = rv(e, 0, c, s) && l, | |
| c = c.__ngNextListenerFn__; | |
| return i && !1 === l && (s.preventDefault(), | |
| s.returnValue = !1), | |
| l | |
| } | |
| } | |
| function be(n=1) { | |
| return function dA(n) { | |
| return (me.lFrame.contextLView = function hA(n, e) { | |
| for (; n > 0; ) | |
| e = e[15], | |
| n--; | |
| return e | |
| }(n, me.lFrame.contextLView))[8] | |
| }(n) | |
| } | |
| function mR(n, e) { | |
| let t = null; | |
| const r = function HS(n) { | |
| const e = n.attrs; | |
| if (null != e) { | |
| const t = e.indexOf(5); | |
| if (0 == (1 & t)) | |
| return e[t + 1] | |
| } | |
| return null | |
| }(n); | |
| for (let i = 0; i < e.length; i++) { | |
| const o = e[i]; | |
| if ("*" !== o) { | |
| if (null === r ? ey(n, o, !0) : WS(r, o)) | |
| return i | |
| } else | |
| t = i | |
| } | |
| return t | |
| } | |
| function Ah(n) { | |
| const e = H()[16][6]; | |
| if (!e.projection) { | |
| const r = e.projection = vs(n ? n.length : 1, null) | |
| , i = r.slice(); | |
| let o = e.child; | |
| for (; null !== o; ) { | |
| const s = n ? mR(o, n) : 0; | |
| null !== s && (i[s] ? i[s].projectionNext = o : r[s] = o, | |
| i[s] = o), | |
| o = o.next | |
| } | |
| } | |
| } | |
| function Pl(n, e=0, t) { | |
| const r = H() | |
| , i = Pe() | |
| , o = Eo(i, 22 + n, 16, null, t || null); | |
| null === o.projection && (o.projection = e), | |
| Qu(), | |
| 64 != (64 & o.flags) && function kI(n, e, t) { | |
| E_(e[11], 0, e, t, p_(n, t, e), y_(t.parent || e[6], t, e)) | |
| }(i, r, o) | |
| } | |
| function pv(n, e, t, r, i) { | |
| const o = n[t + 1] | |
| , s = null === e; | |
| let a = r ? Zn(o) : Rr(o) | |
| , l = !1; | |
| for (; 0 !== a && (!1 === l || s); ) { | |
| const u = n[a + 1]; | |
| vR(n[a], e) && (l = !0, | |
| n[a + 1] = r ? rh(u) : th(u)), | |
| a = r ? Zn(u) : Rr(u) | |
| } | |
| l && (n[t + 1] = r ? th(o) : rh(o)) | |
| } | |
| function vR(n, e) { | |
| return null === n || null == e || (Array.isArray(n) ? n[1] : n) === e || !(!Array.isArray(n) || "string" != typeof e) && po(n, e) >= 0 | |
| } | |
| function Sh(n, e, t) { | |
| return Jn(n, e, t, !1), | |
| Sh | |
| } | |
| function Xn(n, e) { | |
| return Jn(n, e, null, !0), | |
| Xn | |
| } | |
| function Jn(n, e, t, r) { | |
| const i = H() | |
| , o = Pe() | |
| , s = function Mr(n) { | |
| const e = me.lFrame | |
| , t = e.bindingIndex; | |
| return e.bindingIndex = e.bindingIndex + n, | |
| t | |
| }(2); | |
| o.firstUpdatePass && function Tv(n, e, t, r) { | |
| const i = n.data; | |
| if (null === i[t + 1]) { | |
| const o = i[en()] | |
| , s = function Cv(n, e) { | |
| return e >= n.expandoStartIndex | |
| }(n, t); | |
| (function Mv(n, e) { | |
| return 0 != (n.flags & (e ? 16 : 32)) | |
| } | |
| )(o, r) && null === e && !s && (e = !1), | |
| e = function IR(n, e, t, r) { | |
| const i = function Zu(n) { | |
| const e = me.lFrame.currentDirectiveIndex; | |
| return -1 === e ? null : n[e] | |
| }(n); | |
| let o = r ? e.residualClasses : e.residualStyles; | |
| if (null === i) | |
| 0 === (r ? e.classBindings : e.styleBindings) && (t = Us(t = xh(null, n, e, t, r), e.attrs, r), | |
| o = null); | |
| else { | |
| const s = e.directiveStylingLast; | |
| if (-1 === s || n[s] !== i) | |
| if (t = xh(i, n, e, t, r), | |
| null === o) { | |
| let l = function SR(n, e, t) { | |
| const r = t ? e.classBindings : e.styleBindings; | |
| if (0 !== Rr(r)) | |
| return n[Zn(r)] | |
| }(n, e, r); | |
| void 0 !== l && Array.isArray(l) && (l = xh(null, n, e, l[1], r), | |
| l = Us(l, e.attrs, r), | |
| function xR(n, e, t, r) { | |
| n[Zn(t ? e.classBindings : e.styleBindings)] = r | |
| }(n, e, r, l)) | |
| } else | |
| o = function RR(n, e, t) { | |
| let r; | |
| const i = e.directiveEnd; | |
| for (let o = 1 + e.directiveStylingLast; o < i; o++) | |
| r = Us(r, n[o].hostAttrs, t); | |
| return Us(r, e.attrs, t) | |
| }(n, e, r) | |
| } | |
| return void 0 !== o && (r ? e.residualClasses = o : e.residualStyles = o), | |
| t | |
| }(i, o, e, r), | |
| function _R(n, e, t, r, i, o) { | |
| let s = o ? e.classBindings : e.styleBindings | |
| , a = Zn(s) | |
| , l = Rr(s); | |
| n[r] = t; | |
| let u, c = !1; | |
| if (Array.isArray(t)) { | |
| const d = t; | |
| u = d[1], | |
| (null === u || po(d, u) > 0) && (c = !0) | |
| } else | |
| u = t; | |
| if (i) | |
| if (0 !== l) { | |
| const h = Zn(n[a + 1]); | |
| n[r + 1] = Tl(h, a), | |
| 0 !== h && (n[h + 1] = nh(n[h + 1], r)), | |
| n[a + 1] = function fx(n, e) { | |
| return 131071 & n | e << 17 | |
| }(n[a + 1], r) | |
| } else | |
| n[r + 1] = Tl(a, 0), | |
| 0 !== a && (n[a + 1] = nh(n[a + 1], r)), | |
| a = r; | |
| else | |
| n[r + 1] = Tl(l, 0), | |
| 0 === a ? a = r : n[l + 1] = nh(n[l + 1], r), | |
| l = r; | |
| c && (n[r + 1] = th(n[r + 1])), | |
| pv(n, u, r, !0), | |
| pv(n, u, r, !1), | |
| function yR(n, e, t, r, i) { | |
| const o = i ? n.residualClasses : n.residualStyles; | |
| null != o && "string" == typeof e && po(o, e) >= 0 && (t[r + 1] = rh(t[r + 1])) | |
| }(e, u, n, r, o), | |
| s = Tl(a, l), | |
| o ? e.classBindings = s : e.styleBindings = s | |
| }(i, o, e, t, s, r) | |
| } | |
| }(o, n, s, r), | |
| e !== ve && qt(i, s, e) && function wv(n, e, t, r, i, o, s, a) { | |
| if (!(3 & e.type)) | |
| return; | |
| const l = n.data | |
| , c = l[a + 1]; | |
| Ol(function my(n) { | |
| return 1 == (1 & n) | |
| }(c) ? Dv(l, e, t, i, Rr(c), s) : void 0) || (Ol(o) || function gy(n) { | |
| return 2 == (2 & n) | |
| }(c) && (o = Dv(l, null, t, i, a, s)), | |
| function VI(n, e, t, r, i) { | |
| if (e) | |
| i ? n.addClass(t, r) : n.removeClass(t, r); | |
| else { | |
| let o = -1 === r.indexOf("-") ? void 0 : pn.DashCase; | |
| null == i ? n.removeStyle(t, r, o) : ("string" == typeof i && i.endsWith("!important") && (i = i.slice(0, -10), | |
| o |= pn.Important), | |
| n.setStyle(t, r, i, o)) | |
| } | |
| }(r, s, Za(en(), t), i, o)) | |
| }(o, o.data[en()], i, i[11], n, i[s + 1] = function OR(n, e) { | |
| return null == n || ("string" == typeof e ? n += e : "object" == typeof n && (n = Ge(Jr(n)))), | |
| n | |
| }(e, t), r, s) | |
| } | |
| function xh(n, e, t, r, i) { | |
| let o = null; | |
| const s = t.directiveEnd; | |
| let a = t.directiveStylingLast; | |
| for (-1 === a ? a = t.directiveStart : a++; a < s && (o = e[a], | |
| r = Us(r, o.hostAttrs, i), | |
| o !== n); ) | |
| a++; | |
| return null !== n && (t.directiveStylingLast = a), | |
| r | |
| } | |
| function Us(n, e, t) { | |
| const r = t ? 1 : 2; | |
| let i = -1; | |
| if (null !== e) | |
| for (let o = 0; o < e.length; o++) { | |
| const s = e[o]; | |
| "number" == typeof s ? i = s : i === r && (Array.isArray(n) || (n = void 0 === n ? [] : ["", n]), | |
| Mn(n, s, !!t || e[++o])) | |
| } | |
| return void 0 === n ? null : n | |
| } | |
| function Dv(n, e, t, r, i, o) { | |
| const s = null === e; | |
| let a; | |
| for (; i > 0; ) { | |
| const l = n[i] | |
| , c = Array.isArray(l) | |
| , u = c ? l[1] : l | |
| , d = null === u; | |
| let h = t[i + 1]; | |
| h === ve && (h = d ? Ne : void 0); | |
| let f = d ? cd(h, r) : u === r ? h : void 0; | |
| if (c && !Ol(f) && (f = cd(l, r)), | |
| Ol(f) && (a = f, | |
| s)) | |
| return a; | |
| const p = n[i + 1]; | |
| i = s ? Zn(p) : Rr(p) | |
| } | |
| if (null !== e) { | |
| let l = o ? e.residualClasses : e.residualStyles; | |
| null != l && (a = cd(l, r)) | |
| } | |
| return a | |
| } | |
| function Ol(n) { | |
| return void 0 !== n | |
| } | |
| function $e(n, e="") { | |
| const t = H() | |
| , r = Pe() | |
| , i = n + 22 | |
| , o = r.firstCreatePass ? Eo(r, i, 1, e, null) : r.data[i] | |
| , s = t[i] = function wd(n, e) { | |
| return n.createText(e) | |
| }(t[11], e); | |
| pl(r, t, s, o), | |
| lr(o, !1) | |
| } | |
| function pr(n) { | |
| return Rh("", n, ""), | |
| pr | |
| } | |
| function Rh(n, e, t) { | |
| const r = H() | |
| , i = function Mo(n, e, t, r) { | |
| return qt(n, io(), t) ? e + ye(t) + r : ve | |
| }(r, n, e, t); | |
| return i !== ve && function Fr(n, e, t) { | |
| const r = Za(e, n); | |
| !function d_(n, e, t) { | |
| n.setValue(e, t) | |
| }(n[11], r, t) | |
| }(r, en(), i), | |
| Rh | |
| } | |
| const ko = "en-US"; | |
| let Kv = ko; | |
| function Oh(n, e, t, r, i) { | |
| if (n = ge(n), | |
| Array.isArray(n)) | |
| for (let o = 0; o < n.length; o++) | |
| Oh(n[o], e, t, r, i); | |
| else { | |
| const o = Pe() | |
| , s = H(); | |
| let a = Si(n) ? n : ge(n.provide) | |
| , l = W_(n); | |
| const c = St() | |
| , u = 1048575 & c.providerIndexes | |
| , d = c.directiveStart | |
| , h = c.providerIndexes >> 20; | |
| if (Si(n) || !n.multi) { | |
| const f = new fs(l,i,B) | |
| , p = kh(a, e, i ? u : u + h, d); | |
| -1 === p ? (sl(gs(c, s), o, a), | |
| Nh(o, n, e.length), | |
| e.push(a), | |
| c.directiveStart++, | |
| c.directiveEnd++, | |
| i && (c.providerIndexes += 1048576), | |
| t.push(f), | |
| s.push(f)) : (t[p] = f, | |
| s[p] = f) | |
| } else { | |
| const f = kh(a, e, u + h, d) | |
| , p = kh(a, e, u, u + h) | |
| , _ = f >= 0 && t[f] | |
| , C = p >= 0 && t[p]; | |
| if (i && !C || !i && !_) { | |
| sl(gs(c, s), o, a); | |
| const S = function J1(n, e, t, r, i) { | |
| const o = new fs(n,t,B); | |
| return o.multi = [], | |
| o.index = e, | |
| o.componentProviders = 0, | |
| vb(o, i, r && !t), | |
| o | |
| }(i ? X1 : Z1, t.length, i, r, l); | |
| !i && C && (t[p].providerFactory = S), | |
| Nh(o, n, e.length, 0), | |
| e.push(a), | |
| c.directiveStart++, | |
| c.directiveEnd++, | |
| i && (c.providerIndexes += 1048576), | |
| t.push(S), | |
| s.push(S) | |
| } else | |
| Nh(o, n, f > -1 ? f : p, vb(t[i ? p : f], l, !i && r)); | |
| !i && r && C && t[p].componentProviders++ | |
| } | |
| } | |
| } | |
| function Nh(n, e, t, r) { | |
| const i = Si(e) | |
| , o = function pS(n) { | |
| return !!n.useClass | |
| }(e); | |
| if (i || o) { | |
| const l = (o ? ge(e.useClass) : e).prototype.ngOnDestroy; | |
| if (l) { | |
| const c = n.destroyHooks || (n.destroyHooks = []); | |
| if (!i && e.multi) { | |
| const u = c.indexOf(t); | |
| -1 === u ? c.push(t, [r, l]) : c[u + 1].push(r, l) | |
| } else | |
| c.push(t, l) | |
| } | |
| } | |
| } | |
| function vb(n, e, t) { | |
| return t && n.componentProviders++, | |
| n.multi.push(e) - 1 | |
| } | |
| function kh(n, e, t, r) { | |
| for (let i = t; i < r; i++) | |
| if (e[i] === n) | |
| return i; | |
| return -1 | |
| } | |
| function Z1(n, e, t, r) { | |
| return Lh(this.multi, []) | |
| } | |
| function X1(n, e, t, r) { | |
| const i = this.multi; | |
| let o; | |
| if (this.providerFactory) { | |
| const s = this.providerFactory.componentProviders | |
| , a = ms(t, t[1], this.providerFactory.index, r); | |
| o = a.slice(0, s), | |
| Lh(i, o); | |
| for (let l = s; l < a.length; l++) | |
| o.push(a[l]) | |
| } else | |
| o = [], | |
| Lh(i, o); | |
| return o | |
| } | |
| function Lh(n, e) { | |
| for (let t = 0; t < n.length; t++) | |
| e.push((0, | |
| n[t])()); | |
| return e | |
| } | |
| function tt(n, e=[]) { | |
| return t => { | |
| t.providersResolver = (r, i) => function Y1(n, e, t) { | |
| const r = Pe(); | |
| if (r.firstCreatePass) { | |
| const i = Qn(n); | |
| Oh(t, r.data, r.blueprint, i, !0), | |
| Oh(e, r.data, r.blueprint, i, !1) | |
| } | |
| }(r, i ? i(n) : n, e) | |
| } | |
| } | |
| class ki { | |
| } | |
| class bb { | |
| } | |
| class Cb extends ki { | |
| constructor(e, t) { | |
| super(), | |
| this._parent = t, | |
| this._bootstrapComponents = [], | |
| this.destroyCbs = [], | |
| this.componentFactoryResolver = new Th(this); | |
| const r = bn(e); | |
| this._bootstrapComponents = xr(r.bootstrap), | |
| this._r3Injector = ay(e, t, [{ | |
| provide: ki, | |
| useValue: this | |
| }, { | |
| provide: Ps, | |
| useValue: this.componentFactoryResolver | |
| }], Ge(e), new Set(["environment"])), | |
| this._r3Injector.resolveInjectorInitializers(), | |
| this.instance = this._r3Injector.get(e) | |
| } | |
| get injector() { | |
| return this._r3Injector | |
| } | |
| destroy() { | |
| const e = this._r3Injector; | |
| !e.destroyed && e.destroy(), | |
| this.destroyCbs.forEach(t => t()), | |
| this.destroyCbs = null | |
| } | |
| onDestroy(e) { | |
| this.destroyCbs.push(e) | |
| } | |
| } | |
| class Vh extends bb { | |
| constructor(e) { | |
| super(), | |
| this.moduleType = e | |
| } | |
| create(e) { | |
| return new Cb(this.moduleType,e) | |
| } | |
| } | |
| class tF extends ki { | |
| constructor(e, t, r) { | |
| super(), | |
| this.componentFactoryResolver = new Th(this), | |
| this.instance = null; | |
| const i = new $_([...e, { | |
| provide: ki, | |
| useValue: this | |
| }, { | |
| provide: Ps, | |
| useValue: this.componentFactoryResolver | |
| }],t || bl(),r,new Set(["environment"])); | |
| this.injector = i, | |
| i.resolveInjectorInitializers() | |
| } | |
| destroy() { | |
| this.injector.destroy() | |
| } | |
| onDestroy(e) { | |
| this.injector.onDestroy(e) | |
| } | |
| } | |
| function Bl(n, e, t=null) { | |
| return new tF(n,e,t).injector | |
| } | |
| let nF = ( () => { | |
| class n { | |
| constructor(t) { | |
| this._injector = t, | |
| this.cachedInjectors = new Map | |
| } | |
| getOrCreateStandaloneInjector(t) { | |
| if (!t.standalone) | |
| return null; | |
| if (!this.cachedInjectors.has(t.id)) { | |
| const r = U_(0, t.type) | |
| , i = r.length > 0 ? Bl([r], this._injector, `Standalone[${t.type.name}]`) : null; | |
| this.cachedInjectors.set(t.id, i) | |
| } | |
| return this.cachedInjectors.get(t.id) | |
| } | |
| ngOnDestroy() { | |
| try { | |
| for (const t of this.cachedInjectors.values()) | |
| null !== t && t.destroy() | |
| } finally { | |
| this.cachedInjectors.clear() | |
| } | |
| } | |
| } | |
| return n.\u0275prov = se({ | |
| token: n, | |
| providedIn: "environment", | |
| factory: () => new n(Q(ti)) | |
| }), | |
| n | |
| } | |
| )(); | |
| function Tb(n) { | |
| n.getStandaloneInjector = e => e.get(nF).getOrCreateStandaloneInjector(n) | |
| } | |
| function Uh(n) { | |
| return e => { | |
| setTimeout(n, void 0, e) | |
| } | |
| } | |
| const Se = class IF extends un { | |
| constructor(e=!1) { | |
| super(), | |
| this.__isAsync = e | |
| } | |
| emit(e) { | |
| super.next(e) | |
| } | |
| subscribe(e, t, r) { | |
| var i, o, s; | |
| let a = e | |
| , l = t || ( () => null) | |
| , c = r; | |
| if (e && "object" == typeof e) { | |
| const d = e; | |
| a = null === (i = d.next) || void 0 === i ? void 0 : i.bind(d), | |
| l = null === (o = d.error) || void 0 === o ? void 0 : o.bind(d), | |
| c = null === (s = d.complete) || void 0 === s ? void 0 : s.bind(d) | |
| } | |
| this.__isAsync && (l = Uh(l), | |
| a && (a = Uh(a)), | |
| c && (c = Uh(c))); | |
| const u = super.subscribe({ | |
| next: a, | |
| error: l, | |
| complete: c | |
| }); | |
| return e instanceof mn && e.add(u), | |
| u | |
| } | |
| } | |
| ; | |
| function SF() { | |
| return this._results[Ri()]() | |
| } | |
| class jh { | |
| constructor(e=!1) { | |
| this._emitDistinctChangesOnly = e, | |
| this.dirty = !0, | |
| this._results = [], | |
| this._changesDetected = !1, | |
| this._changes = null, | |
| this.length = 0, | |
| this.first = void 0, | |
| this.last = void 0; | |
| const t = Ri() | |
| , r = jh.prototype; | |
| r[t] || (r[t] = SF) | |
| } | |
| get changes() { | |
| return this._changes || (this._changes = new Se) | |
| } | |
| get(e) { | |
| return this._results[e] | |
| } | |
| map(e) { | |
| return this._results.map(e) | |
| } | |
| filter(e) { | |
| return this._results.filter(e) | |
| } | |
| find(e) { | |
| return this._results.find(e) | |
| } | |
| reduce(e, t) { | |
| return this._results.reduce(e, t) | |
| } | |
| forEach(e) { | |
| this._results.forEach(e) | |
| } | |
| some(e) { | |
| return this._results.some(e) | |
| } | |
| toArray() { | |
| return this._results.slice() | |
| } | |
| toString() { | |
| return this._results.toString() | |
| } | |
| reset(e, t) { | |
| const r = this; | |
| r.dirty = !1; | |
| const i = Dn(e); | |
| (this._changesDetected = !function PA(n, e, t) { | |
| if (n.length !== e.length) | |
| return !1; | |
| for (let r = 0; r < n.length; r++) { | |
| let i = n[r] | |
| , o = e[r]; | |
| if (t && (i = t(i), | |
| o = t(o)), | |
| o !== i) | |
| return !1 | |
| } | |
| return !0 | |
| }(r._results, i, t)) && (r._results = i, | |
| r.length = i.length, | |
| r.last = i[this.length - 1], | |
| r.first = i[0]) | |
| } | |
| notifyOnChanges() { | |
| this._changes && (this._changesDetected || !this._emitDistinctChangesOnly) && this._changes.emit(this) | |
| } | |
| setDirty() { | |
| this.dirty = !0 | |
| } | |
| destroy() { | |
| this.changes.complete(), | |
| this.changes.unsubscribe() | |
| } | |
| } | |
| let Pr = ( () => { | |
| class n { | |
| } | |
| return n.__NG_ELEMENT_ID__ = FF, | |
| n | |
| } | |
| )(); | |
| const xF = Pr | |
| , RF = class extends xF { | |
| constructor(e, t, r) { | |
| super(), | |
| this._declarationLView = e, | |
| this._declarationTContainer = t, | |
| this.elementRef = r | |
| } | |
| createEmbeddedView(e, t) { | |
| const r = this._declarationTContainer.tViews | |
| , i = Dl(this._declarationLView, r, e, 16, null, r.declTNode, null, null, null, null, t || null); | |
| i[17] = this._declarationLView[this._declarationTContainer.index]; | |
| const s = this._declarationLView[19]; | |
| return null !== s && (i[19] = s.createEmbeddedView(r)), | |
| hh(r, i, e), | |
| new Ns(i) | |
| } | |
| } | |
| ; | |
| function FF() { | |
| return Ul(St(), H()) | |
| } | |
| function Ul(n, e) { | |
| return 4 & n.type ? new RF(e,n,vo(n, e)) : null | |
| } | |
| let tr = ( () => { | |
| class n { | |
| } | |
| return n.__NG_ELEMENT_ID__ = PF, | |
| n | |
| } | |
| )(); | |
| function PF() { | |
| return kb(St(), H()) | |
| } | |
| const OF = tr | |
| , Ob = class extends OF { | |
| constructor(e, t, r) { | |
| super(), | |
| this._lContainer = e, | |
| this._hostTNode = t, | |
| this._hostLView = r | |
| } | |
| get element() { | |
| return vo(this._hostTNode, this._hostLView) | |
| } | |
| get injector() { | |
| return new ao(this._hostTNode,this._hostLView) | |
| } | |
| get parentInjector() { | |
| const e = ol(this._hostTNode, this._hostLView); | |
| if (Im(e)) { | |
| const t = so(e, this._hostLView) | |
| , r = oo(e); | |
| return new ao(t[1].data[r + 8],t) | |
| } | |
| return new ao(null,this._hostLView) | |
| } | |
| clear() { | |
| for (; this.length > 0; ) | |
| this.remove(this.length - 1) | |
| } | |
| get(e) { | |
| const t = Nb(this._lContainer); | |
| return null !== t && t[e] || null | |
| } | |
| get length() { | |
| return this._lContainer.length - 10 | |
| } | |
| createEmbeddedView(e, t, r) { | |
| let i, o; | |
| "number" == typeof r ? i = r : null != r && (i = r.index, | |
| o = r.injector); | |
| const s = e.createEmbeddedView(t || {}, o); | |
| return this.insert(s, i), | |
| s | |
| } | |
| createComponent(e, t, r, i, o) { | |
| const s = e && !function ys(n) { | |
| return "function" == typeof n | |
| }(e); | |
| let a; | |
| if (s) | |
| a = t; | |
| else { | |
| const d = t || {}; | |
| a = d.index, | |
| r = d.injector, | |
| i = d.projectableNodes, | |
| o = d.environmentInjector || d.ngModuleRef | |
| } | |
| const l = s ? e : new ks(ze(e)) | |
| , c = r || this.parentInjector; | |
| if (!o && null == l.ngModule) { | |
| const h = (s ? c : this.parentInjector).get(ti, null); | |
| h && (o = h) | |
| } | |
| const u = l.create(c, i, void 0, o); | |
| return this.insert(u.hostView, a), | |
| u | |
| } | |
| insert(e, t) { | |
| const r = e._lView | |
| , i = r[1]; | |
| if (function eA(n) { | |
| return Kn(n[3]) | |
| }(r)) { | |
| const u = this.indexOf(e); | |
| if (-1 !== u) | |
| this.detach(u); | |
| else { | |
| const d = r[3] | |
| , h = new Ob(d,d[6],d[3]); | |
| h.detach(h.indexOf(e)) | |
| } | |
| } | |
| const o = this._adjustIndex(t) | |
| , s = this._lContainer; | |
| !function xI(n, e, t, r) { | |
| const i = 10 + r | |
| , o = t.length; | |
| r > 0 && (t[i - 1][4] = e), | |
| r < o - 10 ? (e[4] = t[i], | |
| Bm(t, 10 + r, e)) : (t.push(e), | |
| e[4] = null), | |
| e[3] = t; | |
| const s = e[17]; | |
| null !== s && t !== s && function RI(n, e) { | |
| const t = n[9]; | |
| e[16] !== e[3][3][16] && (n[2] = !0), | |
| null === t ? n[9] = [e] : t.push(e) | |
| }(s, e); | |
| const a = e[19]; | |
| null !== a && a.insertView(n), | |
| e[2] |= 64 | |
| }(i, r, s, o); | |
| const a = Sd(o, s) | |
| , l = r[11] | |
| , c = fl(l, s[7]); | |
| return null !== c && function AI(n, e, t, r, i, o) { | |
| r[0] = i, | |
| r[6] = e, | |
| Ss(n, r, t, 1, i, o) | |
| }(i, s[6], l, r, c, a), | |
| e.attachToViewContainerRef(), | |
| Bm(Hh(s), o, e), | |
| e | |
| } | |
| move(e, t) { | |
| return this.insert(e, t) | |
| } | |
| indexOf(e) { | |
| const t = Nb(this._lContainer); | |
| return null !== t ? t.indexOf(e) : -1 | |
| } | |
| remove(e) { | |
| const t = this._adjustIndex(e, -1) | |
| , r = Md(this._lContainer, t); | |
| r && (ll(Hh(this._lContainer), t), | |
| f_(r[1], r)) | |
| } | |
| detach(e) { | |
| const t = this._adjustIndex(e, -1) | |
| , r = Md(this._lContainer, t); | |
| return r && null != ll(Hh(this._lContainer), t) ? new Ns(r) : null | |
| } | |
| _adjustIndex(e, t=0) { | |
| return null == e ? this.length + t : e | |
| } | |
| } | |
| ; | |
| function Nb(n) { | |
| return n[8] | |
| } | |
| function Hh(n) { | |
| return n[8] || (n[8] = []) | |
| } | |
| function kb(n, e) { | |
| let t; | |
| const r = e[n.index]; | |
| if (Kn(r)) | |
| t = r; | |
| else { | |
| let i; | |
| if (8 & n.type) | |
| i = Dt(r); | |
| else { | |
| const o = e[11]; | |
| i = o.createComment(""); | |
| const s = En(n, e); | |
| Ai(o, fl(o, s), i, function NI(n, e) { | |
| return n.nextSibling(e) | |
| }(o, s), !1) | |
| } | |
| e[n.index] = t = Ly(r, e, i, n), | |
| Al(e, t) | |
| } | |
| return new Ob(t,n,e) | |
| } | |
| class zh { | |
| constructor(e) { | |
| this.queryList = e, | |
| this.matches = null | |
| } | |
| clone() { | |
| return new zh(this.queryList) | |
| } | |
| setDirty() { | |
| this.queryList.setDirty() | |
| } | |
| } | |
| class $h { | |
| constructor(e=[]) { | |
| this.queries = e | |
| } | |
| createEmbeddedView(e) { | |
| const t = e.queries; | |
| if (null !== t) { | |
| const r = null !== e.contentQueries ? e.contentQueries[0] : t.length | |
| , i = []; | |
| for (let o = 0; o < r; o++) { | |
| const s = t.getByIndex(o); | |
| i.push(this.queries[s.indexInDeclarationView].clone()) | |
| } | |
| return new $h(i) | |
| } | |
| return null | |
| } | |
| insertView(e) { | |
| this.dirtyQueriesWithMatches(e) | |
| } | |
| detachView(e) { | |
| this.dirtyQueriesWithMatches(e) | |
| } | |
| dirtyQueriesWithMatches(e) { | |
| for (let t = 0; t < this.queries.length; t++) | |
| null !== jb(e, t).matches && this.queries[t].setDirty() | |
| } | |
| } | |
| class Lb { | |
| constructor(e, t, r=null) { | |
| this.predicate = e, | |
| this.flags = t, | |
| this.read = r | |
| } | |
| } | |
| class Wh { | |
| constructor(e=[]) { | |
| this.queries = e | |
| } | |
| elementStart(e, t) { | |
| for (let r = 0; r < this.queries.length; r++) | |
| this.queries[r].elementStart(e, t) | |
| } | |
| elementEnd(e) { | |
| for (let t = 0; t < this.queries.length; t++) | |
| this.queries[t].elementEnd(e) | |
| } | |
| embeddedTView(e) { | |
| let t = null; | |
| for (let r = 0; r < this.length; r++) { | |
| const i = null !== t ? t.length : 0 | |
| , o = this.getByIndex(r).embeddedTView(e, i); | |
| o && (o.indexInDeclarationView = r, | |
| null !== t ? t.push(o) : t = [o]) | |
| } | |
| return null !== t ? new Wh(t) : null | |
| } | |
| template(e, t) { | |
| for (let r = 0; r < this.queries.length; r++) | |
| this.queries[r].template(e, t) | |
| } | |
| getByIndex(e) { | |
| return this.queries[e] | |
| } | |
| get length() { | |
| return this.queries.length | |
| } | |
| track(e) { | |
| this.queries.push(e) | |
| } | |
| } | |
| class Gh { | |
| constructor(e, t=-1) { | |
| this.metadata = e, | |
| this.matches = null, | |
| this.indexInDeclarationView = -1, | |
| this.crossesNgTemplate = !1, | |
| this._appliesToNextNode = !0, | |
| this._declarationNodeIndex = t | |
| } | |
| elementStart(e, t) { | |
| this.isApplyingToNode(t) && this.matchTNode(e, t) | |
| } | |
| elementEnd(e) { | |
| this._declarationNodeIndex === e.index && (this._appliesToNextNode = !1) | |
| } | |
| template(e, t) { | |
| this.elementStart(e, t) | |
| } | |
| embeddedTView(e, t) { | |
| return this.isApplyingToNode(e) ? (this.crossesNgTemplate = !0, | |
| this.addMatch(-e.index, t), | |
| new Gh(this.metadata)) : null | |
| } | |
| isApplyingToNode(e) { | |
| if (this._appliesToNextNode && 1 != (1 & this.metadata.flags)) { | |
| const t = this._declarationNodeIndex; | |
| let r = e.parent; | |
| for (; null !== r && 8 & r.type && r.index !== t; ) | |
| r = r.parent; | |
| return t === (null !== r ? r.index : -1) | |
| } | |
| return this._appliesToNextNode | |
| } | |
| matchTNode(e, t) { | |
| const r = this.metadata.predicate; | |
| if (Array.isArray(r)) | |
| for (let i = 0; i < r.length; i++) { | |
| const o = r[i]; | |
| this.matchTNodeWithReadOption(e, t, LF(t, o)), | |
| this.matchTNodeWithReadOption(e, t, al(t, e, o, !1, !1)) | |
| } | |
| else | |
| r === Pr ? 4 & t.type && this.matchTNodeWithReadOption(e, t, -1) : this.matchTNodeWithReadOption(e, t, al(t, e, r, !1, !1)) | |
| } | |
| matchTNodeWithReadOption(e, t, r) { | |
| if (null !== r) { | |
| const i = this.metadata.read; | |
| if (null !== i) | |
| if (i === Vt || i === tr || i === Pr && 4 & t.type) | |
| this.addMatch(t.index, -2); | |
| else { | |
| const o = al(t, e, i, !1, !1); | |
| null !== o && this.addMatch(t.index, o) | |
| } | |
| else | |
| this.addMatch(t.index, r) | |
| } | |
| } | |
| addMatch(e, t) { | |
| null === this.matches ? this.matches = [e, t] : this.matches.push(e, t) | |
| } | |
| } | |
| function LF(n, e) { | |
| const t = n.localNames; | |
| if (null !== t) | |
| for (let r = 0; r < t.length; r += 2) | |
| if (t[r] === e) | |
| return t[r + 1]; | |
| return null | |
| } | |
| function BF(n, e, t, r) { | |
| return -1 === t ? function VF(n, e) { | |
| return 11 & n.type ? vo(n, e) : 4 & n.type ? Ul(n, e) : null | |
| }(e, n) : -2 === t ? function UF(n, e, t) { | |
| return t === Vt ? vo(e, n) : t === Pr ? Ul(e, n) : t === tr ? kb(e, n) : void 0 | |
| }(n, e, r) : ms(n, n[1], t, e) | |
| } | |
| function Vb(n, e, t, r) { | |
| const i = e[19].queries[r]; | |
| if (null === i.matches) { | |
| const o = n.data | |
| , s = t.matches | |
| , a = []; | |
| for (let l = 0; l < s.length; l += 2) { | |
| const c = s[l]; | |
| a.push(c < 0 ? null : BF(e, o[c], s[l + 1], t.metadata.read)) | |
| } | |
| i.matches = a | |
| } | |
| return i.matches | |
| } | |
| function qh(n, e, t, r) { | |
| const i = n.queries.getByIndex(t) | |
| , o = i.matches; | |
| if (null !== o) { | |
| const s = Vb(n, e, i, t); | |
| for (let a = 0; a < o.length; a += 2) { | |
| const l = o[a]; | |
| if (l > 0) | |
| r.push(s[a / 2]); | |
| else { | |
| const c = o[a + 1] | |
| , u = e[-l]; | |
| for (let d = 10; d < u.length; d++) { | |
| const h = u[d]; | |
| h[17] === h[3] && qh(h[1], h, c, r) | |
| } | |
| if (null !== u[9]) { | |
| const d = u[9]; | |
| for (let h = 0; h < d.length; h++) { | |
| const f = d[h]; | |
| qh(f[1], f, c, r) | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return r | |
| } | |
| function rn(n) { | |
| const e = H() | |
| , t = Pe() | |
| , r = ym(); | |
| Xu(r + 1); | |
| const i = jb(t, r); | |
| if (n.dirty && function JM(n) { | |
| return 4 == (4 & n[2]) | |
| }(e) === (2 == (2 & i.metadata.flags))) { | |
| if (null === i.matches) | |
| n.reset([]); | |
| else { | |
| const o = i.crossesNgTemplate ? qh(t, e, r, []) : Vb(t, e, i, r); | |
| n.reset(o, MS), | |
| n.notifyOnChanges() | |
| } | |
| return !0 | |
| } | |
| return !1 | |
| } | |
| function nr(n, e, t) { | |
| const r = Pe(); | |
| r.firstCreatePass && (Ub(r, new Lb(n,e,t), -1), | |
| 2 == (2 & e) && (r.staticViewQueries = !0)), | |
| Bb(r, H(), e) | |
| } | |
| function Ks(n, e, t, r) { | |
| const i = Pe(); | |
| if (i.firstCreatePass) { | |
| const o = St(); | |
| Ub(i, new Lb(e,t,r), o.index), | |
| function HF(n, e) { | |
| const t = n.contentQueries || (n.contentQueries = []); | |
| e !== (t.length ? t[t.length - 1] : -1) && t.push(n.queries.length - 1, e) | |
| }(i, n), | |
| 2 == (2 & t) && (i.staticContentQueries = !0) | |
| } | |
| Bb(i, H(), t) | |
| } | |
| function on() { | |
| return function jF(n, e) { | |
| return n[19].queries[e].queryList | |
| }(H(), ym()) | |
| } | |
| function Bb(n, e, t) { | |
| const r = new jh(4 == (4 & t)); | |
| Iy(n, e, r, r.destroy), | |
| null === e[19] && (e[19] = new $h), | |
| e[19].queries.push(new zh(r)) | |
| } | |
| function Ub(n, e, t) { | |
| null === n.queries && (n.queries = new Wh), | |
| n.queries.track(new Gh(e,t)) | |
| } | |
| function jb(n, e) { | |
| return n.queries.getByIndex(e) | |
| } | |
| function rr(n, e) { | |
| return Ul(n, e) | |
| } | |
| function Hl(...n) {} | |
| const zl = new ee("Application Initializer"); | |
| let $l = ( () => { | |
| class n { | |
| constructor(t) { | |
| this.appInits = t, | |
| this.resolve = Hl, | |
| this.reject = Hl, | |
| this.initialized = !1, | |
| this.done = !1, | |
| this.donePromise = new Promise( (r, i) => { | |
| this.resolve = r, | |
| this.reject = i | |
| } | |
| ) | |
| } | |
| runInitializers() { | |
| if (this.initialized) | |
| return; | |
| const t = [] | |
| , r = () => { | |
| this.done = !0, | |
| this.resolve() | |
| } | |
| ; | |
| if (this.appInits) | |
| for (let i = 0; i < this.appInits.length; i++) { | |
| const o = this.appInits[i](); | |
| if (Bs(o)) | |
| t.push(o); | |
| else if (Mh(o)) { | |
| const s = new Promise( (a, l) => { | |
| o.subscribe({ | |
| complete: a, | |
| error: l | |
| }) | |
| } | |
| ); | |
| t.push(s) | |
| } | |
| } | |
| Promise.all(t).then( () => { | |
| r() | |
| } | |
| ).catch(i => { | |
| this.reject(i) | |
| } | |
| ), | |
| 0 === t.length && r(), | |
| this.initialized = !0 | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(zl, 8)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| const Ys = new ee("AppId",{ | |
| providedIn: "root", | |
| factory: function a0() { | |
| return `${Xh()}${Xh()}${Xh()}` | |
| } | |
| }); | |
| function Xh() { | |
| return String.fromCharCode(97 + Math.floor(25 * Math.random())) | |
| } | |
| const l0 = new ee("Platform Initializer") | |
| , Jh = new ee("Platform ID",{ | |
| providedIn: "platform", | |
| factory: () => "unknown" | |
| }) | |
| , c0 = new ee("appBootstrapListener") | |
| , ef = new ee("AnimationModuleType"); | |
| let lP = ( () => { | |
| class n { | |
| log(t) { | |
| console.log(t) | |
| } | |
| warn(t) { | |
| console.warn(t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "platform" | |
| }), | |
| n | |
| } | |
| )(); | |
| const gr = new ee("LocaleId",{ | |
| providedIn: "root", | |
| factory: () => ot(gr, he.Optional | he.SkipSelf) || function cP() { | |
| return "undefined" != typeof $localize && $localize.locale || ko | |
| }() | |
| }); | |
| class dP { | |
| constructor(e, t) { | |
| this.ngModuleFactory = e, | |
| this.componentFactories = t | |
| } | |
| } | |
| let tf = ( () => { | |
| class n { | |
| compileModuleSync(t) { | |
| return new Vh(t) | |
| } | |
| compileModuleAsync(t) { | |
| return Promise.resolve(this.compileModuleSync(t)) | |
| } | |
| compileModuleAndAllComponentsSync(t) { | |
| const r = this.compileModuleSync(t) | |
| , o = xr(bn(t).declarations).reduce( (s, a) => { | |
| const l = ze(a); | |
| return l && s.push(new ks(l)), | |
| s | |
| } | |
| , []); | |
| return new dP(r,o) | |
| } | |
| compileModuleAndAllComponentsAsync(t) { | |
| return Promise.resolve(this.compileModuleAndAllComponentsSync(t)) | |
| } | |
| clearCache() {} | |
| clearCacheFor(t) {} | |
| getModuleId(t) {} | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| const pP = ( () => Promise.resolve(0))(); | |
| function nf(n) { | |
| "undefined" == typeof Zone ? pP.then( () => { | |
| n && n.apply(null, null) | |
| } | |
| ) : Zone.current.scheduleMicroTask("scheduleMicrotask", n) | |
| } | |
| class nt { | |
| constructor({enableLongStackTrace: e=!1, shouldCoalesceEventChangeDetection: t=!1, shouldCoalesceRunChangeDetection: r=!1}) { | |
| if (this.hasPendingMacrotasks = !1, | |
| this.hasPendingMicrotasks = !1, | |
| this.isStable = !0, | |
| this.onUnstable = new Se(!1), | |
| this.onMicrotaskEmpty = new Se(!1), | |
| this.onStable = new Se(!1), | |
| this.onError = new Se(!1), | |
| "undefined" == typeof Zone) | |
| throw new U(908,!1); | |
| Zone.assertZonePatched(); | |
| const i = this; | |
| if (i._nesting = 0, | |
| i._outer = i._inner = Zone.current, | |
| Zone.AsyncStackTaggingZoneSpec) { | |
| const o = Zone.AsyncStackTaggingZoneSpec; | |
| i._inner = i._inner.fork(new o("Angular")) | |
| } | |
| Zone.TaskTrackingZoneSpec && (i._inner = i._inner.fork(new Zone.TaskTrackingZoneSpec)), | |
| e && Zone.longStackTraceZoneSpec && (i._inner = i._inner.fork(Zone.longStackTraceZoneSpec)), | |
| i.shouldCoalesceEventChangeDetection = !r && t, | |
| i.shouldCoalesceRunChangeDetection = r, | |
| i.lastRequestAnimationFrameId = -1, | |
| i.nativeRequestAnimationFrame = function gP() { | |
| let n = Ze.requestAnimationFrame | |
| , e = Ze.cancelAnimationFrame; | |
| if ("undefined" != typeof Zone && n && e) { | |
| const t = n[Zone.__symbol__("OriginalDelegate")]; | |
| t && (n = t); | |
| const r = e[Zone.__symbol__("OriginalDelegate")]; | |
| r && (e = r) | |
| } | |
| return { | |
| nativeRequestAnimationFrame: n, | |
| nativeCancelAnimationFrame: e | |
| } | |
| }().nativeRequestAnimationFrame, | |
| function yP(n) { | |
| const e = () => { | |
| !function _P(n) { | |
| n.isCheckStableRunning || -1 !== n.lastRequestAnimationFrameId || (n.lastRequestAnimationFrameId = n.nativeRequestAnimationFrame.call(Ze, () => { | |
| n.fakeTopEventTask || (n.fakeTopEventTask = Zone.root.scheduleEventTask("fakeTopEventTask", () => { | |
| n.lastRequestAnimationFrameId = -1, | |
| sf(n), | |
| n.isCheckStableRunning = !0, | |
| rf(n), | |
| n.isCheckStableRunning = !1 | |
| } | |
| , void 0, () => {} | |
| , () => {} | |
| )), | |
| n.fakeTopEventTask.invoke() | |
| } | |
| ), | |
| sf(n)) | |
| }(n) | |
| } | |
| ; | |
| n._inner = n._inner.fork({ | |
| name: "angular", | |
| properties: { | |
| isAngularZone: !0 | |
| }, | |
| onInvokeTask: (t, r, i, o, s, a) => { | |
| try { | |
| return h0(n), | |
| t.invokeTask(i, o, s, a) | |
| } finally { | |
| (n.shouldCoalesceEventChangeDetection && "eventTask" === o.type || n.shouldCoalesceRunChangeDetection) && e(), | |
| f0(n) | |
| } | |
| } | |
| , | |
| onInvoke: (t, r, i, o, s, a, l) => { | |
| try { | |
| return h0(n), | |
| t.invoke(i, o, s, a, l) | |
| } finally { | |
| n.shouldCoalesceRunChangeDetection && e(), | |
| f0(n) | |
| } | |
| } | |
| , | |
| onHasTask: (t, r, i, o) => { | |
| t.hasTask(i, o), | |
| r === i && ("microTask" == o.change ? (n._hasPendingMicrotasks = o.microTask, | |
| sf(n), | |
| rf(n)) : "macroTask" == o.change && (n.hasPendingMacrotasks = o.macroTask)) | |
| } | |
| , | |
| onHandleError: (t, r, i, o) => (t.handleError(i, o), | |
| n.runOutsideAngular( () => n.onError.emit(o)), | |
| !1) | |
| }) | |
| }(i) | |
| } | |
| static isInAngularZone() { | |
| return "undefined" != typeof Zone && !0 === Zone.current.get("isAngularZone") | |
| } | |
| static assertInAngularZone() { | |
| if (!nt.isInAngularZone()) | |
| throw new U(909,!1) | |
| } | |
| static assertNotInAngularZone() { | |
| if (nt.isInAngularZone()) | |
| throw new U(909,!1) | |
| } | |
| run(e, t, r) { | |
| return this._inner.run(e, t, r) | |
| } | |
| runTask(e, t, r, i) { | |
| const o = this._inner | |
| , s = o.scheduleEventTask("NgZoneEvent: " + i, e, mP, Hl, Hl); | |
| try { | |
| return o.runTask(s, t, r) | |
| } finally { | |
| o.cancelTask(s) | |
| } | |
| } | |
| runGuarded(e, t, r) { | |
| return this._inner.runGuarded(e, t, r) | |
| } | |
| runOutsideAngular(e) { | |
| return this._outer.run(e) | |
| } | |
| } | |
| const mP = {}; | |
| function rf(n) { | |
| if (0 == n._nesting && !n.hasPendingMicrotasks && !n.isStable) | |
| try { | |
| n._nesting++, | |
| n.onMicrotaskEmpty.emit(null) | |
| } finally { | |
| if (n._nesting--, | |
| !n.hasPendingMicrotasks) | |
| try { | |
| n.runOutsideAngular( () => n.onStable.emit(null)) | |
| } finally { | |
| n.isStable = !0 | |
| } | |
| } | |
| } | |
| function sf(n) { | |
| n.hasPendingMicrotasks = !!(n._hasPendingMicrotasks || (n.shouldCoalesceEventChangeDetection || n.shouldCoalesceRunChangeDetection) && -1 !== n.lastRequestAnimationFrameId) | |
| } | |
| function h0(n) { | |
| n._nesting++, | |
| n.isStable && (n.isStable = !1, | |
| n.onUnstable.emit(null)) | |
| } | |
| function f0(n) { | |
| n._nesting--, | |
| rf(n) | |
| } | |
| class vP { | |
| constructor() { | |
| this.hasPendingMicrotasks = !1, | |
| this.hasPendingMacrotasks = !1, | |
| this.isStable = !0, | |
| this.onUnstable = new Se, | |
| this.onMicrotaskEmpty = new Se, | |
| this.onStable = new Se, | |
| this.onError = new Se | |
| } | |
| run(e, t, r) { | |
| return e.apply(t, r) | |
| } | |
| runGuarded(e, t, r) { | |
| return e.apply(t, r) | |
| } | |
| runOutsideAngular(e) { | |
| return e() | |
| } | |
| runTask(e, t, r, i) { | |
| return e.apply(t, r) | |
| } | |
| } | |
| const p0 = new ee("") | |
| , Wl = new ee(""); | |
| let Zs, af = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this._ngZone = t, | |
| this.registry = r, | |
| this._pendingCount = 0, | |
| this._isZoneStable = !0, | |
| this._didWork = !1, | |
| this._callbacks = [], | |
| this.taskTrackingZone = null, | |
| Zs || (function bP(n) { | |
| Zs = n | |
| }(i), | |
| i.addToWindow(r)), | |
| this._watchAngularEvents(), | |
| t.run( () => { | |
| this.taskTrackingZone = "undefined" == typeof Zone ? null : Zone.current.get("TaskTrackingZone") | |
| } | |
| ) | |
| } | |
| _watchAngularEvents() { | |
| this._ngZone.onUnstable.subscribe({ | |
| next: () => { | |
| this._didWork = !0, | |
| this._isZoneStable = !1 | |
| } | |
| }), | |
| this._ngZone.runOutsideAngular( () => { | |
| this._ngZone.onStable.subscribe({ | |
| next: () => { | |
| nt.assertNotInAngularZone(), | |
| nf( () => { | |
| this._isZoneStable = !0, | |
| this._runCallbacksIfReady() | |
| } | |
| ) | |
| } | |
| }) | |
| } | |
| ) | |
| } | |
| increasePendingRequestCount() { | |
| return this._pendingCount += 1, | |
| this._didWork = !0, | |
| this._pendingCount | |
| } | |
| decreasePendingRequestCount() { | |
| if (this._pendingCount -= 1, | |
| this._pendingCount < 0) | |
| throw new Error("pending async requests below zero"); | |
| return this._runCallbacksIfReady(), | |
| this._pendingCount | |
| } | |
| isStable() { | |
| return this._isZoneStable && 0 === this._pendingCount && !this._ngZone.hasPendingMacrotasks | |
| } | |
| _runCallbacksIfReady() { | |
| if (this.isStable()) | |
| nf( () => { | |
| for (; 0 !== this._callbacks.length; ) { | |
| let t = this._callbacks.pop(); | |
| clearTimeout(t.timeoutId), | |
| t.doneCb(this._didWork) | |
| } | |
| this._didWork = !1 | |
| } | |
| ); | |
| else { | |
| let t = this.getPendingTasks(); | |
| this._callbacks = this._callbacks.filter(r => !r.updateCb || !r.updateCb(t) || (clearTimeout(r.timeoutId), | |
| !1)), | |
| this._didWork = !0 | |
| } | |
| } | |
| getPendingTasks() { | |
| return this.taskTrackingZone ? this.taskTrackingZone.macroTasks.map(t => ({ | |
| source: t.source, | |
| creationLocation: t.creationLocation, | |
| data: t.data | |
| })) : [] | |
| } | |
| addCallback(t, r, i) { | |
| let o = -1; | |
| r && r > 0 && (o = setTimeout( () => { | |
| this._callbacks = this._callbacks.filter(s => s.timeoutId !== o), | |
| t(this._didWork, this.getPendingTasks()) | |
| } | |
| , r)), | |
| this._callbacks.push({ | |
| doneCb: t, | |
| timeoutId: o, | |
| updateCb: i | |
| }) | |
| } | |
| whenStable(t, r, i) { | |
| if (i && !this.taskTrackingZone) | |
| throw new Error('Task tracking zone is required when passing an update callback to whenStable(). Is "zone.js/plugins/task-tracking" loaded?'); | |
| this.addCallback(t, r, i), | |
| this._runCallbacksIfReady() | |
| } | |
| getPendingRequestCount() { | |
| return this._pendingCount | |
| } | |
| registerApplication(t) { | |
| this.registry.registerApplication(t, this) | |
| } | |
| unregisterApplication(t) { | |
| this.registry.unregisterApplication(t) | |
| } | |
| findProviders(t, r, i) { | |
| return [] | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(nt),Q(lf),Q(Wl)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(), lf = ( () => { | |
| class n { | |
| constructor() { | |
| this._applications = new Map | |
| } | |
| registerApplication(t, r) { | |
| this._applications.set(t, r) | |
| } | |
| unregisterApplication(t) { | |
| this._applications.delete(t) | |
| } | |
| unregisterAllApplications() { | |
| this._applications.clear() | |
| } | |
| getTestability(t) { | |
| return this._applications.get(t) || null | |
| } | |
| getAllTestabilities() { | |
| return Array.from(this._applications.values()) | |
| } | |
| getAllRootElements() { | |
| return Array.from(this._applications.keys()) | |
| } | |
| findTestabilityInTree(t, r=!0) { | |
| var i; | |
| return null !== (i = null == Zs ? void 0 : Zs.findTestabilityInTree(this, t, r)) && void 0 !== i ? i : null | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "platform" | |
| }), | |
| n | |
| } | |
| )(), mr = null; | |
| const g0 = new ee("AllowMultipleToken") | |
| , cf = new ee("PlatformDestroyListeners"); | |
| class m0 { | |
| constructor(e, t) { | |
| this.name = e, | |
| this.token = t | |
| } | |
| } | |
| function y0(n, e, t=[]) { | |
| const r = `Platform: ${e}` | |
| , i = new ee(r); | |
| return (o=[]) => { | |
| let s = uf(); | |
| if (!s || s.injector.get(g0, !1)) { | |
| const a = [...t, ...o, { | |
| provide: i, | |
| useValue: !0 | |
| }]; | |
| n ? n(a) : function EP(n) { | |
| if (mr && !mr.get(g0, !1)) | |
| throw new U(400,!1); | |
| mr = n; | |
| const e = n.get(b0); | |
| (function _0(n) { | |
| const e = n.get(l0, null); | |
| e && e.forEach(t => t()) | |
| } | |
| )(n) | |
| }(function v0(n=[], e) { | |
| return On.create({ | |
| name: e, | |
| providers: [{ | |
| provide: zd, | |
| useValue: "platform" | |
| }, { | |
| provide: cf, | |
| useValue: new Set([ () => mr = null]) | |
| }, ...n] | |
| }) | |
| }(a, r)) | |
| } | |
| return function DP(n) { | |
| const e = uf(); | |
| if (!e) | |
| throw new U(401,!1); | |
| return e | |
| }() | |
| } | |
| } | |
| function uf() { | |
| var n; | |
| return null !== (n = null == mr ? void 0 : mr.get(b0)) && void 0 !== n ? n : null | |
| } | |
| let b0 = ( () => { | |
| class n { | |
| constructor(t) { | |
| this._injector = t, | |
| this._modules = [], | |
| this._destroyListeners = [], | |
| this._destroyed = !1 | |
| } | |
| bootstrapModuleFactory(t, r) { | |
| const i = function T0(n, e) { | |
| let t; | |
| return t = "noop" === n ? new vP : ("zone.js" === n ? void 0 : n) || new nt(e), | |
| t | |
| }(null == r ? void 0 : r.ngZone, function C0(n) { | |
| return { | |
| enableLongStackTrace: !1, | |
| shouldCoalesceEventChangeDetection: !(!n || !n.ngZoneEventCoalescing) || !1, | |
| shouldCoalesceRunChangeDetection: !(!n || !n.ngZoneRunCoalescing) || !1 | |
| } | |
| }(r)) | |
| , o = [{ | |
| provide: nt, | |
| useValue: i | |
| }]; | |
| return i.run( () => { | |
| const s = On.create({ | |
| providers: o, | |
| parent: this.injector, | |
| name: t.moduleType.name | |
| }) | |
| , a = t.create(s) | |
| , l = a.injector.get(bo, null); | |
| if (!l) | |
| throw new U(402,!1); | |
| return i.runOutsideAngular( () => { | |
| const c = i.onError.subscribe({ | |
| next: u => { | |
| l.handleError(u) | |
| } | |
| }); | |
| a.onDestroy( () => { | |
| Gl(this._modules, a), | |
| c.unsubscribe() | |
| } | |
| ) | |
| } | |
| ), | |
| function E0(n, e, t) { | |
| try { | |
| const r = t(); | |
| return Bs(r) ? r.catch(i => { | |
| throw e.runOutsideAngular( () => n.handleError(i)), | |
| i | |
| } | |
| ) : r | |
| } catch (r) { | |
| throw e.runOutsideAngular( () => n.handleError(r)), | |
| r | |
| } | |
| }(l, i, () => { | |
| const c = a.injector.get($l); | |
| return c.runInitializers(), | |
| c.donePromise.then( () => (function Qv(n) { | |
| vn(n, "Expected localeId to be defined"), | |
| "string" == typeof n && (Kv = n.toLowerCase().replace(/_/g, "-")) | |
| }(a.injector.get(gr, ko) || ko), | |
| this._moduleDoBootstrap(a), | |
| a)) | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| bootstrapModule(t, r=[]) { | |
| const i = w0({}, r); | |
| return function CP(n, e, t) { | |
| const r = new Vh(t); | |
| return Promise.resolve(r) | |
| }(0, 0, t).then(o => this.bootstrapModuleFactory(o, i)) | |
| } | |
| _moduleDoBootstrap(t) { | |
| const r = t.injector.get(Xs); | |
| if (t._bootstrapComponents.length > 0) | |
| t._bootstrapComponents.forEach(i => r.bootstrap(i)); | |
| else { | |
| if (!t.instance.ngDoBootstrap) | |
| throw new U(403,!1); | |
| t.instance.ngDoBootstrap(r) | |
| } | |
| this._modules.push(t) | |
| } | |
| onDestroy(t) { | |
| this._destroyListeners.push(t) | |
| } | |
| get injector() { | |
| return this._injector | |
| } | |
| destroy() { | |
| if (this._destroyed) | |
| throw new U(404,!1); | |
| this._modules.slice().forEach(r => r.destroy()), | |
| this._destroyListeners.forEach(r => r()); | |
| const t = this._injector.get(cf, null); | |
| t && (t.forEach(r => r()), | |
| t.clear()), | |
| this._destroyed = !0 | |
| } | |
| get destroyed() { | |
| return this._destroyed | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(On)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "platform" | |
| }), | |
| n | |
| } | |
| )(); | |
| function w0(n, e) { | |
| return Array.isArray(e) ? e.reduce(w0, n) : Object.assign(Object.assign({}, n), e) | |
| } | |
| let Xs = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this._zone = t, | |
| this._injector = r, | |
| this._exceptionHandler = i, | |
| this._bootstrapListeners = [], | |
| this._views = [], | |
| this._runningTick = !1, | |
| this._stable = !0, | |
| this._destroyed = !1, | |
| this._destroyListeners = [], | |
| this.componentTypes = [], | |
| this.components = [], | |
| this._onMicrotaskEmptySubscription = this._zone.onMicrotaskEmpty.subscribe({ | |
| next: () => { | |
| this._zone.run( () => { | |
| this.tick() | |
| } | |
| ) | |
| } | |
| }); | |
| const o = new vt(a => { | |
| this._stable = this._zone.isStable && !this._zone.hasPendingMacrotasks && !this._zone.hasPendingMicrotasks, | |
| this._zone.runOutsideAngular( () => { | |
| a.next(this._stable), | |
| a.complete() | |
| } | |
| ) | |
| } | |
| ) | |
| , s = new vt(a => { | |
| let l; | |
| this._zone.runOutsideAngular( () => { | |
| l = this._zone.onStable.subscribe( () => { | |
| nt.assertNotInAngularZone(), | |
| nf( () => { | |
| !this._stable && !this._zone.hasPendingMacrotasks && !this._zone.hasPendingMicrotasks && (this._stable = !0, | |
| a.next(!0)) | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| ); | |
| const c = this._zone.onUnstable.subscribe( () => { | |
| nt.assertInAngularZone(), | |
| this._stable && (this._stable = !1, | |
| this._zone.runOutsideAngular( () => { | |
| a.next(!1) | |
| } | |
| )) | |
| } | |
| ); | |
| return () => { | |
| l.unsubscribe(), | |
| c.unsubscribe() | |
| } | |
| } | |
| ); | |
| this.isStable = function TM(...n) { | |
| const e = ss(n) | |
| , t = function gM(n, e) { | |
| return "number" == typeof xu(n) ? n.pop() : e | |
| }(n, 1 / 0) | |
| , r = n; | |
| return r.length ? 1 === r.length ? _n(r[0]) : Zi(t)(wt(r, e)) : Tr | |
| }(o, s.pipe(function EM(n={}) { | |
| const {connector: e=( () => new un), resetOnError: t=!0, resetOnComplete: r=!0, resetOnRefCountZero: i=!0} = n; | |
| return o => { | |
| let s, a, l, c = 0, u = !1, d = !1; | |
| const h = () => { | |
| null == a || a.unsubscribe(), | |
| a = void 0 | |
| } | |
| , f = () => { | |
| h(), | |
| s = l = void 0, | |
| u = d = !1 | |
| } | |
| , p = () => { | |
| const _ = s; | |
| f(), | |
| null == _ || _.unsubscribe() | |
| } | |
| ; | |
| return bt( (_, C) => { | |
| c++, | |
| !d && !u && h(); | |
| const S = l = null != l ? l : e(); | |
| C.add( () => { | |
| c--, | |
| 0 === c && !d && !u && (a = Ru(p, i)) | |
| } | |
| ), | |
| S.subscribe(C), | |
| !s && c > 0 && (s = new os({ | |
| next: R => S.next(R), | |
| error: R => { | |
| d = !0, | |
| h(), | |
| a = Ru(f, t, R), | |
| S.error(R) | |
| } | |
| , | |
| complete: () => { | |
| u = !0, | |
| h(), | |
| a = Ru(f, r), | |
| S.complete() | |
| } | |
| }), | |
| _n(_).subscribe(s)) | |
| } | |
| )(o) | |
| } | |
| }())) | |
| } | |
| get destroyed() { | |
| return this._destroyed | |
| } | |
| get injector() { | |
| return this._injector | |
| } | |
| bootstrap(t, r) { | |
| const i = t instanceof G_; | |
| if (!this._injector.get($l).done) | |
| throw !i && function Ji(n) { | |
| const e = ze(n) || Zt(n) || Xt(n); | |
| return null !== e && e.standalone | |
| }(t), | |
| new U(405,false); | |
| let s; | |
| s = i ? t : this._injector.get(Ps).resolveComponentFactory(t), | |
| this.componentTypes.push(s.componentType); | |
| const a = function TP(n) { | |
| return n.isBoundToModule | |
| }(s) ? void 0 : this._injector.get(ki) | |
| , c = s.create(On.NULL, [], r || s.selector, a) | |
| , u = c.location.nativeElement | |
| , d = c.injector.get(p0, null); | |
| return null == d || d.registerApplication(u), | |
| c.onDestroy( () => { | |
| this.detachView(c.hostView), | |
| Gl(this.components, c), | |
| null == d || d.unregisterApplication(u) | |
| } | |
| ), | |
| this._loadComponent(c), | |
| c | |
| } | |
| tick() { | |
| if (this._runningTick) | |
| throw new U(101,!1); | |
| try { | |
| this._runningTick = !0; | |
| for (let t of this._views) | |
| t.detectChanges() | |
| } catch (t) { | |
| this._zone.runOutsideAngular( () => this._exceptionHandler.handleError(t)) | |
| } finally { | |
| this._runningTick = !1 | |
| } | |
| } | |
| attachView(t) { | |
| const r = t; | |
| this._views.push(r), | |
| r.attachToAppRef(this) | |
| } | |
| detachView(t) { | |
| const r = t; | |
| Gl(this._views, r), | |
| r.detachFromAppRef() | |
| } | |
| _loadComponent(t) { | |
| this.attachView(t.hostView), | |
| this.tick(), | |
| this.components.push(t), | |
| this._injector.get(c0, []).concat(this._bootstrapListeners).forEach(i => i(t)) | |
| } | |
| ngOnDestroy() { | |
| if (!this._destroyed) | |
| try { | |
| this._destroyListeners.forEach(t => t()), | |
| this._views.slice().forEach(t => t.destroy()), | |
| this._onMicrotaskEmptySubscription.unsubscribe() | |
| } finally { | |
| this._destroyed = !0, | |
| this._views = [], | |
| this._bootstrapListeners = [], | |
| this._destroyListeners = [] | |
| } | |
| } | |
| onDestroy(t) { | |
| return this._destroyListeners.push(t), | |
| () => Gl(this._destroyListeners, t) | |
| } | |
| destroy() { | |
| if (this._destroyed) | |
| throw new U(406,!1); | |
| const t = this._injector; | |
| t.destroy && !t.destroyed && t.destroy() | |
| } | |
| get viewCount() { | |
| return this._views.length | |
| } | |
| warnIfDestroyed() {} | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(nt),Q(ti),Q(bo)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| function Gl(n, e) { | |
| const t = n.indexOf(e); | |
| t > -1 && n.splice(t, 1) | |
| } | |
| let M0 = !0 | |
| , Bo = ( () => { | |
| class n { | |
| } | |
| return n.__NG_ELEMENT_ID__ = IP, | |
| n | |
| } | |
| )(); | |
| function IP(n) { | |
| return function SP(n, e, t) { | |
| if (Qa(n) && !t) { | |
| const r = wn(n.index, e); | |
| return new Ns(r,r) | |
| } | |
| return 47 & n.type ? new Ns(e[16],e) : null | |
| }(St(), H(), 16 == (16 & n)) | |
| } | |
| class R0 { | |
| constructor() {} | |
| supports(e) { | |
| return Ls(e) | |
| } | |
| create(e) { | |
| return new NP(e) | |
| } | |
| } | |
| const OP = (n, e) => e; | |
| class NP { | |
| constructor(e) { | |
| this.length = 0, | |
| this._linkedRecords = null, | |
| this._unlinkedRecords = null, | |
| this._previousItHead = null, | |
| this._itHead = null, | |
| this._itTail = null, | |
| this._additionsHead = null, | |
| this._additionsTail = null, | |
| this._movesHead = null, | |
| this._movesTail = null, | |
| this._removalsHead = null, | |
| this._removalsTail = null, | |
| this._identityChangesHead = null, | |
| this._identityChangesTail = null, | |
| this._trackByFn = e || OP | |
| } | |
| forEachItem(e) { | |
| let t; | |
| for (t = this._itHead; null !== t; t = t._next) | |
| e(t) | |
| } | |
| forEachOperation(e) { | |
| let t = this._itHead | |
| , r = this._removalsHead | |
| , i = 0 | |
| , o = null; | |
| for (; t || r; ) { | |
| const s = !r || t && t.currentIndex < P0(r, i, o) ? t : r | |
| , a = P0(s, i, o) | |
| , l = s.currentIndex; | |
| if (s === r) | |
| i--, | |
| r = r._nextRemoved; | |
| else if (t = t._next, | |
| null == s.previousIndex) | |
| i++; | |
| else { | |
| o || (o = []); | |
| const c = a - i | |
| , u = l - i; | |
| if (c != u) { | |
| for (let h = 0; h < c; h++) { | |
| const f = h < o.length ? o[h] : o[h] = 0 | |
| , p = f + h; | |
| u <= p && p < c && (o[h] = f + 1) | |
| } | |
| o[s.previousIndex] = u - c | |
| } | |
| } | |
| a !== l && e(s, a, l) | |
| } | |
| } | |
| forEachPreviousItem(e) { | |
| let t; | |
| for (t = this._previousItHead; null !== t; t = t._nextPrevious) | |
| e(t) | |
| } | |
| forEachAddedItem(e) { | |
| let t; | |
| for (t = this._additionsHead; null !== t; t = t._nextAdded) | |
| e(t) | |
| } | |
| forEachMovedItem(e) { | |
| let t; | |
| for (t = this._movesHead; null !== t; t = t._nextMoved) | |
| e(t) | |
| } | |
| forEachRemovedItem(e) { | |
| let t; | |
| for (t = this._removalsHead; null !== t; t = t._nextRemoved) | |
| e(t) | |
| } | |
| forEachIdentityChange(e) { | |
| let t; | |
| for (t = this._identityChangesHead; null !== t; t = t._nextIdentityChange) | |
| e(t) | |
| } | |
| diff(e) { | |
| if (null == e && (e = []), | |
| !Ls(e)) | |
| throw new U(900,!1); | |
| return this.check(e) ? this : null | |
| } | |
| onDestroy() {} | |
| check(e) { | |
| this._reset(); | |
| let i, o, s, t = this._itHead, r = !1; | |
| if (Array.isArray(e)) { | |
| this.length = e.length; | |
| for (let a = 0; a < this.length; a++) | |
| o = e[a], | |
| s = this._trackByFn(a, o), | |
| null !== t && Object.is(t.trackById, s) ? (r && (t = this._verifyReinsertion(t, o, s, a)), | |
| Object.is(t.item, o) || this._addIdentityChange(t, o)) : (t = this._mismatch(t, o, s, a), | |
| r = !0), | |
| t = t._next | |
| } else | |
| i = 0, | |
| function lR(n, e) { | |
| if (Array.isArray(n)) | |
| for (let t = 0; t < n.length; t++) | |
| e(n[t]); | |
| else { | |
| const t = n[Ri()](); | |
| let r; | |
| for (; !(r = t.next()).done; ) | |
| e(r.value) | |
| } | |
| }(e, a => { | |
| s = this._trackByFn(i, a), | |
| null !== t && Object.is(t.trackById, s) ? (r && (t = this._verifyReinsertion(t, a, s, i)), | |
| Object.is(t.item, a) || this._addIdentityChange(t, a)) : (t = this._mismatch(t, a, s, i), | |
| r = !0), | |
| t = t._next, | |
| i++ | |
| } | |
| ), | |
| this.length = i; | |
| return this._truncate(t), | |
| this.collection = e, | |
| this.isDirty | |
| } | |
| get isDirty() { | |
| return null !== this._additionsHead || null !== this._movesHead || null !== this._removalsHead || null !== this._identityChangesHead | |
| } | |
| _reset() { | |
| if (this.isDirty) { | |
| let e; | |
| for (e = this._previousItHead = this._itHead; null !== e; e = e._next) | |
| e._nextPrevious = e._next; | |
| for (e = this._additionsHead; null !== e; e = e._nextAdded) | |
| e.previousIndex = e.currentIndex; | |
| for (this._additionsHead = this._additionsTail = null, | |
| e = this._movesHead; null !== e; e = e._nextMoved) | |
| e.previousIndex = e.currentIndex; | |
| this._movesHead = this._movesTail = null, | |
| this._removalsHead = this._removalsTail = null, | |
| this._identityChangesHead = this._identityChangesTail = null | |
| } | |
| } | |
| _mismatch(e, t, r, i) { | |
| let o; | |
| return null === e ? o = this._itTail : (o = e._prev, | |
| this._remove(e)), | |
| null !== (e = null === this._unlinkedRecords ? null : this._unlinkedRecords.get(r, null)) ? (Object.is(e.item, t) || this._addIdentityChange(e, t), | |
| this._reinsertAfter(e, o, i)) : null !== (e = null === this._linkedRecords ? null : this._linkedRecords.get(r, i)) ? (Object.is(e.item, t) || this._addIdentityChange(e, t), | |
| this._moveAfter(e, o, i)) : e = this._addAfter(new kP(t,r), o, i), | |
| e | |
| } | |
| _verifyReinsertion(e, t, r, i) { | |
| let o = null === this._unlinkedRecords ? null : this._unlinkedRecords.get(r, null); | |
| return null !== o ? e = this._reinsertAfter(o, e._prev, i) : e.currentIndex != i && (e.currentIndex = i, | |
| this._addToMoves(e, i)), | |
| e | |
| } | |
| _truncate(e) { | |
| for (; null !== e; ) { | |
| const t = e._next; | |
| this._addToRemovals(this._unlink(e)), | |
| e = t | |
| } | |
| null !== this._unlinkedRecords && this._unlinkedRecords.clear(), | |
| null !== this._additionsTail && (this._additionsTail._nextAdded = null), | |
| null !== this._movesTail && (this._movesTail._nextMoved = null), | |
| null !== this._itTail && (this._itTail._next = null), | |
| null !== this._removalsTail && (this._removalsTail._nextRemoved = null), | |
| null !== this._identityChangesTail && (this._identityChangesTail._nextIdentityChange = null) | |
| } | |
| _reinsertAfter(e, t, r) { | |
| null !== this._unlinkedRecords && this._unlinkedRecords.remove(e); | |
| const i = e._prevRemoved | |
| , o = e._nextRemoved; | |
| return null === i ? this._removalsHead = o : i._nextRemoved = o, | |
| null === o ? this._removalsTail = i : o._prevRemoved = i, | |
| this._insertAfter(e, t, r), | |
| this._addToMoves(e, r), | |
| e | |
| } | |
| _moveAfter(e, t, r) { | |
| return this._unlink(e), | |
| this._insertAfter(e, t, r), | |
| this._addToMoves(e, r), | |
| e | |
| } | |
| _addAfter(e, t, r) { | |
| return this._insertAfter(e, t, r), | |
| this._additionsTail = null === this._additionsTail ? this._additionsHead = e : this._additionsTail._nextAdded = e, | |
| e | |
| } | |
| _insertAfter(e, t, r) { | |
| const i = null === t ? this._itHead : t._next; | |
| return e._next = i, | |
| e._prev = t, | |
| null === i ? this._itTail = e : i._prev = e, | |
| null === t ? this._itHead = e : t._next = e, | |
| null === this._linkedRecords && (this._linkedRecords = new F0), | |
| this._linkedRecords.put(e), | |
| e.currentIndex = r, | |
| e | |
| } | |
| _remove(e) { | |
| return this._addToRemovals(this._unlink(e)) | |
| } | |
| _unlink(e) { | |
| null !== this._linkedRecords && this._linkedRecords.remove(e); | |
| const t = e._prev | |
| , r = e._next; | |
| return null === t ? this._itHead = r : t._next = r, | |
| null === r ? this._itTail = t : r._prev = t, | |
| e | |
| } | |
| _addToMoves(e, t) { | |
| return e.previousIndex === t || (this._movesTail = null === this._movesTail ? this._movesHead = e : this._movesTail._nextMoved = e), | |
| e | |
| } | |
| _addToRemovals(e) { | |
| return null === this._unlinkedRecords && (this._unlinkedRecords = new F0), | |
| this._unlinkedRecords.put(e), | |
| e.currentIndex = null, | |
| e._nextRemoved = null, | |
| null === this._removalsTail ? (this._removalsTail = this._removalsHead = e, | |
| e._prevRemoved = null) : (e._prevRemoved = this._removalsTail, | |
| this._removalsTail = this._removalsTail._nextRemoved = e), | |
| e | |
| } | |
| _addIdentityChange(e, t) { | |
| return e.item = t, | |
| this._identityChangesTail = null === this._identityChangesTail ? this._identityChangesHead = e : this._identityChangesTail._nextIdentityChange = e, | |
| e | |
| } | |
| } | |
| class kP { | |
| constructor(e, t) { | |
| this.item = e, | |
| this.trackById = t, | |
| this.currentIndex = null, | |
| this.previousIndex = null, | |
| this._nextPrevious = null, | |
| this._prev = null, | |
| this._next = null, | |
| this._prevDup = null, | |
| this._nextDup = null, | |
| this._prevRemoved = null, | |
| this._nextRemoved = null, | |
| this._nextAdded = null, | |
| this._nextMoved = null, | |
| this._nextIdentityChange = null | |
| } | |
| } | |
| class LP { | |
| constructor() { | |
| this._head = null, | |
| this._tail = null | |
| } | |
| add(e) { | |
| null === this._head ? (this._head = this._tail = e, | |
| e._nextDup = null, | |
| e._prevDup = null) : (this._tail._nextDup = e, | |
| e._prevDup = this._tail, | |
| e._nextDup = null, | |
| this._tail = e) | |
| } | |
| get(e, t) { | |
| let r; | |
| for (r = this._head; null !== r; r = r._nextDup) | |
| if ((null === t || t <= r.currentIndex) && Object.is(r.trackById, e)) | |
| return r; | |
| return null | |
| } | |
| remove(e) { | |
| const t = e._prevDup | |
| , r = e._nextDup; | |
| return null === t ? this._head = r : t._nextDup = r, | |
| null === r ? this._tail = t : r._prevDup = t, | |
| null === this._head | |
| } | |
| } | |
| class F0 { | |
| constructor() { | |
| this.map = new Map | |
| } | |
| put(e) { | |
| const t = e.trackById; | |
| let r = this.map.get(t); | |
| r || (r = new LP, | |
| this.map.set(t, r)), | |
| r.add(e) | |
| } | |
| get(e, t) { | |
| const i = this.map.get(e); | |
| return i ? i.get(e, t) : null | |
| } | |
| remove(e) { | |
| const t = e.trackById; | |
| return this.map.get(t).remove(e) && this.map.delete(t), | |
| e | |
| } | |
| get isEmpty() { | |
| return 0 === this.map.size | |
| } | |
| clear() { | |
| this.map.clear() | |
| } | |
| } | |
| function P0(n, e, t) { | |
| const r = n.previousIndex; | |
| if (null === r) | |
| return r; | |
| let i = 0; | |
| return t && r < t.length && (i = t[r]), | |
| r + e + i | |
| } | |
| class O0 { | |
| constructor() {} | |
| supports(e) { | |
| return e instanceof Map || wh(e) | |
| } | |
| create() { | |
| return new VP | |
| } | |
| } | |
| class VP { | |
| constructor() { | |
| this._records = new Map, | |
| this._mapHead = null, | |
| this._appendAfter = null, | |
| this._previousMapHead = null, | |
| this._changesHead = null, | |
| this._changesTail = null, | |
| this._additionsHead = null, | |
| this._additionsTail = null, | |
| this._removalsHead = null, | |
| this._removalsTail = null | |
| } | |
| get isDirty() { | |
| return null !== this._additionsHead || null !== this._changesHead || null !== this._removalsHead | |
| } | |
| forEachItem(e) { | |
| let t; | |
| for (t = this._mapHead; null !== t; t = t._next) | |
| e(t) | |
| } | |
| forEachPreviousItem(e) { | |
| let t; | |
| for (t = this._previousMapHead; null !== t; t = t._nextPrevious) | |
| e(t) | |
| } | |
| forEachChangedItem(e) { | |
| let t; | |
| for (t = this._changesHead; null !== t; t = t._nextChanged) | |
| e(t) | |
| } | |
| forEachAddedItem(e) { | |
| let t; | |
| for (t = this._additionsHead; null !== t; t = t._nextAdded) | |
| e(t) | |
| } | |
| forEachRemovedItem(e) { | |
| let t; | |
| for (t = this._removalsHead; null !== t; t = t._nextRemoved) | |
| e(t) | |
| } | |
| diff(e) { | |
| if (e) { | |
| if (!(e instanceof Map || wh(e))) | |
| throw new U(900,!1) | |
| } else | |
| e = new Map; | |
| return this.check(e) ? this : null | |
| } | |
| onDestroy() {} | |
| check(e) { | |
| this._reset(); | |
| let t = this._mapHead; | |
| if (this._appendAfter = null, | |
| this._forEach(e, (r, i) => { | |
| if (t && t.key === i) | |
| this._maybeAddToChanges(t, r), | |
| this._appendAfter = t, | |
| t = t._next; | |
| else { | |
| const o = this._getOrCreateRecordForKey(i, r); | |
| t = this._insertBeforeOrAppend(t, o) | |
| } | |
| } | |
| ), | |
| t) { | |
| t._prev && (t._prev._next = null), | |
| this._removalsHead = t; | |
| for (let r = t; null !== r; r = r._nextRemoved) | |
| r === this._mapHead && (this._mapHead = null), | |
| this._records.delete(r.key), | |
| r._nextRemoved = r._next, | |
| r.previousValue = r.currentValue, | |
| r.currentValue = null, | |
| r._prev = null, | |
| r._next = null | |
| } | |
| return this._changesTail && (this._changesTail._nextChanged = null), | |
| this._additionsTail && (this._additionsTail._nextAdded = null), | |
| this.isDirty | |
| } | |
| _insertBeforeOrAppend(e, t) { | |
| if (e) { | |
| const r = e._prev; | |
| return t._next = e, | |
| t._prev = r, | |
| e._prev = t, | |
| r && (r._next = t), | |
| e === this._mapHead && (this._mapHead = t), | |
| this._appendAfter = e, | |
| e | |
| } | |
| return this._appendAfter ? (this._appendAfter._next = t, | |
| t._prev = this._appendAfter) : this._mapHead = t, | |
| this._appendAfter = t, | |
| null | |
| } | |
| _getOrCreateRecordForKey(e, t) { | |
| if (this._records.has(e)) { | |
| const i = this._records.get(e); | |
| this._maybeAddToChanges(i, t); | |
| const o = i._prev | |
| , s = i._next; | |
| return o && (o._next = s), | |
| s && (s._prev = o), | |
| i._next = null, | |
| i._prev = null, | |
| i | |
| } | |
| const r = new BP(e); | |
| return this._records.set(e, r), | |
| r.currentValue = t, | |
| this._addToAdditions(r), | |
| r | |
| } | |
| _reset() { | |
| if (this.isDirty) { | |
| let e; | |
| for (this._previousMapHead = this._mapHead, | |
| e = this._previousMapHead; null !== e; e = e._next) | |
| e._nextPrevious = e._next; | |
| for (e = this._changesHead; null !== e; e = e._nextChanged) | |
| e.previousValue = e.currentValue; | |
| for (e = this._additionsHead; null != e; e = e._nextAdded) | |
| e.previousValue = e.currentValue; | |
| this._changesHead = this._changesTail = null, | |
| this._additionsHead = this._additionsTail = null, | |
| this._removalsHead = null | |
| } | |
| } | |
| _maybeAddToChanges(e, t) { | |
| Object.is(t, e.currentValue) || (e.previousValue = e.currentValue, | |
| e.currentValue = t, | |
| this._addToChanges(e)) | |
| } | |
| _addToAdditions(e) { | |
| null === this._additionsHead ? this._additionsHead = this._additionsTail = e : (this._additionsTail._nextAdded = e, | |
| this._additionsTail = e) | |
| } | |
| _addToChanges(e) { | |
| null === this._changesHead ? this._changesHead = this._changesTail = e : (this._changesTail._nextChanged = e, | |
| this._changesTail = e) | |
| } | |
| _forEach(e, t) { | |
| e instanceof Map ? e.forEach(t) : Object.keys(e).forEach(r => t(e[r], r)) | |
| } | |
| } | |
| class BP { | |
| constructor(e) { | |
| this.key = e, | |
| this.previousValue = null, | |
| this.currentValue = null, | |
| this._nextPrevious = null, | |
| this._next = null, | |
| this._prev = null, | |
| this._nextAdded = null, | |
| this._nextRemoved = null, | |
| this._nextChanged = null | |
| } | |
| } | |
| function N0() { | |
| return new Ql([new R0]) | |
| } | |
| let Ql = ( () => { | |
| class n { | |
| constructor(t) { | |
| this.factories = t | |
| } | |
| static create(t, r) { | |
| if (null != r) { | |
| const i = r.factories.slice(); | |
| t = t.concat(i) | |
| } | |
| return new n(t) | |
| } | |
| static extend(t) { | |
| return { | |
| provide: n, | |
| useFactory: r => n.create(t, r || N0()), | |
| deps: [[n, new ws, new Es]] | |
| } | |
| } | |
| find(t) { | |
| const r = this.factories.find(i => i.supports(t)); | |
| if (null != r) | |
| return r; | |
| throw new U(901,!1) | |
| } | |
| } | |
| return n.\u0275prov = se({ | |
| token: n, | |
| providedIn: "root", | |
| factory: N0 | |
| }), | |
| n | |
| } | |
| )(); | |
| function k0() { | |
| return new Js([new O0]) | |
| } | |
| let Js = ( () => { | |
| class n { | |
| constructor(t) { | |
| this.factories = t | |
| } | |
| static create(t, r) { | |
| if (r) { | |
| const i = r.factories.slice(); | |
| t = t.concat(i) | |
| } | |
| return new n(t) | |
| } | |
| static extend(t) { | |
| return { | |
| provide: n, | |
| useFactory: r => n.create(t, r || k0()), | |
| deps: [[n, new ws, new Es]] | |
| } | |
| } | |
| find(t) { | |
| const r = this.factories.find(i => i.supports(t)); | |
| if (r) | |
| return r; | |
| throw new U(901,!1) | |
| } | |
| } | |
| return n.\u0275prov = se({ | |
| token: n, | |
| providedIn: "root", | |
| factory: k0 | |
| }), | |
| n | |
| } | |
| )(); | |
| const HP = y0(null, "core", []); | |
| let zP = ( () => { | |
| class n { | |
| constructor(t) {} | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(Xs)) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({}), | |
| n | |
| } | |
| )(); | |
| let Yl = null; | |
| function _r() { | |
| return Yl | |
| } | |
| const yt = new ee("DocumentToken"); | |
| let gf = ( () => { | |
| class n { | |
| historyGo(t) { | |
| throw new Error("Not implemented") | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function() { | |
| return function qP() { | |
| return Q(L0) | |
| }() | |
| }, | |
| providedIn: "platform" | |
| }), | |
| n | |
| } | |
| )(); | |
| const KP = new ee("Location Initialized"); | |
| let L0 = ( () => { | |
| class n extends gf { | |
| constructor(t) { | |
| super(), | |
| this._doc = t, | |
| this._init() | |
| } | |
| _init() { | |
| this.location = window.location, | |
| this._history = window.history | |
| } | |
| getBaseHrefFromDOM() { | |
| return _r().getBaseHref(this._doc) | |
| } | |
| onPopState(t) { | |
| const r = _r().getGlobalEventTarget(this._doc, "window"); | |
| return r.addEventListener("popstate", t, !1), | |
| () => r.removeEventListener("popstate", t) | |
| } | |
| onHashChange(t) { | |
| const r = _r().getGlobalEventTarget(this._doc, "window"); | |
| return r.addEventListener("hashchange", t, !1), | |
| () => r.removeEventListener("hashchange", t) | |
| } | |
| get href() { | |
| return this.location.href | |
| } | |
| get protocol() { | |
| return this.location.protocol | |
| } | |
| get hostname() { | |
| return this.location.hostname | |
| } | |
| get port() { | |
| return this.location.port | |
| } | |
| get pathname() { | |
| return this.location.pathname | |
| } | |
| get search() { | |
| return this.location.search | |
| } | |
| get hash() { | |
| return this.location.hash | |
| } | |
| set pathname(t) { | |
| this.location.pathname = t | |
| } | |
| pushState(t, r, i) { | |
| V0() ? this._history.pushState(t, r, i) : this.location.hash = i | |
| } | |
| replaceState(t, r, i) { | |
| V0() ? this._history.replaceState(t, r, i) : this.location.hash = i | |
| } | |
| forward() { | |
| this._history.forward() | |
| } | |
| back() { | |
| this._history.back() | |
| } | |
| historyGo(t=0) { | |
| this._history.go(t) | |
| } | |
| getState() { | |
| return this._history.state | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(yt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function() { | |
| return function QP() { | |
| return new L0(Q(yt)) | |
| }() | |
| }, | |
| providedIn: "platform" | |
| }), | |
| n | |
| } | |
| )(); | |
| function V0() { | |
| return !!window.history.pushState | |
| } | |
| function mf(n, e) { | |
| if (0 == n.length) | |
| return e; | |
| if (0 == e.length) | |
| return n; | |
| let t = 0; | |
| return n.endsWith("/") && t++, | |
| e.startsWith("/") && t++, | |
| 2 == t ? n + e.substring(1) : 1 == t ? n + e : n + "/" + e | |
| } | |
| function B0(n) { | |
| const e = n.match(/#|\?|$/) | |
| , t = e && e.index || n.length; | |
| return n.slice(0, t - ("/" === n[t - 1] ? 1 : 0)) + n.slice(t) | |
| } | |
| function kr(n) { | |
| return n && "?" !== n[0] ? "?" + n : n | |
| } | |
| let ii = ( () => { | |
| class n { | |
| historyGo(t) { | |
| throw new Error("Not implemented") | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function() { | |
| return ot(j0) | |
| }, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| const U0 = new ee("appBaseHref"); | |
| let j0 = ( () => { | |
| class n extends ii { | |
| constructor(t, r) { | |
| var i, o, s; | |
| super(), | |
| this._platformLocation = t, | |
| this._removeListenerFns = [], | |
| this._baseHref = null !== (s = null !== (i = null != r ? r : this._platformLocation.getBaseHrefFromDOM()) && void 0 !== i ? i : null === (o = ot(yt).location) || void 0 === o ? void 0 : o.origin) && void 0 !== s ? s : "" | |
| } | |
| ngOnDestroy() { | |
| for (; this._removeListenerFns.length; ) | |
| this._removeListenerFns.pop()() | |
| } | |
| onPopState(t) { | |
| this._removeListenerFns.push(this._platformLocation.onPopState(t), this._platformLocation.onHashChange(t)) | |
| } | |
| getBaseHref() { | |
| return this._baseHref | |
| } | |
| prepareExternalUrl(t) { | |
| return mf(this._baseHref, t) | |
| } | |
| path(t=!1) { | |
| const r = this._platformLocation.pathname + kr(this._platformLocation.search) | |
| , i = this._platformLocation.hash; | |
| return i && t ? `${r}${i}` : r | |
| } | |
| pushState(t, r, i, o) { | |
| const s = this.prepareExternalUrl(i + kr(o)); | |
| this._platformLocation.pushState(t, r, s) | |
| } | |
| replaceState(t, r, i, o) { | |
| const s = this.prepareExternalUrl(i + kr(o)); | |
| this._platformLocation.replaceState(t, r, s) | |
| } | |
| forward() { | |
| this._platformLocation.forward() | |
| } | |
| back() { | |
| this._platformLocation.back() | |
| } | |
| getState() { | |
| return this._platformLocation.getState() | |
| } | |
| historyGo(t=0) { | |
| var r, i; | |
| null === (i = (r = this._platformLocation).historyGo) || void 0 === i || i.call(r, t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(gf),Q(U0, 8)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )() | |
| , YP = ( () => { | |
| class n extends ii { | |
| constructor(t, r) { | |
| super(), | |
| this._platformLocation = t, | |
| this._baseHref = "", | |
| this._removeListenerFns = [], | |
| null != r && (this._baseHref = r) | |
| } | |
| ngOnDestroy() { | |
| for (; this._removeListenerFns.length; ) | |
| this._removeListenerFns.pop()() | |
| } | |
| onPopState(t) { | |
| this._removeListenerFns.push(this._platformLocation.onPopState(t), this._platformLocation.onHashChange(t)) | |
| } | |
| getBaseHref() { | |
| return this._baseHref | |
| } | |
| path(t=!1) { | |
| let r = this._platformLocation.hash; | |
| return null == r && (r = "#"), | |
| r.length > 0 ? r.substring(1) : r | |
| } | |
| prepareExternalUrl(t) { | |
| const r = mf(this._baseHref, t); | |
| return r.length > 0 ? "#" + r : r | |
| } | |
| pushState(t, r, i, o) { | |
| let s = this.prepareExternalUrl(i + kr(o)); | |
| 0 == s.length && (s = this._platformLocation.pathname), | |
| this._platformLocation.pushState(t, r, s) | |
| } | |
| replaceState(t, r, i, o) { | |
| let s = this.prepareExternalUrl(i + kr(o)); | |
| 0 == s.length && (s = this._platformLocation.pathname), | |
| this._platformLocation.replaceState(t, r, s) | |
| } | |
| forward() { | |
| this._platformLocation.forward() | |
| } | |
| back() { | |
| this._platformLocation.back() | |
| } | |
| getState() { | |
| return this._platformLocation.getState() | |
| } | |
| historyGo(t=0) { | |
| var r, i; | |
| null === (i = (r = this._platformLocation).historyGo) || void 0 === i || i.call(r, t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(gf),Q(U0, 8)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )() | |
| , _f = ( () => { | |
| class n { | |
| constructor(t) { | |
| this._subject = new Se, | |
| this._urlChangeListeners = [], | |
| this._urlChangeSubscription = null, | |
| this._locationStrategy = t; | |
| const r = this._locationStrategy.getBaseHref(); | |
| this._baseHref = B0(H0(r)), | |
| this._locationStrategy.onPopState(i => { | |
| this._subject.emit({ | |
| url: this.path(!0), | |
| pop: !0, | |
| state: i.state, | |
| type: i.type | |
| }) | |
| } | |
| ) | |
| } | |
| ngOnDestroy() { | |
| var t; | |
| null === (t = this._urlChangeSubscription) || void 0 === t || t.unsubscribe(), | |
| this._urlChangeListeners = [] | |
| } | |
| path(t=!1) { | |
| return this.normalize(this._locationStrategy.path(t)) | |
| } | |
| getState() { | |
| return this._locationStrategy.getState() | |
| } | |
| isCurrentPathEqualTo(t, r="") { | |
| return this.path() == this.normalize(t + kr(r)) | |
| } | |
| normalize(t) { | |
| return n.stripTrailingSlash(function XP(n, e) { | |
| return n && e.startsWith(n) ? e.substring(n.length) : e | |
| }(this._baseHref, H0(t))) | |
| } | |
| prepareExternalUrl(t) { | |
| return t && "/" !== t[0] && (t = "/" + t), | |
| this._locationStrategy.prepareExternalUrl(t) | |
| } | |
| go(t, r="", i=null) { | |
| this._locationStrategy.pushState(i, "", t, r), | |
| this._notifyUrlChangeListeners(this.prepareExternalUrl(t + kr(r)), i) | |
| } | |
| replaceState(t, r="", i=null) { | |
| this._locationStrategy.replaceState(i, "", t, r), | |
| this._notifyUrlChangeListeners(this.prepareExternalUrl(t + kr(r)), i) | |
| } | |
| forward() { | |
| this._locationStrategy.forward() | |
| } | |
| back() { | |
| this._locationStrategy.back() | |
| } | |
| historyGo(t=0) { | |
| var r, i; | |
| null === (i = (r = this._locationStrategy).historyGo) || void 0 === i || i.call(r, t) | |
| } | |
| onUrlChange(t) { | |
| return this._urlChangeListeners.push(t), | |
| this._urlChangeSubscription || (this._urlChangeSubscription = this.subscribe(r => { | |
| this._notifyUrlChangeListeners(r.url, r.state) | |
| } | |
| )), | |
| () => { | |
| var r; | |
| const i = this._urlChangeListeners.indexOf(t); | |
| this._urlChangeListeners.splice(i, 1), | |
| 0 === this._urlChangeListeners.length && (null === (r = this._urlChangeSubscription) || void 0 === r || r.unsubscribe(), | |
| this._urlChangeSubscription = null) | |
| } | |
| } | |
| _notifyUrlChangeListeners(t="", r) { | |
| this._urlChangeListeners.forEach(i => i(t, r)) | |
| } | |
| subscribe(t, r, i) { | |
| return this._subject.subscribe({ | |
| next: t, | |
| error: r, | |
| complete: i | |
| }) | |
| } | |
| } | |
| return n.normalizeQueryParams = kr, | |
| n.joinWithSlash = mf, | |
| n.stripTrailingSlash = B0, | |
| n.\u0275fac = function(t) { | |
| return new (t || n)(Q(ii)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function() { | |
| return function ZP() { | |
| return new _f(Q(ii)) | |
| }() | |
| }, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| function H0(n) { | |
| return n.replace(/\/index.html$/, "") | |
| } | |
| let Z0 = ( () => { | |
| class n { | |
| constructor(t, r, i, o) { | |
| this._iterableDiffers = t, | |
| this._keyValueDiffers = r, | |
| this._ngEl = i, | |
| this._renderer = o, | |
| this._iterableDiffer = null, | |
| this._keyValueDiffer = null, | |
| this._initialClasses = [], | |
| this._rawClass = null | |
| } | |
| set klass(t) { | |
| this._removeClasses(this._initialClasses), | |
| this._initialClasses = "string" == typeof t ? t.split(/\s+/) : [], | |
| this._applyClasses(this._initialClasses), | |
| this._applyClasses(this._rawClass) | |
| } | |
| set ngClass(t) { | |
| this._removeClasses(this._rawClass), | |
| this._applyClasses(this._initialClasses), | |
| this._iterableDiffer = null, | |
| this._keyValueDiffer = null, | |
| this._rawClass = "string" == typeof t ? t.split(/\s+/) : t, | |
| this._rawClass && (Ls(this._rawClass) ? this._iterableDiffer = this._iterableDiffers.find(this._rawClass).create() : this._keyValueDiffer = this._keyValueDiffers.find(this._rawClass).create()) | |
| } | |
| ngDoCheck() { | |
| if (this._iterableDiffer) { | |
| const t = this._iterableDiffer.diff(this._rawClass); | |
| t && this._applyIterableChanges(t) | |
| } else if (this._keyValueDiffer) { | |
| const t = this._keyValueDiffer.diff(this._rawClass); | |
| t && this._applyKeyValueChanges(t) | |
| } | |
| } | |
| _applyKeyValueChanges(t) { | |
| t.forEachAddedItem(r => this._toggleClass(r.key, r.currentValue)), | |
| t.forEachChangedItem(r => this._toggleClass(r.key, r.currentValue)), | |
| t.forEachRemovedItem(r => { | |
| r.previousValue && this._toggleClass(r.key, !1) | |
| } | |
| ) | |
| } | |
| _applyIterableChanges(t) { | |
| t.forEachAddedItem(r => { | |
| if ("string" != typeof r.item) | |
| throw new Error(`NgClass can only toggle CSS classes expressed as strings, got ${Ge(r.item)}`); | |
| this._toggleClass(r.item, !0) | |
| } | |
| ), | |
| t.forEachRemovedItem(r => this._toggleClass(r.item, !1)) | |
| } | |
| _applyClasses(t) { | |
| t && (Array.isArray(t) || t instanceof Set ? t.forEach(r => this._toggleClass(r, !0)) : Object.keys(t).forEach(r => this._toggleClass(r, !!t[r]))) | |
| } | |
| _removeClasses(t) { | |
| t && (Array.isArray(t) || t instanceof Set ? t.forEach(r => this._toggleClass(r, !1)) : Object.keys(t).forEach(r => this._toggleClass(r, !1))) | |
| } | |
| _toggleClass(t, r) { | |
| (t = t.trim()) && t.split(/\s+/g).forEach(i => { | |
| r ? this._renderer.addClass(this._ngEl.nativeElement, i) : this._renderer.removeClass(this._ngEl.nativeElement, i) | |
| } | |
| ) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Ql),B(Js),B(Vt),B(Sr)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["", "ngClass", ""]], | |
| inputs: { | |
| klass: ["class", "klass"], | |
| ngClass: "ngClass" | |
| }, | |
| standalone: !0 | |
| }), | |
| n | |
| } | |
| )(); | |
| class LO { | |
| constructor(e, t, r, i) { | |
| this.$implicit = e, | |
| this.ngForOf = t, | |
| this.index = r, | |
| this.count = i | |
| } | |
| get first() { | |
| return 0 === this.index | |
| } | |
| get last() { | |
| return this.index === this.count - 1 | |
| } | |
| get even() { | |
| return this.index % 2 == 0 | |
| } | |
| get odd() { | |
| return !this.even | |
| } | |
| } | |
| let Af = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this._viewContainer = t, | |
| this._template = r, | |
| this._differs = i, | |
| this._ngForOf = null, | |
| this._ngForOfDirty = !0, | |
| this._differ = null | |
| } | |
| set ngForOf(t) { | |
| this._ngForOf = t, | |
| this._ngForOfDirty = !0 | |
| } | |
| set ngForTrackBy(t) { | |
| this._trackByFn = t | |
| } | |
| get ngForTrackBy() { | |
| return this._trackByFn | |
| } | |
| set ngForTemplate(t) { | |
| t && (this._template = t) | |
| } | |
| ngDoCheck() { | |
| if (this._ngForOfDirty) { | |
| this._ngForOfDirty = !1; | |
| const t = this._ngForOf; | |
| !this._differ && t && (this._differ = this._differs.find(t).create(this.ngForTrackBy)) | |
| } | |
| if (this._differ) { | |
| const t = this._differ.diff(this._ngForOf); | |
| t && this._applyChanges(t) | |
| } | |
| } | |
| _applyChanges(t) { | |
| const r = this._viewContainer; | |
| t.forEachOperation( (i, o, s) => { | |
| if (null == i.previousIndex) | |
| r.createEmbeddedView(this._template, new LO(i.item,this._ngForOf,-1,-1), null === s ? void 0 : s); | |
| else if (null == s) | |
| r.remove(null === o ? void 0 : o); | |
| else if (null !== o) { | |
| const a = r.get(o); | |
| r.move(a, s), | |
| eC(a, i) | |
| } | |
| } | |
| ); | |
| for (let i = 0, o = r.length; i < o; i++) { | |
| const a = r.get(i).context; | |
| a.index = i, | |
| a.count = o, | |
| a.ngForOf = this._ngForOf | |
| } | |
| t.forEachIdentityChange(i => { | |
| eC(r.get(i.currentIndex), i) | |
| } | |
| ) | |
| } | |
| static ngTemplateContextGuard(t, r) { | |
| return !0 | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(tr),B(Pr),B(Ql)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["", "ngFor", "", "ngForOf", ""]], | |
| inputs: { | |
| ngForOf: "ngForOf", | |
| ngForTrackBy: "ngForTrackBy", | |
| ngForTemplate: "ngForTemplate" | |
| }, | |
| standalone: !0 | |
| }), | |
| n | |
| } | |
| )(); | |
| function eC(n, e) { | |
| n.context.$implicit = e.item | |
| } | |
| let na = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this._viewContainer = t, | |
| this._context = new BO, | |
| this._thenTemplateRef = null, | |
| this._elseTemplateRef = null, | |
| this._thenViewRef = null, | |
| this._elseViewRef = null, | |
| this._thenTemplateRef = r | |
| } | |
| set ngIf(t) { | |
| this._context.$implicit = this._context.ngIf = t, | |
| this._updateView() | |
| } | |
| set ngIfThen(t) { | |
| tC("ngIfThen", t), | |
| this._thenTemplateRef = t, | |
| this._thenViewRef = null, | |
| this._updateView() | |
| } | |
| set ngIfElse(t) { | |
| tC("ngIfElse", t), | |
| this._elseTemplateRef = t, | |
| this._elseViewRef = null, | |
| this._updateView() | |
| } | |
| _updateView() { | |
| this._context.$implicit ? this._thenViewRef || (this._viewContainer.clear(), | |
| this._elseViewRef = null, | |
| this._thenTemplateRef && (this._thenViewRef = this._viewContainer.createEmbeddedView(this._thenTemplateRef, this._context))) : this._elseViewRef || (this._viewContainer.clear(), | |
| this._thenViewRef = null, | |
| this._elseTemplateRef && (this._elseViewRef = this._viewContainer.createEmbeddedView(this._elseTemplateRef, this._context))) | |
| } | |
| static ngTemplateContextGuard(t, r) { | |
| return !0 | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(tr),B(Pr)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["", "ngIf", ""]], | |
| inputs: { | |
| ngIf: "ngIf", | |
| ngIfThen: "ngIfThen", | |
| ngIfElse: "ngIfElse" | |
| }, | |
| standalone: !0 | |
| }), | |
| n | |
| } | |
| )(); | |
| class BO { | |
| constructor() { | |
| this.$implicit = null, | |
| this.ngIf = null | |
| } | |
| } | |
| function tC(n, e) { | |
| if (e && !e.createEmbeddedView) | |
| throw new Error(`${n} must be a TemplateRef, but received '${Ge(e)}'.`) | |
| } | |
| let rC = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this._ngEl = t, | |
| this._differs = r, | |
| this._renderer = i, | |
| this._ngStyle = null, | |
| this._differ = null | |
| } | |
| set ngStyle(t) { | |
| this._ngStyle = t, | |
| !this._differ && t && (this._differ = this._differs.find(t).create()) | |
| } | |
| ngDoCheck() { | |
| if (this._differ) { | |
| const t = this._differ.diff(this._ngStyle); | |
| t && this._applyChanges(t) | |
| } | |
| } | |
| _setStyle(t, r) { | |
| const [i,o] = t.split(".") | |
| , s = -1 === i.indexOf("-") ? void 0 : pn.DashCase; | |
| null != r ? this._renderer.setStyle(this._ngEl.nativeElement, i, o ? `${r}${o}` : r, s) : this._renderer.removeStyle(this._ngEl.nativeElement, i, s) | |
| } | |
| _applyChanges(t) { | |
| t.forEachRemovedItem(r => this._setStyle(r.key, null)), | |
| t.forEachAddedItem(r => this._setStyle(r.key, r.currentValue)), | |
| t.forEachChangedItem(r => this._setStyle(r.key, r.currentValue)) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Vt),B(Js),B(Sr)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["", "ngStyle", ""]], | |
| inputs: { | |
| ngStyle: "ngStyle" | |
| }, | |
| standalone: !0 | |
| }), | |
| n | |
| } | |
| )() | |
| , Ff = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({}), | |
| n | |
| } | |
| )(); | |
| const oC = "browser"; | |
| let gN = ( () => { | |
| class n { | |
| } | |
| return n.\u0275prov = se({ | |
| token: n, | |
| providedIn: "root", | |
| factory: () => new mN(Q(yt),window) | |
| }), | |
| n | |
| } | |
| )(); | |
| class mN { | |
| constructor(e, t) { | |
| this.document = e, | |
| this.window = t, | |
| this.offset = () => [0, 0] | |
| } | |
| setOffset(e) { | |
| this.offset = Array.isArray(e) ? () => e : e | |
| } | |
| getScrollPosition() { | |
| return this.supportsScrolling() ? [this.window.pageXOffset, this.window.pageYOffset] : [0, 0] | |
| } | |
| scrollToPosition(e) { | |
| this.supportsScrolling() && this.window.scrollTo(e[0], e[1]) | |
| } | |
| scrollToAnchor(e) { | |
| if (!this.supportsScrolling()) | |
| return; | |
| const t = function _N(n, e) { | |
| const t = n.getElementById(e) || n.getElementsByName(e)[0]; | |
| if (t) | |
| return t; | |
| if ("function" == typeof n.createTreeWalker && n.body && (n.body.createShadowRoot || n.body.attachShadow)) { | |
| const r = n.createTreeWalker(n.body, NodeFilter.SHOW_ELEMENT); | |
| let i = r.currentNode; | |
| for (; i; ) { | |
| const o = i.shadowRoot; | |
| if (o) { | |
| const s = o.getElementById(e) || o.querySelector(`[name="${e}"]`); | |
| if (s) | |
| return s | |
| } | |
| i = r.nextNode() | |
| } | |
| } | |
| return null | |
| }(this.document, e); | |
| t && (this.scrollToElement(t), | |
| t.focus()) | |
| } | |
| setHistoryScrollRestoration(e) { | |
| if (this.supportScrollRestoration()) { | |
| const t = this.window.history; | |
| t && t.scrollRestoration && (t.scrollRestoration = e) | |
| } | |
| } | |
| scrollToElement(e) { | |
| const t = e.getBoundingClientRect() | |
| , r = t.left + this.window.pageXOffset | |
| , i = t.top + this.window.pageYOffset | |
| , o = this.offset(); | |
| this.window.scrollTo(r - o[0], i - o[1]) | |
| } | |
| supportScrollRestoration() { | |
| try { | |
| if (!this.supportsScrolling()) | |
| return !1; | |
| const e = sC(this.window.history) || sC(Object.getPrototypeOf(this.window.history)); | |
| return !(!e || !e.writable && !e.set) | |
| } catch (e) { | |
| return !1 | |
| } | |
| } | |
| supportsScrolling() { | |
| try { | |
| return !!this.window && !!this.window.scrollTo && "pageXOffset"in this.window | |
| } catch (e) { | |
| return !1 | |
| } | |
| } | |
| } | |
| function sC(n) { | |
| return Object.getOwnPropertyDescriptor(n, "scrollRestoration") | |
| } | |
| class Nf extends class WN extends class GP { | |
| } | |
| { | |
| constructor() { | |
| super(...arguments), | |
| this.supportsDOMEvents = !0 | |
| } | |
| } | |
| { | |
| static makeCurrent() { | |
| !function WP(n) { | |
| Yl || (Yl = n) | |
| }(new Nf) | |
| } | |
| onAndCancel(e, t, r) { | |
| return e.addEventListener(t, r, !1), | |
| () => { | |
| e.removeEventListener(t, r, !1) | |
| } | |
| } | |
| dispatchEvent(e, t) { | |
| e.dispatchEvent(t) | |
| } | |
| remove(e) { | |
| e.parentNode && e.parentNode.removeChild(e) | |
| } | |
| createElement(e, t) { | |
| return (t = t || this.getDefaultDocument()).createElement(e) | |
| } | |
| createHtmlDocument() { | |
| return document.implementation.createHTMLDocument("fakeTitle") | |
| } | |
| getDefaultDocument() { | |
| return document | |
| } | |
| isElementNode(e) { | |
| return e.nodeType === Node.ELEMENT_NODE | |
| } | |
| isShadowRoot(e) { | |
| return e instanceof DocumentFragment | |
| } | |
| getGlobalEventTarget(e, t) { | |
| return "window" === t ? window : "document" === t ? e : "body" === t ? e.body : null | |
| } | |
| getBaseHref(e) { | |
| const t = function GN() { | |
| return ia = ia || document.querySelector("base"), | |
| ia ? ia.getAttribute("href") : null | |
| }(); | |
| return null == t ? null : function qN(n) { | |
| lc = lc || document.createElement("a"), | |
| lc.setAttribute("href", n); | |
| const e = lc.pathname; | |
| return "/" === e.charAt(0) ? e : `/${e}` | |
| }(t) | |
| } | |
| resetBaseElement() { | |
| ia = null | |
| } | |
| getUserAgent() { | |
| return window.navigator.userAgent | |
| } | |
| getCookie(e) { | |
| return function NO(n, e) { | |
| e = encodeURIComponent(e); | |
| for (const t of n.split(";")) { | |
| const r = t.indexOf("=") | |
| , [i,o] = -1 == r ? [t, ""] : [t.slice(0, r), t.slice(r + 1)]; | |
| if (i.trim() === e) | |
| return decodeURIComponent(o) | |
| } | |
| return null | |
| }(document.cookie, e) | |
| } | |
| } | |
| let lc, ia = null; | |
| const dC = new ee("TRANSITION_ID") | |
| , QN = [{ | |
| provide: zl, | |
| useFactory: function KN(n, e, t) { | |
| return () => { | |
| t.get($l).donePromise.then( () => { | |
| const r = _r() | |
| , i = e.querySelectorAll(`style[ng-transition="${n}"]`); | |
| for (let o = 0; o < i.length; o++) | |
| r.remove(i[o]) | |
| } | |
| ) | |
| } | |
| }, | |
| deps: [dC, yt, On], | |
| multi: !0 | |
| }]; | |
| let ZN = ( () => { | |
| class n { | |
| build() { | |
| return new XMLHttpRequest | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| const cc = new ee("EventManagerPlugins"); | |
| let uc = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this._zone = r, | |
| this._eventNameToPlugin = new Map, | |
| t.forEach(i => i.manager = this), | |
| this._plugins = t.slice().reverse() | |
| } | |
| addEventListener(t, r, i) { | |
| return this._findPluginFor(r).addEventListener(t, r, i) | |
| } | |
| addGlobalEventListener(t, r, i) { | |
| return this._findPluginFor(r).addGlobalEventListener(t, r, i) | |
| } | |
| getZone() { | |
| return this._zone | |
| } | |
| _findPluginFor(t) { | |
| const r = this._eventNameToPlugin.get(t); | |
| if (r) | |
| return r; | |
| const i = this._plugins; | |
| for (let o = 0; o < i.length; o++) { | |
| const s = i[o]; | |
| if (s.supports(t)) | |
| return this._eventNameToPlugin.set(t, s), | |
| s | |
| } | |
| throw new Error(`No event manager plugin found for event ${t}`) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(cc),Q(nt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| class hC { | |
| constructor(e) { | |
| this._doc = e | |
| } | |
| addGlobalEventListener(e, t, r) { | |
| const i = _r().getGlobalEventTarget(this._doc, e); | |
| if (!i) | |
| throw new Error(`Unsupported event target ${i} for event ${t}`); | |
| return this.addEventListener(i, t, r) | |
| } | |
| } | |
| let fC = ( () => { | |
| class n { | |
| constructor() { | |
| this._stylesSet = new Set | |
| } | |
| addStyles(t) { | |
| const r = new Set; | |
| t.forEach(i => { | |
| this._stylesSet.has(i) || (this._stylesSet.add(i), | |
| r.add(i)) | |
| } | |
| ), | |
| this.onStylesAdded(r) | |
| } | |
| onStylesAdded(t) {} | |
| getAllStyles() { | |
| return Array.from(this._stylesSet) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )() | |
| , oa = ( () => { | |
| class n extends fC { | |
| constructor(t) { | |
| super(), | |
| this._doc = t, | |
| this._hostNodes = new Map, | |
| this._hostNodes.set(t.head, []) | |
| } | |
| _addStylesToHost(t, r, i) { | |
| t.forEach(o => { | |
| const s = this._doc.createElement("style"); | |
| s.textContent = o, | |
| i.push(r.appendChild(s)) | |
| } | |
| ) | |
| } | |
| addHost(t) { | |
| const r = []; | |
| this._addStylesToHost(this._stylesSet, t, r), | |
| this._hostNodes.set(t, r) | |
| } | |
| removeHost(t) { | |
| const r = this._hostNodes.get(t); | |
| r && r.forEach(pC), | |
| this._hostNodes.delete(t) | |
| } | |
| onStylesAdded(t) { | |
| this._hostNodes.forEach( (r, i) => { | |
| this._addStylesToHost(t, i, r) | |
| } | |
| ) | |
| } | |
| ngOnDestroy() { | |
| this._hostNodes.forEach(t => t.forEach(pC)) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(yt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| function pC(n) { | |
| _r().remove(n) | |
| } | |
| const kf = { | |
| svg: "http://www.w3.org/2000/svg", | |
| xhtml: "http://www.w3.org/1999/xhtml", | |
| xlink: "http://www.w3.org/1999/xlink", | |
| xml: "http://www.w3.org/XML/1998/namespace", | |
| xmlns: "http://www.w3.org/2000/xmlns/", | |
| math: "http://www.w3.org/1998/MathML/" | |
| } | |
| , Lf = /%COMP%/g; | |
| function dc(n, e, t) { | |
| for (let r = 0; r < e.length; r++) { | |
| let i = e[r]; | |
| Array.isArray(i) ? dc(n, i, t) : (i = i.replace(Lf, n), | |
| t.push(i)) | |
| } | |
| return t | |
| } | |
| function _C(n) { | |
| return e => { | |
| if ("__ngUnwrap__" === e) | |
| return n; | |
| !1 === n(e) && (e.preventDefault(), | |
| e.returnValue = !1) | |
| } | |
| } | |
| let hc = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this.eventManager = t, | |
| this.sharedStylesHost = r, | |
| this.appId = i, | |
| this.rendererByCompId = new Map, | |
| this.defaultRenderer = new Vf(t) | |
| } | |
| createRenderer(t, r) { | |
| if (!t || !r) | |
| return this.defaultRenderer; | |
| switch (r.encapsulation) { | |
| case Gn.Emulated: | |
| { | |
| let i = this.rendererByCompId.get(r.id); | |
| return i || (i = new rk(this.eventManager,this.sharedStylesHost,r,this.appId), | |
| this.rendererByCompId.set(r.id, i)), | |
| i.applyToHost(t), | |
| i | |
| } | |
| case 1: | |
| case Gn.ShadowDom: | |
| return new ik(this.eventManager,this.sharedStylesHost,t,r); | |
| default: | |
| if (!this.rendererByCompId.has(r.id)) { | |
| const i = dc(r.id, r.styles, []); | |
| this.sharedStylesHost.addStyles(i), | |
| this.rendererByCompId.set(r.id, this.defaultRenderer) | |
| } | |
| return this.defaultRenderer | |
| } | |
| } | |
| begin() {} | |
| end() {} | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(uc),Q(oa),Q(Ys)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| class Vf { | |
| constructor(e) { | |
| this.eventManager = e, | |
| this.data = Object.create(null), | |
| this.destroyNode = null | |
| } | |
| destroy() {} | |
| createElement(e, t) { | |
| return t ? document.createElementNS(kf[t] || t, e) : document.createElement(e) | |
| } | |
| createComment(e) { | |
| return document.createComment(e) | |
| } | |
| createText(e) { | |
| return document.createTextNode(e) | |
| } | |
| appendChild(e, t) { | |
| (vC(e) ? e.content : e).appendChild(t) | |
| } | |
| insertBefore(e, t, r) { | |
| e && (vC(e) ? e.content : e).insertBefore(t, r) | |
| } | |
| removeChild(e, t) { | |
| e && e.removeChild(t) | |
| } | |
| selectRootElement(e, t) { | |
| let r = "string" == typeof e ? document.querySelector(e) : e; | |
| if (!r) | |
| throw new Error(`The selector "${e}" did not match any elements`); | |
| return t || (r.textContent = ""), | |
| r | |
| } | |
| parentNode(e) { | |
| return e.parentNode | |
| } | |
| nextSibling(e) { | |
| return e.nextSibling | |
| } | |
| setAttribute(e, t, r, i) { | |
| if (i) { | |
| t = i + ":" + t; | |
| const o = kf[i]; | |
| o ? e.setAttributeNS(o, t, r) : e.setAttribute(t, r) | |
| } else | |
| e.setAttribute(t, r) | |
| } | |
| removeAttribute(e, t, r) { | |
| if (r) { | |
| const i = kf[r]; | |
| i ? e.removeAttributeNS(i, t) : e.removeAttribute(`${r}:${t}`) | |
| } else | |
| e.removeAttribute(t) | |
| } | |
| addClass(e, t) { | |
| e.classList.add(t) | |
| } | |
| removeClass(e, t) { | |
| e.classList.remove(t) | |
| } | |
| setStyle(e, t, r, i) { | |
| i & (pn.DashCase | pn.Important) ? e.style.setProperty(t, r, i & pn.Important ? "important" : "") : e.style[t] = r | |
| } | |
| removeStyle(e, t, r) { | |
| r & pn.DashCase ? e.style.removeProperty(t) : e.style[t] = "" | |
| } | |
| setProperty(e, t, r) { | |
| e[t] = r | |
| } | |
| setValue(e, t) { | |
| e.nodeValue = t | |
| } | |
| listen(e, t, r) { | |
| return "string" == typeof e ? this.eventManager.addGlobalEventListener(e, t, _C(r)) : this.eventManager.addEventListener(e, t, _C(r)) | |
| } | |
| } | |
| function vC(n) { | |
| return "TEMPLATE" === n.tagName && void 0 !== n.content | |
| } | |
| class rk extends Vf { | |
| constructor(e, t, r, i) { | |
| super(e), | |
| this.component = r; | |
| const o = dc(i + "-" + r.id, r.styles, []); | |
| t.addStyles(o), | |
| this.contentAttr = function ek(n) { | |
| return "_ngcontent-%COMP%".replace(Lf, n) | |
| }(i + "-" + r.id), | |
| this.hostAttr = function tk(n) { | |
| return "_nghost-%COMP%".replace(Lf, n) | |
| }(i + "-" + r.id) | |
| } | |
| applyToHost(e) { | |
| super.setAttribute(e, this.hostAttr, "") | |
| } | |
| createElement(e, t) { | |
| const r = super.createElement(e, t); | |
| return super.setAttribute(r, this.contentAttr, ""), | |
| r | |
| } | |
| } | |
| class ik extends Vf { | |
| constructor(e, t, r, i) { | |
| super(e), | |
| this.sharedStylesHost = t, | |
| this.hostEl = r, | |
| this.shadowRoot = r.attachShadow({ | |
| mode: "open" | |
| }), | |
| this.sharedStylesHost.addHost(this.shadowRoot); | |
| const o = dc(i.id, i.styles, []); | |
| for (let s = 0; s < o.length; s++) { | |
| const a = document.createElement("style"); | |
| a.textContent = o[s], | |
| this.shadowRoot.appendChild(a) | |
| } | |
| } | |
| nodeOrShadowRoot(e) { | |
| return e === this.hostEl ? this.shadowRoot : e | |
| } | |
| destroy() { | |
| this.sharedStylesHost.removeHost(this.shadowRoot) | |
| } | |
| appendChild(e, t) { | |
| return super.appendChild(this.nodeOrShadowRoot(e), t) | |
| } | |
| insertBefore(e, t, r) { | |
| return super.insertBefore(this.nodeOrShadowRoot(e), t, r) | |
| } | |
| removeChild(e, t) { | |
| return super.removeChild(this.nodeOrShadowRoot(e), t) | |
| } | |
| parentNode(e) { | |
| return this.nodeOrShadowRoot(super.parentNode(this.nodeOrShadowRoot(e))) | |
| } | |
| } | |
| let ok = ( () => { | |
| class n extends hC { | |
| constructor(t) { | |
| super(t) | |
| } | |
| supports(t) { | |
| return !0 | |
| } | |
| addEventListener(t, r, i) { | |
| return t.addEventListener(r, i, !1), | |
| () => this.removeEventListener(t, r, i) | |
| } | |
| removeEventListener(t, r, i) { | |
| return t.removeEventListener(r, i) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(yt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| const bC = ["alt", "control", "meta", "shift"] | |
| , sk = { | |
| "\b": "Backspace", | |
| "\t": "Tab", | |
| "\x7f": "Delete", | |
| "\x1b": "Escape", | |
| Del: "Delete", | |
| Esc: "Escape", | |
| Left: "ArrowLeft", | |
| Right: "ArrowRight", | |
| Up: "ArrowUp", | |
| Down: "ArrowDown", | |
| Menu: "ContextMenu", | |
| Scroll: "ScrollLock", | |
| Win: "OS" | |
| } | |
| , ak = { | |
| alt: n => n.altKey, | |
| control: n => n.ctrlKey, | |
| meta: n => n.metaKey, | |
| shift: n => n.shiftKey | |
| }; | |
| let lk = ( () => { | |
| class n extends hC { | |
| constructor(t) { | |
| super(t) | |
| } | |
| supports(t) { | |
| return null != n.parseEventName(t) | |
| } | |
| addEventListener(t, r, i) { | |
| const o = n.parseEventName(r) | |
| , s = n.eventCallback(o.fullKey, i, this.manager.getZone()); | |
| return this.manager.getZone().runOutsideAngular( () => _r().onAndCancel(t, o.domEventName, s)) | |
| } | |
| static parseEventName(t) { | |
| const r = t.toLowerCase().split(".") | |
| , i = r.shift(); | |
| if (0 === r.length || "keydown" !== i && "keyup" !== i) | |
| return null; | |
| const o = n._normalizeKey(r.pop()); | |
| let s = "" | |
| , a = r.indexOf("code"); | |
| if (a > -1 && (r.splice(a, 1), | |
| s = "code."), | |
| bC.forEach(c => { | |
| const u = r.indexOf(c); | |
| u > -1 && (r.splice(u, 1), | |
| s += c + ".") | |
| } | |
| ), | |
| s += o, | |
| 0 != r.length || 0 === o.length) | |
| return null; | |
| const l = {}; | |
| return l.domEventName = i, | |
| l.fullKey = s, | |
| l | |
| } | |
| static matchEventFullKeyCode(t, r) { | |
| let i = sk[t.key] || t.key | |
| , o = ""; | |
| return r.indexOf("code.") > -1 && (i = t.code, | |
| o = "code."), | |
| !(null == i || !i) && (i = i.toLowerCase(), | |
| " " === i ? i = "space" : "." === i && (i = "dot"), | |
| bC.forEach(s => { | |
| s !== i && (0, | |
| ak[s])(t) && (o += s + ".") | |
| } | |
| ), | |
| o += i, | |
| o === r) | |
| } | |
| static eventCallback(t, r, i) { | |
| return o => { | |
| n.matchEventFullKeyCode(o, t) && i.runGuarded( () => r(o)) | |
| } | |
| } | |
| static _normalizeKey(t) { | |
| return "esc" === t ? "escape" : t | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(yt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| const TC = [{ | |
| provide: Jh, | |
| useValue: oC | |
| }, { | |
| provide: l0, | |
| useValue: function ck() { | |
| Nf.makeCurrent() | |
| }, | |
| multi: !0 | |
| }, { | |
| provide: yt, | |
| useFactory: function dk() { | |
| return function HI(n) { | |
| Od = n | |
| }(document), | |
| document | |
| }, | |
| deps: [] | |
| }] | |
| , hk = y0(HP, "browser", TC) | |
| , EC = new ee("") | |
| , wC = [{ | |
| provide: Wl, | |
| useClass: class YN { | |
| addToWindow(e) { | |
| Ze.getAngularTestability = (r, i=!0) => { | |
| const o = e.findTestabilityInTree(r, i); | |
| if (null == o) | |
| throw new Error("Could not find testability for element."); | |
| return o | |
| } | |
| , | |
| Ze.getAllAngularTestabilities = () => e.getAllTestabilities(), | |
| Ze.getAllAngularRootElements = () => e.getAllRootElements(), | |
| Ze.frameworkStabilizers || (Ze.frameworkStabilizers = []), | |
| Ze.frameworkStabilizers.push(r => { | |
| const i = Ze.getAllAngularTestabilities(); | |
| let o = i.length | |
| , s = !1; | |
| const a = function(l) { | |
| s = s || l, | |
| o--, | |
| 0 == o && r(s) | |
| }; | |
| i.forEach(function(l) { | |
| l.whenStable(a) | |
| }) | |
| } | |
| ) | |
| } | |
| findTestabilityInTree(e, t, r) { | |
| if (null == t) | |
| return null; | |
| const i = e.getTestability(t); | |
| return null != i ? i : r ? _r().isShadowRoot(t) ? this.findTestabilityInTree(e, t.host, !0) : this.findTestabilityInTree(e, t.parentElement, !0) : null | |
| } | |
| } | |
| , | |
| deps: [] | |
| }, { | |
| provide: p0, | |
| useClass: af, | |
| deps: [nt, lf, Wl] | |
| }, { | |
| provide: af, | |
| useClass: af, | |
| deps: [nt, lf, Wl] | |
| }] | |
| , DC = [{ | |
| provide: zd, | |
| useValue: "root" | |
| }, { | |
| provide: bo, | |
| useFactory: function uk() { | |
| return new bo | |
| }, | |
| deps: [] | |
| }, { | |
| provide: cc, | |
| useClass: ok, | |
| multi: !0, | |
| deps: [yt, nt, Jh] | |
| }, { | |
| provide: cc, | |
| useClass: lk, | |
| multi: !0, | |
| deps: [yt] | |
| }, { | |
| provide: hc, | |
| useClass: hc, | |
| deps: [uc, oa, Ys] | |
| }, { | |
| provide: Os, | |
| useExisting: hc | |
| }, { | |
| provide: fC, | |
| useExisting: oa | |
| }, { | |
| provide: oa, | |
| useClass: oa, | |
| deps: [yt] | |
| }, { | |
| provide: uc, | |
| useClass: uc, | |
| deps: [cc, nt] | |
| }, { | |
| provide: class yN { | |
| } | |
| , | |
| useClass: ZN, | |
| deps: [] | |
| }, []]; | |
| let MC = ( () => { | |
| class n { | |
| constructor(t) {} | |
| static withServerTransition(t) { | |
| return { | |
| ngModule: n, | |
| providers: [{ | |
| provide: Ys, | |
| useValue: t.appId | |
| }, { | |
| provide: dC, | |
| useExisting: Ys | |
| }, QN] | |
| } | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(EC, 12)) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| providers: [...DC, ...wC], | |
| imports: [Ff, zP] | |
| }), | |
| n | |
| } | |
| )() | |
| , AC = ( () => { | |
| class n { | |
| constructor(t) { | |
| this._doc = t | |
| } | |
| getTitle() { | |
| return this._doc.title | |
| } | |
| setTitle(t) { | |
| this._doc.title = t || "" | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(yt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function(t) { | |
| let r = null; | |
| return r = t ? new t : function pk() { | |
| return new AC(Q(yt)) | |
| }(), | |
| r | |
| }, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| "undefined" != typeof window && window; | |
| const {isArray: Tk} = Array | |
| , {getPrototypeOf: Ek, prototype: wk, keys: Dk} = Object; | |
| function xC(n) { | |
| if (1 === n.length) { | |
| const e = n[0]; | |
| if (Tk(e)) | |
| return { | |
| args: e, | |
| keys: null | |
| }; | |
| if (function Mk(n) { | |
| return n && "object" == typeof n && Ek(n) === wk | |
| }(e)) { | |
| const t = Dk(e); | |
| return { | |
| args: t.map(r => e[r]), | |
| keys: t | |
| } | |
| } | |
| } | |
| return { | |
| args: n, | |
| keys: null | |
| } | |
| } | |
| const {isArray: Ak} = Array; | |
| function RC(n) { | |
| return Fe(e => function Ik(n, e) { | |
| return Ak(e) ? n(...e) : n(e) | |
| }(n, e)) | |
| } | |
| function FC(n, e) { | |
| return n.reduce( (t, r, i) => (t[r] = e[i], | |
| t), {}) | |
| } | |
| let PC = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this._renderer = t, | |
| this._elementRef = r, | |
| this.onChange = i => {} | |
| , | |
| this.onTouched = () => {} | |
| } | |
| setProperty(t, r) { | |
| this._renderer.setProperty(this._elementRef.nativeElement, t, r) | |
| } | |
| registerOnTouched(t) { | |
| this.onTouched = t | |
| } | |
| registerOnChange(t) { | |
| this.onChange = t | |
| } | |
| setDisabledState(t) { | |
| this.setProperty("disabled", t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Sr),B(Vt)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n | |
| }), | |
| n | |
| } | |
| )() | |
| , Vi = ( () => { | |
| class n extends PC { | |
| } | |
| return n.\u0275fac = function() { | |
| let e; | |
| return function(r) { | |
| return (e || (e = function Wt(n) { | |
| return Qr( () => { | |
| const e = n.prototype.constructor | |
| , t = e[wr] || sd(e) | |
| , r = Object.prototype; | |
| let i = Object.getPrototypeOf(n.prototype).constructor; | |
| for (; i && i !== r; ) { | |
| const o = i[wr] || sd(i); | |
| if (o && o !== t) | |
| return o; | |
| i = Object.getPrototypeOf(i) | |
| } | |
| return o => new o | |
| } | |
| ) | |
| }(n)))(r || n) | |
| } | |
| }(), | |
| n.\u0275dir = ue({ | |
| type: n, | |
| features: [ke] | |
| }), | |
| n | |
| } | |
| )(); | |
| const ar = new ee("NgValueAccessor") | |
| , Rk = { | |
| provide: ar, | |
| useExisting: qe( () => jf), | |
| multi: !0 | |
| } | |
| , Pk = new ee("CompositionEventMode"); | |
| let jf = ( () => { | |
| class n extends PC { | |
| constructor(t, r, i) { | |
| super(t, r), | |
| this._compositionMode = i, | |
| this._composing = !1, | |
| null == this._compositionMode && (this._compositionMode = !function Fk() { | |
| const n = _r() ? _r().getUserAgent() : ""; | |
| return /android (\d+)/.test(n.toLowerCase()) | |
| }()) | |
| } | |
| writeValue(t) { | |
| this.setProperty("value", null == t ? "" : t) | |
| } | |
| _handleInput(t) { | |
| (!this._compositionMode || this._compositionMode && !this._composing) && this.onChange(t) | |
| } | |
| _compositionStart() { | |
| this._composing = !0 | |
| } | |
| _compositionEnd(t) { | |
| this._composing = !1, | |
| this._compositionMode && this.onChange(t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Sr),B(Vt),B(Pk, 8)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["input", "formControlName", "", 3, "type", "checkbox"], ["textarea", "formControlName", ""], ["input", "formControl", "", 3, "type", "checkbox"], ["textarea", "formControl", ""], ["input", "ngModel", "", 3, "type", "checkbox"], ["textarea", "ngModel", ""], ["", "ngDefaultControl", ""]], | |
| hostBindings: function(t, r) { | |
| 1 & t && _e("input", function(o) { | |
| return r._handleInput(o.target.value) | |
| })("blur", function() { | |
| return r.onTouched() | |
| })("compositionstart", function() { | |
| return r._compositionStart() | |
| })("compositionend", function(o) { | |
| return r._compositionEnd(o.target.value) | |
| }) | |
| }, | |
| features: [tt([Rk]), ke] | |
| }), | |
| n | |
| } | |
| )(); | |
| const Kt = new ee("NgValidators") | |
| , ai = new ee("NgAsyncValidators"); | |
| function $C(n) { | |
| return null != n | |
| } | |
| function WC(n) { | |
| return Bs(n) ? wt(n) : n | |
| } | |
| function GC(n) { | |
| let e = {}; | |
| return n.forEach(t => { | |
| e = null != t ? Object.assign(Object.assign({}, e), t) : e | |
| } | |
| ), | |
| 0 === Object.keys(e).length ? null : e | |
| } | |
| function qC(n, e) { | |
| return e.map(t => t(n)) | |
| } | |
| function KC(n) { | |
| return n.map(e => function kk(n) { | |
| return !n.validate | |
| }(e) ? e : t => e.validate(t)) | |
| } | |
| function Hf(n) { | |
| return null != n ? function QC(n) { | |
| if (!n) | |
| return null; | |
| const e = n.filter($C); | |
| return 0 == e.length ? null : function(t) { | |
| return GC(qC(t, e)) | |
| } | |
| }(KC(n)) : null | |
| } | |
| function zf(n) { | |
| return null != n ? function YC(n) { | |
| if (!n) | |
| return null; | |
| const e = n.filter($C); | |
| return 0 == e.length ? null : function(t) { | |
| return function Sk(...n) { | |
| const e = Kg(n) | |
| , {args: t, keys: r} = xC(n) | |
| , i = new vt(o => { | |
| const {length: s} = t; | |
| if (!s) | |
| return void o.complete(); | |
| const a = new Array(s); | |
| let l = s | |
| , c = s; | |
| for (let u = 0; u < s; u++) { | |
| let d = !1; | |
| _n(t[u]).subscribe(pt(o, h => { | |
| d || (d = !0, | |
| c--), | |
| a[u] = h | |
| } | |
| , () => l--, void 0, () => { | |
| (!l || !d) && (c || o.next(r ? FC(r, a) : a), | |
| o.complete()) | |
| } | |
| )) | |
| } | |
| } | |
| ); | |
| return e ? i.pipe(RC(e)) : i | |
| }(qC(t, e).map(WC)).pipe(Fe(GC)) | |
| } | |
| }(KC(n)) : null | |
| } | |
| function ZC(n, e) { | |
| return null === n ? [e] : Array.isArray(n) ? [...n, e] : [n, e] | |
| } | |
| function $f(n) { | |
| return n ? Array.isArray(n) ? n : [n] : [] | |
| } | |
| function pc(n, e) { | |
| return Array.isArray(n) ? n.includes(e) : n === e | |
| } | |
| function eT(n, e) { | |
| const t = $f(e); | |
| return $f(n).forEach(i => { | |
| pc(t, i) || t.push(i) | |
| } | |
| ), | |
| t | |
| } | |
| function tT(n, e) { | |
| return $f(e).filter(t => !pc(n, t)) | |
| } | |
| class nT { | |
| constructor() { | |
| this._rawValidators = [], | |
| this._rawAsyncValidators = [], | |
| this._onDestroyCallbacks = [] | |
| } | |
| get value() { | |
| return this.control ? this.control.value : null | |
| } | |
| get valid() { | |
| return this.control ? this.control.valid : null | |
| } | |
| get invalid() { | |
| return this.control ? this.control.invalid : null | |
| } | |
| get pending() { | |
| return this.control ? this.control.pending : null | |
| } | |
| get disabled() { | |
| return this.control ? this.control.disabled : null | |
| } | |
| get enabled() { | |
| return this.control ? this.control.enabled : null | |
| } | |
| get errors() { | |
| return this.control ? this.control.errors : null | |
| } | |
| get pristine() { | |
| return this.control ? this.control.pristine : null | |
| } | |
| get dirty() { | |
| return this.control ? this.control.dirty : null | |
| } | |
| get touched() { | |
| return this.control ? this.control.touched : null | |
| } | |
| get status() { | |
| return this.control ? this.control.status : null | |
| } | |
| get untouched() { | |
| return this.control ? this.control.untouched : null | |
| } | |
| get statusChanges() { | |
| return this.control ? this.control.statusChanges : null | |
| } | |
| get valueChanges() { | |
| return this.control ? this.control.valueChanges : null | |
| } | |
| get path() { | |
| return null | |
| } | |
| _setValidators(e) { | |
| this._rawValidators = e || [], | |
| this._composedValidatorFn = Hf(this._rawValidators) | |
| } | |
| _setAsyncValidators(e) { | |
| this._rawAsyncValidators = e || [], | |
| this._composedAsyncValidatorFn = zf(this._rawAsyncValidators) | |
| } | |
| get validator() { | |
| return this._composedValidatorFn || null | |
| } | |
| get asyncValidator() { | |
| return this._composedAsyncValidatorFn || null | |
| } | |
| _registerOnDestroy(e) { | |
| this._onDestroyCallbacks.push(e) | |
| } | |
| _invokeOnDestroyCallbacks() { | |
| this._onDestroyCallbacks.forEach(e => e()), | |
| this._onDestroyCallbacks = [] | |
| } | |
| reset(e) { | |
| this.control && this.control.reset(e) | |
| } | |
| hasError(e, t) { | |
| return !!this.control && this.control.hasError(e, t) | |
| } | |
| getError(e, t) { | |
| return this.control ? this.control.getError(e, t) : null | |
| } | |
| } | |
| class li extends nT { | |
| constructor() { | |
| super(...arguments), | |
| this._parent = null, | |
| this.name = null, | |
| this.valueAccessor = null | |
| } | |
| } | |
| class an extends nT { | |
| get formDirective() { | |
| return null | |
| } | |
| get path() { | |
| return null | |
| } | |
| } | |
| let iT = ( () => { | |
| class n extends class rT { | |
| constructor(e) { | |
| this._cd = e | |
| } | |
| get isTouched() { | |
| var e, t; | |
| return !(null === (t = null === (e = this._cd) || void 0 === e ? void 0 : e.control) || void 0 === t || !t.touched) | |
| } | |
| get isUntouched() { | |
| var e, t; | |
| return !(null === (t = null === (e = this._cd) || void 0 === e ? void 0 : e.control) || void 0 === t || !t.untouched) | |
| } | |
| get isPristine() { | |
| var e, t; | |
| return !(null === (t = null === (e = this._cd) || void 0 === e ? void 0 : e.control) || void 0 === t || !t.pristine) | |
| } | |
| get isDirty() { | |
| var e, t; | |
| return !(null === (t = null === (e = this._cd) || void 0 === e ? void 0 : e.control) || void 0 === t || !t.dirty) | |
| } | |
| get isValid() { | |
| var e, t; | |
| return !(null === (t = null === (e = this._cd) || void 0 === e ? void 0 : e.control) || void 0 === t || !t.valid) | |
| } | |
| get isInvalid() { | |
| var e, t; | |
| return !(null === (t = null === (e = this._cd) || void 0 === e ? void 0 : e.control) || void 0 === t || !t.invalid) | |
| } | |
| get isPending() { | |
| var e, t; | |
| return !(null === (t = null === (e = this._cd) || void 0 === e ? void 0 : e.control) || void 0 === t || !t.pending) | |
| } | |
| get isSubmitted() { | |
| var e; | |
| return !(null === (e = this._cd) || void 0 === e || !e.submitted) | |
| } | |
| } | |
| { | |
| constructor(t) { | |
| super(t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(li, 2)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["", "formControlName", ""], ["", "ngModel", ""], ["", "formControl", ""]], | |
| hostVars: 14, | |
| hostBindings: function(t, r) { | |
| 2 & t && Xn("ng-untouched", r.isUntouched)("ng-touched", r.isTouched)("ng-pristine", r.isPristine)("ng-dirty", r.isDirty)("ng-valid", r.isValid)("ng-invalid", r.isInvalid)("ng-pending", r.isPending) | |
| }, | |
| features: [ke] | |
| }), | |
| n | |
| } | |
| )(); | |
| const sa = "VALID" | |
| , mc = "INVALID" | |
| , Uo = "PENDING" | |
| , aa = "DISABLED"; | |
| function sT(n) { | |
| return Array.isArray(n) ? Hf(n) : n || null | |
| } | |
| function aT(n) { | |
| return Array.isArray(n) ? zf(n) : n || null | |
| } | |
| function _c(n) { | |
| return null != n && !Array.isArray(n) && "object" == typeof n | |
| } | |
| function la(n, e) { | |
| var t, r; | |
| (function Zf(n, e) { | |
| const t = function XC(n) { | |
| return n._rawValidators | |
| }(n); | |
| null !== e.validator ? n.setValidators(ZC(t, e.validator)) : "function" == typeof t && n.setValidators([t]); | |
| const r = function JC(n) { | |
| return n._rawAsyncValidators | |
| }(n); | |
| null !== e.asyncValidator ? n.setAsyncValidators(ZC(r, e.asyncValidator)) : "function" == typeof r && n.setAsyncValidators([r]); | |
| const i = () => n.updateValueAndValidity(); | |
| bc(e._rawValidators, i), | |
| bc(e._rawAsyncValidators, i) | |
| } | |
| )(n, e), | |
| e.valueAccessor.writeValue(n.value), | |
| n.disabled && (null === (r = (t = e.valueAccessor).setDisabledState) || void 0 === r || r.call(t, !0)), | |
| function Gk(n, e) { | |
| e.valueAccessor.registerOnChange(t => { | |
| n._pendingValue = t, | |
| n._pendingChange = !0, | |
| n._pendingDirty = !0, | |
| "change" === n.updateOn && dT(n, e) | |
| } | |
| ) | |
| }(n, e), | |
| function Kk(n, e) { | |
| const t = (r, i) => { | |
| e.valueAccessor.writeValue(r), | |
| i && e.viewToModelUpdate(r) | |
| } | |
| ; | |
| n.registerOnChange(t), | |
| e._registerOnDestroy( () => { | |
| n._unregisterOnChange(t) | |
| } | |
| ) | |
| }(n, e), | |
| function qk(n, e) { | |
| e.valueAccessor.registerOnTouched( () => { | |
| n._pendingTouched = !0, | |
| "blur" === n.updateOn && n._pendingChange && dT(n, e), | |
| "submit" !== n.updateOn && n.markAsTouched() | |
| } | |
| ) | |
| }(n, e), | |
| function Wk(n, e) { | |
| if (e.valueAccessor.setDisabledState) { | |
| const t = r => { | |
| e.valueAccessor.setDisabledState(r) | |
| } | |
| ; | |
| n.registerOnDisabledChange(t), | |
| e._registerOnDestroy( () => { | |
| n._unregisterOnDisabledChange(t) | |
| } | |
| ) | |
| } | |
| }(n, e) | |
| } | |
| function bc(n, e) { | |
| n.forEach(t => { | |
| t.registerOnValidatorChange && t.registerOnValidatorChange(e) | |
| } | |
| ) | |
| } | |
| function dT(n, e) { | |
| n._pendingDirty && n.markAsDirty(), | |
| n.setValue(n._pendingValue, { | |
| emitModelToViewChange: !1 | |
| }), | |
| e.viewToModelUpdate(n._pendingValue), | |
| n._pendingChange = !1 | |
| } | |
| function gT(n, e) { | |
| const t = n.indexOf(e); | |
| t > -1 && n.splice(t, 1) | |
| } | |
| function mT(n) { | |
| return "object" == typeof n && null !== n && 2 === Object.keys(n).length && "value"in n && "disabled"in n | |
| } | |
| const nL = { | |
| provide: li, | |
| useExisting: qe( () => tp) | |
| } | |
| , bT = ( () => Promise.resolve())(); | |
| let tp = ( () => { | |
| class n extends li { | |
| constructor(t, r, i, o, s) { | |
| super(), | |
| this._changeDetectorRef = s, | |
| this.control = new class extends class uT { | |
| constructor(e, t) { | |
| this._pendingDirty = !1, | |
| this._hasOwnPendingAsyncValidator = !1, | |
| this._pendingTouched = !1, | |
| this._onCollectionChange = () => {} | |
| , | |
| this._parent = null, | |
| this.pristine = !0, | |
| this.touched = !1, | |
| this._onDisabledChange = [], | |
| this._rawValidators = e, | |
| this._rawAsyncValidators = t, | |
| this._composedValidatorFn = sT(this._rawValidators), | |
| this._composedAsyncValidatorFn = aT(this._rawAsyncValidators) | |
| } | |
| get validator() { | |
| return this._composedValidatorFn | |
| } | |
| set validator(e) { | |
| this._rawValidators = this._composedValidatorFn = e | |
| } | |
| get asyncValidator() { | |
| return this._composedAsyncValidatorFn | |
| } | |
| set asyncValidator(e) { | |
| this._rawAsyncValidators = this._composedAsyncValidatorFn = e | |
| } | |
| get parent() { | |
| return this._parent | |
| } | |
| get valid() { | |
| return this.status === sa | |
| } | |
| get invalid() { | |
| return this.status === mc | |
| } | |
| get pending() { | |
| return this.status == Uo | |
| } | |
| get disabled() { | |
| return this.status === aa | |
| } | |
| get enabled() { | |
| return this.status !== aa | |
| } | |
| get dirty() { | |
| return !this.pristine | |
| } | |
| get untouched() { | |
| return !this.touched | |
| } | |
| get updateOn() { | |
| return this._updateOn ? this._updateOn : this.parent ? this.parent.updateOn : "change" | |
| } | |
| setValidators(e) { | |
| this._rawValidators = e, | |
| this._composedValidatorFn = sT(e) | |
| } | |
| setAsyncValidators(e) { | |
| this._rawAsyncValidators = e, | |
| this._composedAsyncValidatorFn = aT(e) | |
| } | |
| addValidators(e) { | |
| this.setValidators(eT(e, this._rawValidators)) | |
| } | |
| addAsyncValidators(e) { | |
| this.setAsyncValidators(eT(e, this._rawAsyncValidators)) | |
| } | |
| removeValidators(e) { | |
| this.setValidators(tT(e, this._rawValidators)) | |
| } | |
| removeAsyncValidators(e) { | |
| this.setAsyncValidators(tT(e, this._rawAsyncValidators)) | |
| } | |
| hasValidator(e) { | |
| return pc(this._rawValidators, e) | |
| } | |
| hasAsyncValidator(e) { | |
| return pc(this._rawAsyncValidators, e) | |
| } | |
| clearValidators() { | |
| this.validator = null | |
| } | |
| clearAsyncValidators() { | |
| this.asyncValidator = null | |
| } | |
| markAsTouched(e={}) { | |
| this.touched = !0, | |
| this._parent && !e.onlySelf && this._parent.markAsTouched(e) | |
| } | |
| markAllAsTouched() { | |
| this.markAsTouched({ | |
| onlySelf: !0 | |
| }), | |
| this._forEachChild(e => e.markAllAsTouched()) | |
| } | |
| markAsUntouched(e={}) { | |
| this.touched = !1, | |
| this._pendingTouched = !1, | |
| this._forEachChild(t => { | |
| t.markAsUntouched({ | |
| onlySelf: !0 | |
| }) | |
| } | |
| ), | |
| this._parent && !e.onlySelf && this._parent._updateTouched(e) | |
| } | |
| markAsDirty(e={}) { | |
| this.pristine = !1, | |
| this._parent && !e.onlySelf && this._parent.markAsDirty(e) | |
| } | |
| markAsPristine(e={}) { | |
| this.pristine = !0, | |
| this._pendingDirty = !1, | |
| this._forEachChild(t => { | |
| t.markAsPristine({ | |
| onlySelf: !0 | |
| }) | |
| } | |
| ), | |
| this._parent && !e.onlySelf && this._parent._updatePristine(e) | |
| } | |
| markAsPending(e={}) { | |
| this.status = Uo, | |
| !1 !== e.emitEvent && this.statusChanges.emit(this.status), | |
| this._parent && !e.onlySelf && this._parent.markAsPending(e) | |
| } | |
| disable(e={}) { | |
| const t = this._parentMarkedDirty(e.onlySelf); | |
| this.status = aa, | |
| this.errors = null, | |
| this._forEachChild(r => { | |
| r.disable(Object.assign(Object.assign({}, e), { | |
| onlySelf: !0 | |
| })) | |
| } | |
| ), | |
| this._updateValue(), | |
| !1 !== e.emitEvent && (this.valueChanges.emit(this.value), | |
| this.statusChanges.emit(this.status)), | |
| this._updateAncestors(Object.assign(Object.assign({}, e), { | |
| skipPristineCheck: t | |
| })), | |
| this._onDisabledChange.forEach(r => r(!0)) | |
| } | |
| enable(e={}) { | |
| const t = this._parentMarkedDirty(e.onlySelf); | |
| this.status = sa, | |
| this._forEachChild(r => { | |
| r.enable(Object.assign(Object.assign({}, e), { | |
| onlySelf: !0 | |
| })) | |
| } | |
| ), | |
| this.updateValueAndValidity({ | |
| onlySelf: !0, | |
| emitEvent: e.emitEvent | |
| }), | |
| this._updateAncestors(Object.assign(Object.assign({}, e), { | |
| skipPristineCheck: t | |
| })), | |
| this._onDisabledChange.forEach(r => r(!1)) | |
| } | |
| _updateAncestors(e) { | |
| this._parent && !e.onlySelf && (this._parent.updateValueAndValidity(e), | |
| e.skipPristineCheck || this._parent._updatePristine(), | |
| this._parent._updateTouched()) | |
| } | |
| setParent(e) { | |
| this._parent = e | |
| } | |
| getRawValue() { | |
| return this.value | |
| } | |
| updateValueAndValidity(e={}) { | |
| this._setInitialStatus(), | |
| this._updateValue(), | |
| this.enabled && (this._cancelExistingSubscription(), | |
| this.errors = this._runValidator(), | |
| this.status = this._calculateStatus(), | |
| (this.status === sa || this.status === Uo) && this._runAsyncValidator(e.emitEvent)), | |
| !1 !== e.emitEvent && (this.valueChanges.emit(this.value), | |
| this.statusChanges.emit(this.status)), | |
| this._parent && !e.onlySelf && this._parent.updateValueAndValidity(e) | |
| } | |
| _updateTreeValidity(e={ | |
| emitEvent: !0 | |
| }) { | |
| this._forEachChild(t => t._updateTreeValidity(e)), | |
| this.updateValueAndValidity({ | |
| onlySelf: !0, | |
| emitEvent: e.emitEvent | |
| }) | |
| } | |
| _setInitialStatus() { | |
| this.status = this._allControlsDisabled() ? aa : sa | |
| } | |
| _runValidator() { | |
| return this.validator ? this.validator(this) : null | |
| } | |
| _runAsyncValidator(e) { | |
| if (this.asyncValidator) { | |
| this.status = Uo, | |
| this._hasOwnPendingAsyncValidator = !0; | |
| const t = WC(this.asyncValidator(this)); | |
| this._asyncValidationSubscription = t.subscribe(r => { | |
| this._hasOwnPendingAsyncValidator = !1, | |
| this.setErrors(r, { | |
| emitEvent: e | |
| }) | |
| } | |
| ) | |
| } | |
| } | |
| _cancelExistingSubscription() { | |
| this._asyncValidationSubscription && (this._asyncValidationSubscription.unsubscribe(), | |
| this._hasOwnPendingAsyncValidator = !1) | |
| } | |
| setErrors(e, t={}) { | |
| this.errors = e, | |
| this._updateControlsErrors(!1 !== t.emitEvent) | |
| } | |
| get(e) { | |
| let t = e; | |
| return null == t || (Array.isArray(t) || (t = t.split(".")), | |
| 0 === t.length) ? null : t.reduce( (r, i) => r && r._find(i), this) | |
| } | |
| getError(e, t) { | |
| const r = t ? this.get(t) : this; | |
| return r && r.errors ? r.errors[e] : null | |
| } | |
| hasError(e, t) { | |
| return !!this.getError(e, t) | |
| } | |
| get root() { | |
| let e = this; | |
| for (; e._parent; ) | |
| e = e._parent; | |
| return e | |
| } | |
| _updateControlsErrors(e) { | |
| this.status = this._calculateStatus(), | |
| e && this.statusChanges.emit(this.status), | |
| this._parent && this._parent._updateControlsErrors(e) | |
| } | |
| _initObservables() { | |
| this.valueChanges = new Se, | |
| this.statusChanges = new Se | |
| } | |
| _calculateStatus() { | |
| return this._allControlsDisabled() ? aa : this.errors ? mc : this._hasOwnPendingAsyncValidator || this._anyControlsHaveStatus(Uo) ? Uo : this._anyControlsHaveStatus(mc) ? mc : sa | |
| } | |
| _anyControlsHaveStatus(e) { | |
| return this._anyControls(t => t.status === e) | |
| } | |
| _anyControlsDirty() { | |
| return this._anyControls(e => e.dirty) | |
| } | |
| _anyControlsTouched() { | |
| return this._anyControls(e => e.touched) | |
| } | |
| _updatePristine(e={}) { | |
| this.pristine = !this._anyControlsDirty(), | |
| this._parent && !e.onlySelf && this._parent._updatePristine(e) | |
| } | |
| _updateTouched(e={}) { | |
| this.touched = this._anyControlsTouched(), | |
| this._parent && !e.onlySelf && this._parent._updateTouched(e) | |
| } | |
| _registerOnCollectionChange(e) { | |
| this._onCollectionChange = e | |
| } | |
| _setUpdateStrategy(e) { | |
| _c(e) && null != e.updateOn && (this._updateOn = e.updateOn) | |
| } | |
| _parentMarkedDirty(e) { | |
| return !e && !(!this._parent || !this._parent.dirty) && !this._parent._anyControlsDirty() | |
| } | |
| _find(e) { | |
| return null | |
| } | |
| } | |
| { | |
| constructor(e=null, t, r) { | |
| super(function Kf(n) { | |
| return (_c(n) ? n.validators : n) || null | |
| }(t), function Qf(n, e) { | |
| return (_c(e) ? e.asyncValidators : n) || null | |
| }(r, t)), | |
| this.defaultValue = null, | |
| this._onChange = [], | |
| this._pendingChange = !1, | |
| this._applyFormState(e), | |
| this._setUpdateStrategy(t), | |
| this._initObservables(), | |
| this.updateValueAndValidity({ | |
| onlySelf: !0, | |
| emitEvent: !!this.asyncValidator | |
| }), | |
| _c(t) && (t.nonNullable || t.initialValueIsDefault) && (this.defaultValue = mT(e) ? e.value : e) | |
| } | |
| setValue(e, t={}) { | |
| this.value = this._pendingValue = e, | |
| this._onChange.length && !1 !== t.emitModelToViewChange && this._onChange.forEach(r => r(this.value, !1 !== t.emitViewToModelChange)), | |
| this.updateValueAndValidity(t) | |
| } | |
| patchValue(e, t={}) { | |
| this.setValue(e, t) | |
| } | |
| reset(e=this.defaultValue, t={}) { | |
| this._applyFormState(e), | |
| this.markAsPristine(t), | |
| this.markAsUntouched(t), | |
| this.setValue(this.value, t), | |
| this._pendingChange = !1 | |
| } | |
| _updateValue() {} | |
| _anyControls(e) { | |
| return !1 | |
| } | |
| _allControlsDisabled() { | |
| return this.disabled | |
| } | |
| registerOnChange(e) { | |
| this._onChange.push(e) | |
| } | |
| _unregisterOnChange(e) { | |
| gT(this._onChange, e) | |
| } | |
| registerOnDisabledChange(e) { | |
| this._onDisabledChange.push(e) | |
| } | |
| _unregisterOnDisabledChange(e) { | |
| gT(this._onDisabledChange, e) | |
| } | |
| _forEachChild(e) {} | |
| _syncPendingControls() { | |
| return !("submit" !== this.updateOn || (this._pendingDirty && this.markAsDirty(), | |
| this._pendingTouched && this.markAsTouched(), | |
| !this._pendingChange) || (this.setValue(this._pendingValue, { | |
| onlySelf: !0, | |
| emitModelToViewChange: !1 | |
| }), | |
| 0)) | |
| } | |
| _applyFormState(e) { | |
| mT(e) ? (this.value = this._pendingValue = e.value, | |
| e.disabled ? this.disable({ | |
| onlySelf: !0, | |
| emitEvent: !1 | |
| }) : this.enable({ | |
| onlySelf: !0, | |
| emitEvent: !1 | |
| })) : this.value = this._pendingValue = e | |
| } | |
| } | |
| , | |
| this._registered = !1, | |
| this.update = new Se, | |
| this._parent = t, | |
| this._setValidators(r), | |
| this._setAsyncValidators(i), | |
| this.valueAccessor = function Jf(n, e) { | |
| if (!e) | |
| return null; | |
| let t, r, i; | |
| return Array.isArray(e), | |
| e.forEach(o => { | |
| o.constructor === jf ? t = o : function Zk(n) { | |
| return Object.getPrototypeOf(n.constructor) === Vi | |
| }(o) ? r = o : i = o | |
| } | |
| ), | |
| i || r || t || null | |
| }(0, o) | |
| } | |
| ngOnChanges(t) { | |
| if (this._checkForErrors(), | |
| !this._registered || "name"in t) { | |
| if (this._registered && (this._checkName(), | |
| this.formDirective)) { | |
| const r = t.name.previousValue; | |
| this.formDirective.removeControl({ | |
| name: r, | |
| path: this._getPath(r) | |
| }) | |
| } | |
| this._setUpControl() | |
| } | |
| "isDisabled"in t && this._updateDisabled(t), | |
| function Xf(n, e) { | |
| if (!n.hasOwnProperty("model")) | |
| return !1; | |
| const t = n.model; | |
| return !!t.isFirstChange() || !Object.is(e, t.currentValue) | |
| }(t, this.viewModel) && (this._updateValue(this.model), | |
| this.viewModel = this.model) | |
| } | |
| ngOnDestroy() { | |
| this.formDirective && this.formDirective.removeControl(this) | |
| } | |
| get path() { | |
| return this._getPath(this.name) | |
| } | |
| get formDirective() { | |
| return this._parent ? this._parent.formDirective : null | |
| } | |
| viewToModelUpdate(t) { | |
| this.viewModel = t, | |
| this.update.emit(t) | |
| } | |
| _setUpControl() { | |
| this._setUpdateStrategy(), | |
| this._isStandalone() ? this._setUpStandalone() : this.formDirective.addControl(this), | |
| this._registered = !0 | |
| } | |
| _setUpdateStrategy() { | |
| this.options && null != this.options.updateOn && (this.control._updateOn = this.options.updateOn) | |
| } | |
| _isStandalone() { | |
| return !this._parent || !(!this.options || !this.options.standalone) | |
| } | |
| _setUpStandalone() { | |
| la(this.control, this), | |
| this.control.updateValueAndValidity({ | |
| emitEvent: !1 | |
| }) | |
| } | |
| _checkForErrors() { | |
| this._isStandalone() || this._checkParentType(), | |
| this._checkName() | |
| } | |
| _checkParentType() {} | |
| _checkName() { | |
| this.options && this.options.name && (this.name = this.options.name), | |
| this._isStandalone() | |
| } | |
| _updateValue(t) { | |
| bT.then( () => { | |
| var r; | |
| this.control.setValue(t, { | |
| emitViewToModelChange: !1 | |
| }), | |
| null === (r = this._changeDetectorRef) || void 0 === r || r.markForCheck() | |
| } | |
| ) | |
| } | |
| _updateDisabled(t) { | |
| const r = t.isDisabled.currentValue | |
| , i = 0 !== r && function Nr(n) { | |
| return "boolean" == typeof n ? n : null != n && "false" !== n | |
| }(r); | |
| bT.then( () => { | |
| var o; | |
| i && !this.control.disabled ? this.control.disable() : !i && this.control.disabled && this.control.enable(), | |
| null === (o = this._changeDetectorRef) || void 0 === o || o.markForCheck() | |
| } | |
| ) | |
| } | |
| _getPath(t) { | |
| return this._parent ? function yc(n, e) { | |
| return [...e.path, n] | |
| }(t, this._parent) : [t] | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(an, 9),B(Kt, 10),B(ai, 10),B(ar, 10),B(Bo, 8)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["", "ngModel", "", 3, "formControlName", "", 3, "formControl", ""]], | |
| inputs: { | |
| name: "name", | |
| isDisabled: ["disabled", "isDisabled"], | |
| model: ["ngModel", "model"], | |
| options: ["ngModelOptions", "options"] | |
| }, | |
| outputs: { | |
| update: "ngModelChange" | |
| }, | |
| exportAs: ["ngModel"], | |
| features: [tt([nL]), ke, Tn] | |
| }), | |
| n | |
| } | |
| )() | |
| , TT = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({}), | |
| n | |
| } | |
| )(); | |
| const np = new ee("NgModelWithFormControlWarning"); | |
| let BT = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [TT] | |
| }), | |
| n | |
| } | |
| )() | |
| , AL = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [BT] | |
| }), | |
| n | |
| } | |
| )() | |
| , IL = ( () => { | |
| class n { | |
| static withConfig(t) { | |
| return { | |
| ngModule: n, | |
| providers: [{ | |
| provide: np, | |
| useValue: t.warnOnNgModelWithFormControl | |
| }] | |
| } | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [BT] | |
| }), | |
| n | |
| } | |
| )(); | |
| class UT { | |
| } | |
| const Vr = "*"; | |
| function jT(n, e=null) { | |
| return { | |
| type: 2, | |
| steps: n, | |
| options: e | |
| } | |
| } | |
| function Ui(n) { | |
| return { | |
| type: 6, | |
| styles: n, | |
| offset: null | |
| } | |
| } | |
| function HT(n) { | |
| Promise.resolve().then(n) | |
| } | |
| class ua { | |
| constructor(e=0, t=0) { | |
| this._onDoneFns = [], | |
| this._onStartFns = [], | |
| this._onDestroyFns = [], | |
| this._originalOnDoneFns = [], | |
| this._originalOnStartFns = [], | |
| this._started = !1, | |
| this._destroyed = !1, | |
| this._finished = !1, | |
| this._position = 0, | |
| this.parentPlayer = null, | |
| this.totalTime = e + t | |
| } | |
| _onFinish() { | |
| this._finished || (this._finished = !0, | |
| this._onDoneFns.forEach(e => e()), | |
| this._onDoneFns = []) | |
| } | |
| onStart(e) { | |
| this._originalOnStartFns.push(e), | |
| this._onStartFns.push(e) | |
| } | |
| onDone(e) { | |
| this._originalOnDoneFns.push(e), | |
| this._onDoneFns.push(e) | |
| } | |
| onDestroy(e) { | |
| this._onDestroyFns.push(e) | |
| } | |
| hasStarted() { | |
| return this._started | |
| } | |
| init() {} | |
| play() { | |
| this.hasStarted() || (this._onStart(), | |
| this.triggerMicrotask()), | |
| this._started = !0 | |
| } | |
| triggerMicrotask() { | |
| HT( () => this._onFinish()) | |
| } | |
| _onStart() { | |
| this._onStartFns.forEach(e => e()), | |
| this._onStartFns = [] | |
| } | |
| pause() {} | |
| restart() {} | |
| finish() { | |
| this._onFinish() | |
| } | |
| destroy() { | |
| this._destroyed || (this._destroyed = !0, | |
| this.hasStarted() || this._onStart(), | |
| this.finish(), | |
| this._onDestroyFns.forEach(e => e()), | |
| this._onDestroyFns = []) | |
| } | |
| reset() { | |
| this._started = !1, | |
| this._finished = !1, | |
| this._onStartFns = this._originalOnStartFns, | |
| this._onDoneFns = this._originalOnDoneFns | |
| } | |
| setPosition(e) { | |
| this._position = this.totalTime ? e * this.totalTime : 1 | |
| } | |
| getPosition() { | |
| return this.totalTime ? this._position / this.totalTime : 1 | |
| } | |
| triggerCallback(e) { | |
| const t = "start" == e ? this._onStartFns : this._onDoneFns; | |
| t.forEach(r => r()), | |
| t.length = 0 | |
| } | |
| } | |
| class zT { | |
| constructor(e) { | |
| this._onDoneFns = [], | |
| this._onStartFns = [], | |
| this._finished = !1, | |
| this._started = !1, | |
| this._destroyed = !1, | |
| this._onDestroyFns = [], | |
| this.parentPlayer = null, | |
| this.totalTime = 0, | |
| this.players = e; | |
| let t = 0 | |
| , r = 0 | |
| , i = 0; | |
| const o = this.players.length; | |
| 0 == o ? HT( () => this._onFinish()) : this.players.forEach(s => { | |
| s.onDone( () => { | |
| ++t == o && this._onFinish() | |
| } | |
| ), | |
| s.onDestroy( () => { | |
| ++r == o && this._onDestroy() | |
| } | |
| ), | |
| s.onStart( () => { | |
| ++i == o && this._onStart() | |
| } | |
| ) | |
| } | |
| ), | |
| this.totalTime = this.players.reduce( (s, a) => Math.max(s, a.totalTime), 0) | |
| } | |
| _onFinish() { | |
| this._finished || (this._finished = !0, | |
| this._onDoneFns.forEach(e => e()), | |
| this._onDoneFns = []) | |
| } | |
| init() { | |
| this.players.forEach(e => e.init()) | |
| } | |
| onStart(e) { | |
| this._onStartFns.push(e) | |
| } | |
| _onStart() { | |
| this.hasStarted() || (this._started = !0, | |
| this._onStartFns.forEach(e => e()), | |
| this._onStartFns = []) | |
| } | |
| onDone(e) { | |
| this._onDoneFns.push(e) | |
| } | |
| onDestroy(e) { | |
| this._onDestroyFns.push(e) | |
| } | |
| hasStarted() { | |
| return this._started | |
| } | |
| play() { | |
| this.parentPlayer || this.init(), | |
| this._onStart(), | |
| this.players.forEach(e => e.play()) | |
| } | |
| pause() { | |
| this.players.forEach(e => e.pause()) | |
| } | |
| restart() { | |
| this.players.forEach(e => e.restart()) | |
| } | |
| finish() { | |
| this._onFinish(), | |
| this.players.forEach(e => e.finish()) | |
| } | |
| destroy() { | |
| this._onDestroy() | |
| } | |
| _onDestroy() { | |
| this._destroyed || (this._destroyed = !0, | |
| this._onFinish(), | |
| this.players.forEach(e => e.destroy()), | |
| this._onDestroyFns.forEach(e => e()), | |
| this._onDestroyFns = []) | |
| } | |
| reset() { | |
| this.players.forEach(e => e.reset()), | |
| this._destroyed = !1, | |
| this._finished = !1, | |
| this._started = !1 | |
| } | |
| setPosition(e) { | |
| const t = e * this.totalTime; | |
| this.players.forEach(r => { | |
| const i = r.totalTime ? Math.min(1, t / r.totalTime) : 1; | |
| r.setPosition(i) | |
| } | |
| ) | |
| } | |
| getPosition() { | |
| const e = this.players.reduce( (t, r) => null === t || r.totalTime > t.totalTime ? r : t, null); | |
| return null != e ? e.getPosition() : 0 | |
| } | |
| beforeDestroy() { | |
| this.players.forEach(e => { | |
| e.beforeDestroy && e.beforeDestroy() | |
| } | |
| ) | |
| } | |
| triggerCallback(e) { | |
| const t = "start" == e ? this._onStartFns : this._onDoneFns; | |
| t.forEach(r => r()), | |
| t.length = 0 | |
| } | |
| } | |
| function $T(n) { | |
| return new U(3e3,!1) | |
| } | |
| function f2() { | |
| return "undefined" != typeof window && void 0 !== window.document | |
| } | |
| function fp() { | |
| return "undefined" != typeof process && "[object process]" === {}.toString.call(process) | |
| } | |
| function ci(n) { | |
| switch (n.length) { | |
| case 0: | |
| return new ua; | |
| case 1: | |
| return n[0]; | |
| default: | |
| return new zT(n) | |
| } | |
| } | |
| function WT(n, e, t, r, i=new Map, o=new Map) { | |
| const s = [] | |
| , a = []; | |
| let l = -1 | |
| , c = null; | |
| if (r.forEach(u => { | |
| const d = u.get("offset") | |
| , h = d == l | |
| , f = h && c || new Map; | |
| u.forEach( (p, _) => { | |
| let C = _ | |
| , S = p; | |
| if ("offset" !== _) | |
| switch (C = e.normalizePropertyName(C, s), | |
| S) { | |
| case "!": | |
| S = i.get(_); | |
| break; | |
| case Vr: | |
| S = o.get(_); | |
| break; | |
| default: | |
| S = e.normalizeStyleValue(_, C, S, s) | |
| } | |
| f.set(C, S) | |
| } | |
| ), | |
| h || a.push(f), | |
| c = f, | |
| l = d | |
| } | |
| ), | |
| s.length) | |
| throw function e2(n) { | |
| return new U(3502,!1) | |
| }(); | |
| return a | |
| } | |
| function pp(n, e, t, r) { | |
| switch (e) { | |
| case "start": | |
| n.onStart( () => r(t && gp(t, "start", n))); | |
| break; | |
| case "done": | |
| n.onDone( () => r(t && gp(t, "done", n))); | |
| break; | |
| case "destroy": | |
| n.onDestroy( () => r(t && gp(t, "destroy", n))) | |
| } | |
| } | |
| function gp(n, e, t) { | |
| const r = t.totalTime | |
| , o = mp(n.element, n.triggerName, n.fromState, n.toState, e || n.phaseName, null == r ? n.totalTime : r, !!t.disabled) | |
| , s = n._data; | |
| return null != s && (o._data = s), | |
| o | |
| } | |
| function mp(n, e, t, r, i="", o=0, s) { | |
| return { | |
| element: n, | |
| triggerName: e, | |
| fromState: t, | |
| toState: r, | |
| phaseName: i, | |
| totalTime: o, | |
| disabled: !!s | |
| } | |
| } | |
| function Sn(n, e, t) { | |
| let r = n.get(e); | |
| return r || n.set(e, r = t), | |
| r | |
| } | |
| function GT(n) { | |
| const e = n.indexOf(":"); | |
| return [n.substring(1, e), n.slice(e + 1)] | |
| } | |
| let _p = (n, e) => !1 | |
| , qT = (n, e, t) => [] | |
| , KT = null; | |
| function yp(n) { | |
| const e = n.parentNode || n.host; | |
| return e === KT ? null : e | |
| } | |
| (fp() || "undefined" != typeof Element) && (f2() ? (KT = ( () => document.documentElement)(), | |
| _p = (n, e) => { | |
| for (; e; ) { | |
| if (e === n) | |
| return !0; | |
| e = yp(e) | |
| } | |
| return !1 | |
| } | |
| ) : _p = (n, e) => n.contains(e), | |
| qT = (n, e, t) => { | |
| if (t) | |
| return Array.from(n.querySelectorAll(e)); | |
| const r = n.querySelector(e); | |
| return r ? [r] : [] | |
| } | |
| ); | |
| let ji = null | |
| , QT = !1; | |
| const YT = _p | |
| , ZT = qT; | |
| let XT = ( () => { | |
| class n { | |
| validateStyleProperty(t) { | |
| return function g2(n) { | |
| ji || (ji = function m2() { | |
| return "undefined" != typeof document ? document.body : null | |
| }() || {}, | |
| QT = !!ji.style && "WebkitAppearance"in ji.style); | |
| let e = !0; | |
| return ji.style && !function p2(n) { | |
| return "ebkit" == n.substring(1, 6) | |
| }(n) && (e = n in ji.style, | |
| !e && QT && (e = "Webkit" + n.charAt(0).toUpperCase() + n.slice(1)in ji.style)), | |
| e | |
| }(t) | |
| } | |
| matchesElement(t, r) { | |
| return !1 | |
| } | |
| containsElement(t, r) { | |
| return YT(t, r) | |
| } | |
| getParentElement(t) { | |
| return yp(t) | |
| } | |
| query(t, r, i) { | |
| return ZT(t, r, i) | |
| } | |
| computeStyle(t, r, i) { | |
| return i || "" | |
| } | |
| animate(t, r, i, o, s, a=[], l) { | |
| return new ua(i,o) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )() | |
| , vp = ( () => { | |
| class n { | |
| } | |
| return n.NOOP = new XT, | |
| n | |
| } | |
| )(); | |
| const bp = "ng-enter" | |
| , Tc = "ng-leave" | |
| , Ec = "ng-trigger" | |
| , wc = ".ng-trigger" | |
| , eE = "ng-animating" | |
| , Cp = ".ng-animating"; | |
| function Br(n) { | |
| if ("number" == typeof n) | |
| return n; | |
| const e = n.match(/^(-?[\.\d]+)(m?s)/); | |
| return !e || e.length < 2 ? 0 : Tp(parseFloat(e[1]), e[2]) | |
| } | |
| function Tp(n, e) { | |
| return "s" === e ? 1e3 * n : n | |
| } | |
| function Dc(n, e, t) { | |
| return n.hasOwnProperty("duration") ? n : function v2(n, e, t) { | |
| let i, o = 0, s = ""; | |
| if ("string" == typeof n) { | |
| const a = n.match(/^(-?[\.\d]+)(m?s)(?:\s+(-?[\.\d]+)(m?s))?(?:\s+([-a-z]+(?:\(.+?\))?))?$/i); | |
| if (null === a) | |
| return e.push($T()), | |
| { | |
| duration: 0, | |
| delay: 0, | |
| easing: "" | |
| }; | |
| i = Tp(parseFloat(a[1]), a[2]); | |
| const l = a[3]; | |
| null != l && (o = Tp(parseFloat(l), a[4])); | |
| const c = a[5]; | |
| c && (s = c) | |
| } else | |
| i = n; | |
| if (!t) { | |
| let a = !1 | |
| , l = e.length; | |
| i < 0 && (e.push(function FL() { | |
| return new U(3100,!1) | |
| }()), | |
| a = !0), | |
| o < 0 && (e.push(function PL() { | |
| return new U(3101,!1) | |
| }()), | |
| a = !0), | |
| a && e.splice(l, 0, $T()) | |
| } | |
| return { | |
| duration: i, | |
| delay: o, | |
| easing: s | |
| } | |
| }(n, e, t) | |
| } | |
| function da(n, e={}) { | |
| return Object.keys(n).forEach(t => { | |
| e[t] = n[t] | |
| } | |
| ), | |
| e | |
| } | |
| function tE(n) { | |
| const e = new Map; | |
| return Object.keys(n).forEach(t => { | |
| e.set(t, n[t]) | |
| } | |
| ), | |
| e | |
| } | |
| function ui(n, e=new Map, t) { | |
| if (t) | |
| for (let[r,i] of t) | |
| e.set(r, i); | |
| for (let[r,i] of n) | |
| e.set(r, i); | |
| return e | |
| } | |
| function rE(n, e, t) { | |
| return t ? e + ":" + t + ";" : "" | |
| } | |
| function iE(n) { | |
| let e = ""; | |
| for (let t = 0; t < n.style.length; t++) { | |
| const r = n.style.item(t); | |
| e += rE(0, r, n.style.getPropertyValue(r)) | |
| } | |
| for (const t in n.style) | |
| n.style.hasOwnProperty(t) && !t.startsWith("_") && (e += rE(0, E2(t), n.style[t])); | |
| n.setAttribute("style", e) | |
| } | |
| function yr(n, e, t) { | |
| n.style && (e.forEach( (r, i) => { | |
| const o = wp(i); | |
| t && !t.has(i) && t.set(i, n.style[o]), | |
| n.style[o] = r | |
| } | |
| ), | |
| fp() && iE(n)) | |
| } | |
| function Hi(n, e) { | |
| n.style && (e.forEach( (t, r) => { | |
| const i = wp(r); | |
| n.style[i] = "" | |
| } | |
| ), | |
| fp() && iE(n)) | |
| } | |
| function ha(n) { | |
| return Array.isArray(n) ? 1 == n.length ? n[0] : jT(n) : n | |
| } | |
| const Ep = new RegExp("{{\\s*(.+?)\\s*}}","g"); | |
| function oE(n) { | |
| let e = []; | |
| if ("string" == typeof n) { | |
| let t; | |
| for (; t = Ep.exec(n); ) | |
| e.push(t[1]); | |
| Ep.lastIndex = 0 | |
| } | |
| return e | |
| } | |
| function fa(n, e, t) { | |
| const r = n.toString() | |
| , i = r.replace(Ep, (o, s) => { | |
| let a = e[s]; | |
| return null == a && (t.push(function NL(n) { | |
| return new U(3003,!1) | |
| }()), | |
| a = ""), | |
| a.toString() | |
| } | |
| ); | |
| return i == r ? n : i | |
| } | |
| function Mc(n) { | |
| const e = []; | |
| let t = n.next(); | |
| for (; !t.done; ) | |
| e.push(t.value), | |
| t = n.next(); | |
| return e | |
| } | |
| const T2 = /-+([a-z0-9])/g; | |
| function wp(n) { | |
| return n.replace(T2, (...e) => e[1].toUpperCase()) | |
| } | |
| function E2(n) { | |
| return n.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase() | |
| } | |
| function xn(n, e, t) { | |
| switch (e.type) { | |
| case 7: | |
| return n.visitTrigger(e, t); | |
| case 0: | |
| return n.visitState(e, t); | |
| case 1: | |
| return n.visitTransition(e, t); | |
| case 2: | |
| return n.visitSequence(e, t); | |
| case 3: | |
| return n.visitGroup(e, t); | |
| case 4: | |
| return n.visitAnimate(e, t); | |
| case 5: | |
| return n.visitKeyframes(e, t); | |
| case 6: | |
| return n.visitStyle(e, t); | |
| case 8: | |
| return n.visitReference(e, t); | |
| case 9: | |
| return n.visitAnimateChild(e, t); | |
| case 10: | |
| return n.visitAnimateRef(e, t); | |
| case 11: | |
| return n.visitQuery(e, t); | |
| case 12: | |
| return n.visitStagger(e, t); | |
| default: | |
| throw function kL(n) { | |
| return new U(3004,!1) | |
| }() | |
| } | |
| } | |
| function sE(n, e) { | |
| return window.getComputedStyle(n)[e] | |
| } | |
| function S2(n, e) { | |
| const t = []; | |
| return "string" == typeof n ? n.split(/\s*,\s*/).forEach(r => function x2(n, e, t) { | |
| if (":" == n[0]) { | |
| const l = function R2(n, e) { | |
| switch (n) { | |
| case ":enter": | |
| return "void => *"; | |
| case ":leave": | |
| return "* => void"; | |
| case ":increment": | |
| return (t, r) => parseFloat(r) > parseFloat(t); | |
| case ":decrement": | |
| return (t, r) => parseFloat(r) < parseFloat(t); | |
| default: | |
| return e.push(function YL(n) { | |
| return new U(3016,!1) | |
| }()), | |
| "* => *" | |
| } | |
| }(n, t); | |
| if ("function" == typeof l) | |
| return void e.push(l); | |
| n = l | |
| } | |
| const r = n.match(/^(\*|[-\w]+)\s*(<?[=-]>)\s*(\*|[-\w]+)$/); | |
| if (null == r || r.length < 4) | |
| return t.push(function QL(n) { | |
| return new U(3015,!1) | |
| }()), | |
| e; | |
| const i = r[1] | |
| , o = r[2] | |
| , s = r[3]; | |
| e.push(aE(i, s)); | |
| "<" == o[0] && !("*" == i && "*" == s) && e.push(aE(s, i)) | |
| }(r, t, e)) : t.push(n), | |
| t | |
| } | |
| const xc = new Set(["true", "1"]) | |
| , Rc = new Set(["false", "0"]); | |
| function aE(n, e) { | |
| const t = xc.has(n) || Rc.has(n) | |
| , r = xc.has(e) || Rc.has(e); | |
| return (i, o) => { | |
| let s = "*" == n || n == i | |
| , a = "*" == e || e == o; | |
| return !s && t && "boolean" == typeof i && (s = i ? xc.has(n) : Rc.has(n)), | |
| !a && r && "boolean" == typeof o && (a = o ? xc.has(e) : Rc.has(e)), | |
| s && a | |
| } | |
| } | |
| const F2 = new RegExp("s*:selfs*,?","g"); | |
| function Dp(n, e, t, r) { | |
| return new P2(n).build(e, t, r) | |
| } | |
| class P2 { | |
| constructor(e) { | |
| this._driver = e | |
| } | |
| build(e, t, r) { | |
| const i = new k2(t); | |
| return this._resetContextStyleTimingState(i), | |
| xn(this, ha(e), i) | |
| } | |
| _resetContextStyleTimingState(e) { | |
| e.currentQuerySelector = "", | |
| e.collectedStyles = new Map, | |
| e.collectedStyles.set("", new Map), | |
| e.currentTime = 0 | |
| } | |
| visitTrigger(e, t) { | |
| let r = t.queryCount = 0 | |
| , i = t.depCount = 0; | |
| const o = [] | |
| , s = []; | |
| return "@" == e.name.charAt(0) && t.errors.push(function VL() { | |
| return new U(3006,!1) | |
| }()), | |
| e.definitions.forEach(a => { | |
| if (this._resetContextStyleTimingState(t), | |
| 0 == a.type) { | |
| const l = a | |
| , c = l.name; | |
| c.toString().split(/\s*,\s*/).forEach(u => { | |
| l.name = u, | |
| o.push(this.visitState(l, t)) | |
| } | |
| ), | |
| l.name = c | |
| } else if (1 == a.type) { | |
| const l = this.visitTransition(a, t); | |
| r += l.queryCount, | |
| i += l.depCount, | |
| s.push(l) | |
| } else | |
| t.errors.push(function BL() { | |
| return new U(3007,!1) | |
| }()) | |
| } | |
| ), | |
| { | |
| type: 7, | |
| name: e.name, | |
| states: o, | |
| transitions: s, | |
| queryCount: r, | |
| depCount: i, | |
| options: null | |
| } | |
| } | |
| visitState(e, t) { | |
| const r = this.visitStyle(e.styles, t) | |
| , i = e.options && e.options.params || null; | |
| if (r.containsDynamicStyles) { | |
| const o = new Set | |
| , s = i || {}; | |
| r.styles.forEach(a => { | |
| a instanceof Map && a.forEach(l => { | |
| oE(l).forEach(c => { | |
| s.hasOwnProperty(c) || o.add(c) | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| ), | |
| o.size && (Mc(o.values()), | |
| t.errors.push(function UL(n, e) { | |
| return new U(3008,!1) | |
| }())) | |
| } | |
| return { | |
| type: 0, | |
| name: e.name, | |
| style: r, | |
| options: i ? { | |
| params: i | |
| } : null | |
| } | |
| } | |
| visitTransition(e, t) { | |
| t.queryCount = 0, | |
| t.depCount = 0; | |
| const r = xn(this, ha(e.animation), t); | |
| return { | |
| type: 1, | |
| matchers: S2(e.expr, t.errors), | |
| animation: r, | |
| queryCount: t.queryCount, | |
| depCount: t.depCount, | |
| options: zi(e.options) | |
| } | |
| } | |
| visitSequence(e, t) { | |
| return { | |
| type: 2, | |
| steps: e.steps.map(r => xn(this, r, t)), | |
| options: zi(e.options) | |
| } | |
| } | |
| visitGroup(e, t) { | |
| const r = t.currentTime; | |
| let i = 0; | |
| const o = e.steps.map(s => { | |
| t.currentTime = r; | |
| const a = xn(this, s, t); | |
| return i = Math.max(i, t.currentTime), | |
| a | |
| } | |
| ); | |
| return t.currentTime = i, | |
| { | |
| type: 3, | |
| steps: o, | |
| options: zi(e.options) | |
| } | |
| } | |
| visitAnimate(e, t) { | |
| const r = function V2(n, e) { | |
| if (n.hasOwnProperty("duration")) | |
| return n; | |
| if ("number" == typeof n) | |
| return Mp(Dc(n, e).duration, 0, ""); | |
| const t = n; | |
| if (t.split(/\s+/).some(o => "{" == o.charAt(0) && "{" == o.charAt(1))) { | |
| const o = Mp(0, 0, ""); | |
| return o.dynamic = !0, | |
| o.strValue = t, | |
| o | |
| } | |
| const i = Dc(t, e); | |
| return Mp(i.duration, i.delay, i.easing) | |
| }(e.timings, t.errors); | |
| t.currentAnimateTimings = r; | |
| let i, o = e.styles ? e.styles : Ui({}); | |
| if (5 == o.type) | |
| i = this.visitKeyframes(o, t); | |
| else { | |
| let s = e.styles | |
| , a = !1; | |
| if (!s) { | |
| a = !0; | |
| const c = {}; | |
| r.easing && (c.easing = r.easing), | |
| s = Ui(c) | |
| } | |
| t.currentTime += r.duration + r.delay; | |
| const l = this.visitStyle(s, t); | |
| l.isEmptyStep = a, | |
| i = l | |
| } | |
| return t.currentAnimateTimings = null, | |
| { | |
| type: 4, | |
| timings: r, | |
| style: i, | |
| options: null | |
| } | |
| } | |
| visitStyle(e, t) { | |
| const r = this._makeStyleAst(e, t); | |
| return this._validateStyleAst(r, t), | |
| r | |
| } | |
| _makeStyleAst(e, t) { | |
| const r = [] | |
| , i = Array.isArray(e.styles) ? e.styles : [e.styles]; | |
| for (let a of i) | |
| "string" == typeof a ? a === Vr ? r.push(a) : t.errors.push(new U(3002,!1)) : r.push(tE(a)); | |
| let o = !1 | |
| , s = null; | |
| return r.forEach(a => { | |
| if (a instanceof Map && (a.has("easing") && (s = a.get("easing"), | |
| a.delete("easing")), | |
| !o)) | |
| for (let l of a.values()) | |
| if (l.toString().indexOf("{{") >= 0) { | |
| o = !0; | |
| break | |
| } | |
| } | |
| ), | |
| { | |
| type: 6, | |
| styles: r, | |
| easing: s, | |
| offset: e.offset, | |
| containsDynamicStyles: o, | |
| options: null | |
| } | |
| } | |
| _validateStyleAst(e, t) { | |
| const r = t.currentAnimateTimings; | |
| let i = t.currentTime | |
| , o = t.currentTime; | |
| r && o > 0 && (o -= r.duration + r.delay), | |
| e.styles.forEach(s => { | |
| "string" != typeof s && s.forEach( (a, l) => { | |
| const c = t.collectedStyles.get(t.currentQuerySelector) | |
| , u = c.get(l); | |
| let d = !0; | |
| u && (o != i && o >= u.startTime && i <= u.endTime && (t.errors.push(function HL(n, e, t, r, i) { | |
| return new U(3010,!1) | |
| }()), | |
| d = !1), | |
| o = u.startTime), | |
| d && c.set(l, { | |
| startTime: o, | |
| endTime: i | |
| }), | |
| t.options && function C2(n, e, t) { | |
| const r = e.params || {} | |
| , i = oE(n); | |
| i.length && i.forEach(o => { | |
| r.hasOwnProperty(o) || t.push(function OL(n) { | |
| return new U(3001,!1) | |
| }()) | |
| } | |
| ) | |
| }(a, t.options, t.errors) | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| visitKeyframes(e, t) { | |
| const r = { | |
| type: 5, | |
| styles: [], | |
| options: null | |
| }; | |
| if (!t.currentAnimateTimings) | |
| return t.errors.push(function zL() { | |
| return new U(3011,!1) | |
| }()), | |
| r; | |
| let o = 0; | |
| const s = []; | |
| let a = !1 | |
| , l = !1 | |
| , c = 0; | |
| const u = e.steps.map(S => { | |
| const R = this._makeStyleAst(S, t); | |
| let v = null != R.offset ? R.offset : function L2(n) { | |
| if ("string" == typeof n) | |
| return null; | |
| let e = null; | |
| if (Array.isArray(n)) | |
| n.forEach(t => { | |
| if (t instanceof Map && t.has("offset")) { | |
| const r = t; | |
| e = parseFloat(r.get("offset")), | |
| r.delete("offset") | |
| } | |
| } | |
| ); | |
| else if (n instanceof Map && n.has("offset")) { | |
| const t = n; | |
| e = parseFloat(t.get("offset")), | |
| t.delete("offset") | |
| } | |
| return e | |
| }(R.styles) | |
| , O = 0; | |
| return null != v && (o++, | |
| O = R.offset = v), | |
| l = l || O < 0 || O > 1, | |
| a = a || O < c, | |
| c = O, | |
| s.push(O), | |
| R | |
| } | |
| ); | |
| l && t.errors.push(function $L() { | |
| return new U(3012,!1) | |
| }()), | |
| a && t.errors.push(function WL() { | |
| return new U(3200,!1) | |
| }()); | |
| const d = e.steps.length; | |
| let h = 0; | |
| o > 0 && o < d ? t.errors.push(function GL() { | |
| return new U(3202,!1) | |
| }()) : 0 == o && (h = 1 / (d - 1)); | |
| const f = d - 1 | |
| , p = t.currentTime | |
| , _ = t.currentAnimateTimings | |
| , C = _.duration; | |
| return u.forEach( (S, R) => { | |
| const v = h > 0 ? R == f ? 1 : h * R : s[R] | |
| , O = v * C; | |
| t.currentTime = p + _.delay + O, | |
| _.duration = O, | |
| this._validateStyleAst(S, t), | |
| S.offset = v, | |
| r.styles.push(S) | |
| } | |
| ), | |
| r | |
| } | |
| visitReference(e, t) { | |
| return { | |
| type: 8, | |
| animation: xn(this, ha(e.animation), t), | |
| options: zi(e.options) | |
| } | |
| } | |
| visitAnimateChild(e, t) { | |
| return t.depCount++, | |
| { | |
| type: 9, | |
| options: zi(e.options) | |
| } | |
| } | |
| visitAnimateRef(e, t) { | |
| return { | |
| type: 10, | |
| animation: this.visitReference(e.animation, t), | |
| options: zi(e.options) | |
| } | |
| } | |
| visitQuery(e, t) { | |
| const r = t.currentQuerySelector | |
| , i = e.options || {}; | |
| t.queryCount++, | |
| t.currentQuery = e; | |
| const [o,s] = function O2(n) { | |
| const e = !!n.split(/\s*,\s*/).find(t => ":self" == t); | |
| return e && (n = n.replace(F2, "")), | |
| n = n.replace(/@\*/g, wc).replace(/@\w+/g, t => wc + "-" + t.slice(1)).replace(/:animating/g, Cp), | |
| [n, e] | |
| }(e.selector); | |
| t.currentQuerySelector = r.length ? r + " " + o : o, | |
| Sn(t.collectedStyles, t.currentQuerySelector, new Map); | |
| const a = xn(this, ha(e.animation), t); | |
| return t.currentQuery = null, | |
| t.currentQuerySelector = r, | |
| { | |
| type: 11, | |
| selector: o, | |
| limit: i.limit || 0, | |
| optional: !!i.optional, | |
| includeSelf: s, | |
| animation: a, | |
| originalSelector: e.selector, | |
| options: zi(e.options) | |
| } | |
| } | |
| visitStagger(e, t) { | |
| t.currentQuery || t.errors.push(function qL() { | |
| return new U(3013,!1) | |
| }()); | |
| const r = "full" === e.timings ? { | |
| duration: 0, | |
| delay: 0, | |
| easing: "full" | |
| } : Dc(e.timings, t.errors, !0); | |
| return { | |
| type: 12, | |
| animation: xn(this, ha(e.animation), t), | |
| timings: r, | |
| options: null | |
| } | |
| } | |
| } | |
| class k2 { | |
| constructor(e) { | |
| this.errors = e, | |
| this.queryCount = 0, | |
| this.depCount = 0, | |
| this.currentTransition = null, | |
| this.currentQuery = null, | |
| this.currentQuerySelector = null, | |
| this.currentAnimateTimings = null, | |
| this.currentTime = 0, | |
| this.collectedStyles = new Map, | |
| this.options = null, | |
| this.unsupportedCSSPropertiesFound = new Set | |
| } | |
| } | |
| function zi(n) { | |
| return n ? (n = da(n)).params && (n.params = function N2(n) { | |
| return n ? da(n) : null | |
| }(n.params)) : n = {}, | |
| n | |
| } | |
| function Mp(n, e, t) { | |
| return { | |
| duration: n, | |
| delay: e, | |
| easing: t | |
| } | |
| } | |
| function Ap(n, e, t, r, i, o, s=null, a=!1) { | |
| return { | |
| type: 1, | |
| element: n, | |
| keyframes: e, | |
| preStyleProps: t, | |
| postStyleProps: r, | |
| duration: i, | |
| delay: o, | |
| totalTime: i + o, | |
| easing: s, | |
| subTimeline: a | |
| } | |
| } | |
| class Fc { | |
| constructor() { | |
| this._map = new Map | |
| } | |
| get(e) { | |
| return this._map.get(e) || [] | |
| } | |
| append(e, t) { | |
| let r = this._map.get(e); | |
| r || this._map.set(e, r = []), | |
| r.push(...t) | |
| } | |
| has(e) { | |
| return this._map.has(e) | |
| } | |
| clear() { | |
| this._map.clear() | |
| } | |
| } | |
| const j2 = new RegExp(":enter","g") | |
| , z2 = new RegExp(":leave","g"); | |
| function Ip(n, e, t, r, i, o=new Map, s=new Map, a, l, c=[]) { | |
| return (new $2).buildKeyframes(n, e, t, r, i, o, s, a, l, c) | |
| } | |
| class $2 { | |
| buildKeyframes(e, t, r, i, o, s, a, l, c, u=[]) { | |
| c = c || new Fc; | |
| const d = new Sp(e,t,c,i,o,u,[]); | |
| d.options = l; | |
| const h = l.delay ? Br(l.delay) : 0; | |
| d.currentTimeline.delayNextStep(h), | |
| d.currentTimeline.setStyles([s], null, d.errors, l), | |
| xn(this, r, d); | |
| const f = d.timelines.filter(p => p.containsAnimation()); | |
| if (f.length && a.size) { | |
| let p; | |
| for (let _ = f.length - 1; _ >= 0; _--) { | |
| const C = f[_]; | |
| if (C.element === t) { | |
| p = C; | |
| break | |
| } | |
| } | |
| p && !p.allowOnlyTimelineStyles() && p.setStyles([a], null, d.errors, l) | |
| } | |
| return f.length ? f.map(p => p.buildKeyframes()) : [Ap(t, [], [], [], 0, h, "", !1)] | |
| } | |
| visitTrigger(e, t) {} | |
| visitState(e, t) {} | |
| visitTransition(e, t) {} | |
| visitAnimateChild(e, t) { | |
| const r = t.subInstructions.get(t.element); | |
| if (r) { | |
| const i = t.createSubContext(e.options) | |
| , o = t.currentTimeline.currentTime | |
| , s = this._visitSubInstructions(r, i, i.options); | |
| o != s && t.transformIntoNewTimeline(s) | |
| } | |
| t.previousNode = e | |
| } | |
| visitAnimateRef(e, t) { | |
| const r = t.createSubContext(e.options); | |
| r.transformIntoNewTimeline(), | |
| this._applyAnimationRefDelays([e.options, e.animation.options], t, r), | |
| this.visitReference(e.animation, r), | |
| t.transformIntoNewTimeline(r.currentTimeline.currentTime), | |
| t.previousNode = e | |
| } | |
| _applyAnimationRefDelays(e, t, r) { | |
| var i; | |
| for (const o of e) { | |
| const s = null == o ? void 0 : o.delay; | |
| if (s) { | |
| const a = "number" == typeof s ? s : Br(fa(s, null !== (i = null == o ? void 0 : o.params) && void 0 !== i ? i : {}, t.errors)); | |
| r.delayNextStep(a) | |
| } | |
| } | |
| } | |
| _visitSubInstructions(e, t, r) { | |
| let o = t.currentTimeline.currentTime; | |
| const s = null != r.duration ? Br(r.duration) : null | |
| , a = null != r.delay ? Br(r.delay) : null; | |
| return 0 !== s && e.forEach(l => { | |
| const c = t.appendInstructionToTimeline(l, s, a); | |
| o = Math.max(o, c.duration + c.delay) | |
| } | |
| ), | |
| o | |
| } | |
| visitReference(e, t) { | |
| t.updateOptions(e.options, !0), | |
| xn(this, e.animation, t), | |
| t.previousNode = e | |
| } | |
| visitSequence(e, t) { | |
| const r = t.subContextCount; | |
| let i = t; | |
| const o = e.options; | |
| if (o && (o.params || o.delay) && (i = t.createSubContext(o), | |
| i.transformIntoNewTimeline(), | |
| null != o.delay)) { | |
| 6 == i.previousNode.type && (i.currentTimeline.snapshotCurrentStyles(), | |
| i.previousNode = Pc); | |
| const s = Br(o.delay); | |
| i.delayNextStep(s) | |
| } | |
| e.steps.length && (e.steps.forEach(s => xn(this, s, i)), | |
| i.currentTimeline.applyStylesToKeyframe(), | |
| i.subContextCount > r && i.transformIntoNewTimeline()), | |
| t.previousNode = e | |
| } | |
| visitGroup(e, t) { | |
| const r = []; | |
| let i = t.currentTimeline.currentTime; | |
| const o = e.options && e.options.delay ? Br(e.options.delay) : 0; | |
| e.steps.forEach(s => { | |
| const a = t.createSubContext(e.options); | |
| o && a.delayNextStep(o), | |
| xn(this, s, a), | |
| i = Math.max(i, a.currentTimeline.currentTime), | |
| r.push(a.currentTimeline) | |
| } | |
| ), | |
| r.forEach(s => t.currentTimeline.mergeTimelineCollectedStyles(s)), | |
| t.transformIntoNewTimeline(i), | |
| t.previousNode = e | |
| } | |
| _visitTiming(e, t) { | |
| if (e.dynamic) { | |
| const r = e.strValue; | |
| return Dc(t.params ? fa(r, t.params, t.errors) : r, t.errors) | |
| } | |
| return { | |
| duration: e.duration, | |
| delay: e.delay, | |
| easing: e.easing | |
| } | |
| } | |
| visitAnimate(e, t) { | |
| const r = t.currentAnimateTimings = this._visitTiming(e.timings, t) | |
| , i = t.currentTimeline; | |
| r.delay && (t.incrementTime(r.delay), | |
| i.snapshotCurrentStyles()); | |
| const o = e.style; | |
| 5 == o.type ? this.visitKeyframes(o, t) : (t.incrementTime(r.duration), | |
| this.visitStyle(o, t), | |
| i.applyStylesToKeyframe()), | |
| t.currentAnimateTimings = null, | |
| t.previousNode = e | |
| } | |
| visitStyle(e, t) { | |
| const r = t.currentTimeline | |
| , i = t.currentAnimateTimings; | |
| !i && r.hasCurrentStyleProperties() && r.forwardFrame(); | |
| const o = i && i.easing || e.easing; | |
| e.isEmptyStep ? r.applyEmptyStep(o) : r.setStyles(e.styles, o, t.errors, t.options), | |
| t.previousNode = e | |
| } | |
| visitKeyframes(e, t) { | |
| const r = t.currentAnimateTimings | |
| , i = t.currentTimeline.duration | |
| , o = r.duration | |
| , a = t.createSubContext().currentTimeline; | |
| a.easing = r.easing, | |
| e.styles.forEach(l => { | |
| a.forwardTime((l.offset || 0) * o), | |
| a.setStyles(l.styles, l.easing, t.errors, t.options), | |
| a.applyStylesToKeyframe() | |
| } | |
| ), | |
| t.currentTimeline.mergeTimelineCollectedStyles(a), | |
| t.transformIntoNewTimeline(i + o), | |
| t.previousNode = e | |
| } | |
| visitQuery(e, t) { | |
| const r = t.currentTimeline.currentTime | |
| , i = e.options || {} | |
| , o = i.delay ? Br(i.delay) : 0; | |
| o && (6 === t.previousNode.type || 0 == r && t.currentTimeline.hasCurrentStyleProperties()) && (t.currentTimeline.snapshotCurrentStyles(), | |
| t.previousNode = Pc); | |
| let s = r; | |
| const a = t.invokeQuery(e.selector, e.originalSelector, e.limit, e.includeSelf, !!i.optional, t.errors); | |
| t.currentQueryTotal = a.length; | |
| let l = null; | |
| a.forEach( (c, u) => { | |
| t.currentQueryIndex = u; | |
| const d = t.createSubContext(e.options, c); | |
| o && d.delayNextStep(o), | |
| c === t.element && (l = d.currentTimeline), | |
| xn(this, e.animation, d), | |
| d.currentTimeline.applyStylesToKeyframe(), | |
| s = Math.max(s, d.currentTimeline.currentTime) | |
| } | |
| ), | |
| t.currentQueryIndex = 0, | |
| t.currentQueryTotal = 0, | |
| t.transformIntoNewTimeline(s), | |
| l && (t.currentTimeline.mergeTimelineCollectedStyles(l), | |
| t.currentTimeline.snapshotCurrentStyles()), | |
| t.previousNode = e | |
| } | |
| visitStagger(e, t) { | |
| const r = t.parentContext | |
| , i = t.currentTimeline | |
| , o = e.timings | |
| , s = Math.abs(o.duration) | |
| , a = s * (t.currentQueryTotal - 1); | |
| let l = s * t.currentQueryIndex; | |
| switch (o.duration < 0 ? "reverse" : o.easing) { | |
| case "reverse": | |
| l = a - l; | |
| break; | |
| case "full": | |
| l = r.currentStaggerTime | |
| } | |
| const u = t.currentTimeline; | |
| l && u.delayNextStep(l); | |
| const d = u.currentTime; | |
| xn(this, e.animation, t), | |
| t.previousNode = e, | |
| r.currentStaggerTime = i.currentTime - d + (i.startTime - r.currentTimeline.startTime) | |
| } | |
| } | |
| const Pc = {}; | |
| class Sp { | |
| constructor(e, t, r, i, o, s, a, l) { | |
| this._driver = e, | |
| this.element = t, | |
| this.subInstructions = r, | |
| this._enterClassName = i, | |
| this._leaveClassName = o, | |
| this.errors = s, | |
| this.timelines = a, | |
| this.parentContext = null, | |
| this.currentAnimateTimings = null, | |
| this.previousNode = Pc, | |
| this.subContextCount = 0, | |
| this.options = {}, | |
| this.currentQueryIndex = 0, | |
| this.currentQueryTotal = 0, | |
| this.currentStaggerTime = 0, | |
| this.currentTimeline = l || new Oc(this._driver,t,0), | |
| a.push(this.currentTimeline) | |
| } | |
| get params() { | |
| return this.options.params | |
| } | |
| updateOptions(e, t) { | |
| if (!e) | |
| return; | |
| const r = e; | |
| let i = this.options; | |
| null != r.duration && (i.duration = Br(r.duration)), | |
| null != r.delay && (i.delay = Br(r.delay)); | |
| const o = r.params; | |
| if (o) { | |
| let s = i.params; | |
| s || (s = this.options.params = {}), | |
| Object.keys(o).forEach(a => { | |
| (!t || !s.hasOwnProperty(a)) && (s[a] = fa(o[a], s, this.errors)) | |
| } | |
| ) | |
| } | |
| } | |
| _copyOptions() { | |
| const e = {}; | |
| if (this.options) { | |
| const t = this.options.params; | |
| if (t) { | |
| const r = e.params = {}; | |
| Object.keys(t).forEach(i => { | |
| r[i] = t[i] | |
| } | |
| ) | |
| } | |
| } | |
| return e | |
| } | |
| createSubContext(e=null, t, r) { | |
| const i = t || this.element | |
| , o = new Sp(this._driver,i,this.subInstructions,this._enterClassName,this._leaveClassName,this.errors,this.timelines,this.currentTimeline.fork(i, r || 0)); | |
| return o.previousNode = this.previousNode, | |
| o.currentAnimateTimings = this.currentAnimateTimings, | |
| o.options = this._copyOptions(), | |
| o.updateOptions(e), | |
| o.currentQueryIndex = this.currentQueryIndex, | |
| o.currentQueryTotal = this.currentQueryTotal, | |
| o.parentContext = this, | |
| this.subContextCount++, | |
| o | |
| } | |
| transformIntoNewTimeline(e) { | |
| return this.previousNode = Pc, | |
| this.currentTimeline = this.currentTimeline.fork(this.element, e), | |
| this.timelines.push(this.currentTimeline), | |
| this.currentTimeline | |
| } | |
| appendInstructionToTimeline(e, t, r) { | |
| const i = { | |
| duration: null != t ? t : e.duration, | |
| delay: this.currentTimeline.currentTime + (null != r ? r : 0) + e.delay, | |
| easing: "" | |
| } | |
| , o = new W2(this._driver,e.element,e.keyframes,e.preStyleProps,e.postStyleProps,i,e.stretchStartingKeyframe); | |
| return this.timelines.push(o), | |
| i | |
| } | |
| incrementTime(e) { | |
| this.currentTimeline.forwardTime(this.currentTimeline.duration + e) | |
| } | |
| delayNextStep(e) { | |
| e > 0 && this.currentTimeline.delayNextStep(e) | |
| } | |
| invokeQuery(e, t, r, i, o, s) { | |
| let a = []; | |
| if (i && a.push(this.element), | |
| e.length > 0) { | |
| e = (e = e.replace(j2, "." + this._enterClassName)).replace(z2, "." + this._leaveClassName); | |
| let c = this._driver.query(this.element, e, 1 != r); | |
| 0 !== r && (c = r < 0 ? c.slice(c.length + r, c.length) : c.slice(0, r)), | |
| a.push(...c) | |
| } | |
| return !o && 0 == a.length && s.push(function KL(n) { | |
| return new U(3014,!1) | |
| }()), | |
| a | |
| } | |
| } | |
| class Oc { | |
| constructor(e, t, r, i) { | |
| this._driver = e, | |
| this.element = t, | |
| this.startTime = r, | |
| this._elementTimelineStylesLookup = i, | |
| this.duration = 0, | |
| this._previousKeyframe = new Map, | |
| this._currentKeyframe = new Map, | |
| this._keyframes = new Map, | |
| this._styleSummary = new Map, | |
| this._localTimelineStyles = new Map, | |
| this._pendingStyles = new Map, | |
| this._backFill = new Map, | |
| this._currentEmptyStepKeyframe = null, | |
| this._elementTimelineStylesLookup || (this._elementTimelineStylesLookup = new Map), | |
| this._globalTimelineStyles = this._elementTimelineStylesLookup.get(t), | |
| this._globalTimelineStyles || (this._globalTimelineStyles = this._localTimelineStyles, | |
| this._elementTimelineStylesLookup.set(t, this._localTimelineStyles)), | |
| this._loadKeyframe() | |
| } | |
| containsAnimation() { | |
| switch (this._keyframes.size) { | |
| case 0: | |
| return !1; | |
| case 1: | |
| return this.hasCurrentStyleProperties(); | |
| default: | |
| return !0 | |
| } | |
| } | |
| hasCurrentStyleProperties() { | |
| return this._currentKeyframe.size > 0 | |
| } | |
| get currentTime() { | |
| return this.startTime + this.duration | |
| } | |
| delayNextStep(e) { | |
| const t = 1 === this._keyframes.size && this._pendingStyles.size; | |
| this.duration || t ? (this.forwardTime(this.currentTime + e), | |
| t && this.snapshotCurrentStyles()) : this.startTime += e | |
| } | |
| fork(e, t) { | |
| return this.applyStylesToKeyframe(), | |
| new Oc(this._driver,e,t || this.currentTime,this._elementTimelineStylesLookup) | |
| } | |
| _loadKeyframe() { | |
| this._currentKeyframe && (this._previousKeyframe = this._currentKeyframe), | |
| this._currentKeyframe = this._keyframes.get(this.duration), | |
| this._currentKeyframe || (this._currentKeyframe = new Map, | |
| this._keyframes.set(this.duration, this._currentKeyframe)) | |
| } | |
| forwardFrame() { | |
| this.duration += 1, | |
| this._loadKeyframe() | |
| } | |
| forwardTime(e) { | |
| this.applyStylesToKeyframe(), | |
| this.duration = e, | |
| this._loadKeyframe() | |
| } | |
| _updateStyle(e, t) { | |
| this._localTimelineStyles.set(e, t), | |
| this._globalTimelineStyles.set(e, t), | |
| this._styleSummary.set(e, { | |
| time: this.currentTime, | |
| value: t | |
| }) | |
| } | |
| allowOnlyTimelineStyles() { | |
| return this._currentEmptyStepKeyframe !== this._currentKeyframe | |
| } | |
| applyEmptyStep(e) { | |
| e && this._previousKeyframe.set("easing", e); | |
| for (let[t,r] of this._globalTimelineStyles) | |
| this._backFill.set(t, r || Vr), | |
| this._currentKeyframe.set(t, Vr); | |
| this._currentEmptyStepKeyframe = this._currentKeyframe | |
| } | |
| setStyles(e, t, r, i) { | |
| var o; | |
| t && this._previousKeyframe.set("easing", t); | |
| const s = i && i.params || {} | |
| , a = function G2(n, e) { | |
| const t = new Map; | |
| let r; | |
| return n.forEach(i => { | |
| if ("*" === i) { | |
| r = r || e.keys(); | |
| for (let o of r) | |
| t.set(o, Vr) | |
| } else | |
| ui(i, t) | |
| } | |
| ), | |
| t | |
| }(e, this._globalTimelineStyles); | |
| for (let[l,c] of a) { | |
| const u = fa(c, s, r); | |
| this._pendingStyles.set(l, u), | |
| this._localTimelineStyles.has(l) || this._backFill.set(l, null !== (o = this._globalTimelineStyles.get(l)) && void 0 !== o ? o : Vr), | |
| this._updateStyle(l, u) | |
| } | |
| } | |
| applyStylesToKeyframe() { | |
| 0 != this._pendingStyles.size && (this._pendingStyles.forEach( (e, t) => { | |
| this._currentKeyframe.set(t, e) | |
| } | |
| ), | |
| this._pendingStyles.clear(), | |
| this._localTimelineStyles.forEach( (e, t) => { | |
| this._currentKeyframe.has(t) || this._currentKeyframe.set(t, e) | |
| } | |
| )) | |
| } | |
| snapshotCurrentStyles() { | |
| for (let[e,t] of this._localTimelineStyles) | |
| this._pendingStyles.set(e, t), | |
| this._updateStyle(e, t) | |
| } | |
| getFinalKeyframe() { | |
| return this._keyframes.get(this.duration) | |
| } | |
| get properties() { | |
| const e = []; | |
| for (let t in this._currentKeyframe) | |
| e.push(t); | |
| return e | |
| } | |
| mergeTimelineCollectedStyles(e) { | |
| e._styleSummary.forEach( (t, r) => { | |
| const i = this._styleSummary.get(r); | |
| (!i || t.time > i.time) && this._updateStyle(r, t.value) | |
| } | |
| ) | |
| } | |
| buildKeyframes() { | |
| this.applyStylesToKeyframe(); | |
| const e = new Set | |
| , t = new Set | |
| , r = 1 === this._keyframes.size && 0 === this.duration; | |
| let i = []; | |
| this._keyframes.forEach( (a, l) => { | |
| const c = ui(a, new Map, this._backFill); | |
| c.forEach( (u, d) => { | |
| "!" === u ? e.add(d) : u === Vr && t.add(d) | |
| } | |
| ), | |
| r || c.set("offset", l / this.duration), | |
| i.push(c) | |
| } | |
| ); | |
| const o = e.size ? Mc(e.values()) : [] | |
| , s = t.size ? Mc(t.values()) : []; | |
| if (r) { | |
| const a = i[0] | |
| , l = new Map(a); | |
| a.set("offset", 0), | |
| l.set("offset", 1), | |
| i = [a, l] | |
| } | |
| return Ap(this.element, i, o, s, this.duration, this.startTime, this.easing, !1) | |
| } | |
| } | |
| class W2 extends Oc { | |
| constructor(e, t, r, i, o, s, a=!1) { | |
| super(e, t, s.delay), | |
| this.keyframes = r, | |
| this.preStyleProps = i, | |
| this.postStyleProps = o, | |
| this._stretchStartingKeyframe = a, | |
| this.timings = { | |
| duration: s.duration, | |
| delay: s.delay, | |
| easing: s.easing | |
| } | |
| } | |
| containsAnimation() { | |
| return this.keyframes.length > 1 | |
| } | |
| buildKeyframes() { | |
| let e = this.keyframes | |
| , {delay: t, duration: r, easing: i} = this.timings; | |
| if (this._stretchStartingKeyframe && t) { | |
| const o = [] | |
| , s = r + t | |
| , a = t / s | |
| , l = ui(e[0]); | |
| l.set("offset", 0), | |
| o.push(l); | |
| const c = ui(e[0]); | |
| c.set("offset", uE(a)), | |
| o.push(c); | |
| const u = e.length - 1; | |
| for (let d = 1; d <= u; d++) { | |
| let h = ui(e[d]); | |
| const f = h.get("offset"); | |
| h.set("offset", uE((t + f * r) / s)), | |
| o.push(h) | |
| } | |
| r = s, | |
| t = 0, | |
| i = "", | |
| e = o | |
| } | |
| return Ap(this.element, e, this.preStyleProps, this.postStyleProps, r, t, i, !0) | |
| } | |
| } | |
| function uE(n, e=3) { | |
| const t = Math.pow(10, e - 1); | |
| return Math.round(n * t) / t | |
| } | |
| class xp { | |
| } | |
| const q2 = new Set(["width", "height", "minWidth", "minHeight", "maxWidth", "maxHeight", "left", "top", "bottom", "right", "fontSize", "outlineWidth", "outlineOffset", "paddingTop", "paddingLeft", "paddingBottom", "paddingRight", "marginTop", "marginLeft", "marginBottom", "marginRight", "borderRadius", "borderWidth", "borderTopWidth", "borderLeftWidth", "borderRightWidth", "borderBottomWidth", "textIndent", "perspective"]); | |
| class K2 extends xp { | |
| normalizePropertyName(e, t) { | |
| return wp(e) | |
| } | |
| normalizeStyleValue(e, t, r, i) { | |
| let o = ""; | |
| const s = r.toString().trim(); | |
| if (q2.has(t) && 0 !== r && "0" !== r) | |
| if ("number" == typeof r) | |
| o = "px"; | |
| else { | |
| const a = r.match(/^[+-]?[\d\.]+([a-z]*)$/); | |
| a && 0 == a[1].length && i.push(function LL(n, e) { | |
| return new U(3005,!1) | |
| }()) | |
| } | |
| return s + o | |
| } | |
| } | |
| function dE(n, e, t, r, i, o, s, a, l, c, u, d, h) { | |
| return { | |
| type: 0, | |
| element: n, | |
| triggerName: e, | |
| isRemovalTransition: i, | |
| fromState: t, | |
| fromStyles: o, | |
| toState: r, | |
| toStyles: s, | |
| timelines: a, | |
| queriedElements: l, | |
| preStyleProps: c, | |
| postStyleProps: u, | |
| totalTime: d, | |
| errors: h | |
| } | |
| } | |
| const Rp = {}; | |
| class hE { | |
| constructor(e, t, r) { | |
| this._triggerName = e, | |
| this.ast = t, | |
| this._stateStyles = r | |
| } | |
| match(e, t, r, i) { | |
| return function Q2(n, e, t, r, i) { | |
| return n.some(o => o(e, t, r, i)) | |
| }(this.ast.matchers, e, t, r, i) | |
| } | |
| buildStyles(e, t, r) { | |
| let i = this._stateStyles.get("*"); | |
| return void 0 !== e && (i = this._stateStyles.get(null == e ? void 0 : e.toString()) || i), | |
| i ? i.buildStyles(t, r) : new Map | |
| } | |
| build(e, t, r, i, o, s, a, l, c, u) { | |
| var d; | |
| const h = [] | |
| , f = this.ast.options && this.ast.options.params || Rp | |
| , _ = this.buildStyles(r, a && a.params || Rp, h) | |
| , C = l && l.params || Rp | |
| , S = this.buildStyles(i, C, h) | |
| , R = new Set | |
| , v = new Map | |
| , O = new Map | |
| , M = "void" === i | |
| , N = { | |
| params: Y2(C, f), | |
| delay: null === (d = this.ast.options) || void 0 === d ? void 0 : d.delay | |
| } | |
| , F = u ? [] : Ip(e, t, this.ast.animation, o, s, _, S, N, c, h); | |
| let $ = 0; | |
| if (F.forEach(K => { | |
| $ = Math.max(K.duration + K.delay, $) | |
| } | |
| ), | |
| h.length) | |
| return dE(t, this._triggerName, r, i, M, _, S, [], [], v, O, $, h); | |
| F.forEach(K => { | |
| const X = K.element | |
| , ie = Sn(v, X, new Set); | |
| K.preStyleProps.forEach(y => ie.add(y)); | |
| const g = Sn(O, X, new Set); | |
| K.postStyleProps.forEach(y => g.add(y)), | |
| X !== t && R.add(X) | |
| } | |
| ); | |
| const q = Mc(R.values()); | |
| return dE(t, this._triggerName, r, i, M, _, S, F, q, v, O, $) | |
| } | |
| } | |
| function Y2(n, e) { | |
| const t = da(e); | |
| for (const r in n) | |
| n.hasOwnProperty(r) && null != n[r] && (t[r] = n[r]); | |
| return t | |
| } | |
| class Z2 { | |
| constructor(e, t, r) { | |
| this.styles = e, | |
| this.defaultParams = t, | |
| this.normalizer = r | |
| } | |
| buildStyles(e, t) { | |
| const r = new Map | |
| , i = da(this.defaultParams); | |
| return Object.keys(e).forEach(o => { | |
| const s = e[o]; | |
| null !== s && (i[o] = s) | |
| } | |
| ), | |
| this.styles.styles.forEach(o => { | |
| "string" != typeof o && o.forEach( (s, a) => { | |
| s && (s = fa(s, i, t)); | |
| const l = this.normalizer.normalizePropertyName(a, t); | |
| s = this.normalizer.normalizeStyleValue(a, l, s, t), | |
| r.set(l, s) | |
| } | |
| ) | |
| } | |
| ), | |
| r | |
| } | |
| } | |
| class J2 { | |
| constructor(e, t, r) { | |
| this.name = e, | |
| this.ast = t, | |
| this._normalizer = r, | |
| this.transitionFactories = [], | |
| this.states = new Map, | |
| t.states.forEach(i => { | |
| this.states.set(i.name, new Z2(i.style,i.options && i.options.params || {},r)) | |
| } | |
| ), | |
| fE(this.states, "true", "1"), | |
| fE(this.states, "false", "0"), | |
| t.transitions.forEach(i => { | |
| this.transitionFactories.push(new hE(e,i,this.states)) | |
| } | |
| ), | |
| this.fallbackTransition = function eV(n, e, t) { | |
| return new hE(n,{ | |
| type: 1, | |
| animation: { | |
| type: 2, | |
| steps: [], | |
| options: null | |
| }, | |
| matchers: [ (s, a) => !0], | |
| options: null, | |
| queryCount: 0, | |
| depCount: 0 | |
| },e) | |
| }(e, this.states) | |
| } | |
| get containsQueries() { | |
| return this.ast.queryCount > 0 | |
| } | |
| matchTransition(e, t, r, i) { | |
| return this.transitionFactories.find(s => s.match(e, t, r, i)) || null | |
| } | |
| matchStyles(e, t, r) { | |
| return this.fallbackTransition.buildStyles(e, t, r) | |
| } | |
| } | |
| function fE(n, e, t) { | |
| n.has(e) ? n.has(t) || n.set(t, n.get(e)) : n.has(t) && n.set(e, n.get(t)) | |
| } | |
| const tV = new Fc; | |
| class nV { | |
| constructor(e, t, r) { | |
| this.bodyNode = e, | |
| this._driver = t, | |
| this._normalizer = r, | |
| this._animations = new Map, | |
| this._playersById = new Map, | |
| this.players = [] | |
| } | |
| register(e, t) { | |
| const r = [] | |
| , o = Dp(this._driver, t, r, []); | |
| if (r.length) | |
| throw function t2(n) { | |
| return new U(3503,!1) | |
| }(); | |
| this._animations.set(e, o) | |
| } | |
| _buildPlayer(e, t, r) { | |
| const i = e.element | |
| , o = WT(0, this._normalizer, 0, e.keyframes, t, r); | |
| return this._driver.animate(i, o, e.duration, e.delay, e.easing, [], !0) | |
| } | |
| create(e, t, r={}) { | |
| const i = [] | |
| , o = this._animations.get(e); | |
| let s; | |
| const a = new Map; | |
| if (o ? (s = Ip(this._driver, t, o, bp, Tc, new Map, new Map, r, tV, i), | |
| s.forEach(u => { | |
| const d = Sn(a, u.element, new Map); | |
| u.postStyleProps.forEach(h => d.set(h, null)) | |
| } | |
| )) : (i.push(function n2() { | |
| return new U(3300,!1) | |
| }()), | |
| s = []), | |
| i.length) | |
| throw function r2(n) { | |
| return new U(3504,!1) | |
| }(); | |
| a.forEach( (u, d) => { | |
| u.forEach( (h, f) => { | |
| u.set(f, this._driver.computeStyle(d, f, Vr)) | |
| } | |
| ) | |
| } | |
| ); | |
| const c = ci(s.map(u => { | |
| const d = a.get(u.element); | |
| return this._buildPlayer(u, new Map, d) | |
| } | |
| )); | |
| return this._playersById.set(e, c), | |
| c.onDestroy( () => this.destroy(e)), | |
| this.players.push(c), | |
| c | |
| } | |
| destroy(e) { | |
| const t = this._getPlayer(e); | |
| t.destroy(), | |
| this._playersById.delete(e); | |
| const r = this.players.indexOf(t); | |
| r >= 0 && this.players.splice(r, 1) | |
| } | |
| _getPlayer(e) { | |
| const t = this._playersById.get(e); | |
| if (!t) | |
| throw function o2(n) { | |
| return new U(3301,!1) | |
| }(); | |
| return t | |
| } | |
| listen(e, t, r, i) { | |
| const o = mp(t, "", "", ""); | |
| return pp(this._getPlayer(e), r, o, i), | |
| () => {} | |
| } | |
| command(e, t, r, i) { | |
| if ("register" == r) | |
| return void this.register(e, i[0]); | |
| if ("create" == r) | |
| return void this.create(e, t, i[0] || {}); | |
| const o = this._getPlayer(e); | |
| switch (r) { | |
| case "play": | |
| o.play(); | |
| break; | |
| case "pause": | |
| o.pause(); | |
| break; | |
| case "reset": | |
| o.reset(); | |
| break; | |
| case "restart": | |
| o.restart(); | |
| break; | |
| case "finish": | |
| o.finish(); | |
| break; | |
| case "init": | |
| o.init(); | |
| break; | |
| case "setPosition": | |
| o.setPosition(parseFloat(i[0])); | |
| break; | |
| case "destroy": | |
| this.destroy(e) | |
| } | |
| } | |
| } | |
| const pE = "ng-animate-queued" | |
| , Fp = "ng-animate-disabled" | |
| , aV = [] | |
| , gE = { | |
| namespaceId: "", | |
| setForRemoval: !1, | |
| setForMove: !1, | |
| hasAnimation: !1, | |
| removedBeforeQueried: !1 | |
| } | |
| , lV = { | |
| namespaceId: "", | |
| setForMove: !1, | |
| setForRemoval: !1, | |
| hasAnimation: !1, | |
| removedBeforeQueried: !0 | |
| } | |
| , Un = "__ng_removed"; | |
| class Pp { | |
| constructor(e, t="") { | |
| this.namespaceId = t; | |
| const r = e && e.hasOwnProperty("value"); | |
| if (this.value = function hV(n) { | |
| return null != n ? n : null | |
| }(r ? e.value : e), | |
| r) { | |
| const o = da(e); | |
| delete o.value, | |
| this.options = o | |
| } else | |
| this.options = {}; | |
| this.options.params || (this.options.params = {}) | |
| } | |
| get params() { | |
| return this.options.params | |
| } | |
| absorbOptions(e) { | |
| const t = e.params; | |
| if (t) { | |
| const r = this.options.params; | |
| Object.keys(t).forEach(i => { | |
| null == r[i] && (r[i] = t[i]) | |
| } | |
| ) | |
| } | |
| } | |
| } | |
| const pa = "void" | |
| , Op = new Pp(pa); | |
| class cV { | |
| constructor(e, t, r) { | |
| this.id = e, | |
| this.hostElement = t, | |
| this._engine = r, | |
| this.players = [], | |
| this._triggers = new Map, | |
| this._queue = [], | |
| this._elementListeners = new Map, | |
| this._hostClassName = "ng-tns-" + e, | |
| jn(t, this._hostClassName) | |
| } | |
| listen(e, t, r, i) { | |
| if (!this._triggers.has(t)) | |
| throw function s2(n, e) { | |
| return new U(3302,!1) | |
| }(); | |
| if (null == r || 0 == r.length) | |
| throw function a2(n) { | |
| return new U(3303,!1) | |
| }(); | |
| if (!function fV(n) { | |
| return "start" == n || "done" == n | |
| }(r)) | |
| throw function l2(n, e) { | |
| return new U(3400,!1) | |
| }(); | |
| const o = Sn(this._elementListeners, e, []) | |
| , s = { | |
| name: t, | |
| phase: r, | |
| callback: i | |
| }; | |
| o.push(s); | |
| const a = Sn(this._engine.statesByElement, e, new Map); | |
| return a.has(t) || (jn(e, Ec), | |
| jn(e, Ec + "-" + t), | |
| a.set(t, Op)), | |
| () => { | |
| this._engine.afterFlush( () => { | |
| const l = o.indexOf(s); | |
| l >= 0 && o.splice(l, 1), | |
| this._triggers.has(t) || a.delete(t) | |
| } | |
| ) | |
| } | |
| } | |
| register(e, t) { | |
| return !this._triggers.has(e) && (this._triggers.set(e, t), | |
| !0) | |
| } | |
| _getTrigger(e) { | |
| const t = this._triggers.get(e); | |
| if (!t) | |
| throw function c2(n) { | |
| return new U(3401,!1) | |
| }(); | |
| return t | |
| } | |
| trigger(e, t, r, i=!0) { | |
| const o = this._getTrigger(t) | |
| , s = new Np(this.id,t,e); | |
| let a = this._engine.statesByElement.get(e); | |
| a || (jn(e, Ec), | |
| jn(e, Ec + "-" + t), | |
| this._engine.statesByElement.set(e, a = new Map)); | |
| let l = a.get(t); | |
| const c = new Pp(r,this.id); | |
| if (!(r && r.hasOwnProperty("value")) && l && c.absorbOptions(l.options), | |
| a.set(t, c), | |
| l || (l = Op), | |
| c.value !== pa && l.value === c.value) { | |
| if (!function mV(n, e) { | |
| const t = Object.keys(n) | |
| , r = Object.keys(e); | |
| if (t.length != r.length) | |
| return !1; | |
| for (let i = 0; i < t.length; i++) { | |
| const o = t[i]; | |
| if (!e.hasOwnProperty(o) || n[o] !== e[o]) | |
| return !1 | |
| } | |
| return !0 | |
| }(l.params, c.params)) { | |
| const _ = [] | |
| , C = o.matchStyles(l.value, l.params, _) | |
| , S = o.matchStyles(c.value, c.params, _); | |
| _.length ? this._engine.reportError(_) : this._engine.afterFlush( () => { | |
| Hi(e, C), | |
| yr(e, S) | |
| } | |
| ) | |
| } | |
| return | |
| } | |
| const h = Sn(this._engine.playersByElement, e, []); | |
| h.forEach(_ => { | |
| _.namespaceId == this.id && _.triggerName == t && _.queued && _.destroy() | |
| } | |
| ); | |
| let f = o.matchTransition(l.value, c.value, e, c.params) | |
| , p = !1; | |
| if (!f) { | |
| if (!i) | |
| return; | |
| f = o.fallbackTransition, | |
| p = !0 | |
| } | |
| return this._engine.totalQueuedPlayers++, | |
| this._queue.push({ | |
| element: e, | |
| triggerName: t, | |
| transition: f, | |
| fromState: l, | |
| toState: c, | |
| player: s, | |
| isFallbackTransition: p | |
| }), | |
| p || (jn(e, pE), | |
| s.onStart( () => { | |
| jo(e, pE) | |
| } | |
| )), | |
| s.onDone( () => { | |
| let _ = this.players.indexOf(s); | |
| _ >= 0 && this.players.splice(_, 1); | |
| const C = this._engine.playersByElement.get(e); | |
| if (C) { | |
| let S = C.indexOf(s); | |
| S >= 0 && C.splice(S, 1) | |
| } | |
| } | |
| ), | |
| this.players.push(s), | |
| h.push(s), | |
| s | |
| } | |
| deregister(e) { | |
| this._triggers.delete(e), | |
| this._engine.statesByElement.forEach(t => t.delete(e)), | |
| this._elementListeners.forEach( (t, r) => { | |
| this._elementListeners.set(r, t.filter(i => i.name != e)) | |
| } | |
| ) | |
| } | |
| clearElementCache(e) { | |
| this._engine.statesByElement.delete(e), | |
| this._elementListeners.delete(e); | |
| const t = this._engine.playersByElement.get(e); | |
| t && (t.forEach(r => r.destroy()), | |
| this._engine.playersByElement.delete(e)) | |
| } | |
| _signalRemovalForInnerTriggers(e, t) { | |
| const r = this._engine.driver.query(e, wc, !0); | |
| r.forEach(i => { | |
| if (i[Un]) | |
| return; | |
| const o = this._engine.fetchNamespacesByElement(i); | |
| o.size ? o.forEach(s => s.triggerLeaveAnimation(i, t, !1, !0)) : this.clearElementCache(i) | |
| } | |
| ), | |
| this._engine.afterFlushAnimationsDone( () => r.forEach(i => this.clearElementCache(i))) | |
| } | |
| triggerLeaveAnimation(e, t, r, i) { | |
| const o = this._engine.statesByElement.get(e) | |
| , s = new Map; | |
| if (o) { | |
| const a = []; | |
| if (o.forEach( (l, c) => { | |
| if (s.set(c, l.value), | |
| this._triggers.has(c)) { | |
| const u = this.trigger(e, c, pa, i); | |
| u && a.push(u) | |
| } | |
| } | |
| ), | |
| a.length) | |
| return this._engine.markElementAsRemoved(this.id, e, !0, t, s), | |
| r && ci(a).onDone( () => this._engine.processLeaveNode(e)), | |
| !0 | |
| } | |
| return !1 | |
| } | |
| prepareLeaveAnimationListeners(e) { | |
| const t = this._elementListeners.get(e) | |
| , r = this._engine.statesByElement.get(e); | |
| if (t && r) { | |
| const i = new Set; | |
| t.forEach(o => { | |
| const s = o.name; | |
| if (i.has(s)) | |
| return; | |
| i.add(s); | |
| const l = this._triggers.get(s).fallbackTransition | |
| , c = r.get(s) || Op | |
| , u = new Pp(pa) | |
| , d = new Np(this.id,s,e); | |
| this._engine.totalQueuedPlayers++, | |
| this._queue.push({ | |
| element: e, | |
| triggerName: s, | |
| transition: l, | |
| fromState: c, | |
| toState: u, | |
| player: d, | |
| isFallbackTransition: !0 | |
| }) | |
| } | |
| ) | |
| } | |
| } | |
| removeNode(e, t) { | |
| const r = this._engine; | |
| if (e.childElementCount && this._signalRemovalForInnerTriggers(e, t), | |
| this.triggerLeaveAnimation(e, t, !0)) | |
| return; | |
| let i = !1; | |
| if (r.totalAnimations) { | |
| const o = r.players.length ? r.playersByQueriedElement.get(e) : []; | |
| if (o && o.length) | |
| i = !0; | |
| else { | |
| let s = e; | |
| for (; s = s.parentNode; ) | |
| if (r.statesByElement.get(s)) { | |
| i = !0; | |
| break | |
| } | |
| } | |
| } | |
| if (this.prepareLeaveAnimationListeners(e), | |
| i) | |
| r.markElementAsRemoved(this.id, e, !1, t); | |
| else { | |
| const o = e[Un]; | |
| (!o || o === gE) && (r.afterFlush( () => this.clearElementCache(e)), | |
| r.destroyInnerAnimations(e), | |
| r._onRemovalComplete(e, t)) | |
| } | |
| } | |
| insertNode(e, t) { | |
| jn(e, this._hostClassName) | |
| } | |
| drainQueuedTransitions(e) { | |
| const t = []; | |
| return this._queue.forEach(r => { | |
| const i = r.player; | |
| if (i.destroyed) | |
| return; | |
| const o = r.element | |
| , s = this._elementListeners.get(o); | |
| s && s.forEach(a => { | |
| if (a.name == r.triggerName) { | |
| const l = mp(o, r.triggerName, r.fromState.value, r.toState.value); | |
| l._data = e, | |
| pp(r.player, a.phase, l, a.callback) | |
| } | |
| } | |
| ), | |
| i.markedForDestroy ? this._engine.afterFlush( () => { | |
| i.destroy() | |
| } | |
| ) : t.push(r) | |
| } | |
| ), | |
| this._queue = [], | |
| t.sort( (r, i) => { | |
| const o = r.transition.ast.depCount | |
| , s = i.transition.ast.depCount; | |
| return 0 == o || 0 == s ? o - s : this._engine.driver.containsElement(r.element, i.element) ? 1 : -1 | |
| } | |
| ) | |
| } | |
| destroy(e) { | |
| this.players.forEach(t => t.destroy()), | |
| this._signalRemovalForInnerTriggers(this.hostElement, e) | |
| } | |
| elementContainsData(e) { | |
| let t = !1; | |
| return this._elementListeners.has(e) && (t = !0), | |
| t = !!this._queue.find(r => r.element === e) || t, | |
| t | |
| } | |
| } | |
| class uV { | |
| constructor(e, t, r) { | |
| this.bodyNode = e, | |
| this.driver = t, | |
| this._normalizer = r, | |
| this.players = [], | |
| this.newHostElements = new Map, | |
| this.playersByElement = new Map, | |
| this.playersByQueriedElement = new Map, | |
| this.statesByElement = new Map, | |
| this.disabledNodes = new Set, | |
| this.totalAnimations = 0, | |
| this.totalQueuedPlayers = 0, | |
| this._namespaceLookup = {}, | |
| this._namespaceList = [], | |
| this._flushFns = [], | |
| this._whenQuietFns = [], | |
| this.namespacesByHostElement = new Map, | |
| this.collectedEnterElements = [], | |
| this.collectedLeaveElements = [], | |
| this.onRemovalComplete = (i, o) => {} | |
| } | |
| _onRemovalComplete(e, t) { | |
| this.onRemovalComplete(e, t) | |
| } | |
| get queuedPlayers() { | |
| const e = []; | |
| return this._namespaceList.forEach(t => { | |
| t.players.forEach(r => { | |
| r.queued && e.push(r) | |
| } | |
| ) | |
| } | |
| ), | |
| e | |
| } | |
| createNamespace(e, t) { | |
| const r = new cV(e,t,this); | |
| return this.bodyNode && this.driver.containsElement(this.bodyNode, t) ? this._balanceNamespaceList(r, t) : (this.newHostElements.set(t, r), | |
| this.collectEnterElement(t)), | |
| this._namespaceLookup[e] = r | |
| } | |
| _balanceNamespaceList(e, t) { | |
| const r = this._namespaceList | |
| , i = this.namespacesByHostElement; | |
| if (r.length - 1 >= 0) { | |
| let s = !1 | |
| , a = this.driver.getParentElement(t); | |
| for (; a; ) { | |
| const l = i.get(a); | |
| if (l) { | |
| const c = r.indexOf(l); | |
| r.splice(c + 1, 0, e), | |
| s = !0; | |
| break | |
| } | |
| a = this.driver.getParentElement(a) | |
| } | |
| s || r.unshift(e) | |
| } else | |
| r.push(e); | |
| return i.set(t, e), | |
| e | |
| } | |
| register(e, t) { | |
| let r = this._namespaceLookup[e]; | |
| return r || (r = this.createNamespace(e, t)), | |
| r | |
| } | |
| registerTrigger(e, t, r) { | |
| let i = this._namespaceLookup[e]; | |
| i && i.register(t, r) && this.totalAnimations++ | |
| } | |
| destroy(e, t) { | |
| if (!e) | |
| return; | |
| const r = this._fetchNamespace(e); | |
| this.afterFlush( () => { | |
| this.namespacesByHostElement.delete(r.hostElement), | |
| delete this._namespaceLookup[e]; | |
| const i = this._namespaceList.indexOf(r); | |
| i >= 0 && this._namespaceList.splice(i, 1) | |
| } | |
| ), | |
| this.afterFlushAnimationsDone( () => r.destroy(t)) | |
| } | |
| _fetchNamespace(e) { | |
| return this._namespaceLookup[e] | |
| } | |
| fetchNamespacesByElement(e) { | |
| const t = new Set | |
| , r = this.statesByElement.get(e); | |
| if (r) | |
| for (let i of r.values()) | |
| if (i.namespaceId) { | |
| const o = this._fetchNamespace(i.namespaceId); | |
| o && t.add(o) | |
| } | |
| return t | |
| } | |
| trigger(e, t, r, i) { | |
| if (Nc(t)) { | |
| const o = this._fetchNamespace(e); | |
| if (o) | |
| return o.trigger(t, r, i), | |
| !0 | |
| } | |
| return !1 | |
| } | |
| insertNode(e, t, r, i) { | |
| if (!Nc(t)) | |
| return; | |
| const o = t[Un]; | |
| if (o && o.setForRemoval) { | |
| o.setForRemoval = !1, | |
| o.setForMove = !0; | |
| const s = this.collectedLeaveElements.indexOf(t); | |
| s >= 0 && this.collectedLeaveElements.splice(s, 1) | |
| } | |
| if (e) { | |
| const s = this._fetchNamespace(e); | |
| s && s.insertNode(t, r) | |
| } | |
| i && this.collectEnterElement(t) | |
| } | |
| collectEnterElement(e) { | |
| this.collectedEnterElements.push(e) | |
| } | |
| markElementAsDisabled(e, t) { | |
| t ? this.disabledNodes.has(e) || (this.disabledNodes.add(e), | |
| jn(e, Fp)) : this.disabledNodes.has(e) && (this.disabledNodes.delete(e), | |
| jo(e, Fp)) | |
| } | |
| removeNode(e, t, r, i) { | |
| if (Nc(t)) { | |
| const o = e ? this._fetchNamespace(e) : null; | |
| if (o ? o.removeNode(t, i) : this.markElementAsRemoved(e, t, !1, i), | |
| r) { | |
| const s = this.namespacesByHostElement.get(t); | |
| s && s.id !== e && s.removeNode(t, i) | |
| } | |
| } else | |
| this._onRemovalComplete(t, i) | |
| } | |
| markElementAsRemoved(e, t, r, i, o) { | |
| this.collectedLeaveElements.push(t), | |
| t[Un] = { | |
| namespaceId: e, | |
| setForRemoval: i, | |
| hasAnimation: r, | |
| removedBeforeQueried: !1, | |
| previousTriggersValues: o | |
| } | |
| } | |
| listen(e, t, r, i, o) { | |
| return Nc(t) ? this._fetchNamespace(e).listen(t, r, i, o) : () => {} | |
| } | |
| _buildInstruction(e, t, r, i, o) { | |
| return e.transition.build(this.driver, e.element, e.fromState.value, e.toState.value, r, i, e.fromState.options, e.toState.options, t, o) | |
| } | |
| destroyInnerAnimations(e) { | |
| let t = this.driver.query(e, wc, !0); | |
| t.forEach(r => this.destroyActiveAnimationsForElement(r)), | |
| 0 != this.playersByQueriedElement.size && (t = this.driver.query(e, Cp, !0), | |
| t.forEach(r => this.finishActiveQueriedAnimationOnElement(r))) | |
| } | |
| destroyActiveAnimationsForElement(e) { | |
| const t = this.playersByElement.get(e); | |
| t && t.forEach(r => { | |
| r.queued ? r.markedForDestroy = !0 : r.destroy() | |
| } | |
| ) | |
| } | |
| finishActiveQueriedAnimationOnElement(e) { | |
| const t = this.playersByQueriedElement.get(e); | |
| t && t.forEach(r => r.finish()) | |
| } | |
| whenRenderingDone() { | |
| return new Promise(e => { | |
| if (this.players.length) | |
| return ci(this.players).onDone( () => e()); | |
| e() | |
| } | |
| ) | |
| } | |
| processLeaveNode(e) { | |
| var t; | |
| const r = e[Un]; | |
| if (r && r.setForRemoval) { | |
| if (e[Un] = gE, | |
| r.namespaceId) { | |
| this.destroyInnerAnimations(e); | |
| const i = this._fetchNamespace(r.namespaceId); | |
| i && i.clearElementCache(e) | |
| } | |
| this._onRemovalComplete(e, r.setForRemoval) | |
| } | |
| !(null === (t = e.classList) || void 0 === t) && t.contains(Fp) && this.markElementAsDisabled(e, !1), | |
| this.driver.query(e, ".ng-animate-disabled", !0).forEach(i => { | |
| this.markElementAsDisabled(i, !1) | |
| } | |
| ) | |
| } | |
| flush(e=-1) { | |
| let t = []; | |
| if (this.newHostElements.size && (this.newHostElements.forEach( (r, i) => this._balanceNamespaceList(r, i)), | |
| this.newHostElements.clear()), | |
| this.totalAnimations && this.collectedEnterElements.length) | |
| for (let r = 0; r < this.collectedEnterElements.length; r++) | |
| jn(this.collectedEnterElements[r], "ng-star-inserted"); | |
| if (this._namespaceList.length && (this.totalQueuedPlayers || this.collectedLeaveElements.length)) { | |
| const r = []; | |
| try { | |
| t = this._flushAnimations(r, e) | |
| } finally { | |
| for (let i = 0; i < r.length; i++) | |
| r[i]() | |
| } | |
| } else | |
| for (let r = 0; r < this.collectedLeaveElements.length; r++) | |
| this.processLeaveNode(this.collectedLeaveElements[r]); | |
| if (this.totalQueuedPlayers = 0, | |
| this.collectedEnterElements.length = 0, | |
| this.collectedLeaveElements.length = 0, | |
| this._flushFns.forEach(r => r()), | |
| this._flushFns = [], | |
| this._whenQuietFns.length) { | |
| const r = this._whenQuietFns; | |
| this._whenQuietFns = [], | |
| t.length ? ci(t).onDone( () => { | |
| r.forEach(i => i()) | |
| } | |
| ) : r.forEach(i => i()) | |
| } | |
| } | |
| reportError(e) { | |
| throw function u2(n) { | |
| return new U(3402,!1) | |
| }() | |
| } | |
| _flushAnimations(e, t) { | |
| const r = new Fc | |
| , i = [] | |
| , o = new Map | |
| , s = [] | |
| , a = new Map | |
| , l = new Map | |
| , c = new Map | |
| , u = new Set; | |
| this.disabledNodes.forEach(b => { | |
| u.add(b); | |
| const w = this.driver.query(b, ".ng-animate-queued", !0); | |
| for (let I = 0; I < w.length; I++) | |
| u.add(w[I]) | |
| } | |
| ); | |
| const d = this.bodyNode | |
| , h = Array.from(this.statesByElement.keys()) | |
| , f = yE(h, this.collectedEnterElements) | |
| , p = new Map; | |
| let _ = 0; | |
| f.forEach( (b, w) => { | |
| const I = bp + _++; | |
| p.set(w, I), | |
| b.forEach(P => jn(P, I)) | |
| } | |
| ); | |
| const C = [] | |
| , S = new Set | |
| , R = new Set; | |
| for (let b = 0; b < this.collectedLeaveElements.length; b++) { | |
| const w = this.collectedLeaveElements[b] | |
| , I = w[Un]; | |
| I && I.setForRemoval && (C.push(w), | |
| S.add(w), | |
| I.hasAnimation ? this.driver.query(w, ".ng-star-inserted", !0).forEach(P => S.add(P)) : R.add(w)) | |
| } | |
| const v = new Map | |
| , O = yE(h, Array.from(S)); | |
| O.forEach( (b, w) => { | |
| const I = Tc + _++; | |
| v.set(w, I), | |
| b.forEach(P => jn(P, I)) | |
| } | |
| ), | |
| e.push( () => { | |
| f.forEach( (b, w) => { | |
| const I = p.get(w); | |
| b.forEach(P => jo(P, I)) | |
| } | |
| ), | |
| O.forEach( (b, w) => { | |
| const I = v.get(w); | |
| b.forEach(P => jo(P, I)) | |
| } | |
| ), | |
| C.forEach(b => { | |
| this.processLeaveNode(b) | |
| } | |
| ) | |
| } | |
| ); | |
| const M = [] | |
| , N = []; | |
| for (let b = this._namespaceList.length - 1; b >= 0; b--) | |
| this._namespaceList[b].drainQueuedTransitions(t).forEach(I => { | |
| const P = I.player | |
| , L = I.element; | |
| if (M.push(P), | |
| this.collectedEnterElements.length) { | |
| const z = L[Un]; | |
| if (z && z.setForMove) { | |
| if (z.previousTriggersValues && z.previousTriggersValues.has(I.triggerName)) { | |
| const j = z.previousTriggersValues.get(I.triggerName) | |
| , Y = this.statesByElement.get(I.element); | |
| if (Y && Y.has(I.triggerName)) { | |
| const ae = Y.get(I.triggerName); | |
| ae.value = j, | |
| Y.set(I.triggerName, ae) | |
| } | |
| } | |
| return void P.destroy() | |
| } | |
| } | |
| const G = !d || !this.driver.containsElement(d, L) | |
| , m = v.get(L) | |
| , x = p.get(L) | |
| , D = this._buildInstruction(I, r, x, m, G); | |
| if (D.errors && D.errors.length) | |
| return void N.push(D); | |
| if (G) | |
| return P.onStart( () => Hi(L, D.fromStyles)), | |
| P.onDestroy( () => yr(L, D.toStyles)), | |
| void i.push(P); | |
| if (I.isFallbackTransition) | |
| return P.onStart( () => Hi(L, D.fromStyles)), | |
| P.onDestroy( () => yr(L, D.toStyles)), | |
| void i.push(P); | |
| const k = []; | |
| D.timelines.forEach(z => { | |
| z.stretchStartingKeyframe = !0, | |
| this.disabledNodes.has(z.element) || k.push(z) | |
| } | |
| ), | |
| D.timelines = k, | |
| r.append(L, D.timelines), | |
| s.push({ | |
| instruction: D, | |
| player: P, | |
| element: L | |
| }), | |
| D.queriedElements.forEach(z => Sn(a, z, []).push(P)), | |
| D.preStyleProps.forEach( (z, j) => { | |
| if (z.size) { | |
| let Y = l.get(j); | |
| Y || l.set(j, Y = new Set), | |
| z.forEach( (ae, ne) => Y.add(ne)) | |
| } | |
| } | |
| ), | |
| D.postStyleProps.forEach( (z, j) => { | |
| let Y = c.get(j); | |
| Y || c.set(j, Y = new Set), | |
| z.forEach( (ae, ne) => Y.add(ne)) | |
| } | |
| ) | |
| } | |
| ); | |
| if (N.length) { | |
| const b = []; | |
| N.forEach(w => { | |
| b.push(function d2(n, e) { | |
| return new U(3505,!1) | |
| }()) | |
| } | |
| ), | |
| M.forEach(w => w.destroy()), | |
| this.reportError(b) | |
| } | |
| const F = new Map | |
| , $ = new Map; | |
| s.forEach(b => { | |
| const w = b.element; | |
| r.has(w) && ($.set(w, w), | |
| this._beforeAnimationBuild(b.player.namespaceId, b.instruction, F)) | |
| } | |
| ), | |
| i.forEach(b => { | |
| const w = b.element; | |
| this._getPreviousPlayers(w, !1, b.namespaceId, b.triggerName, null).forEach(P => { | |
| Sn(F, w, []).push(P), | |
| P.destroy() | |
| } | |
| ) | |
| } | |
| ); | |
| const q = C.filter(b => bE(b, l, c)) | |
| , K = new Map; | |
| _E(K, this.driver, R, c, Vr).forEach(b => { | |
| bE(b, l, c) && q.push(b) | |
| } | |
| ); | |
| const ie = new Map; | |
| f.forEach( (b, w) => { | |
| _E(ie, this.driver, new Set(b), l, "!") | |
| } | |
| ), | |
| q.forEach(b => { | |
| var w, I; | |
| const P = K.get(b) | |
| , L = ie.get(b); | |
| K.set(b, new Map([...Array.from(null !== (w = null == P ? void 0 : P.entries()) && void 0 !== w ? w : []), ...Array.from(null !== (I = null == L ? void 0 : L.entries()) && void 0 !== I ? I : [])])) | |
| } | |
| ); | |
| const g = [] | |
| , y = [] | |
| , E = {}; | |
| s.forEach(b => { | |
| const {element: w, player: I, instruction: P} = b; | |
| if (r.has(w)) { | |
| if (u.has(w)) | |
| return I.onDestroy( () => yr(w, P.toStyles)), | |
| I.disabled = !0, | |
| I.overrideTotalTime(P.totalTime), | |
| void i.push(I); | |
| let L = E; | |
| if ($.size > 1) { | |
| let m = w; | |
| const x = []; | |
| for (; m = m.parentNode; ) { | |
| const D = $.get(m); | |
| if (D) { | |
| L = D; | |
| break | |
| } | |
| x.push(m) | |
| } | |
| x.forEach(D => $.set(D, L)) | |
| } | |
| const G = this._buildAnimation(I.namespaceId, P, F, o, ie, K); | |
| if (I.setRealPlayer(G), | |
| L === E) | |
| g.push(I); | |
| else { | |
| const m = this.playersByElement.get(L); | |
| m && m.length && (I.parentPlayer = ci(m)), | |
| i.push(I) | |
| } | |
| } else | |
| Hi(w, P.fromStyles), | |
| I.onDestroy( () => yr(w, P.toStyles)), | |
| y.push(I), | |
| u.has(w) && i.push(I) | |
| } | |
| ), | |
| y.forEach(b => { | |
| const w = o.get(b.element); | |
| if (w && w.length) { | |
| const I = ci(w); | |
| b.setRealPlayer(I) | |
| } | |
| } | |
| ), | |
| i.forEach(b => { | |
| b.parentPlayer ? b.syncPlayerEvents(b.parentPlayer) : b.destroy() | |
| } | |
| ); | |
| for (let b = 0; b < C.length; b++) { | |
| const w = C[b] | |
| , I = w[Un]; | |
| if (jo(w, Tc), | |
| I && I.hasAnimation) | |
| continue; | |
| let P = []; | |
| if (a.size) { | |
| let G = a.get(w); | |
| G && G.length && P.push(...G); | |
| let m = this.driver.query(w, Cp, !0); | |
| for (let x = 0; x < m.length; x++) { | |
| let D = a.get(m[x]); | |
| D && D.length && P.push(...D) | |
| } | |
| } | |
| const L = P.filter(G => !G.destroyed); | |
| L.length ? pV(this, w, L) : this.processLeaveNode(w) | |
| } | |
| return C.length = 0, | |
| g.forEach(b => { | |
| this.players.push(b), | |
| b.onDone( () => { | |
| b.destroy(); | |
| const w = this.players.indexOf(b); | |
| this.players.splice(w, 1) | |
| } | |
| ), | |
| b.play() | |
| } | |
| ), | |
| g | |
| } | |
| elementContainsData(e, t) { | |
| let r = !1; | |
| const i = t[Un]; | |
| return i && i.setForRemoval && (r = !0), | |
| this.playersByElement.has(t) && (r = !0), | |
| this.playersByQueriedElement.has(t) && (r = !0), | |
| this.statesByElement.has(t) && (r = !0), | |
| this._fetchNamespace(e).elementContainsData(t) || r | |
| } | |
| afterFlush(e) { | |
| this._flushFns.push(e) | |
| } | |
| afterFlushAnimationsDone(e) { | |
| this._whenQuietFns.push(e) | |
| } | |
| _getPreviousPlayers(e, t, r, i, o) { | |
| let s = []; | |
| if (t) { | |
| const a = this.playersByQueriedElement.get(e); | |
| a && (s = a) | |
| } else { | |
| const a = this.playersByElement.get(e); | |
| if (a) { | |
| const l = !o || o == pa; | |
| a.forEach(c => { | |
| c.queued || !l && c.triggerName != i || s.push(c) | |
| } | |
| ) | |
| } | |
| } | |
| return (r || i) && (s = s.filter(a => !(r && r != a.namespaceId || i && i != a.triggerName))), | |
| s | |
| } | |
| _beforeAnimationBuild(e, t, r) { | |
| const o = t.element | |
| , s = t.isRemovalTransition ? void 0 : e | |
| , a = t.isRemovalTransition ? void 0 : t.triggerName; | |
| for (const l of t.timelines) { | |
| const c = l.element | |
| , u = c !== o | |
| , d = Sn(r, c, []); | |
| this._getPreviousPlayers(c, u, s, a, t.toState).forEach(f => { | |
| const p = f.getRealPlayer(); | |
| p.beforeDestroy && p.beforeDestroy(), | |
| f.destroy(), | |
| d.push(f) | |
| } | |
| ) | |
| } | |
| Hi(o, t.fromStyles) | |
| } | |
| _buildAnimation(e, t, r, i, o, s) { | |
| const a = t.triggerName | |
| , l = t.element | |
| , c = [] | |
| , u = new Set | |
| , d = new Set | |
| , h = t.timelines.map(p => { | |
| const _ = p.element; | |
| u.add(_); | |
| const C = _[Un]; | |
| if (C && C.removedBeforeQueried) | |
| return new ua(p.duration,p.delay); | |
| const S = _ !== l | |
| , R = function gV(n) { | |
| const e = []; | |
| return vE(n, e), | |
| e | |
| }((r.get(_) || aV).map(F => F.getRealPlayer())).filter(F => !!F.element && F.element === _) | |
| , v = o.get(_) | |
| , O = s.get(_) | |
| , M = WT(0, this._normalizer, 0, p.keyframes, v, O) | |
| , N = this._buildPlayer(p, M, R); | |
| if (p.subTimeline && i && d.add(_), | |
| S) { | |
| const F = new Np(e,a,_); | |
| F.setRealPlayer(N), | |
| c.push(F) | |
| } | |
| return N | |
| } | |
| ); | |
| c.forEach(p => { | |
| Sn(this.playersByQueriedElement, p.element, []).push(p), | |
| p.onDone( () => function dV(n, e, t) { | |
| let r = n.get(e); | |
| if (r) { | |
| if (r.length) { | |
| const i = r.indexOf(t); | |
| r.splice(i, 1) | |
| } | |
| 0 == r.length && n.delete(e) | |
| } | |
| return r | |
| }(this.playersByQueriedElement, p.element, p)) | |
| } | |
| ), | |
| u.forEach(p => jn(p, eE)); | |
| const f = ci(h); | |
| return f.onDestroy( () => { | |
| u.forEach(p => jo(p, eE)), | |
| yr(l, t.toStyles) | |
| } | |
| ), | |
| d.forEach(p => { | |
| Sn(i, p, []).push(f) | |
| } | |
| ), | |
| f | |
| } | |
| _buildPlayer(e, t, r) { | |
| return t.length > 0 ? this.driver.animate(e.element, t, e.duration, e.delay, e.easing, r) : new ua(e.duration,e.delay) | |
| } | |
| } | |
| class Np { | |
| constructor(e, t, r) { | |
| this.namespaceId = e, | |
| this.triggerName = t, | |
| this.element = r, | |
| this._player = new ua, | |
| this._containsRealPlayer = !1, | |
| this._queuedCallbacks = new Map, | |
| this.destroyed = !1, | |
| this.markedForDestroy = !1, | |
| this.disabled = !1, | |
| this.queued = !0, | |
| this.totalTime = 0 | |
| } | |
| setRealPlayer(e) { | |
| this._containsRealPlayer || (this._player = e, | |
| this._queuedCallbacks.forEach( (t, r) => { | |
| t.forEach(i => pp(e, r, void 0, i)) | |
| } | |
| ), | |
| this._queuedCallbacks.clear(), | |
| this._containsRealPlayer = !0, | |
| this.overrideTotalTime(e.totalTime), | |
| this.queued = !1) | |
| } | |
| getRealPlayer() { | |
| return this._player | |
| } | |
| overrideTotalTime(e) { | |
| this.totalTime = e | |
| } | |
| syncPlayerEvents(e) { | |
| const t = this._player; | |
| t.triggerCallback && e.onStart( () => t.triggerCallback("start")), | |
| e.onDone( () => this.finish()), | |
| e.onDestroy( () => this.destroy()) | |
| } | |
| _queueEvent(e, t) { | |
| Sn(this._queuedCallbacks, e, []).push(t) | |
| } | |
| onDone(e) { | |
| this.queued && this._queueEvent("done", e), | |
| this._player.onDone(e) | |
| } | |
| onStart(e) { | |
| this.queued && this._queueEvent("start", e), | |
| this._player.onStart(e) | |
| } | |
| onDestroy(e) { | |
| this.queued && this._queueEvent("destroy", e), | |
| this._player.onDestroy(e) | |
| } | |
| init() { | |
| this._player.init() | |
| } | |
| hasStarted() { | |
| return !this.queued && this._player.hasStarted() | |
| } | |
| play() { | |
| !this.queued && this._player.play() | |
| } | |
| pause() { | |
| !this.queued && this._player.pause() | |
| } | |
| restart() { | |
| !this.queued && this._player.restart() | |
| } | |
| finish() { | |
| this._player.finish() | |
| } | |
| destroy() { | |
| this.destroyed = !0, | |
| this._player.destroy() | |
| } | |
| reset() { | |
| !this.queued && this._player.reset() | |
| } | |
| setPosition(e) { | |
| this.queued || this._player.setPosition(e) | |
| } | |
| getPosition() { | |
| return this.queued ? 0 : this._player.getPosition() | |
| } | |
| triggerCallback(e) { | |
| const t = this._player; | |
| t.triggerCallback && t.triggerCallback(e) | |
| } | |
| } | |
| function Nc(n) { | |
| return n && 1 === n.nodeType | |
| } | |
| function mE(n, e) { | |
| const t = n.style.display; | |
| return n.style.display = null != e ? e : "none", | |
| t | |
| } | |
| function _E(n, e, t, r, i) { | |
| const o = []; | |
| t.forEach(l => o.push(mE(l))); | |
| const s = []; | |
| r.forEach( (l, c) => { | |
| const u = new Map; | |
| l.forEach(d => { | |
| const h = e.computeStyle(c, d, i); | |
| u.set(d, h), | |
| (!h || 0 == h.length) && (c[Un] = lV, | |
| s.push(c)) | |
| } | |
| ), | |
| n.set(c, u) | |
| } | |
| ); | |
| let a = 0; | |
| return t.forEach(l => mE(l, o[a++])), | |
| s | |
| } | |
| function yE(n, e) { | |
| const t = new Map; | |
| if (n.forEach(a => t.set(a, [])), | |
| 0 == e.length) | |
| return t; | |
| const i = new Set(e) | |
| , o = new Map; | |
| function s(a) { | |
| if (!a) | |
| return 1; | |
| let l = o.get(a); | |
| if (l) | |
| return l; | |
| const c = a.parentNode; | |
| return l = t.has(c) ? c : i.has(c) ? 1 : s(c), | |
| o.set(a, l), | |
| l | |
| } | |
| return e.forEach(a => { | |
| const l = s(a); | |
| 1 !== l && t.get(l).push(a) | |
| } | |
| ), | |
| t | |
| } | |
| function jn(n, e) { | |
| var t; | |
| null === (t = n.classList) || void 0 === t || t.add(e) | |
| } | |
| function jo(n, e) { | |
| var t; | |
| null === (t = n.classList) || void 0 === t || t.remove(e) | |
| } | |
| function pV(n, e, t) { | |
| ci(t).onDone( () => n.processLeaveNode(e)) | |
| } | |
| function vE(n, e) { | |
| for (let t = 0; t < n.length; t++) { | |
| const r = n[t]; | |
| r instanceof zT ? vE(r.players, e) : e.push(r) | |
| } | |
| } | |
| function bE(n, e, t) { | |
| const r = t.get(n); | |
| if (!r) | |
| return !1; | |
| let i = e.get(n); | |
| return i ? r.forEach(o => i.add(o)) : e.set(n, r), | |
| t.delete(n), | |
| !0 | |
| } | |
| class kc { | |
| constructor(e, t, r) { | |
| this.bodyNode = e, | |
| this._driver = t, | |
| this._normalizer = r, | |
| this._triggerCache = {}, | |
| this.onRemovalComplete = (i, o) => {} | |
| , | |
| this._transitionEngine = new uV(e,t,r), | |
| this._timelineEngine = new nV(e,t,r), | |
| this._transitionEngine.onRemovalComplete = (i, o) => this.onRemovalComplete(i, o) | |
| } | |
| registerTrigger(e, t, r, i, o) { | |
| const s = e + "-" + i; | |
| let a = this._triggerCache[s]; | |
| if (!a) { | |
| const l = [] | |
| , u = Dp(this._driver, o, l, []); | |
| if (l.length) | |
| throw function JL(n, e) { | |
| return new U(3404,!1) | |
| }(); | |
| a = function X2(n, e, t) { | |
| return new J2(n,e,t) | |
| }(i, u, this._normalizer), | |
| this._triggerCache[s] = a | |
| } | |
| this._transitionEngine.registerTrigger(t, i, a) | |
| } | |
| register(e, t) { | |
| this._transitionEngine.register(e, t) | |
| } | |
| destroy(e, t) { | |
| this._transitionEngine.destroy(e, t) | |
| } | |
| onInsert(e, t, r, i) { | |
| this._transitionEngine.insertNode(e, t, r, i) | |
| } | |
| onRemove(e, t, r, i) { | |
| this._transitionEngine.removeNode(e, t, i || !1, r) | |
| } | |
| disableAnimations(e, t) { | |
| this._transitionEngine.markElementAsDisabled(e, t) | |
| } | |
| process(e, t, r, i) { | |
| if ("@" == r.charAt(0)) { | |
| const [o,s] = GT(r); | |
| this._timelineEngine.command(o, t, s, i) | |
| } else | |
| this._transitionEngine.trigger(e, t, r, i) | |
| } | |
| listen(e, t, r, i, o) { | |
| if ("@" == r.charAt(0)) { | |
| const [s,a] = GT(r); | |
| return this._timelineEngine.listen(s, t, a, o) | |
| } | |
| return this._transitionEngine.listen(e, t, r, i, o) | |
| } | |
| flush(e=-1) { | |
| this._transitionEngine.flush(e) | |
| } | |
| get players() { | |
| return this._transitionEngine.players.concat(this._timelineEngine.players) | |
| } | |
| whenRenderingDone() { | |
| return this._transitionEngine.whenRenderingDone() | |
| } | |
| } | |
| let yV = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this._element = t, | |
| this._startStyles = r, | |
| this._endStyles = i, | |
| this._state = 0; | |
| let o = n.initialStylesByElement.get(t); | |
| o || n.initialStylesByElement.set(t, o = new Map), | |
| this._initialStyles = o | |
| } | |
| start() { | |
| this._state < 1 && (this._startStyles && yr(this._element, this._startStyles, this._initialStyles), | |
| this._state = 1) | |
| } | |
| finish() { | |
| this.start(), | |
| this._state < 2 && (yr(this._element, this._initialStyles), | |
| this._endStyles && (yr(this._element, this._endStyles), | |
| this._endStyles = null), | |
| this._state = 1) | |
| } | |
| destroy() { | |
| this.finish(), | |
| this._state < 3 && (n.initialStylesByElement.delete(this._element), | |
| this._startStyles && (Hi(this._element, this._startStyles), | |
| this._endStyles = null), | |
| this._endStyles && (Hi(this._element, this._endStyles), | |
| this._endStyles = null), | |
| yr(this._element, this._initialStyles), | |
| this._state = 3) | |
| } | |
| } | |
| return n.initialStylesByElement = new WeakMap, | |
| n | |
| } | |
| )(); | |
| function kp(n) { | |
| let e = null; | |
| return n.forEach( (t, r) => { | |
| (function vV(n) { | |
| return "display" === n || "position" === n | |
| } | |
| )(r) && (e = e || new Map, | |
| e.set(r, t)) | |
| } | |
| ), | |
| e | |
| } | |
| class CE { | |
| constructor(e, t, r, i) { | |
| this.element = e, | |
| this.keyframes = t, | |
| this.options = r, | |
| this._specialStyles = i, | |
| this._onDoneFns = [], | |
| this._onStartFns = [], | |
| this._onDestroyFns = [], | |
| this._initialized = !1, | |
| this._finished = !1, | |
| this._started = !1, | |
| this._destroyed = !1, | |
| this._originalOnDoneFns = [], | |
| this._originalOnStartFns = [], | |
| this.time = 0, | |
| this.parentPlayer = null, | |
| this.currentSnapshot = new Map, | |
| this._duration = r.duration, | |
| this._delay = r.delay || 0, | |
| this.time = this._duration + this._delay | |
| } | |
| _onFinish() { | |
| this._finished || (this._finished = !0, | |
| this._onDoneFns.forEach(e => e()), | |
| this._onDoneFns = []) | |
| } | |
| init() { | |
| this._buildPlayer(), | |
| this._preparePlayerBeforeStart() | |
| } | |
| _buildPlayer() { | |
| if (this._initialized) | |
| return; | |
| this._initialized = !0; | |
| const e = this.keyframes; | |
| this.domPlayer = this._triggerWebAnimation(this.element, e, this.options), | |
| this._finalKeyframe = e.length ? e[e.length - 1] : new Map, | |
| this.domPlayer.addEventListener("finish", () => this._onFinish()) | |
| } | |
| _preparePlayerBeforeStart() { | |
| this._delay ? this._resetDomPlayerState() : this.domPlayer.pause() | |
| } | |
| _convertKeyframesToObject(e) { | |
| const t = []; | |
| return e.forEach(r => { | |
| t.push(Object.fromEntries(r)) | |
| } | |
| ), | |
| t | |
| } | |
| _triggerWebAnimation(e, t, r) { | |
| return e.animate(this._convertKeyframesToObject(t), r) | |
| } | |
| onStart(e) { | |
| this._originalOnStartFns.push(e), | |
| this._onStartFns.push(e) | |
| } | |
| onDone(e) { | |
| this._originalOnDoneFns.push(e), | |
| this._onDoneFns.push(e) | |
| } | |
| onDestroy(e) { | |
| this._onDestroyFns.push(e) | |
| } | |
| play() { | |
| this._buildPlayer(), | |
| this.hasStarted() || (this._onStartFns.forEach(e => e()), | |
| this._onStartFns = [], | |
| this._started = !0, | |
| this._specialStyles && this._specialStyles.start()), | |
| this.domPlayer.play() | |
| } | |
| pause() { | |
| this.init(), | |
| this.domPlayer.pause() | |
| } | |
| finish() { | |
| this.init(), | |
| this._specialStyles && this._specialStyles.finish(), | |
| this._onFinish(), | |
| this.domPlayer.finish() | |
| } | |
| reset() { | |
| this._resetDomPlayerState(), | |
| this._destroyed = !1, | |
| this._finished = !1, | |
| this._started = !1, | |
| this._onStartFns = this._originalOnStartFns, | |
| this._onDoneFns = this._originalOnDoneFns | |
| } | |
| _resetDomPlayerState() { | |
| this.domPlayer && this.domPlayer.cancel() | |
| } | |
| restart() { | |
| this.reset(), | |
| this.play() | |
| } | |
| hasStarted() { | |
| return this._started | |
| } | |
| destroy() { | |
| this._destroyed || (this._destroyed = !0, | |
| this._resetDomPlayerState(), | |
| this._onFinish(), | |
| this._specialStyles && this._specialStyles.destroy(), | |
| this._onDestroyFns.forEach(e => e()), | |
| this._onDestroyFns = []) | |
| } | |
| setPosition(e) { | |
| void 0 === this.domPlayer && this.init(), | |
| this.domPlayer.currentTime = e * this.time | |
| } | |
| getPosition() { | |
| return this.domPlayer.currentTime / this.time | |
| } | |
| get totalTime() { | |
| return this._delay + this._duration | |
| } | |
| beforeDestroy() { | |
| const e = new Map; | |
| this.hasStarted() && this._finalKeyframe.forEach( (r, i) => { | |
| "offset" !== i && e.set(i, this._finished ? r : sE(this.element, i)) | |
| } | |
| ), | |
| this.currentSnapshot = e | |
| } | |
| triggerCallback(e) { | |
| const t = "start" === e ? this._onStartFns : this._onDoneFns; | |
| t.forEach(r => r()), | |
| t.length = 0 | |
| } | |
| } | |
| class bV { | |
| validateStyleProperty(e) { | |
| return !0 | |
| } | |
| validateAnimatableStyleProperty(e) { | |
| return !0 | |
| } | |
| matchesElement(e, t) { | |
| return !1 | |
| } | |
| containsElement(e, t) { | |
| return YT(e, t) | |
| } | |
| getParentElement(e) { | |
| return yp(e) | |
| } | |
| query(e, t, r) { | |
| return ZT(e, t, r) | |
| } | |
| computeStyle(e, t, r) { | |
| return window.getComputedStyle(e)[t] | |
| } | |
| animate(e, t, r, i, o, s=[]) { | |
| const l = { | |
| duration: r, | |
| delay: i, | |
| fill: 0 == i ? "both" : "forwards" | |
| }; | |
| o && (l.easing = o); | |
| const c = new Map | |
| , u = s.filter(f => f instanceof CE); | |
| (function w2(n, e) { | |
| return 0 === n || 0 === e | |
| } | |
| )(r, i) && u.forEach(f => { | |
| f.currentSnapshot.forEach( (p, _) => c.set(_, p)) | |
| } | |
| ); | |
| let d = function b2(n) { | |
| return n.length ? n[0]instanceof Map ? n : n.map(e => tE(e)) : [] | |
| }(t).map(f => ui(f)); | |
| d = function D2(n, e, t) { | |
| if (t.size && e.length) { | |
| let r = e[0] | |
| , i = []; | |
| if (t.forEach( (o, s) => { | |
| r.has(s) || i.push(s), | |
| r.set(s, o) | |
| } | |
| ), | |
| i.length) | |
| for (let o = 1; o < e.length; o++) { | |
| let s = e[o]; | |
| i.forEach(a => s.set(a, sE(n, a))) | |
| } | |
| } | |
| return e | |
| }(e, d, c); | |
| const h = function _V(n, e) { | |
| let t = null | |
| , r = null; | |
| return Array.isArray(e) && e.length ? (t = kp(e[0]), | |
| e.length > 1 && (r = kp(e[e.length - 1]))) : e instanceof Map && (t = kp(e)), | |
| t || r ? new yV(n,t,r) : null | |
| }(e, d); | |
| return new CE(e,d,l,h) | |
| } | |
| } | |
| let CV = ( () => { | |
| class n extends UT { | |
| constructor(t, r) { | |
| super(), | |
| this._nextAnimationId = 0, | |
| this._renderer = t.createRenderer(r.body, { | |
| id: "0", | |
| encapsulation: Gn.None, | |
| styles: [], | |
| data: { | |
| animation: [] | |
| } | |
| }) | |
| } | |
| build(t) { | |
| const r = this._nextAnimationId.toString(); | |
| this._nextAnimationId++; | |
| const i = Array.isArray(t) ? jT(t) : t; | |
| return TE(this._renderer, null, r, "register", [i]), | |
| new TV(r,this._renderer) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(Os),Q(yt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| class TV extends class xL { | |
| } | |
| { | |
| constructor(e, t) { | |
| super(), | |
| this._id = e, | |
| this._renderer = t | |
| } | |
| create(e, t) { | |
| return new EV(this._id,e,t || {},this._renderer) | |
| } | |
| } | |
| class EV { | |
| constructor(e, t, r, i) { | |
| this.id = e, | |
| this.element = t, | |
| this._renderer = i, | |
| this.parentPlayer = null, | |
| this._started = !1, | |
| this.totalTime = 0, | |
| this._command("create", r) | |
| } | |
| _listen(e, t) { | |
| return this._renderer.listen(this.element, `@@${this.id}:${e}`, t) | |
| } | |
| _command(e, ...t) { | |
| return TE(this._renderer, this.element, this.id, e, t) | |
| } | |
| onDone(e) { | |
| this._listen("done", e) | |
| } | |
| onStart(e) { | |
| this._listen("start", e) | |
| } | |
| onDestroy(e) { | |
| this._listen("destroy", e) | |
| } | |
| init() { | |
| this._command("init") | |
| } | |
| hasStarted() { | |
| return this._started | |
| } | |
| play() { | |
| this._command("play"), | |
| this._started = !0 | |
| } | |
| pause() { | |
| this._command("pause") | |
| } | |
| restart() { | |
| this._command("restart") | |
| } | |
| finish() { | |
| this._command("finish") | |
| } | |
| destroy() { | |
| this._command("destroy") | |
| } | |
| reset() { | |
| this._command("reset"), | |
| this._started = !1 | |
| } | |
| setPosition(e) { | |
| this._command("setPosition", e) | |
| } | |
| getPosition() { | |
| var e, t; | |
| return null !== (t = null === (e = this._renderer.engine.players[+this.id]) || void 0 === e ? void 0 : e.getPosition()) && void 0 !== t ? t : 0 | |
| } | |
| } | |
| function TE(n, e, t, r, i) { | |
| return n.setProperty(e, `@@${t}:${r}`, i) | |
| } | |
| const EE = "@.disabled"; | |
| let wV = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this.delegate = t, | |
| this.engine = r, | |
| this._zone = i, | |
| this._currentId = 0, | |
| this._microtaskId = 1, | |
| this._animationCallbacksBuffer = [], | |
| this._rendererCache = new Map, | |
| this._cdRecurDepth = 0, | |
| this.promise = Promise.resolve(0), | |
| r.onRemovalComplete = (o, s) => { | |
| const a = null == s ? void 0 : s.parentNode(o); | |
| a && s.removeChild(a, o) | |
| } | |
| } | |
| createRenderer(t, r) { | |
| const o = this.delegate.createRenderer(t, r); | |
| if (!(t && r && r.data && r.data.animation)) { | |
| let u = this._rendererCache.get(o); | |
| return u || (u = new wE("",o,this.engine, () => this._rendererCache.delete(o)), | |
| this._rendererCache.set(o, u)), | |
| u | |
| } | |
| const s = r.id | |
| , a = r.id + "-" + this._currentId; | |
| this._currentId++, | |
| this.engine.register(a, t); | |
| const l = u => { | |
| Array.isArray(u) ? u.forEach(l) : this.engine.registerTrigger(s, a, t, u.name, u) | |
| } | |
| ; | |
| return r.data.animation.forEach(l), | |
| new DV(this,a,o,this.engine) | |
| } | |
| begin() { | |
| this._cdRecurDepth++, | |
| this.delegate.begin && this.delegate.begin() | |
| } | |
| _scheduleCountTask() { | |
| this.promise.then( () => { | |
| this._microtaskId++ | |
| } | |
| ) | |
| } | |
| scheduleListenerCallback(t, r, i) { | |
| t >= 0 && t < this._microtaskId ? this._zone.run( () => r(i)) : (0 == this._animationCallbacksBuffer.length && Promise.resolve(null).then( () => { | |
| this._zone.run( () => { | |
| this._animationCallbacksBuffer.forEach(o => { | |
| const [s,a] = o; | |
| s(a) | |
| } | |
| ), | |
| this._animationCallbacksBuffer = [] | |
| } | |
| ) | |
| } | |
| ), | |
| this._animationCallbacksBuffer.push([r, i])) | |
| } | |
| end() { | |
| this._cdRecurDepth--, | |
| 0 == this._cdRecurDepth && this._zone.runOutsideAngular( () => { | |
| this._scheduleCountTask(), | |
| this.engine.flush(this._microtaskId) | |
| } | |
| ), | |
| this.delegate.end && this.delegate.end() | |
| } | |
| whenRenderingDone() { | |
| return this.engine.whenRenderingDone() | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(Os),Q(kc),Q(nt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| class wE { | |
| constructor(e, t, r, i) { | |
| this.namespaceId = e, | |
| this.delegate = t, | |
| this.engine = r, | |
| this._onDestroy = i, | |
| this.destroyNode = this.delegate.destroyNode ? o => t.destroyNode(o) : null | |
| } | |
| get data() { | |
| return this.delegate.data | |
| } | |
| destroy() { | |
| var e; | |
| this.engine.destroy(this.namespaceId, this.delegate), | |
| this.delegate.destroy(), | |
| null === (e = this._onDestroy) || void 0 === e || e.call(this) | |
| } | |
| createElement(e, t) { | |
| return this.delegate.createElement(e, t) | |
| } | |
| createComment(e) { | |
| return this.delegate.createComment(e) | |
| } | |
| createText(e) { | |
| return this.delegate.createText(e) | |
| } | |
| appendChild(e, t) { | |
| this.delegate.appendChild(e, t), | |
| this.engine.onInsert(this.namespaceId, t, e, !1) | |
| } | |
| insertBefore(e, t, r, i=!0) { | |
| this.delegate.insertBefore(e, t, r), | |
| this.engine.onInsert(this.namespaceId, t, e, i) | |
| } | |
| removeChild(e, t, r) { | |
| this.engine.onRemove(this.namespaceId, t, this.delegate, r) | |
| } | |
| selectRootElement(e, t) { | |
| return this.delegate.selectRootElement(e, t) | |
| } | |
| parentNode(e) { | |
| return this.delegate.parentNode(e) | |
| } | |
| nextSibling(e) { | |
| return this.delegate.nextSibling(e) | |
| } | |
| setAttribute(e, t, r, i) { | |
| this.delegate.setAttribute(e, t, r, i) | |
| } | |
| removeAttribute(e, t, r) { | |
| this.delegate.removeAttribute(e, t, r) | |
| } | |
| addClass(e, t) { | |
| this.delegate.addClass(e, t) | |
| } | |
| removeClass(e, t) { | |
| this.delegate.removeClass(e, t) | |
| } | |
| setStyle(e, t, r, i) { | |
| this.delegate.setStyle(e, t, r, i) | |
| } | |
| removeStyle(e, t, r) { | |
| this.delegate.removeStyle(e, t, r) | |
| } | |
| setProperty(e, t, r) { | |
| "@" == t.charAt(0) && t == EE ? this.disableAnimations(e, !!r) : this.delegate.setProperty(e, t, r) | |
| } | |
| setValue(e, t) { | |
| this.delegate.setValue(e, t) | |
| } | |
| listen(e, t, r) { | |
| return this.delegate.listen(e, t, r) | |
| } | |
| disableAnimations(e, t) { | |
| this.engine.disableAnimations(e, t) | |
| } | |
| } | |
| class DV extends wE { | |
| constructor(e, t, r, i, o) { | |
| super(t, r, i, o), | |
| this.factory = e, | |
| this.namespaceId = t | |
| } | |
| setProperty(e, t, r) { | |
| "@" == t.charAt(0) ? "." == t.charAt(1) && t == EE ? this.disableAnimations(e, r = void 0 === r || !!r) : this.engine.process(this.namespaceId, e, t.slice(1), r) : this.delegate.setProperty(e, t, r) | |
| } | |
| listen(e, t, r) { | |
| if ("@" == t.charAt(0)) { | |
| const i = function MV(n) { | |
| switch (n) { | |
| case "body": | |
| return document.body; | |
| case "document": | |
| return document; | |
| case "window": | |
| return window; | |
| default: | |
| return n | |
| } | |
| }(e); | |
| let o = t.slice(1) | |
| , s = ""; | |
| return "@" != o.charAt(0) && ([o,s] = function AV(n) { | |
| const e = n.indexOf("."); | |
| return [n.substring(0, e), n.slice(e + 1)] | |
| }(o)), | |
| this.engine.listen(this.namespaceId, i, o, s, a => { | |
| this.factory.scheduleListenerCallback(a._data || -1, r, a) | |
| } | |
| ) | |
| } | |
| return this.delegate.listen(e, t, r) | |
| } | |
| } | |
| let IV = ( () => { | |
| class n extends kc { | |
| constructor(t, r, i, o) { | |
| super(t.body, r, i) | |
| } | |
| ngOnDestroy() { | |
| this.flush() | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(yt),Q(vp),Q(xp),Q(Xs)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| const DE = [{ | |
| provide: UT, | |
| useClass: CV | |
| }, { | |
| provide: xp, | |
| useFactory: function SV() { | |
| return new K2 | |
| } | |
| }, { | |
| provide: kc, | |
| useClass: IV | |
| }, { | |
| provide: Os, | |
| useFactory: function xV(n, e, t) { | |
| return new wV(n,e,t) | |
| }, | |
| deps: [hc, kc, nt] | |
| }] | |
| , Lp = [{ | |
| provide: vp, | |
| useFactory: () => new bV | |
| }, { | |
| provide: ef, | |
| useValue: "BrowserAnimations" | |
| }, ...DE] | |
| , ME = [{ | |
| provide: vp, | |
| useClass: XT | |
| }, { | |
| provide: ef, | |
| useValue: "NoopAnimations" | |
| }, ...DE]; | |
| let RV = ( () => { | |
| class n { | |
| static withConfig(t) { | |
| return { | |
| ngModule: n, | |
| providers: t.disableAnimations ? ME : Lp | |
| } | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| providers: Lp, | |
| imports: [MC] | |
| }), | |
| n | |
| } | |
| )(); | |
| function Ho(n) { | |
| return null != n && "false" != `${n}` | |
| } | |
| function AE(n) { | |
| return Array.isArray(n) ? n : [n] | |
| } | |
| function ga(n) { | |
| return n instanceof Vt ? n.nativeElement : n | |
| } | |
| class PV { | |
| constructor(e=!1, t, r=!0, i) { | |
| this._multiple = e, | |
| this._emitChanges = r, | |
| this.compareWith = i, | |
| this._selection = new Set, | |
| this._deselectedToEmit = [], | |
| this._selectedToEmit = [], | |
| this.changed = new un, | |
| t && t.length && (e ? t.forEach(o => this._markSelected(o)) : this._markSelected(t[0]), | |
| this._selectedToEmit.length = 0) | |
| } | |
| get selected() { | |
| return this._selected || (this._selected = Array.from(this._selection.values())), | |
| this._selected | |
| } | |
| select(...e) { | |
| this._verifyValueAssignment(e), | |
| e.forEach(r => this._markSelected(r)); | |
| const t = this._hasQueuedChanges(); | |
| return this._emitChangeEvent(), | |
| t | |
| } | |
| deselect(...e) { | |
| this._verifyValueAssignment(e), | |
| e.forEach(r => this._unmarkSelected(r)); | |
| const t = this._hasQueuedChanges(); | |
| return this._emitChangeEvent(), | |
| t | |
| } | |
| setSelection(...e) { | |
| this._verifyValueAssignment(e); | |
| const t = this.selected | |
| , r = new Set(e); | |
| e.forEach(o => this._markSelected(o)), | |
| t.filter(o => !r.has(o)).forEach(o => this._unmarkSelected(o)); | |
| const i = this._hasQueuedChanges(); | |
| return this._emitChangeEvent(), | |
| i | |
| } | |
| toggle(e) { | |
| return this.isSelected(e) ? this.deselect(e) : this.select(e) | |
| } | |
| clear(e=!0) { | |
| this._unmarkAll(); | |
| const t = this._hasQueuedChanges(); | |
| return e && this._emitChangeEvent(), | |
| t | |
| } | |
| isSelected(e) { | |
| if (this.compareWith) { | |
| for (const t of this._selection) | |
| if (this.compareWith(t, e)) | |
| return !0; | |
| return !1 | |
| } | |
| return this._selection.has(e) | |
| } | |
| isEmpty() { | |
| return 0 === this._selection.size | |
| } | |
| hasValue() { | |
| return !this.isEmpty() | |
| } | |
| sort(e) { | |
| this._multiple && this.selected && this._selected.sort(e) | |
| } | |
| isMultipleSelection() { | |
| return this._multiple | |
| } | |
| _emitChangeEvent() { | |
| this._selected = null, | |
| (this._selectedToEmit.length || this._deselectedToEmit.length) && (this.changed.next({ | |
| source: this, | |
| added: this._selectedToEmit, | |
| removed: this._deselectedToEmit | |
| }), | |
| this._deselectedToEmit = [], | |
| this._selectedToEmit = []) | |
| } | |
| _markSelected(e) { | |
| this.isSelected(e) || (this._multiple || this._unmarkAll(), | |
| this.isSelected(e) || this._selection.add(e), | |
| this._emitChanges && this._selectedToEmit.push(e)) | |
| } | |
| _unmarkSelected(e) { | |
| this.isSelected(e) && (this._selection.delete(e), | |
| this._emitChanges && this._deselectedToEmit.push(e)) | |
| } | |
| _unmarkAll() { | |
| this.isEmpty() || this._selection.forEach(e => this._unmarkSelected(e)) | |
| } | |
| _verifyValueAssignment(e) {} | |
| _hasQueuedChanges() { | |
| return !(!this._deselectedToEmit.length && !this._selectedToEmit.length) | |
| } | |
| } | |
| let Vp, IE = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({}), | |
| n | |
| } | |
| )(); | |
| try { | |
| Vp = "undefined" != typeof Intl && Intl.v8BreakIterator | |
| } catch (n) { | |
| Vp = !1 | |
| } | |
| let ma, Bp, zo = ( () => { | |
| class n { | |
| constructor(t) { | |
| this._platformId = t, | |
| this.isBrowser = this._platformId ? function pN(n) { | |
| return n === oC | |
| }(this._platformId) : "object" == typeof document && !!document, | |
| this.EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent), | |
| this.TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent), | |
| this.BLINK = this.isBrowser && !(!window.chrome && !Vp) && "undefined" != typeof CSS && !this.EDGE && !this.TRIDENT, | |
| this.WEBKIT = this.isBrowser && /AppleWebKit/i.test(navigator.userAgent) && !this.BLINK && !this.EDGE && !this.TRIDENT, | |
| this.IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !("MSStream"in window), | |
| this.FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent), | |
| this.ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT, | |
| this.SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(Jh)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| function Vc(n) { | |
| return function kV() { | |
| if (null == ma && "undefined" != typeof window) | |
| try { | |
| window.addEventListener("test", null, Object.defineProperty({}, "passive", { | |
| get: () => ma = !0 | |
| })) | |
| } finally { | |
| ma = ma || !1 | |
| } | |
| return ma | |
| }() ? n : !!n.capture | |
| } | |
| function _a(n) { | |
| return n.composedPath ? n.composedPath()[0] : n.target | |
| } | |
| class Hn extends un { | |
| constructor(e) { | |
| super(), | |
| this._value = e | |
| } | |
| get value() { | |
| return this.getValue() | |
| } | |
| _subscribe(e) { | |
| const t = super._subscribe(e); | |
| return !t.closed && e.next(this._value), | |
| t | |
| } | |
| getValue() { | |
| const {hasError: e, thrownError: t, _value: r} = this; | |
| if (e) | |
| throw t; | |
| return this._throwIfClosed(), | |
| r | |
| } | |
| next(e) { | |
| super.next(this._value = e) | |
| } | |
| } | |
| function le(...n) { | |
| return wt(n, ss(n)) | |
| } | |
| function Ur(n, e) { | |
| return bt( (t, r) => { | |
| let i = 0; | |
| t.subscribe(pt(r, o => n.call(e, o, i++) && r.next(o))) | |
| } | |
| ) | |
| } | |
| function RE(n) { | |
| return Ur( (e, t) => n <= t) | |
| } | |
| function GV(n, e) { | |
| return n === e | |
| } | |
| function FE(n) { | |
| return bt( (e, t) => { | |
| _n(n).subscribe(pt(t, () => t.complete(), bu)), | |
| !t.closed && e.subscribe(t) | |
| } | |
| ) | |
| } | |
| let qV = ( () => { | |
| class n { | |
| create(t) { | |
| return "undefined" == typeof MutationObserver ? null : new MutationObserver(t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )() | |
| , PE = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| providers: [qV] | |
| }), | |
| n | |
| } | |
| )(); | |
| function Up(...n) { | |
| const e = ss(n) | |
| , t = Kg(n) | |
| , {args: r, keys: i} = xC(n); | |
| if (0 === r.length) | |
| return wt([], e); | |
| const o = new vt(function KV(n, e, t=qr) { | |
| return r => { | |
| OE(e, () => { | |
| const {length: i} = n | |
| , o = new Array(i); | |
| let s = i | |
| , a = i; | |
| for (let l = 0; l < i; l++) | |
| OE(e, () => { | |
| const c = wt(n[l], e); | |
| let u = !1; | |
| c.subscribe(pt(r, d => { | |
| o[l] = d, | |
| u || (u = !0, | |
| a--), | |
| a || r.next(t(o.slice())) | |
| } | |
| , () => { | |
| --s || r.complete() | |
| } | |
| )) | |
| } | |
| , r) | |
| } | |
| , r) | |
| } | |
| }(r, e, i ? s => FC(i, s) : qr)); | |
| return t ? o.pipe(RC(t)) : o | |
| } | |
| function OE(n, e, t) { | |
| n ? Cr(t, n, e) : e() | |
| } | |
| function Uc(...n) { | |
| return function QV() { | |
| return Zi(1) | |
| }()(wt(n, ss(n))) | |
| } | |
| function Wo(n) { | |
| return n <= 0 ? () => Tr : bt( (e, t) => { | |
| let r = 0; | |
| e.subscribe(pt(t, i => { | |
| ++r <= n && (t.next(i), | |
| n <= r && t.complete()) | |
| } | |
| )) | |
| } | |
| ) | |
| } | |
| class YV extends mn { | |
| constructor(e, t) { | |
| super() | |
| } | |
| schedule(e, t=0) { | |
| return this | |
| } | |
| } | |
| const jc = { | |
| setInterval(n, e, ...t) { | |
| const {delegate: r} = jc; | |
| return null != r && r.setInterval ? r.setInterval(n, e, ...t) : setInterval(n, e, ...t) | |
| }, | |
| clearInterval(n) { | |
| const {delegate: e} = jc; | |
| return ((null == e ? void 0 : e.clearInterval) || clearInterval)(n) | |
| }, | |
| delegate: void 0 | |
| } | |
| , NE = { | |
| now: () => (NE.delegate || Date).now(), | |
| delegate: void 0 | |
| }; | |
| class ya { | |
| constructor(e, t=ya.now) { | |
| this.schedulerActionCtor = e, | |
| this.now = t | |
| } | |
| schedule(e, t=0, r) { | |
| return new this.schedulerActionCtor(this,e).schedule(r, t) | |
| } | |
| } | |
| ya.now = NE.now; | |
| const JV = new class XV extends ya { | |
| constructor(e, t=ya.now) { | |
| super(e, t), | |
| this.actions = [], | |
| this._active = !1 | |
| } | |
| flush(e) { | |
| const {actions: t} = this; | |
| if (this._active) | |
| return void t.push(e); | |
| let r; | |
| this._active = !0; | |
| do { | |
| if (r = e.execute(e.state, e.delay)) | |
| break | |
| } while (e = t.shift()); | |
| if (this._active = !1, | |
| r) { | |
| for (; e = t.shift(); ) | |
| e.unsubscribe(); | |
| throw r | |
| } | |
| } | |
| } | |
| (class ZV extends YV { | |
| constructor(e, t) { | |
| super(e, t), | |
| this.scheduler = e, | |
| this.work = t, | |
| this.pending = !1 | |
| } | |
| schedule(e, t=0) { | |
| var r; | |
| if (this.closed) | |
| return this; | |
| this.state = e; | |
| const i = this.id | |
| , o = this.scheduler; | |
| return null != i && (this.id = this.recycleAsyncId(o, i, t)), | |
| this.pending = !0, | |
| this.delay = t, | |
| this.id = null !== (r = this.id) && void 0 !== r ? r : this.requestAsyncId(o, this.id, t), | |
| this | |
| } | |
| requestAsyncId(e, t, r=0) { | |
| return jc.setInterval(e.flush.bind(e, this), r) | |
| } | |
| recycleAsyncId(e, t, r=0) { | |
| if (null != r && this.delay === r && !1 === this.pending) | |
| return t; | |
| null != t && jc.clearInterval(t) | |
| } | |
| execute(e, t) { | |
| if (this.closed) | |
| return new Error("executing a cancelled action"); | |
| this.pending = !1; | |
| const r = this._execute(e, t); | |
| if (r) | |
| return r; | |
| !1 === this.pending && null != this.id && (this.id = this.recycleAsyncId(this.scheduler, this.id, null)) | |
| } | |
| _execute(e, t) { | |
| let i, r = !1; | |
| try { | |
| this.work(e) | |
| } catch (o) { | |
| r = !0, | |
| i = o || new Error("Scheduled action threw falsy error") | |
| } | |
| if (r) | |
| return this.unsubscribe(), | |
| i | |
| } | |
| unsubscribe() { | |
| if (!this.closed) { | |
| const {id: e, scheduler: t} = this | |
| , {actions: r} = t; | |
| this.work = this.state = this.scheduler = null, | |
| this.pending = !1, | |
| Yi(r, this), | |
| null != e && (this.id = this.recycleAsyncId(t, e, null)), | |
| this.delay = null, | |
| super.unsubscribe() | |
| } | |
| } | |
| } | |
| ); | |
| function kE(...n) { | |
| const e = ss(n); | |
| return bt( (t, r) => { | |
| (e ? Uc(n, t, e) : Uc(n, t)).subscribe(r) | |
| } | |
| ) | |
| } | |
| const LE = new Set; | |
| let Go, tB = ( () => { | |
| class n { | |
| constructor(t) { | |
| this._platform = t, | |
| this._matchMedia = this._platform.isBrowser && window.matchMedia ? window.matchMedia.bind(window) : rB | |
| } | |
| matchMedia(t) { | |
| return (this._platform.WEBKIT || this._platform.BLINK) && function nB(n) { | |
| if (!LE.has(n)) | |
| try { | |
| Go || (Go = document.createElement("style"), | |
| Go.setAttribute("type", "text/css"), | |
| document.head.appendChild(Go)), | |
| Go.sheet && (Go.sheet.insertRule(`@media ${n} {body{ }}`, 0), | |
| LE.add(n)) | |
| } catch (e) { | |
| console.error(e) | |
| } | |
| }(t), | |
| this._matchMedia(t) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(zo)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| function rB(n) { | |
| return { | |
| matches: "all" === n || "" === n, | |
| media: n, | |
| addListener: () => {} | |
| , | |
| removeListener: () => {} | |
| } | |
| } | |
| let iB = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this._mediaMatcher = t, | |
| this._zone = r, | |
| this._queries = new Map, | |
| this._destroySubject = new un | |
| } | |
| ngOnDestroy() { | |
| this._destroySubject.next(), | |
| this._destroySubject.complete() | |
| } | |
| isMatched(t) { | |
| return VE(AE(t)).some(i => this._registerQuery(i).mql.matches) | |
| } | |
| observe(t) { | |
| let o = Up(VE(AE(t)).map(s => this._registerQuery(s).observable)); | |
| return o = Uc(o.pipe(Wo(1)), o.pipe(RE(1), function eB(n, e=JV) { | |
| return bt( (t, r) => { | |
| let i = null | |
| , o = null | |
| , s = null; | |
| const a = () => { | |
| if (i) { | |
| i.unsubscribe(), | |
| i = null; | |
| const c = o; | |
| o = null, | |
| r.next(c) | |
| } | |
| } | |
| ; | |
| function l() { | |
| const c = s + n | |
| , u = e.now(); | |
| if (u < c) | |
| return i = this.schedule(void 0, c - u), | |
| void r.add(i); | |
| a() | |
| } | |
| t.subscribe(pt(r, c => { | |
| o = c, | |
| s = e.now(), | |
| i || (i = e.schedule(l, n), | |
| r.add(i)) | |
| } | |
| , () => { | |
| a(), | |
| r.complete() | |
| } | |
| , void 0, () => { | |
| o = i = null | |
| } | |
| )) | |
| } | |
| ) | |
| }(0))), | |
| o.pipe(Fe(s => { | |
| const a = { | |
| matches: !1, | |
| breakpoints: {} | |
| }; | |
| return s.forEach( ({matches: l, query: c}) => { | |
| a.matches = a.matches || l, | |
| a.breakpoints[c] = l | |
| } | |
| ), | |
| a | |
| } | |
| )) | |
| } | |
| _registerQuery(t) { | |
| if (this._queries.has(t)) | |
| return this._queries.get(t); | |
| const r = this._mediaMatcher.matchMedia(t) | |
| , o = { | |
| observable: new vt(s => { | |
| const a = l => this._zone.run( () => s.next(l)); | |
| return r.addListener(a), | |
| () => { | |
| r.removeListener(a) | |
| } | |
| } | |
| ).pipe(kE(r), Fe( ({matches: s}) => ({ | |
| query: t, | |
| matches: s | |
| })), FE(this._destroySubject)), | |
| mql: r | |
| }; | |
| return this._queries.set(t, o), | |
| o | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(tB),Q(nt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| function VE(n) { | |
| return n.map(e => e.split(",")).reduce( (e, t) => e.concat(t)).map(e => e.trim()) | |
| } | |
| function HE(n) { | |
| return 0 === n.buttons || 0 === n.offsetX && 0 === n.offsetY | |
| } | |
| function zE(n) { | |
| const e = n.touches && n.touches[0] || n.changedTouches && n.changedTouches[0]; | |
| return !(!e || -1 !== e.identifier || null != e.radiusX && 1 !== e.radiusX || null != e.radiusY && 1 !== e.radiusY) | |
| } | |
| const hB = new ee("cdk-input-modality-detector-options") | |
| , fB = { | |
| ignoreKeys: [18, 17, 224, 91, 16] | |
| } | |
| , qo = Vc({ | |
| passive: !0, | |
| capture: !0 | |
| }); | |
| let pB = ( () => { | |
| class n { | |
| constructor(t, r, i, o) { | |
| this._platform = t, | |
| this._mostRecentTarget = null, | |
| this._modality = new Hn(null), | |
| this._lastTouchMs = 0, | |
| this._onKeydown = s => { | |
| var a, l; | |
| null !== (l = null === (a = this._options) || void 0 === a ? void 0 : a.ignoreKeys) && void 0 !== l && l.some(c => c === s.keyCode) || (this._modality.next("keyboard"), | |
| this._mostRecentTarget = _a(s)) | |
| } | |
| , | |
| this._onMousedown = s => { | |
| Date.now() - this._lastTouchMs < 650 || (this._modality.next(HE(s) ? "keyboard" : "mouse"), | |
| this._mostRecentTarget = _a(s)) | |
| } | |
| , | |
| this._onTouchstart = s => { | |
| zE(s) ? this._modality.next("keyboard") : (this._lastTouchMs = Date.now(), | |
| this._modality.next("touch"), | |
| this._mostRecentTarget = _a(s)) | |
| } | |
| , | |
| this._options = Object.assign(Object.assign({}, fB), o), | |
| this.modalityDetected = this._modality.pipe(RE(1)), | |
| this.modalityChanged = this.modalityDetected.pipe(function WV(n, e=qr) { | |
| return n = null != n ? n : GV, | |
| bt( (t, r) => { | |
| let i, o = !0; | |
| t.subscribe(pt(r, s => { | |
| const a = e(s); | |
| (o || !n(i, a)) && (o = !1, | |
| i = a, | |
| r.next(s)) | |
| } | |
| )) | |
| } | |
| ) | |
| }()), | |
| t.isBrowser && r.runOutsideAngular( () => { | |
| i.addEventListener("keydown", this._onKeydown, qo), | |
| i.addEventListener("mousedown", this._onMousedown, qo), | |
| i.addEventListener("touchstart", this._onTouchstart, qo) | |
| } | |
| ) | |
| } | |
| get mostRecentModality() { | |
| return this._modality.value | |
| } | |
| ngOnDestroy() { | |
| this._modality.complete(), | |
| this._platform.isBrowser && (document.removeEventListener("keydown", this._onKeydown, qo), | |
| document.removeEventListener("mousedown", this._onMousedown, qo), | |
| document.removeEventListener("touchstart", this._onTouchstart, qo)) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(zo),Q(nt),Q(yt),Q(hB, 8)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| const mB = new ee("cdk-focus-monitor-default-options") | |
| , Hc = Vc({ | |
| passive: !0, | |
| capture: !0 | |
| }); | |
| let _B = ( () => { | |
| class n { | |
| constructor(t, r, i, o, s) { | |
| this._ngZone = t, | |
| this._platform = r, | |
| this._inputModalityDetector = i, | |
| this._origin = null, | |
| this._windowFocused = !1, | |
| this._originFromTouchInteraction = !1, | |
| this._elementInfo = new Map, | |
| this._monitoredElementCount = 0, | |
| this._rootNodeFocusListenerCount = new Map, | |
| this._windowFocusListener = () => { | |
| this._windowFocused = !0, | |
| this._windowFocusTimeoutId = window.setTimeout( () => this._windowFocused = !1) | |
| } | |
| , | |
| this._stopInputModalityDetector = new un, | |
| this._rootNodeFocusAndBlurListener = a => { | |
| for (let c = _a(a); c; c = c.parentElement) | |
| "focus" === a.type ? this._onFocus(a, c) : this._onBlur(a, c) | |
| } | |
| , | |
| this._document = o, | |
| this._detectionMode = (null == s ? void 0 : s.detectionMode) || 0 | |
| } | |
| monitor(t, r=!1) { | |
| const i = ga(t); | |
| if (!this._platform.isBrowser || 1 !== i.nodeType) | |
| return le(null); | |
| const o = function VV(n) { | |
| if (function LV() { | |
| if (null == Bp) { | |
| const n = "undefined" != typeof document ? document.head : null; | |
| Bp = !(!n || !n.createShadowRoot && !n.attachShadow) | |
| } | |
| return Bp | |
| }()) { | |
| const e = n.getRootNode ? n.getRootNode() : null; | |
| if ("undefined" != typeof ShadowRoot && ShadowRoot && e instanceof ShadowRoot) | |
| return e | |
| } | |
| return null | |
| }(i) || this._getDocument() | |
| , s = this._elementInfo.get(i); | |
| if (s) | |
| return r && (s.checkChildren = !0), | |
| s.subject; | |
| const a = { | |
| checkChildren: r, | |
| subject: new un, | |
| rootNode: o | |
| }; | |
| return this._elementInfo.set(i, a), | |
| this._registerGlobalListeners(a), | |
| a.subject | |
| } | |
| stopMonitoring(t) { | |
| const r = ga(t) | |
| , i = this._elementInfo.get(r); | |
| i && (i.subject.complete(), | |
| this._setClasses(r), | |
| this._elementInfo.delete(r), | |
| this._removeGlobalListeners(i)) | |
| } | |
| focusVia(t, r, i) { | |
| const o = ga(t); | |
| o === this._getDocument().activeElement ? this._getClosestElementsInfo(o).forEach( ([a,l]) => this._originChanged(a, r, l)) : (this._setOrigin(r), | |
| "function" == typeof o.focus && o.focus(i)) | |
| } | |
| ngOnDestroy() { | |
| this._elementInfo.forEach( (t, r) => this.stopMonitoring(r)) | |
| } | |
| _getDocument() { | |
| return this._document || document | |
| } | |
| _getWindow() { | |
| return this._getDocument().defaultView || window | |
| } | |
| _getFocusOrigin(t) { | |
| return this._origin ? this._originFromTouchInteraction ? this._shouldBeAttributedToTouch(t) ? "touch" : "program" : this._origin : this._windowFocused && this._lastFocusOrigin ? this._lastFocusOrigin : t && this._isLastInteractionFromInputLabel(t) ? "mouse" : "program" | |
| } | |
| _shouldBeAttributedToTouch(t) { | |
| return 1 === this._detectionMode || !(null == t || !t.contains(this._inputModalityDetector._mostRecentTarget)) | |
| } | |
| _setClasses(t, r) { | |
| t.classList.toggle("cdk-focused", !!r), | |
| t.classList.toggle("cdk-touch-focused", "touch" === r), | |
| t.classList.toggle("cdk-keyboard-focused", "keyboard" === r), | |
| t.classList.toggle("cdk-mouse-focused", "mouse" === r), | |
| t.classList.toggle("cdk-program-focused", "program" === r) | |
| } | |
| _setOrigin(t, r=!1) { | |
| this._ngZone.runOutsideAngular( () => { | |
| this._origin = t, | |
| this._originFromTouchInteraction = "touch" === t && r, | |
| 0 === this._detectionMode && (clearTimeout(this._originTimeoutId), | |
| this._originTimeoutId = setTimeout( () => this._origin = null, this._originFromTouchInteraction ? 650 : 1)) | |
| } | |
| ) | |
| } | |
| _onFocus(t, r) { | |
| const i = this._elementInfo.get(r) | |
| , o = _a(t); | |
| !i || !i.checkChildren && r !== o || this._originChanged(r, this._getFocusOrigin(o), i) | |
| } | |
| _onBlur(t, r) { | |
| const i = this._elementInfo.get(r); | |
| !i || i.checkChildren && t.relatedTarget instanceof Node && r.contains(t.relatedTarget) || (this._setClasses(r), | |
| this._emitOrigin(i, null)) | |
| } | |
| _emitOrigin(t, r) { | |
| t.subject.observers.length && this._ngZone.run( () => t.subject.next(r)) | |
| } | |
| _registerGlobalListeners(t) { | |
| if (!this._platform.isBrowser) | |
| return; | |
| const r = t.rootNode | |
| , i = this._rootNodeFocusListenerCount.get(r) || 0; | |
| i || this._ngZone.runOutsideAngular( () => { | |
| r.addEventListener("focus", this._rootNodeFocusAndBlurListener, Hc), | |
| r.addEventListener("blur", this._rootNodeFocusAndBlurListener, Hc) | |
| } | |
| ), | |
| this._rootNodeFocusListenerCount.set(r, i + 1), | |
| 1 == ++this._monitoredElementCount && (this._ngZone.runOutsideAngular( () => { | |
| this._getWindow().addEventListener("focus", this._windowFocusListener) | |
| } | |
| ), | |
| this._inputModalityDetector.modalityDetected.pipe(FE(this._stopInputModalityDetector)).subscribe(o => { | |
| this._setOrigin(o, !0) | |
| } | |
| )) | |
| } | |
| _removeGlobalListeners(t) { | |
| const r = t.rootNode; | |
| if (this._rootNodeFocusListenerCount.has(r)) { | |
| const i = this._rootNodeFocusListenerCount.get(r); | |
| i > 1 ? this._rootNodeFocusListenerCount.set(r, i - 1) : (r.removeEventListener("focus", this._rootNodeFocusAndBlurListener, Hc), | |
| r.removeEventListener("blur", this._rootNodeFocusAndBlurListener, Hc), | |
| this._rootNodeFocusListenerCount.delete(r)) | |
| } | |
| --this._monitoredElementCount || (this._getWindow().removeEventListener("focus", this._windowFocusListener), | |
| this._stopInputModalityDetector.next(), | |
| clearTimeout(this._windowFocusTimeoutId), | |
| clearTimeout(this._originTimeoutId)) | |
| } | |
| _originChanged(t, r, i) { | |
| this._setClasses(t, r), | |
| this._emitOrigin(i, r), | |
| this._lastFocusOrigin = r | |
| } | |
| _getClosestElementsInfo(t) { | |
| const r = []; | |
| return this._elementInfo.forEach( (i, o) => { | |
| (o === t || i.checkChildren && o.contains(t)) && r.push([o, i]) | |
| } | |
| ), | |
| r | |
| } | |
| _isLastInteractionFromInputLabel(t) { | |
| const {_mostRecentTarget: r, mostRecentModality: i} = this._inputModalityDetector; | |
| if ("mouse" !== i || !r || r === t || "INPUT" !== t.nodeName && "TEXTAREA" !== t.nodeName || t.disabled) | |
| return !1; | |
| const o = t.labels; | |
| if (o) | |
| for (let s = 0; s < o.length; s++) | |
| if (o[s].contains(r)) | |
| return !0; | |
| return !1 | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(nt),Q(zo),Q(pB),Q(yt, 8),Q(mB, 8)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| const WE = "cdk-high-contrast-black-on-white" | |
| , GE = "cdk-high-contrast-white-on-black" | |
| , jp = "cdk-high-contrast-active"; | |
| let qE = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this._platform = t, | |
| this._document = r, | |
| this._breakpointSubscription = ot(iB).observe("(forced-colors: active)").subscribe( () => { | |
| this._hasCheckedHighContrastMode && (this._hasCheckedHighContrastMode = !1, | |
| this._applyBodyHighContrastModeCssClasses()) | |
| } | |
| ) | |
| } | |
| getHighContrastMode() { | |
| if (!this._platform.isBrowser) | |
| return 0; | |
| const t = this._document.createElement("div"); | |
| t.style.backgroundColor = "rgb(1,2,3)", | |
| t.style.position = "absolute", | |
| this._document.body.appendChild(t); | |
| const r = this._document.defaultView || window | |
| , i = r && r.getComputedStyle ? r.getComputedStyle(t) : null | |
| , o = (i && i.backgroundColor || "").replace(/ /g, ""); | |
| switch (t.remove(), | |
| o) { | |
| case "rgb(0,0,0)": | |
| case "rgb(45,50,54)": | |
| case "rgb(32,32,32)": | |
| return 2; | |
| case "rgb(255,255,255)": | |
| case "rgb(255,250,239)": | |
| return 1 | |
| } | |
| return 0 | |
| } | |
| ngOnDestroy() { | |
| this._breakpointSubscription.unsubscribe() | |
| } | |
| _applyBodyHighContrastModeCssClasses() { | |
| if (!this._hasCheckedHighContrastMode && this._platform.isBrowser && this._document.body) { | |
| const t = this._document.body.classList; | |
| t.remove(jp, WE, GE), | |
| this._hasCheckedHighContrastMode = !0; | |
| const r = this.getHighContrastMode(); | |
| 1 === r ? t.add(jp, WE) : 2 === r && t.add(jp, GE) | |
| } | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(zo),Q(yt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )() | |
| , yB = ( () => { | |
| class n { | |
| constructor(t) { | |
| t._applyBodyHighContrastModeCssClasses() | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(qE)) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [PE] | |
| }), | |
| n | |
| } | |
| )(); | |
| const bB = new ee("mat-sanity-checks",{ | |
| providedIn: "root", | |
| factory: function vB() { | |
| return !0 | |
| } | |
| }); | |
| let di = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this._sanityChecks = r, | |
| this._document = i, | |
| this._hasDoneGlobalChecks = !1, | |
| t._applyBodyHighContrastModeCssClasses(), | |
| this._hasDoneGlobalChecks || (this._hasDoneGlobalChecks = !0) | |
| } | |
| _checkIsEnabled(t) { | |
| return !function BV() { | |
| return "undefined" != typeof __karma__ && !!__karma__ || "undefined" != typeof jasmine && !!jasmine || "undefined" != typeof jest && !!jest || "undefined" != typeof Mocha && !!Mocha | |
| }() && ("boolean" == typeof this._sanityChecks ? this._sanityChecks : !!this._sanityChecks[t]) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(qE),Q(bB, 8),Q(yt)) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [IE, IE] | |
| }), | |
| n | |
| } | |
| )(); | |
| function CB(n, e) { | |
| return class extends n { | |
| constructor(...t) { | |
| super(...t), | |
| this.defaultColor = e, | |
| this.color = e | |
| } | |
| get color() { | |
| return this._color | |
| } | |
| set color(t) { | |
| const r = t || this.defaultColor; | |
| r !== this._color && (this._color && this._elementRef.nativeElement.classList.remove(`mat-${this._color}`), | |
| r && this._elementRef.nativeElement.classList.add(`mat-${r}`), | |
| this._color = r) | |
| } | |
| } | |
| } | |
| function TB(n) { | |
| return class extends n { | |
| constructor(...e) { | |
| super(...e), | |
| this._disableRipple = !1 | |
| } | |
| get disableRipple() { | |
| return this._disableRipple | |
| } | |
| set disableRipple(e) { | |
| this._disableRipple = Ho(e) | |
| } | |
| } | |
| } | |
| class wB { | |
| constructor(e, t, r, i=!1) { | |
| this._renderer = e, | |
| this.element = t, | |
| this.config = r, | |
| this._animationForciblyDisabledThroughCss = i, | |
| this.state = 3 | |
| } | |
| fadeOut() { | |
| this._renderer.fadeOutRipple(this) | |
| } | |
| } | |
| const QE = { | |
| enterDuration: 225, | |
| exitDuration: 150 | |
| } | |
| , Hp = Vc({ | |
| passive: !0 | |
| }) | |
| , YE = ["mousedown", "touchstart"] | |
| , ZE = ["mouseup", "mouseleave", "touchend", "touchcancel"]; | |
| class MB { | |
| constructor(e, t, r, i) { | |
| this._target = e, | |
| this._ngZone = t, | |
| this._isPointerDown = !1, | |
| this._activeRipples = new Map, | |
| this._pointerUpEventsRegistered = !1, | |
| i.isBrowser && (this._containerElement = ga(r)) | |
| } | |
| fadeInRipple(e, t, r={}) { | |
| const i = this._containerRect = this._containerRect || this._containerElement.getBoundingClientRect() | |
| , o = Object.assign(Object.assign({}, QE), r.animation); | |
| r.centered && (e = i.left + i.width / 2, | |
| t = i.top + i.height / 2); | |
| const s = r.radius || function AB(n, e, t) { | |
| const r = Math.max(Math.abs(n - t.left), Math.abs(n - t.right)) | |
| , i = Math.max(Math.abs(e - t.top), Math.abs(e - t.bottom)); | |
| return Math.sqrt(r * r + i * i) | |
| }(e, t, i) | |
| , a = e - i.left | |
| , l = t - i.top | |
| , c = o.enterDuration | |
| , u = document.createElement("div"); | |
| u.classList.add("mat-ripple-element"), | |
| u.style.left = a - s + "px", | |
| u.style.top = l - s + "px", | |
| u.style.height = 2 * s + "px", | |
| u.style.width = 2 * s + "px", | |
| null != r.color && (u.style.backgroundColor = r.color), | |
| u.style.transitionDuration = `${c}ms`, | |
| this._containerElement.appendChild(u); | |
| const d = window.getComputedStyle(u) | |
| , f = d.transitionDuration | |
| , p = "none" === d.transitionProperty || "0s" === f || "0s, 0s" === f | |
| , _ = new wB(this,u,r,p); | |
| u.style.transform = "scale3d(1, 1, 1)", | |
| _.state = 0, | |
| r.persistent || (this._mostRecentTransientRipple = _); | |
| let C = null; | |
| return !p && (c || o.exitDuration) && this._ngZone.runOutsideAngular( () => { | |
| const S = () => this._finishRippleTransition(_) | |
| , R = () => this._destroyRipple(_); | |
| u.addEventListener("transitionend", S), | |
| u.addEventListener("transitioncancel", R), | |
| C = { | |
| onTransitionEnd: S, | |
| onTransitionCancel: R | |
| } | |
| } | |
| ), | |
| this._activeRipples.set(_, C), | |
| (p || !c) && this._finishRippleTransition(_), | |
| _ | |
| } | |
| fadeOutRipple(e) { | |
| if (2 === e.state || 3 === e.state) | |
| return; | |
| const t = e.element | |
| , r = Object.assign(Object.assign({}, QE), e.config.animation); | |
| t.style.transitionDuration = `${r.exitDuration}ms`, | |
| t.style.opacity = "0", | |
| e.state = 2, | |
| (e._animationForciblyDisabledThroughCss || !r.exitDuration) && this._finishRippleTransition(e) | |
| } | |
| fadeOutAll() { | |
| this._getActiveRipples().forEach(e => e.fadeOut()) | |
| } | |
| fadeOutAllNonPersistent() { | |
| this._getActiveRipples().forEach(e => { | |
| e.config.persistent || e.fadeOut() | |
| } | |
| ) | |
| } | |
| setupTriggerEvents(e) { | |
| const t = ga(e); | |
| !t || t === this._triggerElement || (this._removeTriggerEvents(), | |
| this._triggerElement = t, | |
| this._registerEvents(YE)) | |
| } | |
| handleEvent(e) { | |
| "mousedown" === e.type ? this._onMousedown(e) : "touchstart" === e.type ? this._onTouchStart(e) : this._onPointerUp(), | |
| this._pointerUpEventsRegistered || (this._registerEvents(ZE), | |
| this._pointerUpEventsRegistered = !0) | |
| } | |
| _finishRippleTransition(e) { | |
| 0 === e.state ? this._startFadeOutTransition(e) : 2 === e.state && this._destroyRipple(e) | |
| } | |
| _startFadeOutTransition(e) { | |
| const t = e === this._mostRecentTransientRipple | |
| , {persistent: r} = e.config; | |
| e.state = 1, | |
| !r && (!t || !this._isPointerDown) && e.fadeOut() | |
| } | |
| _destroyRipple(e) { | |
| var t; | |
| const r = null !== (t = this._activeRipples.get(e)) && void 0 !== t ? t : null; | |
| this._activeRipples.delete(e), | |
| this._activeRipples.size || (this._containerRect = null), | |
| e === this._mostRecentTransientRipple && (this._mostRecentTransientRipple = null), | |
| e.state = 3, | |
| null !== r && (e.element.removeEventListener("transitionend", r.onTransitionEnd), | |
| e.element.removeEventListener("transitioncancel", r.onTransitionCancel)), | |
| e.element.remove() | |
| } | |
| _onMousedown(e) { | |
| const t = HE(e) | |
| , r = this._lastTouchStartEvent && Date.now() < this._lastTouchStartEvent + 800; | |
| !this._target.rippleDisabled && !t && !r && (this._isPointerDown = !0, | |
| this.fadeInRipple(e.clientX, e.clientY, this._target.rippleConfig)) | |
| } | |
| _onTouchStart(e) { | |
| if (!this._target.rippleDisabled && !zE(e)) { | |
| this._lastTouchStartEvent = Date.now(), | |
| this._isPointerDown = !0; | |
| const t = e.changedTouches; | |
| for (let r = 0; r < t.length; r++) | |
| this.fadeInRipple(t[r].clientX, t[r].clientY, this._target.rippleConfig) | |
| } | |
| } | |
| _onPointerUp() { | |
| !this._isPointerDown || (this._isPointerDown = !1, | |
| this._getActiveRipples().forEach(e => { | |
| !e.config.persistent && (1 === e.state || e.config.terminateOnPointerUp && 0 === e.state) && e.fadeOut() | |
| } | |
| )) | |
| } | |
| _registerEvents(e) { | |
| this._ngZone.runOutsideAngular( () => { | |
| e.forEach(t => { | |
| this._triggerElement.addEventListener(t, this, Hp) | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| _getActiveRipples() { | |
| return Array.from(this._activeRipples.keys()) | |
| } | |
| _removeTriggerEvents() { | |
| this._triggerElement && (YE.forEach(e => { | |
| this._triggerElement.removeEventListener(e, this, Hp) | |
| } | |
| ), | |
| this._pointerUpEventsRegistered && ZE.forEach(e => { | |
| this._triggerElement.removeEventListener(e, this, Hp) | |
| } | |
| )) | |
| } | |
| } | |
| const XE = new ee("mat-ripple-global-options"); | |
| let IB = ( () => { | |
| class n { | |
| constructor(t, r, i, o, s) { | |
| this._elementRef = t, | |
| this._animationMode = s, | |
| this.radius = 0, | |
| this._disabled = !1, | |
| this._isInitialized = !1, | |
| this._globalOptions = o || {}, | |
| this._rippleRenderer = new MB(this,r,t,i) | |
| } | |
| get disabled() { | |
| return this._disabled | |
| } | |
| set disabled(t) { | |
| t && this.fadeOutAllNonPersistent(), | |
| this._disabled = t, | |
| this._setupTriggerEventsIfEnabled() | |
| } | |
| get trigger() { | |
| return this._trigger || this._elementRef.nativeElement | |
| } | |
| set trigger(t) { | |
| this._trigger = t, | |
| this._setupTriggerEventsIfEnabled() | |
| } | |
| ngOnInit() { | |
| this._isInitialized = !0, | |
| this._setupTriggerEventsIfEnabled() | |
| } | |
| ngOnDestroy() { | |
| this._rippleRenderer._removeTriggerEvents() | |
| } | |
| fadeOutAll() { | |
| this._rippleRenderer.fadeOutAll() | |
| } | |
| fadeOutAllNonPersistent() { | |
| this._rippleRenderer.fadeOutAllNonPersistent() | |
| } | |
| get rippleConfig() { | |
| return { | |
| centered: this.centered, | |
| radius: this.radius, | |
| color: this.color, | |
| animation: Object.assign(Object.assign(Object.assign({}, this._globalOptions.animation), "NoopAnimations" === this._animationMode ? { | |
| enterDuration: 0, | |
| exitDuration: 0 | |
| } : {}), this.animation), | |
| terminateOnPointerUp: this._globalOptions.terminateOnPointerUp | |
| } | |
| } | |
| get rippleDisabled() { | |
| return this.disabled || !!this._globalOptions.disabled | |
| } | |
| _setupTriggerEventsIfEnabled() { | |
| !this.disabled && this._isInitialized && this._rippleRenderer.setupTriggerEvents(this.trigger) | |
| } | |
| launch(t, r=0, i) { | |
| return "number" == typeof t ? this._rippleRenderer.fadeInRipple(t, r, Object.assign(Object.assign({}, this.rippleConfig), i)) : this._rippleRenderer.fadeInRipple(0, 0, Object.assign(Object.assign({}, this.rippleConfig), t)) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Vt),B(nt),B(zo),B(XE, 8),B(ef, 8)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["", "mat-ripple", ""], ["", "matRipple", ""]], | |
| hostAttrs: [1, "mat-ripple"], | |
| hostVars: 2, | |
| hostBindings: function(t, r) { | |
| 2 & t && Xn("mat-ripple-unbounded", r.unbounded) | |
| }, | |
| inputs: { | |
| color: ["matRippleColor", "color"], | |
| unbounded: ["matRippleUnbounded", "unbounded"], | |
| centered: ["matRippleCentered", "centered"], | |
| radius: ["matRippleRadius", "radius"], | |
| animation: ["matRippleAnimation", "animation"], | |
| disabled: ["matRippleDisabled", "disabled"], | |
| trigger: ["matRippleTrigger", "trigger"] | |
| }, | |
| exportAs: ["matRipple"] | |
| }), | |
| n | |
| } | |
| )() | |
| , JE = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [di, di] | |
| }), | |
| n | |
| } | |
| )(); | |
| const SB = ["button"] | |
| , xB = ["*"] | |
| , ew = new ee("MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS") | |
| , tw = new ee("MatButtonToggleGroup") | |
| , RB = { | |
| provide: ar, | |
| useExisting: qe( () => iw), | |
| multi: !0 | |
| }; | |
| let nw = 0; | |
| class rw { | |
| constructor(e, t) { | |
| this.source = e, | |
| this.value = t | |
| } | |
| } | |
| let iw = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this._changeDetector = t, | |
| this._vertical = !1, | |
| this._multiple = !1, | |
| this._disabled = !1, | |
| this._controlValueAccessorChangeFn = () => {} | |
| , | |
| this._onTouched = () => {} | |
| , | |
| this._name = "mat-button-toggle-group-" + nw++, | |
| this.valueChange = new Se, | |
| this.change = new Se, | |
| this.appearance = r && r.appearance ? r.appearance : "standard" | |
| } | |
| get name() { | |
| return this._name | |
| } | |
| set name(t) { | |
| this._name = t, | |
| this._markButtonsForCheck() | |
| } | |
| get vertical() { | |
| return this._vertical | |
| } | |
| set vertical(t) { | |
| this._vertical = Ho(t) | |
| } | |
| get value() { | |
| const t = this._selectionModel ? this._selectionModel.selected : []; | |
| return this.multiple ? t.map(r => r.value) : t[0] ? t[0].value : void 0 | |
| } | |
| set value(t) { | |
| this._setSelectionByValue(t), | |
| this.valueChange.emit(this.value) | |
| } | |
| get selected() { | |
| const t = this._selectionModel ? this._selectionModel.selected : []; | |
| return this.multiple ? t : t[0] || null | |
| } | |
| get multiple() { | |
| return this._multiple | |
| } | |
| set multiple(t) { | |
| this._multiple = Ho(t), | |
| this._markButtonsForCheck() | |
| } | |
| get disabled() { | |
| return this._disabled | |
| } | |
| set disabled(t) { | |
| this._disabled = Ho(t), | |
| this._markButtonsForCheck() | |
| } | |
| ngOnInit() { | |
| this._selectionModel = new PV(this.multiple,void 0,!1) | |
| } | |
| ngAfterContentInit() { | |
| this._selectionModel.select(...this._buttonToggles.filter(t => t.checked)) | |
| } | |
| writeValue(t) { | |
| this.value = t, | |
| this._changeDetector.markForCheck() | |
| } | |
| registerOnChange(t) { | |
| this._controlValueAccessorChangeFn = t | |
| } | |
| registerOnTouched(t) { | |
| this._onTouched = t | |
| } | |
| setDisabledState(t) { | |
| this.disabled = t | |
| } | |
| _emitChangeEvent(t) { | |
| const r = new rw(t,this.value); | |
| this._controlValueAccessorChangeFn(r.value), | |
| this.change.emit(r) | |
| } | |
| _syncButtonToggle(t, r, i=!1, o=!1) { | |
| !this.multiple && this.selected && !t.checked && (this.selected.checked = !1), | |
| this._selectionModel ? r ? this._selectionModel.select(t) : this._selectionModel.deselect(t) : o = !0, | |
| o ? Promise.resolve().then( () => this._updateModelValue(t, i)) : this._updateModelValue(t, i) | |
| } | |
| _isSelected(t) { | |
| return this._selectionModel && this._selectionModel.isSelected(t) | |
| } | |
| _isPrechecked(t) { | |
| return void 0 !== this._rawValue && (this.multiple && Array.isArray(this._rawValue) ? this._rawValue.some(r => null != t.value && r === t.value) : t.value === this._rawValue) | |
| } | |
| _setSelectionByValue(t) { | |
| this._rawValue = t, | |
| this._buttonToggles && (this.multiple && t ? (Array.isArray(t), | |
| this._clearSelection(), | |
| t.forEach(r => this._selectValue(r))) : (this._clearSelection(), | |
| this._selectValue(t))) | |
| } | |
| _clearSelection() { | |
| this._selectionModel.clear(), | |
| this._buttonToggles.forEach(t => t.checked = !1) | |
| } | |
| _selectValue(t) { | |
| const r = this._buttonToggles.find(i => null != i.value && i.value === t); | |
| r && (r.checked = !0, | |
| this._selectionModel.select(r)) | |
| } | |
| _updateModelValue(t, r) { | |
| r && this._emitChangeEvent(t), | |
| this.valueChange.emit(this.value) | |
| } | |
| _markButtonsForCheck() { | |
| var t; | |
| null === (t = this._buttonToggles) || void 0 === t || t.forEach(r => r._markForCheck()) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Bo),B(ew, 8)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["mat-button-toggle-group"]], | |
| contentQueries: function(t, r, i) { | |
| if (1 & t && Ks(i, ow, 5), | |
| 2 & t) { | |
| let o; | |
| rn(o = on()) && (r._buttonToggles = o) | |
| } | |
| }, | |
| hostAttrs: ["role", "group", 1, "mat-button-toggle-group"], | |
| hostVars: 5, | |
| hostBindings: function(t, r) { | |
| 2 & t && (In("aria-disabled", r.disabled), | |
| Xn("mat-button-toggle-vertical", r.vertical)("mat-button-toggle-group-appearance-standard", "standard" === r.appearance)) | |
| }, | |
| inputs: { | |
| appearance: "appearance", | |
| name: "name", | |
| vertical: "vertical", | |
| value: "value", | |
| multiple: "multiple", | |
| disabled: "disabled" | |
| }, | |
| outputs: { | |
| valueChange: "valueChange", | |
| change: "change" | |
| }, | |
| exportAs: ["matButtonToggleGroup"], | |
| features: [tt([RB, { | |
| provide: tw, | |
| useExisting: n | |
| }])] | |
| }), | |
| n | |
| } | |
| )(); | |
| const FB = TB(class { | |
| } | |
| ); | |
| let ow = ( () => { | |
| class n extends FB { | |
| constructor(t, r, i, o, s, a) { | |
| super(), | |
| this._changeDetectorRef = r, | |
| this._elementRef = i, | |
| this._focusMonitor = o, | |
| this._checked = !1, | |
| this.ariaLabelledby = null, | |
| this._disabled = !1, | |
| this.change = new Se; | |
| const l = Number(s); | |
| this.tabIndex = l || 0 === l ? l : null, | |
| this.buttonToggleGroup = t, | |
| this.appearance = a && a.appearance ? a.appearance : "standard" | |
| } | |
| get buttonId() { | |
| return `${this.id}-button` | |
| } | |
| get appearance() { | |
| return this.buttonToggleGroup ? this.buttonToggleGroup.appearance : this._appearance | |
| } | |
| set appearance(t) { | |
| this._appearance = t | |
| } | |
| get checked() { | |
| return this.buttonToggleGroup ? this.buttonToggleGroup._isSelected(this) : this._checked | |
| } | |
| set checked(t) { | |
| const r = Ho(t); | |
| r !== this._checked && (this._checked = r, | |
| this.buttonToggleGroup && this.buttonToggleGroup._syncButtonToggle(this, this._checked), | |
| this._changeDetectorRef.markForCheck()) | |
| } | |
| get disabled() { | |
| return this._disabled || this.buttonToggleGroup && this.buttonToggleGroup.disabled | |
| } | |
| set disabled(t) { | |
| this._disabled = Ho(t) | |
| } | |
| ngOnInit() { | |
| const t = this.buttonToggleGroup; | |
| this.id = this.id || "mat-button-toggle-" + nw++, | |
| t && (t._isPrechecked(this) ? this.checked = !0 : t._isSelected(this) !== this._checked && t._syncButtonToggle(this, this._checked)) | |
| } | |
| ngAfterViewInit() { | |
| this._focusMonitor.monitor(this._elementRef, !0) | |
| } | |
| ngOnDestroy() { | |
| const t = this.buttonToggleGroup; | |
| this._focusMonitor.stopMonitoring(this._elementRef), | |
| t && t._isSelected(this) && t._syncButtonToggle(this, !1, !1, !0) | |
| } | |
| focus(t) { | |
| this._buttonElement.nativeElement.focus(t) | |
| } | |
| _onButtonClick() { | |
| const t = !!this._isSingleSelector() || !this._checked; | |
| t !== this._checked && (this._checked = t, | |
| this.buttonToggleGroup && (this.buttonToggleGroup._syncButtonToggle(this, this._checked, !0), | |
| this.buttonToggleGroup._onTouched())), | |
| this.change.emit(new rw(this,this.value)) | |
| } | |
| _markForCheck() { | |
| this._changeDetectorRef.markForCheck() | |
| } | |
| _getButtonName() { | |
| return this._isSingleSelector() ? this.buttonToggleGroup.name : this.name || null | |
| } | |
| _isSingleSelector() { | |
| return this.buttonToggleGroup && !this.buttonToggleGroup.multiple | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(tw, 8),B(Bo),B(Vt),B(_B),lo("tabindex"),B(ew, 8)) | |
| } | |
| , | |
| n.\u0275cmp = dn({ | |
| type: n, | |
| selectors: [["mat-button-toggle"]], | |
| viewQuery: function(t, r) { | |
| if (1 & t && nr(SB, 5), | |
| 2 & t) { | |
| let i; | |
| rn(i = on()) && (r._buttonElement = i.first) | |
| } | |
| }, | |
| hostAttrs: ["role", "presentation", 1, "mat-button-toggle"], | |
| hostVars: 12, | |
| hostBindings: function(t, r) { | |
| 1 & t && _e("focus", function() { | |
| return r.focus() | |
| }), | |
| 2 & t && (In("aria-label", null)("aria-labelledby", null)("id", r.id)("name", null), | |
| Xn("mat-button-toggle-standalone", !r.buttonToggleGroup)("mat-button-toggle-checked", r.checked)("mat-button-toggle-disabled", r.disabled)("mat-button-toggle-appearance-standard", "standard" === r.appearance)) | |
| }, | |
| inputs: { | |
| disableRipple: "disableRipple", | |
| ariaLabel: ["aria-label", "ariaLabel"], | |
| ariaLabelledby: ["aria-labelledby", "ariaLabelledby"], | |
| id: "id", | |
| name: "name", | |
| value: "value", | |
| tabIndex: "tabIndex", | |
| appearance: "appearance", | |
| checked: "checked", | |
| disabled: "disabled" | |
| }, | |
| outputs: { | |
| change: "change" | |
| }, | |
| exportAs: ["matButtonToggle"], | |
| features: [ke], | |
| ngContentSelectors: xB, | |
| decls: 6, | |
| vars: 9, | |
| consts: [["type", "button", 1, "mat-button-toggle-button", "mat-focus-indicator", 3, "id", "disabled", "click"], ["button", ""], [1, "mat-button-toggle-label-content"], [1, "mat-button-toggle-focus-overlay"], ["matRipple", "", 1, "mat-button-toggle-ripple", 3, "matRippleTrigger", "matRippleDisabled"]], | |
| template: function(t, r) { | |
| if (1 & t && (Ah(), | |
| re(0, "button", 0, 1), | |
| _e("click", function() { | |
| return r._onButtonClick() | |
| }), | |
| re(2, "span", 2), | |
| Pl(3), | |
| oe()(), | |
| Ct(4, "span", 3)(5, "span", 4)), | |
| 2 & t) { | |
| const i = kn(1); | |
| Ae("id", r.buttonId)("disabled", r.disabled || null), | |
| In("tabindex", r.disabled ? -1 : r.tabIndex)("aria-pressed", r.checked)("name", r._getButtonName())("aria-label", r.ariaLabel)("aria-labelledby", r.ariaLabelledby), | |
| Ee(5), | |
| Ae("matRippleTrigger", i)("matRippleDisabled", r.disableRipple || r.disabled) | |
| } | |
| }, | |
| dependencies: [IB], | |
| styles: [".mat-button-toggle-standalone,.mat-button-toggle-group{position:relative;display:inline-flex;flex-direction:row;white-space:nowrap;overflow:hidden;border-radius:2px;-webkit-tap-highlight-color:rgba(0,0,0,0);transform:translateZ(0)}.cdk-high-contrast-active .mat-button-toggle-standalone,.cdk-high-contrast-active .mat-button-toggle-group{outline:solid 1px}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border-radius:4px}.cdk-high-contrast-active .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.cdk-high-contrast-active .mat-button-toggle-group-appearance-standard{outline:0}.mat-button-toggle-vertical{flex-direction:column}.mat-button-toggle-vertical .mat-button-toggle-label-content{display:block}.mat-button-toggle{white-space:nowrap;position:relative}.mat-button-toggle .mat-icon svg{vertical-align:top}.mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:1}.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{opacity:.04}.mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.12}@media(hover: none){.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{display:none}}.mat-button-toggle-label-content{-webkit-user-select:none;user-select:none;display:inline-block;line-height:36px;padding:0 16px;position:relative}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{padding:0 12px}.mat-button-toggle-label-content>*{vertical-align:middle}.mat-button-toggle-focus-overlay{top:0;left:0;right:0;bottom:0;position:absolute;border-radius:inherit;pointer-events:none;opacity:0}.cdk-high-contrast-active .mat-button-toggle-checked .mat-button-toggle-focus-overlay{border-bottom:solid 36px;opacity:.5;height:0}.cdk-high-contrast-active .mat-button-toggle-checked:hover .mat-button-toggle-focus-overlay{opacity:.6}.cdk-high-contrast-active .mat-button-toggle-checked.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{border-bottom:solid 500px}.mat-button-toggle .mat-button-toggle-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-button-toggle-button{border:0;background:none;color:inherit;padding:0;margin:0;font:inherit;outline:none;width:100%;cursor:pointer}.mat-button-toggle-disabled .mat-button-toggle-button{cursor:default}.mat-button-toggle-button::-moz-focus-inner{border:0}"], | |
| encapsulation: 2, | |
| changeDetection: 0 | |
| }), | |
| n | |
| } | |
| )() | |
| , PB = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [di, JE, di] | |
| }), | |
| n | |
| } | |
| )(); | |
| const OB = ["*", [["mat-toolbar-row"]]] | |
| , NB = ["*", "mat-toolbar-row"] | |
| , kB = CB(class { | |
| constructor(n) { | |
| this._elementRef = n | |
| } | |
| } | |
| ); | |
| let LB = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["mat-toolbar-row"]], | |
| hostAttrs: [1, "mat-toolbar-row"], | |
| exportAs: ["matToolbarRow"] | |
| }), | |
| n | |
| } | |
| )() | |
| , VB = ( () => { | |
| class n extends kB { | |
| constructor(t, r, i) { | |
| super(t), | |
| this._platform = r, | |
| this._document = i | |
| } | |
| ngAfterViewInit() { | |
| this._platform.isBrowser && (this._checkToolbarMixedModes(), | |
| this._toolbarRows.changes.subscribe( () => this._checkToolbarMixedModes())) | |
| } | |
| _checkToolbarMixedModes() {} | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Vt),B(zo),B(yt)) | |
| } | |
| , | |
| n.\u0275cmp = dn({ | |
| type: n, | |
| selectors: [["mat-toolbar"]], | |
| contentQueries: function(t, r, i) { | |
| if (1 & t && Ks(i, LB, 5), | |
| 2 & t) { | |
| let o; | |
| rn(o = on()) && (r._toolbarRows = o) | |
| } | |
| }, | |
| hostAttrs: [1, "mat-toolbar"], | |
| hostVars: 4, | |
| hostBindings: function(t, r) { | |
| 2 & t && Xn("mat-toolbar-multiple-rows", r._toolbarRows.length > 0)("mat-toolbar-single-row", 0 === r._toolbarRows.length) | |
| }, | |
| inputs: { | |
| color: "color" | |
| }, | |
| exportAs: ["matToolbar"], | |
| features: [ke], | |
| ngContentSelectors: NB, | |
| decls: 2, | |
| vars: 0, | |
| template: function(t, r) { | |
| 1 & t && (Ah(OB), | |
| Pl(0), | |
| Pl(1, 1)) | |
| }, | |
| styles: [".cdk-high-contrast-active .mat-toolbar{outline:solid 1px}.mat-toolbar-row,.mat-toolbar-single-row{display:flex;box-sizing:border-box;padding:0 16px;width:100%;flex-direction:row;align-items:center;white-space:nowrap}.mat-toolbar-multiple-rows{display:flex;box-sizing:border-box;flex-direction:column;width:100%}"], | |
| encapsulation: 2, | |
| changeDetection: 0 | |
| }), | |
| n | |
| } | |
| )() | |
| , BB = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [di, di] | |
| }), | |
| n | |
| } | |
| )() | |
| , zB = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({}), | |
| n | |
| } | |
| )() | |
| , KB = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [Ff, di, zB, JE, PE, yB, di] | |
| }), | |
| n | |
| } | |
| )(); | |
| const zc = is(n => function() { | |
| n(this), | |
| this.name = "EmptyError", | |
| this.message = "no elements in sequence" | |
| } | |
| ); | |
| function sw(n) { | |
| return new vt(e => { | |
| _n(n()).subscribe(e) | |
| } | |
| ) | |
| } | |
| function ba(n, e) { | |
| const t = Ye(n) ? n : () => n | |
| , r = i => i.error(t()); | |
| return new vt(e ? i => e.schedule(r, 0, i) : r) | |
| } | |
| function zp() { | |
| return bt( (n, e) => { | |
| let t = null; | |
| n._refCount++; | |
| const r = pt(e, void 0, void 0, void 0, () => { | |
| if (!n || n._refCount <= 0 || 0 < --n._refCount) | |
| return void (t = null); | |
| const i = n._connection | |
| , o = t; | |
| t = null, | |
| i && (!o || i === o) && i.unsubscribe(), | |
| e.unsubscribe() | |
| } | |
| ); | |
| n.subscribe(r), | |
| r.closed || (t = n.connect()) | |
| } | |
| ) | |
| } | |
| class aw extends vt { | |
| constructor(e, t) { | |
| super(), | |
| this.source = e, | |
| this.subjectFactory = t, | |
| this._subject = null, | |
| this._refCount = 0, | |
| this._connection = null, | |
| Og(e) && (this.lift = e.lift) | |
| } | |
| _subscribe(e) { | |
| return this.getSubject().subscribe(e) | |
| } | |
| getSubject() { | |
| const e = this._subject; | |
| return (!e || e.isStopped) && (this._subject = this.subjectFactory()), | |
| this._subject | |
| } | |
| _teardown() { | |
| this._refCount = 0; | |
| const {_connection: e} = this; | |
| this._subject = this._connection = null, | |
| null == e || e.unsubscribe() | |
| } | |
| connect() { | |
| let e = this._connection; | |
| if (!e) { | |
| e = this._connection = new mn; | |
| const t = this.getSubject(); | |
| e.add(this.source.subscribe(pt(t, void 0, () => { | |
| this._teardown(), | |
| t.complete() | |
| } | |
| , r => { | |
| this._teardown(), | |
| t.error(r) | |
| } | |
| , () => this._teardown()))), | |
| e.closed && (this._connection = null, | |
| e = mn.EMPTY) | |
| } | |
| return e | |
| } | |
| refCount() { | |
| return zp()(this) | |
| } | |
| } | |
| function vr(n, e) { | |
| return bt( (t, r) => { | |
| let i = null | |
| , o = 0 | |
| , s = !1; | |
| const a = () => s && !i && r.complete(); | |
| t.subscribe(pt(r, l => { | |
| null == i || i.unsubscribe(); | |
| let c = 0; | |
| const u = o++; | |
| _n(n(l, u)).subscribe(i = pt(r, d => r.next(e ? e(l, d, u, c++) : d), () => { | |
| i = null, | |
| a() | |
| } | |
| )) | |
| } | |
| , () => { | |
| s = !0, | |
| a() | |
| } | |
| )) | |
| } | |
| ) | |
| } | |
| function $c(n) { | |
| return bt( (e, t) => { | |
| let r = !1; | |
| e.subscribe(pt(t, i => { | |
| r = !0, | |
| t.next(i) | |
| } | |
| , () => { | |
| r || t.next(n), | |
| t.complete() | |
| } | |
| )) | |
| } | |
| ) | |
| } | |
| function lw(n=QB) { | |
| return bt( (e, t) => { | |
| let r = !1; | |
| e.subscribe(pt(t, i => { | |
| r = !0, | |
| t.next(i) | |
| } | |
| , () => r ? t.complete() : t.error(n()))) | |
| } | |
| ) | |
| } | |
| function QB() { | |
| return new zc | |
| } | |
| function hi(n, e) { | |
| const t = arguments.length >= 2; | |
| return r => r.pipe(n ? Ur( (i, o) => n(i, o, r)) : qr, Wo(1), t ? $c(e) : lw( () => new zc)) | |
| } | |
| function Wi(n, e) { | |
| return Ye(e) ? Lt(n, e, 1) : Lt(n, 1) | |
| } | |
| function Qt(n, e, t) { | |
| const r = Ye(n) || e || t ? { | |
| next: n, | |
| error: e, | |
| complete: t | |
| } : n; | |
| return r ? bt( (i, o) => { | |
| var s; | |
| null === (s = r.subscribe) || void 0 === s || s.call(r); | |
| let a = !0; | |
| i.subscribe(pt(o, l => { | |
| var c; | |
| null === (c = r.next) || void 0 === c || c.call(r, l), | |
| o.next(l) | |
| } | |
| , () => { | |
| var l; | |
| a = !1, | |
| null === (l = r.complete) || void 0 === l || l.call(r), | |
| o.complete() | |
| } | |
| , l => { | |
| var c; | |
| a = !1, | |
| null === (c = r.error) || void 0 === c || c.call(r, l), | |
| o.error(l) | |
| } | |
| , () => { | |
| var l, c; | |
| a && (null === (l = r.unsubscribe) || void 0 === l || l.call(r)), | |
| null === (c = r.finalize) || void 0 === c || c.call(r) | |
| } | |
| )) | |
| } | |
| ) : qr | |
| } | |
| function fi(n) { | |
| return bt( (e, t) => { | |
| let o, r = null, i = !1; | |
| r = e.subscribe(pt(t, void 0, void 0, s => { | |
| o = _n(n(s, fi(n)(e))), | |
| r ? (r.unsubscribe(), | |
| r = null, | |
| o.subscribe(t)) : i = !0 | |
| } | |
| )), | |
| i && (r.unsubscribe(), | |
| r = null, | |
| o.subscribe(t)) | |
| } | |
| ) | |
| } | |
| function YB(n, e, t, r, i) { | |
| return (o, s) => { | |
| let a = t | |
| , l = e | |
| , c = 0; | |
| o.subscribe(pt(s, u => { | |
| const d = c++; | |
| l = a ? n(l, u, d) : (a = !0, | |
| u), | |
| r && s.next(l) | |
| } | |
| , i && ( () => { | |
| a && s.next(l), | |
| s.complete() | |
| } | |
| ))) | |
| } | |
| } | |
| function cw(n, e) { | |
| return bt(YB(n, e, arguments.length >= 2, !0)) | |
| } | |
| function $p(n) { | |
| return n <= 0 ? () => Tr : bt( (e, t) => { | |
| let r = []; | |
| e.subscribe(pt(t, i => { | |
| r.push(i), | |
| n < r.length && r.shift() | |
| } | |
| , () => { | |
| for (const i of r) | |
| t.next(i); | |
| t.complete() | |
| } | |
| , void 0, () => { | |
| r = null | |
| } | |
| )) | |
| } | |
| ) | |
| } | |
| function uw(n, e) { | |
| const t = arguments.length >= 2; | |
| return r => r.pipe(n ? Ur( (i, o) => n(i, o, r)) : qr, $p(1), t ? $c(e) : lw( () => new zc)) | |
| } | |
| function Wp(n) { | |
| return bt( (e, t) => { | |
| try { | |
| e.subscribe(t) | |
| } finally { | |
| t.add(n) | |
| } | |
| } | |
| ) | |
| } | |
| const De = "primary" | |
| , Ca = Symbol("RouteTitle"); | |
| class JB { | |
| constructor(e) { | |
| this.params = e || {} | |
| } | |
| has(e) { | |
| return Object.prototype.hasOwnProperty.call(this.params, e) | |
| } | |
| get(e) { | |
| if (this.has(e)) { | |
| const t = this.params[e]; | |
| return Array.isArray(t) ? t[0] : t | |
| } | |
| return null | |
| } | |
| getAll(e) { | |
| if (this.has(e)) { | |
| const t = this.params[e]; | |
| return Array.isArray(t) ? t : [t] | |
| } | |
| return [] | |
| } | |
| get keys() { | |
| return Object.keys(this.params) | |
| } | |
| } | |
| function Ko(n) { | |
| return new JB(n) | |
| } | |
| function e3(n, e, t) { | |
| const r = t.path.split("/"); | |
| if (r.length > n.length || "full" === t.pathMatch && (e.hasChildren() || r.length < n.length)) | |
| return null; | |
| const i = {}; | |
| for (let o = 0; o < r.length; o++) { | |
| const s = r[o] | |
| , a = n[o]; | |
| if (s.startsWith(":")) | |
| i[s.substring(1)] = a; | |
| else if (s !== a.path) | |
| return null | |
| } | |
| return { | |
| consumed: n.slice(0, r.length), | |
| posParams: i | |
| } | |
| } | |
| function br(n, e) { | |
| const t = n ? Object.keys(n) : void 0 | |
| , r = e ? Object.keys(e) : void 0; | |
| if (!t || !r || t.length != r.length) | |
| return !1; | |
| let i; | |
| for (let o = 0; o < t.length; o++) | |
| if (i = t[o], | |
| !dw(n[i], e[i])) | |
| return !1; | |
| return !0 | |
| } | |
| function dw(n, e) { | |
| if (Array.isArray(n) && Array.isArray(e)) { | |
| if (n.length !== e.length) | |
| return !1; | |
| const t = [...n].sort() | |
| , r = [...e].sort(); | |
| return t.every( (i, o) => r[o] === i) | |
| } | |
| return n === e | |
| } | |
| function hw(n) { | |
| return Array.prototype.concat.apply([], n) | |
| } | |
| function fw(n) { | |
| return n.length > 0 ? n[n.length - 1] : null | |
| } | |
| function Bt(n, e) { | |
| for (const t in n) | |
| n.hasOwnProperty(t) && e(n[t], t) | |
| } | |
| function pi(n) { | |
| return Mh(n) ? n : Bs(n) ? wt(Promise.resolve(n)) : le(n) | |
| } | |
| const r3 = { | |
| exact: function mw(n, e, t) { | |
| if (!qi(n.segments, e.segments) || !Wc(n.segments, e.segments, t) || n.numberOfChildren !== e.numberOfChildren) | |
| return !1; | |
| for (const r in e.children) | |
| if (!n.children[r] || !mw(n.children[r], e.children[r], t)) | |
| return !1; | |
| return !0 | |
| }, | |
| subset: _w | |
| } | |
| , pw = { | |
| exact: function o3(n, e) { | |
| return br(n, e) | |
| }, | |
| subset: function s3(n, e) { | |
| return Object.keys(e).length <= Object.keys(n).length && Object.keys(e).every(t => dw(n[t], e[t])) | |
| }, | |
| ignored: () => !0 | |
| }; | |
| function gw(n, e, t) { | |
| return r3[t.paths](n.root, e.root, t.matrixParams) && pw[t.queryParams](n.queryParams, e.queryParams) && !("exact" === t.fragment && n.fragment !== e.fragment) | |
| } | |
| function _w(n, e, t) { | |
| return yw(n, e, e.segments, t) | |
| } | |
| function yw(n, e, t, r) { | |
| if (n.segments.length > t.length) { | |
| const i = n.segments.slice(0, t.length); | |
| return !(!qi(i, t) || e.hasChildren() || !Wc(i, t, r)) | |
| } | |
| if (n.segments.length === t.length) { | |
| if (!qi(n.segments, t) || !Wc(n.segments, t, r)) | |
| return !1; | |
| for (const i in e.children) | |
| if (!n.children[i] || !_w(n.children[i], e.children[i], r)) | |
| return !1; | |
| return !0 | |
| } | |
| { | |
| const i = t.slice(0, n.segments.length) | |
| , o = t.slice(n.segments.length); | |
| return !!(qi(n.segments, i) && Wc(n.segments, i, r) && n.children[De]) && yw(n.children[De], e, o, r) | |
| } | |
| } | |
| function Wc(n, e, t) { | |
| return e.every( (r, i) => pw[t](n[i].parameters, r.parameters)) | |
| } | |
| class Gi { | |
| constructor(e, t, r) { | |
| this.root = e, | |
| this.queryParams = t, | |
| this.fragment = r | |
| } | |
| get queryParamMap() { | |
| return this._queryParamMap || (this._queryParamMap = Ko(this.queryParams)), | |
| this._queryParamMap | |
| } | |
| toString() { | |
| return c3.serialize(this) | |
| } | |
| } | |
| class Ie { | |
| constructor(e, t) { | |
| this.segments = e, | |
| this.children = t, | |
| this.parent = null, | |
| Bt(t, (r, i) => r.parent = this) | |
| } | |
| hasChildren() { | |
| return this.numberOfChildren > 0 | |
| } | |
| get numberOfChildren() { | |
| return Object.keys(this.children).length | |
| } | |
| toString() { | |
| return Gc(this) | |
| } | |
| } | |
| class Ta { | |
| constructor(e, t) { | |
| this.path = e, | |
| this.parameters = t | |
| } | |
| get parameterMap() { | |
| return this._parameterMap || (this._parameterMap = Ko(this.parameters)), | |
| this._parameterMap | |
| } | |
| toString() { | |
| return Tw(this) | |
| } | |
| } | |
| function qi(n, e) { | |
| return n.length === e.length && n.every( (t, r) => t.path === e[r].path) | |
| } | |
| let vw = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function() { | |
| return new qp | |
| }, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| class qp { | |
| parse(e) { | |
| const t = new y3(e); | |
| return new Gi(t.parseRootSegment(),t.parseQueryParams(),t.parseFragment()) | |
| } | |
| serialize(e) { | |
| const t = `/${Ea(e.root, !0)}` | |
| , r = function h3(n) { | |
| const e = Object.keys(n).map(t => { | |
| const r = n[t]; | |
| return Array.isArray(r) ? r.map(i => `${qc(t)}=${qc(i)}`).join("&") : `${qc(t)}=${qc(r)}` | |
| } | |
| ).filter(t => !!t); | |
| return e.length ? `?${e.join("&")}` : "" | |
| }(e.queryParams); | |
| return `${t}${r}${"string" == typeof e.fragment ? `#${function u3(n) { | |
| return encodeURI(n) | |
| }(e.fragment)}` : ""}` | |
| } | |
| } | |
| const c3 = new qp; | |
| function Gc(n) { | |
| return n.segments.map(e => Tw(e)).join("/") | |
| } | |
| function Ea(n, e) { | |
| if (!n.hasChildren()) | |
| return Gc(n); | |
| if (e) { | |
| const t = n.children[De] ? Ea(n.children[De], !1) : "" | |
| , r = []; | |
| return Bt(n.children, (i, o) => { | |
| o !== De && r.push(`${o}:${Ea(i, !1)}`) | |
| } | |
| ), | |
| r.length > 0 ? `${t}(${r.join("//")})` : t | |
| } | |
| { | |
| const t = function l3(n, e) { | |
| let t = []; | |
| return Bt(n.children, (r, i) => { | |
| i === De && (t = t.concat(e(r, i))) | |
| } | |
| ), | |
| Bt(n.children, (r, i) => { | |
| i !== De && (t = t.concat(e(r, i))) | |
| } | |
| ), | |
| t | |
| }(n, (r, i) => i === De ? [Ea(n.children[De], !1)] : [`${i}:${Ea(r, !1)}`]); | |
| return 1 === Object.keys(n.children).length && null != n.children[De] ? `${Gc(n)}/${t[0]}` : `${Gc(n)}/(${t.join("//")})` | |
| } | |
| } | |
| function bw(n) { | |
| return encodeURIComponent(n).replace(/%40/g, "@").replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",") | |
| } | |
| function qc(n) { | |
| return bw(n).replace(/%3B/gi, ";") | |
| } | |
| function Kp(n) { | |
| return bw(n).replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/%26/gi, "&") | |
| } | |
| function Kc(n) { | |
| return decodeURIComponent(n) | |
| } | |
| function Cw(n) { | |
| return Kc(n.replace(/\+/g, "%20")) | |
| } | |
| function Tw(n) { | |
| return `${Kp(n.path)}${function d3(n) { | |
| return Object.keys(n).map(e => `;${Kp(e)}=${Kp(n[e])}`).join("") | |
| }(n.parameters)}` | |
| } | |
| const f3 = /^[^\/()?;=#]+/; | |
| function Qc(n) { | |
| const e = n.match(f3); | |
| return e ? e[0] : "" | |
| } | |
| const p3 = /^[^=?&#]+/ | |
| , m3 = /^[^&#]+/; | |
| class y3 { | |
| constructor(e) { | |
| this.url = e, | |
| this.remaining = e | |
| } | |
| parseRootSegment() { | |
| return this.consumeOptional("/"), | |
| "" === this.remaining || this.peekStartsWith("?") || this.peekStartsWith("#") ? new Ie([],{}) : new Ie([],this.parseChildren()) | |
| } | |
| parseQueryParams() { | |
| const e = {}; | |
| if (this.consumeOptional("?")) | |
| do { | |
| this.parseQueryParam(e) | |
| } while (this.consumeOptional("&")); | |
| return e | |
| } | |
| parseFragment() { | |
| return this.consumeOptional("#") ? decodeURIComponent(this.remaining) : null | |
| } | |
| parseChildren() { | |
| if ("" === this.remaining) | |
| return {}; | |
| this.consumeOptional("/"); | |
| const e = []; | |
| for (this.peekStartsWith("(") || e.push(this.parseSegment()); this.peekStartsWith("/") && !this.peekStartsWith("//") && !this.peekStartsWith("/("); ) | |
| this.capture("/"), | |
| e.push(this.parseSegment()); | |
| let t = {}; | |
| this.peekStartsWith("/(") && (this.capture("/"), | |
| t = this.parseParens(!0)); | |
| let r = {}; | |
| return this.peekStartsWith("(") && (r = this.parseParens(!1)), | |
| (e.length > 0 || Object.keys(t).length > 0) && (r[De] = new Ie(e,t)), | |
| r | |
| } | |
| parseSegment() { | |
| const e = Qc(this.remaining); | |
| if ("" === e && this.peekStartsWith(";")) | |
| throw new U(4009,!1); | |
| return this.capture(e), | |
| new Ta(Kc(e),this.parseMatrixParams()) | |
| } | |
| parseMatrixParams() { | |
| const e = {}; | |
| for (; this.consumeOptional(";"); ) | |
| this.parseParam(e); | |
| return e | |
| } | |
| parseParam(e) { | |
| const t = Qc(this.remaining); | |
| if (!t) | |
| return; | |
| this.capture(t); | |
| let r = ""; | |
| if (this.consumeOptional("=")) { | |
| const i = Qc(this.remaining); | |
| i && (r = i, | |
| this.capture(r)) | |
| } | |
| e[Kc(t)] = Kc(r) | |
| } | |
| parseQueryParam(e) { | |
| const t = function g3(n) { | |
| const e = n.match(p3); | |
| return e ? e[0] : "" | |
| }(this.remaining); | |
| if (!t) | |
| return; | |
| this.capture(t); | |
| let r = ""; | |
| if (this.consumeOptional("=")) { | |
| const s = function _3(n) { | |
| const e = n.match(m3); | |
| return e ? e[0] : "" | |
| }(this.remaining); | |
| s && (r = s, | |
| this.capture(r)) | |
| } | |
| const i = Cw(t) | |
| , o = Cw(r); | |
| if (e.hasOwnProperty(i)) { | |
| let s = e[i]; | |
| Array.isArray(s) || (s = [s], | |
| e[i] = s), | |
| s.push(o) | |
| } else | |
| e[i] = o | |
| } | |
| parseParens(e) { | |
| const t = {}; | |
| for (this.capture("("); !this.consumeOptional(")") && this.remaining.length > 0; ) { | |
| const r = Qc(this.remaining) | |
| , i = this.remaining[r.length]; | |
| if ("/" !== i && ")" !== i && ";" !== i) | |
| throw new U(4010,!1); | |
| let o; | |
| r.indexOf(":") > -1 ? (o = r.slice(0, r.indexOf(":")), | |
| this.capture(o), | |
| this.capture(":")) : e && (o = De); | |
| const s = this.parseChildren(); | |
| t[o] = 1 === Object.keys(s).length ? s[De] : new Ie([],s), | |
| this.consumeOptional("//") | |
| } | |
| return t | |
| } | |
| peekStartsWith(e) { | |
| return this.remaining.startsWith(e) | |
| } | |
| consumeOptional(e) { | |
| return !!this.peekStartsWith(e) && (this.remaining = this.remaining.substring(e.length), | |
| !0) | |
| } | |
| capture(e) { | |
| if (!this.consumeOptional(e)) | |
| throw new U(4011,!1) | |
| } | |
| } | |
| function Qp(n) { | |
| return n.segments.length > 0 ? new Ie([],{ | |
| [De]: n | |
| }) : n | |
| } | |
| function Yc(n) { | |
| const e = {}; | |
| for (const r of Object.keys(n.children)) { | |
| const o = Yc(n.children[r]); | |
| (o.segments.length > 0 || o.hasChildren()) && (e[r] = o) | |
| } | |
| return function v3(n) { | |
| if (1 === n.numberOfChildren && n.children[De]) { | |
| const e = n.children[De]; | |
| return new Ie(n.segments.concat(e.segments),e.children) | |
| } | |
| return n | |
| }(new Ie(n.segments,e)) | |
| } | |
| function Ki(n) { | |
| return n instanceof Gi | |
| } | |
| function T3(n, e, t, r, i) { | |
| var o; | |
| if (0 === t.length) | |
| return Qo(e.root, e.root, e.root, r, i); | |
| const a = function Dw(n) { | |
| if ("string" == typeof n[0] && 1 === n.length && "/" === n[0]) | |
| return new ww(!0,0,n); | |
| let e = 0 | |
| , t = !1; | |
| const r = n.reduce( (i, o, s) => { | |
| if ("object" == typeof o && null != o) { | |
| if (o.outlets) { | |
| const a = {}; | |
| return Bt(o.outlets, (l, c) => { | |
| a[c] = "string" == typeof l ? l.split("/") : l | |
| } | |
| ), | |
| [...i, { | |
| outlets: a | |
| }] | |
| } | |
| if (o.segmentPath) | |
| return [...i, o.segmentPath] | |
| } | |
| return "string" != typeof o ? [...i, o] : 0 === s ? (o.split("/").forEach( (a, l) => { | |
| 0 == l && "." === a || (0 == l && "" === a ? t = !0 : ".." === a ? e++ : "" != a && i.push(a)) | |
| } | |
| ), | |
| i) : [...i, o] | |
| } | |
| , []); | |
| return new ww(t,e,r) | |
| }(t); | |
| return a.toRoot() ? Qo(e.root, e.root, new Ie([],{}), r, i) : function l(u) { | |
| var d; | |
| const h = function w3(n, e, t, r) { | |
| if (n.isAbsolute) | |
| return new Yo(e.root,!0,0); | |
| if (-1 === r) | |
| return new Yo(t,t === e.root,0); | |
| return function Mw(n, e, t) { | |
| let r = n | |
| , i = e | |
| , o = t; | |
| for (; o > i; ) { | |
| if (o -= i, | |
| r = r.parent, | |
| !r) | |
| throw new U(4005,!1); | |
| i = r.segments.length | |
| } | |
| return new Yo(r,!1,i - o) | |
| }(t, r + (wa(n.commands[0]) ? 0 : 1), n.numberOfDoubleDots) | |
| }(a, e, null === (d = n.snapshot) || void 0 === d ? void 0 : d._urlSegment, u) | |
| , f = h.processChildren ? Ma(h.segmentGroup, h.index, a.commands) : Zp(h.segmentGroup, h.index, a.commands); | |
| return Qo(e.root, h.segmentGroup, f, r, i) | |
| }(null === (o = n.snapshot) || void 0 === o ? void 0 : o._lastPathIndex) | |
| } | |
| function wa(n) { | |
| return "object" == typeof n && null != n && !n.outlets && !n.segmentPath | |
| } | |
| function Da(n) { | |
| return "object" == typeof n && null != n && n.outlets | |
| } | |
| function Qo(n, e, t, r, i) { | |
| let s, o = {}; | |
| r && Bt(r, (l, c) => { | |
| o[c] = Array.isArray(l) ? l.map(u => `${u}`) : `${l}` | |
| } | |
| ), | |
| s = n === e ? t : Ew(n, e, t); | |
| const a = Qp(Yc(s)); | |
| return new Gi(a,o,i) | |
| } | |
| function Ew(n, e, t) { | |
| const r = {}; | |
| return Bt(n.children, (i, o) => { | |
| r[o] = i === e ? t : Ew(i, e, t) | |
| } | |
| ), | |
| new Ie(n.segments,r) | |
| } | |
| class ww { | |
| constructor(e, t, r) { | |
| if (this.isAbsolute = e, | |
| this.numberOfDoubleDots = t, | |
| this.commands = r, | |
| e && r.length > 0 && wa(r[0])) | |
| throw new U(4003,!1); | |
| const i = r.find(Da); | |
| if (i && i !== fw(r)) | |
| throw new U(4004,!1) | |
| } | |
| toRoot() { | |
| return this.isAbsolute && 1 === this.commands.length && "/" == this.commands[0] | |
| } | |
| } | |
| class Yo { | |
| constructor(e, t, r) { | |
| this.segmentGroup = e, | |
| this.processChildren = t, | |
| this.index = r | |
| } | |
| } | |
| function Zp(n, e, t) { | |
| if (n || (n = new Ie([],{})), | |
| 0 === n.segments.length && n.hasChildren()) | |
| return Ma(n, e, t); | |
| const r = function M3(n, e, t) { | |
| let r = 0 | |
| , i = e; | |
| const o = { | |
| match: !1, | |
| pathIndex: 0, | |
| commandIndex: 0 | |
| }; | |
| for (; i < n.segments.length; ) { | |
| if (r >= t.length) | |
| return o; | |
| const s = n.segments[i] | |
| , a = t[r]; | |
| if (Da(a)) | |
| break; | |
| const l = `${a}` | |
| , c = r < t.length - 1 ? t[r + 1] : null; | |
| if (i > 0 && void 0 === l) | |
| break; | |
| if (l && c && "object" == typeof c && void 0 === c.outlets) { | |
| if (!Iw(l, c, s)) | |
| return o; | |
| r += 2 | |
| } else { | |
| if (!Iw(l, {}, s)) | |
| return o; | |
| r++ | |
| } | |
| i++ | |
| } | |
| return { | |
| match: !0, | |
| pathIndex: i, | |
| commandIndex: r | |
| } | |
| }(n, e, t) | |
| , i = t.slice(r.commandIndex); | |
| if (r.match && r.pathIndex < n.segments.length) { | |
| const o = new Ie(n.segments.slice(0, r.pathIndex),{}); | |
| return o.children[De] = new Ie(n.segments.slice(r.pathIndex),n.children), | |
| Ma(o, 0, i) | |
| } | |
| return r.match && 0 === i.length ? new Ie(n.segments,{}) : r.match && !n.hasChildren() ? Xp(n, e, t) : r.match ? Ma(n, 0, i) : Xp(n, e, t) | |
| } | |
| function Ma(n, e, t) { | |
| if (0 === t.length) | |
| return new Ie(n.segments,{}); | |
| { | |
| const r = function D3(n) { | |
| return Da(n[0]) ? n[0].outlets : { | |
| [De]: n | |
| } | |
| }(t) | |
| , i = {}; | |
| return Bt(r, (o, s) => { | |
| "string" == typeof o && (o = [o]), | |
| null !== o && (i[s] = Zp(n.children[s], e, o)) | |
| } | |
| ), | |
| Bt(n.children, (o, s) => { | |
| void 0 === r[s] && (i[s] = o) | |
| } | |
| ), | |
| new Ie(n.segments,i) | |
| } | |
| } | |
| function Xp(n, e, t) { | |
| const r = n.segments.slice(0, e); | |
| let i = 0; | |
| for (; i < t.length; ) { | |
| const o = t[i]; | |
| if (Da(o)) { | |
| const l = A3(o.outlets); | |
| return new Ie(r,l) | |
| } | |
| if (0 === i && wa(t[0])) { | |
| r.push(new Ta(n.segments[e].path,Aw(t[0]))), | |
| i++; | |
| continue | |
| } | |
| const s = Da(o) ? o.outlets[De] : `${o}` | |
| , a = i < t.length - 1 ? t[i + 1] : null; | |
| s && a && wa(a) ? (r.push(new Ta(s,Aw(a))), | |
| i += 2) : (r.push(new Ta(s,{})), | |
| i++) | |
| } | |
| return new Ie(r,{}) | |
| } | |
| function A3(n) { | |
| const e = {}; | |
| return Bt(n, (t, r) => { | |
| "string" == typeof t && (t = [t]), | |
| null !== t && (e[r] = Xp(new Ie([],{}), 0, t)) | |
| } | |
| ), | |
| e | |
| } | |
| function Aw(n) { | |
| const e = {}; | |
| return Bt(n, (t, r) => e[r] = `${t}`), | |
| e | |
| } | |
| function Iw(n, e, t) { | |
| return n == t.path && br(e, t.parameters) | |
| } | |
| class jr { | |
| constructor(e, t) { | |
| this.id = e, | |
| this.url = t | |
| } | |
| } | |
| class Jp extends jr { | |
| constructor(e, t, r="imperative", i=null) { | |
| super(e, t), | |
| this.type = 0, | |
| this.navigationTrigger = r, | |
| this.restoredState = i | |
| } | |
| toString() { | |
| return `NavigationStart(id: ${this.id}, url: '${this.url}')` | |
| } | |
| } | |
| class Qi extends jr { | |
| constructor(e, t, r) { | |
| super(e, t), | |
| this.urlAfterRedirects = r, | |
| this.type = 1 | |
| } | |
| toString() { | |
| return `NavigationEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}')` | |
| } | |
| } | |
| class Zc extends jr { | |
| constructor(e, t, r, i) { | |
| super(e, t), | |
| this.reason = r, | |
| this.code = i, | |
| this.type = 2 | |
| } | |
| toString() { | |
| return `NavigationCancel(id: ${this.id}, url: '${this.url}')` | |
| } | |
| } | |
| class Sw extends jr { | |
| constructor(e, t, r, i) { | |
| super(e, t), | |
| this.error = r, | |
| this.target = i, | |
| this.type = 3 | |
| } | |
| toString() { | |
| return `NavigationError(id: ${this.id}, url: '${this.url}', error: ${this.error})` | |
| } | |
| } | |
| class I3 extends jr { | |
| constructor(e, t, r, i) { | |
| super(e, t), | |
| this.urlAfterRedirects = r, | |
| this.state = i, | |
| this.type = 4 | |
| } | |
| toString() { | |
| return `RoutesRecognized(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})` | |
| } | |
| } | |
| class S3 extends jr { | |
| constructor(e, t, r, i) { | |
| super(e, t), | |
| this.urlAfterRedirects = r, | |
| this.state = i, | |
| this.type = 7 | |
| } | |
| toString() { | |
| return `GuardsCheckStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})` | |
| } | |
| } | |
| class x3 extends jr { | |
| constructor(e, t, r, i, o) { | |
| super(e, t), | |
| this.urlAfterRedirects = r, | |
| this.state = i, | |
| this.shouldActivate = o, | |
| this.type = 8 | |
| } | |
| toString() { | |
| return `GuardsCheckEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state}, shouldActivate: ${this.shouldActivate})` | |
| } | |
| } | |
| class R3 extends jr { | |
| constructor(e, t, r, i) { | |
| super(e, t), | |
| this.urlAfterRedirects = r, | |
| this.state = i, | |
| this.type = 5 | |
| } | |
| toString() { | |
| return `ResolveStart(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})` | |
| } | |
| } | |
| class F3 extends jr { | |
| constructor(e, t, r, i) { | |
| super(e, t), | |
| this.urlAfterRedirects = r, | |
| this.state = i, | |
| this.type = 6 | |
| } | |
| toString() { | |
| return `ResolveEnd(id: ${this.id}, url: '${this.url}', urlAfterRedirects: '${this.urlAfterRedirects}', state: ${this.state})` | |
| } | |
| } | |
| class P3 { | |
| constructor(e) { | |
| this.route = e, | |
| this.type = 9 | |
| } | |
| toString() { | |
| return `RouteConfigLoadStart(path: ${this.route.path})` | |
| } | |
| } | |
| class O3 { | |
| constructor(e) { | |
| this.route = e, | |
| this.type = 10 | |
| } | |
| toString() { | |
| return `RouteConfigLoadEnd(path: ${this.route.path})` | |
| } | |
| } | |
| class N3 { | |
| constructor(e) { | |
| this.snapshot = e, | |
| this.type = 11 | |
| } | |
| toString() { | |
| return `ChildActivationStart(path: '${this.snapshot.routeConfig && this.snapshot.routeConfig.path || ""}')` | |
| } | |
| } | |
| class k3 { | |
| constructor(e) { | |
| this.snapshot = e, | |
| this.type = 12 | |
| } | |
| toString() { | |
| return `ChildActivationEnd(path: '${this.snapshot.routeConfig && this.snapshot.routeConfig.path || ""}')` | |
| } | |
| } | |
| class L3 { | |
| constructor(e) { | |
| this.snapshot = e, | |
| this.type = 13 | |
| } | |
| toString() { | |
| return `ActivationStart(path: '${this.snapshot.routeConfig && this.snapshot.routeConfig.path || ""}')` | |
| } | |
| } | |
| class V3 { | |
| constructor(e) { | |
| this.snapshot = e, | |
| this.type = 14 | |
| } | |
| toString() { | |
| return `ActivationEnd(path: '${this.snapshot.routeConfig && this.snapshot.routeConfig.path || ""}')` | |
| } | |
| } | |
| class xw { | |
| constructor(e, t, r) { | |
| this.routerEvent = e, | |
| this.position = t, | |
| this.anchor = r, | |
| this.type = 15 | |
| } | |
| toString() { | |
| return `Scroll(anchor: '${this.anchor}', position: '${this.position ? `${this.position[0]}, ${this.position[1]}` : null}')` | |
| } | |
| } | |
| class Rw { | |
| constructor(e) { | |
| this._root = e | |
| } | |
| get root() { | |
| return this._root.value | |
| } | |
| parent(e) { | |
| const t = this.pathFromRoot(e); | |
| return t.length > 1 ? t[t.length - 2] : null | |
| } | |
| children(e) { | |
| const t = eg(e, this._root); | |
| return t ? t.children.map(r => r.value) : [] | |
| } | |
| firstChild(e) { | |
| const t = eg(e, this._root); | |
| return t && t.children.length > 0 ? t.children[0].value : null | |
| } | |
| siblings(e) { | |
| const t = tg(e, this._root); | |
| return t.length < 2 ? [] : t[t.length - 2].children.map(i => i.value).filter(i => i !== e) | |
| } | |
| pathFromRoot(e) { | |
| return tg(e, this._root).map(t => t.value) | |
| } | |
| } | |
| function eg(n, e) { | |
| if (n === e.value) | |
| return e; | |
| for (const t of e.children) { | |
| const r = eg(n, t); | |
| if (r) | |
| return r | |
| } | |
| return null | |
| } | |
| function tg(n, e) { | |
| if (n === e.value) | |
| return [e]; | |
| for (const t of e.children) { | |
| const r = tg(n, t); | |
| if (r.length) | |
| return r.unshift(e), | |
| r | |
| } | |
| return [] | |
| } | |
| class Hr { | |
| constructor(e, t) { | |
| this.value = e, | |
| this.children = t | |
| } | |
| toString() { | |
| return `TreeNode(${this.value})` | |
| } | |
| } | |
| function Zo(n) { | |
| const e = {}; | |
| return n && n.children.forEach(t => e[t.value.outlet] = t), | |
| e | |
| } | |
| class Fw extends Rw { | |
| constructor(e, t) { | |
| super(e), | |
| this.snapshot = t, | |
| ng(this, e) | |
| } | |
| toString() { | |
| return this.snapshot.toString() | |
| } | |
| } | |
| function Pw(n, e) { | |
| const t = function U3(n, e) { | |
| const s = new Xc([],{},{},"",{},De,e,null,n.root,-1,{}); | |
| return new Nw("",new Hr(s,[])) | |
| }(n, e) | |
| , r = new Hn([new Ta("",{})]) | |
| , i = new Hn({}) | |
| , o = new Hn({}) | |
| , s = new Hn({}) | |
| , a = new Hn("") | |
| , l = new gi(r,i,s,a,o,De,e,t.root); | |
| return l.snapshot = t.root, | |
| new Fw(new Hr(l,[]),t) | |
| } | |
| class gi { | |
| constructor(e, t, r, i, o, s, a, l) { | |
| var c, u; | |
| this.url = e, | |
| this.params = t, | |
| this.queryParams = r, | |
| this.fragment = i, | |
| this.data = o, | |
| this.outlet = s, | |
| this.component = a, | |
| this.title = null !== (u = null === (c = this.data) || void 0 === c ? void 0 : c.pipe(Fe(d => d[Ca]))) && void 0 !== u ? u : le(void 0), | |
| this._futureSnapshot = l | |
| } | |
| get routeConfig() { | |
| return this._futureSnapshot.routeConfig | |
| } | |
| get root() { | |
| return this._routerState.root | |
| } | |
| get parent() { | |
| return this._routerState.parent(this) | |
| } | |
| get firstChild() { | |
| return this._routerState.firstChild(this) | |
| } | |
| get children() { | |
| return this._routerState.children(this) | |
| } | |
| get pathFromRoot() { | |
| return this._routerState.pathFromRoot(this) | |
| } | |
| get paramMap() { | |
| return this._paramMap || (this._paramMap = this.params.pipe(Fe(e => Ko(e)))), | |
| this._paramMap | |
| } | |
| get queryParamMap() { | |
| return this._queryParamMap || (this._queryParamMap = this.queryParams.pipe(Fe(e => Ko(e)))), | |
| this._queryParamMap | |
| } | |
| toString() { | |
| return this.snapshot ? this.snapshot.toString() : `Future(${this._futureSnapshot})` | |
| } | |
| } | |
| function Ow(n, e="emptyOnly") { | |
| const t = n.pathFromRoot; | |
| let r = 0; | |
| if ("always" !== e) | |
| for (r = t.length - 1; r >= 1; ) { | |
| const i = t[r] | |
| , o = t[r - 1]; | |
| if (i.routeConfig && "" === i.routeConfig.path) | |
| r--; | |
| else { | |
| if (o.component) | |
| break; | |
| r-- | |
| } | |
| } | |
| return function j3(n) { | |
| return n.reduce( (e, t) => { | |
| var r; | |
| return { | |
| params: Object.assign(Object.assign({}, e.params), t.params), | |
| data: Object.assign(Object.assign({}, e.data), t.data), | |
| resolve: Object.assign(Object.assign(Object.assign(Object.assign({}, t.data), e.resolve), null === (r = t.routeConfig) || void 0 === r ? void 0 : r.data), t._resolvedData) | |
| } | |
| } | |
| , { | |
| params: {}, | |
| data: {}, | |
| resolve: {} | |
| }) | |
| }(t.slice(r)) | |
| } | |
| class Xc { | |
| constructor(e, t, r, i, o, s, a, l, c, u, d, h) { | |
| var f; | |
| this.url = e, | |
| this.params = t, | |
| this.queryParams = r, | |
| this.fragment = i, | |
| this.data = o, | |
| this.outlet = s, | |
| this.component = a, | |
| this.title = null === (f = this.data) || void 0 === f ? void 0 : f[Ca], | |
| this.routeConfig = l, | |
| this._urlSegment = c, | |
| this._lastPathIndex = u, | |
| this._correctedLastPathIndex = null != h ? h : u, | |
| this._resolve = d | |
| } | |
| get root() { | |
| return this._routerState.root | |
| } | |
| get parent() { | |
| return this._routerState.parent(this) | |
| } | |
| get firstChild() { | |
| return this._routerState.firstChild(this) | |
| } | |
| get children() { | |
| return this._routerState.children(this) | |
| } | |
| get pathFromRoot() { | |
| return this._routerState.pathFromRoot(this) | |
| } | |
| get paramMap() { | |
| return this._paramMap || (this._paramMap = Ko(this.params)), | |
| this._paramMap | |
| } | |
| get queryParamMap() { | |
| return this._queryParamMap || (this._queryParamMap = Ko(this.queryParams)), | |
| this._queryParamMap | |
| } | |
| toString() { | |
| return `Route(url:'${this.url.map(r => r.toString()).join("/")}', path:'${this.routeConfig ? this.routeConfig.path : ""}')` | |
| } | |
| } | |
| class Nw extends Rw { | |
| constructor(e, t) { | |
| super(t), | |
| this.url = e, | |
| ng(this, t) | |
| } | |
| toString() { | |
| return kw(this._root) | |
| } | |
| } | |
| function ng(n, e) { | |
| e.value._routerState = n, | |
| e.children.forEach(t => ng(n, t)) | |
| } | |
| function kw(n) { | |
| const e = n.children.length > 0 ? ` { ${n.children.map(kw).join(", ")} } ` : ""; | |
| return `${n.value}${e}` | |
| } | |
| function rg(n) { | |
| if (n.snapshot) { | |
| const e = n.snapshot | |
| , t = n._futureSnapshot; | |
| n.snapshot = t, | |
| br(e.queryParams, t.queryParams) || n.queryParams.next(t.queryParams), | |
| e.fragment !== t.fragment && n.fragment.next(t.fragment), | |
| br(e.params, t.params) || n.params.next(t.params), | |
| function t3(n, e) { | |
| if (n.length !== e.length) | |
| return !1; | |
| for (let t = 0; t < n.length; ++t) | |
| if (!br(n[t], e[t])) | |
| return !1; | |
| return !0 | |
| }(e.url, t.url) || n.url.next(t.url), | |
| br(e.data, t.data) || n.data.next(t.data) | |
| } else | |
| n.snapshot = n._futureSnapshot, | |
| n.data.next(n._futureSnapshot.data) | |
| } | |
| function ig(n, e) { | |
| const t = br(n.params, e.params) && function a3(n, e) { | |
| return qi(n, e) && n.every( (t, r) => br(t.parameters, e[r].parameters)) | |
| }(n.url, e.url); | |
| return t && !(!n.parent != !e.parent) && (!n.parent || ig(n.parent, e.parent)) | |
| } | |
| function Aa(n, e, t) { | |
| if (t && n.shouldReuseRoute(e.value, t.value.snapshot)) { | |
| const r = t.value; | |
| r._futureSnapshot = e.value; | |
| const i = function z3(n, e, t) { | |
| return e.children.map(r => { | |
| for (const i of t.children) | |
| if (n.shouldReuseRoute(r.value, i.value.snapshot)) | |
| return Aa(n, r, i); | |
| return Aa(n, r) | |
| } | |
| ) | |
| }(n, e, t); | |
| return new Hr(r,i) | |
| } | |
| { | |
| if (n.shouldAttach(e.value)) { | |
| const o = n.retrieve(e.value); | |
| if (null !== o) { | |
| const s = o.route; | |
| return s.value._futureSnapshot = e.value, | |
| s.children = e.children.map(a => Aa(n, a)), | |
| s | |
| } | |
| } | |
| const r = function $3(n) { | |
| return new gi(new Hn(n.url),new Hn(n.params),new Hn(n.queryParams),new Hn(n.fragment),new Hn(n.data),n.outlet,n.component,n) | |
| }(e.value) | |
| , i = e.children.map(o => Aa(n, o)); | |
| return new Hr(r,i) | |
| } | |
| } | |
| const og = "ngNavigationCancelingError"; | |
| function Lw(n, e) { | |
| const {redirectTo: t, navigationBehaviorOptions: r} = Ki(e) ? { | |
| redirectTo: e, | |
| navigationBehaviorOptions: void 0 | |
| } : e | |
| , i = Vw(!1, 0, e); | |
| return i.url = t, | |
| i.navigationBehaviorOptions = r, | |
| i | |
| } | |
| function Vw(n, e, t) { | |
| const r = new Error("NavigationCancelingError: " + (n || "")); | |
| return r[og] = !0, | |
| r.cancellationCode = e, | |
| t && (r.url = t), | |
| r | |
| } | |
| function Bw(n) { | |
| return Uw(n) && Ki(n.url) | |
| } | |
| function Uw(n) { | |
| return n && n[og] | |
| } | |
| class W3 { | |
| constructor() { | |
| this.outlet = null, | |
| this.route = null, | |
| this.resolver = null, | |
| this.injector = null, | |
| this.children = new Ia, | |
| this.attachRef = null | |
| } | |
| } | |
| let Ia = ( () => { | |
| class n { | |
| constructor() { | |
| this.contexts = new Map | |
| } | |
| onChildOutletCreated(t, r) { | |
| const i = this.getOrCreateContext(t); | |
| i.outlet = r, | |
| this.contexts.set(t, i) | |
| } | |
| onChildOutletDestroyed(t) { | |
| const r = this.getContext(t); | |
| r && (r.outlet = null, | |
| r.attachRef = null) | |
| } | |
| onOutletDeactivated() { | |
| const t = this.contexts; | |
| return this.contexts = new Map, | |
| t | |
| } | |
| onOutletReAttached(t) { | |
| this.contexts = t | |
| } | |
| getOrCreateContext(t) { | |
| let r = this.getContext(t); | |
| return r || (r = new W3, | |
| this.contexts.set(t, r)), | |
| r | |
| } | |
| getContext(t) { | |
| return this.contexts.get(t) || null | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| const Jc = !1; | |
| let sg = ( () => { | |
| class n { | |
| constructor(t, r, i, o, s) { | |
| this.parentContexts = t, | |
| this.location = r, | |
| this.changeDetector = o, | |
| this.environmentInjector = s, | |
| this.activated = null, | |
| this._activatedRoute = null, | |
| this.activateEvents = new Se, | |
| this.deactivateEvents = new Se, | |
| this.attachEvents = new Se, | |
| this.detachEvents = new Se, | |
| this.name = i || De, | |
| t.onChildOutletCreated(this.name, this) | |
| } | |
| ngOnDestroy() { | |
| var t; | |
| (null === (t = this.parentContexts.getContext(this.name)) || void 0 === t ? void 0 : t.outlet) === this && this.parentContexts.onChildOutletDestroyed(this.name) | |
| } | |
| ngOnInit() { | |
| if (!this.activated) { | |
| const t = this.parentContexts.getContext(this.name); | |
| t && t.route && (t.attachRef ? this.attach(t.attachRef, t.route) : this.activateWith(t.route, t.injector)) | |
| } | |
| } | |
| get isActivated() { | |
| return !!this.activated | |
| } | |
| get component() { | |
| if (!this.activated) | |
| throw new U(4012,Jc); | |
| return this.activated.instance | |
| } | |
| get activatedRoute() { | |
| if (!this.activated) | |
| throw new U(4012,Jc); | |
| return this._activatedRoute | |
| } | |
| get activatedRouteData() { | |
| return this._activatedRoute ? this._activatedRoute.snapshot.data : {} | |
| } | |
| detach() { | |
| if (!this.activated) | |
| throw new U(4012,Jc); | |
| this.location.detach(); | |
| const t = this.activated; | |
| return this.activated = null, | |
| this._activatedRoute = null, | |
| this.detachEvents.emit(t.instance), | |
| t | |
| } | |
| attach(t, r) { | |
| this.activated = t, | |
| this._activatedRoute = r, | |
| this.location.insert(t.hostView), | |
| this.attachEvents.emit(t.instance) | |
| } | |
| deactivate() { | |
| if (this.activated) { | |
| const t = this.component; | |
| this.activated.destroy(), | |
| this.activated = null, | |
| this._activatedRoute = null, | |
| this.deactivateEvents.emit(t) | |
| } | |
| } | |
| activateWith(t, r) { | |
| if (this.isActivated) | |
| throw new U(4013,Jc); | |
| this._activatedRoute = t; | |
| const i = this.location | |
| , s = t._futureSnapshot.component | |
| , a = this.parentContexts.getOrCreateContext(this.name).children | |
| , l = new G3(t,a,i.injector); | |
| if (r && function q3(n) { | |
| return !!n.resolveComponentFactory | |
| }(r)) { | |
| const c = r.resolveComponentFactory(s); | |
| this.activated = i.createComponent(c, i.length, l) | |
| } else | |
| this.activated = i.createComponent(s, { | |
| index: i.length, | |
| injector: l, | |
| environmentInjector: null != r ? r : this.environmentInjector | |
| }); | |
| this.changeDetector.markForCheck(), | |
| this.activateEvents.emit(this.activated.instance) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Ia),B(tr),lo("name"),B(Bo),B(ti)) | |
| } | |
| , | |
| n.\u0275dir = ue({ | |
| type: n, | |
| selectors: [["router-outlet"]], | |
| outputs: { | |
| activateEvents: "activate", | |
| deactivateEvents: "deactivate", | |
| attachEvents: "attach", | |
| detachEvents: "detach" | |
| }, | |
| exportAs: ["outlet"], | |
| standalone: !0 | |
| }), | |
| n | |
| } | |
| )(); | |
| class G3 { | |
| constructor(e, t, r) { | |
| this.route = e, | |
| this.childContexts = t, | |
| this.parent = r | |
| } | |
| get(e, t) { | |
| return e === gi ? this.route : e === Ia ? this.childContexts : this.parent.get(e, t) | |
| } | |
| } | |
| let ag = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275cmp = dn({ | |
| type: n, | |
| selectors: [["ng-component"]], | |
| standalone: !0, | |
| features: [Tb], | |
| decls: 1, | |
| vars: 0, | |
| template: function(t, r) { | |
| 1 & t && Ct(0, "router-outlet") | |
| }, | |
| dependencies: [sg], | |
| encapsulation: 2 | |
| }), | |
| n | |
| } | |
| )(); | |
| function jw(n, e) { | |
| var t; | |
| return n.providers && !n._injector && (n._injector = Bl(n.providers, e, `Route: ${n.path}`)), | |
| null !== (t = n._injector) && void 0 !== t ? t : e | |
| } | |
| function cg(n) { | |
| const e = n.children && n.children.map(cg) | |
| , t = e ? Object.assign(Object.assign({}, n), { | |
| children: e | |
| }) : Object.assign({}, n); | |
| return !t.component && !t.loadComponent && (e || t.loadChildren) && t.outlet && t.outlet !== De && (t.component = ag), | |
| t | |
| } | |
| function zn(n) { | |
| return n.outlet || De | |
| } | |
| function Hw(n, e) { | |
| const t = n.filter(r => zn(r) === e); | |
| return t.push(...n.filter(r => zn(r) !== e)), | |
| t | |
| } | |
| function Sa(n) { | |
| var e; | |
| if (!n) | |
| return null; | |
| if (null !== (e = n.routeConfig) && void 0 !== e && e._injector) | |
| return n.routeConfig._injector; | |
| for (let t = n.parent; t; t = t.parent) { | |
| const r = t.routeConfig; | |
| if (null != r && r._loadedInjector) | |
| return r._loadedInjector; | |
| if (null != r && r._injector) | |
| return r._injector | |
| } | |
| return null | |
| } | |
| class X3 { | |
| constructor(e, t, r, i) { | |
| this.routeReuseStrategy = e, | |
| this.futureState = t, | |
| this.currState = r, | |
| this.forwardEvent = i | |
| } | |
| activate(e) { | |
| const t = this.futureState._root | |
| , r = this.currState ? this.currState._root : null; | |
| this.deactivateChildRoutes(t, r, e), | |
| rg(this.futureState.root), | |
| this.activateChildRoutes(t, r, e) | |
| } | |
| deactivateChildRoutes(e, t, r) { | |
| const i = Zo(t); | |
| e.children.forEach(o => { | |
| const s = o.value.outlet; | |
| this.deactivateRoutes(o, i[s], r), | |
| delete i[s] | |
| } | |
| ), | |
| Bt(i, (o, s) => { | |
| this.deactivateRouteAndItsChildren(o, r) | |
| } | |
| ) | |
| } | |
| deactivateRoutes(e, t, r) { | |
| const i = e.value | |
| , o = t ? t.value : null; | |
| if (i === o) | |
| if (i.component) { | |
| const s = r.getContext(i.outlet); | |
| s && this.deactivateChildRoutes(e, t, s.children) | |
| } else | |
| this.deactivateChildRoutes(e, t, r); | |
| else | |
| o && this.deactivateRouteAndItsChildren(t, r) | |
| } | |
| deactivateRouteAndItsChildren(e, t) { | |
| e.value.component && this.routeReuseStrategy.shouldDetach(e.value.snapshot) ? this.detachAndStoreRouteSubtree(e, t) : this.deactivateRouteAndOutlet(e, t) | |
| } | |
| detachAndStoreRouteSubtree(e, t) { | |
| const r = t.getContext(e.value.outlet) | |
| , i = r && e.value.component ? r.children : t | |
| , o = Zo(e); | |
| for (const s of Object.keys(o)) | |
| this.deactivateRouteAndItsChildren(o[s], i); | |
| if (r && r.outlet) { | |
| const s = r.outlet.detach() | |
| , a = r.children.onOutletDeactivated(); | |
| this.routeReuseStrategy.store(e.value.snapshot, { | |
| componentRef: s, | |
| route: e, | |
| contexts: a | |
| }) | |
| } | |
| } | |
| deactivateRouteAndOutlet(e, t) { | |
| const r = t.getContext(e.value.outlet) | |
| , i = r && e.value.component ? r.children : t | |
| , o = Zo(e); | |
| for (const s of Object.keys(o)) | |
| this.deactivateRouteAndItsChildren(o[s], i); | |
| r && r.outlet && (r.outlet.deactivate(), | |
| r.children.onOutletDeactivated(), | |
| r.attachRef = null, | |
| r.resolver = null, | |
| r.route = null) | |
| } | |
| activateChildRoutes(e, t, r) { | |
| const i = Zo(t); | |
| e.children.forEach(o => { | |
| this.activateRoutes(o, i[o.value.outlet], r), | |
| this.forwardEvent(new V3(o.value.snapshot)) | |
| } | |
| ), | |
| e.children.length && this.forwardEvent(new k3(e.value.snapshot)) | |
| } | |
| activateRoutes(e, t, r) { | |
| var i; | |
| const o = e.value | |
| , s = t ? t.value : null; | |
| if (rg(o), | |
| o === s) | |
| if (o.component) { | |
| const a = r.getOrCreateContext(o.outlet); | |
| this.activateChildRoutes(e, t, a.children) | |
| } else | |
| this.activateChildRoutes(e, t, r); | |
| else if (o.component) { | |
| const a = r.getOrCreateContext(o.outlet); | |
| if (this.routeReuseStrategy.shouldAttach(o.snapshot)) { | |
| const l = this.routeReuseStrategy.retrieve(o.snapshot); | |
| this.routeReuseStrategy.store(o.snapshot, null), | |
| a.children.onOutletReAttached(l.contexts), | |
| a.attachRef = l.componentRef, | |
| a.route = l.route.value, | |
| a.outlet && a.outlet.attach(l.componentRef, l.route.value), | |
| rg(l.route.value), | |
| this.activateChildRoutes(e, null, a.children) | |
| } else { | |
| const l = Sa(o.snapshot) | |
| , c = null !== (i = null == l ? void 0 : l.get(Ps)) && void 0 !== i ? i : null; | |
| a.attachRef = null, | |
| a.route = o, | |
| a.resolver = c, | |
| a.injector = l, | |
| a.outlet && a.outlet.activateWith(o, a.injector), | |
| this.activateChildRoutes(e, null, a.children) | |
| } | |
| } else | |
| this.activateChildRoutes(e, null, r) | |
| } | |
| } | |
| class zw { | |
| constructor(e) { | |
| this.path = e, | |
| this.route = this.path[this.path.length - 1] | |
| } | |
| } | |
| class eu { | |
| constructor(e, t) { | |
| this.component = e, | |
| this.route = t | |
| } | |
| } | |
| function J3(n, e, t) { | |
| const r = n._root; | |
| return xa(r, e ? e._root : null, t, [r.value]) | |
| } | |
| function Xo(n, e) { | |
| const t = Symbol() | |
| , r = e.get(n, t); | |
| return r === t ? "function" != typeof n || function xM(n) { | |
| return null !== za(n) | |
| }(n) ? e.get(n) : n : r | |
| } | |
| function xa(n, e, t, r, i={ | |
| canDeactivateChecks: [], | |
| canActivateChecks: [] | |
| }) { | |
| const o = Zo(e); | |
| return n.children.forEach(s => { | |
| (function tU(n, e, t, r, i={ | |
| canDeactivateChecks: [], | |
| canActivateChecks: [] | |
| }) { | |
| const o = n.value | |
| , s = e ? e.value : null | |
| , a = t ? t.getContext(n.value.outlet) : null; | |
| if (s && o.routeConfig === s.routeConfig) { | |
| const l = function nU(n, e, t) { | |
| if ("function" == typeof t) | |
| return t(n, e); | |
| switch (t) { | |
| case "pathParamsChange": | |
| return !qi(n.url, e.url); | |
| case "pathParamsOrQueryParamsChange": | |
| return !qi(n.url, e.url) || !br(n.queryParams, e.queryParams); | |
| case "always": | |
| return !0; | |
| case "paramsOrQueryParamsChange": | |
| return !ig(n, e) || !br(n.queryParams, e.queryParams); | |
| default: | |
| return !ig(n, e) | |
| } | |
| }(s, o, o.routeConfig.runGuardsAndResolvers); | |
| l ? i.canActivateChecks.push(new zw(r)) : (o.data = s.data, | |
| o._resolvedData = s._resolvedData), | |
| xa(n, e, o.component ? a ? a.children : null : t, r, i), | |
| l && a && a.outlet && a.outlet.isActivated && i.canDeactivateChecks.push(new eu(a.outlet.component,s)) | |
| } else | |
| s && Ra(e, a, i), | |
| i.canActivateChecks.push(new zw(r)), | |
| xa(n, null, o.component ? a ? a.children : null : t, r, i) | |
| } | |
| )(s, o[s.value.outlet], t, r.concat([s.value]), i), | |
| delete o[s.value.outlet] | |
| } | |
| ), | |
| Bt(o, (s, a) => Ra(s, t.getContext(a), i)), | |
| i | |
| } | |
| function Ra(n, e, t) { | |
| const r = Zo(n) | |
| , i = n.value; | |
| Bt(r, (o, s) => { | |
| Ra(o, i.component ? e ? e.children.getContext(s) : null : e, t) | |
| } | |
| ), | |
| t.canDeactivateChecks.push(new eu(i.component && e && e.outlet && e.outlet.isActivated ? e.outlet.component : null,i)) | |
| } | |
| function Fa(n) { | |
| return "function" == typeof n | |
| } | |
| function ug(n) { | |
| return n instanceof zc || "EmptyError" === (null == n ? void 0 : n.name) | |
| } | |
| const tu = Symbol("INITIAL_VALUE"); | |
| function Jo() { | |
| return vr(n => Up(n.map(e => e.pipe(Wo(1), kE(tu)))).pipe(Fe(e => { | |
| for (const t of e) | |
| if (!0 !== t) { | |
| if (t === tu) | |
| return tu; | |
| if (!1 === t || t instanceof Gi) | |
| return t | |
| } | |
| return !0 | |
| } | |
| ), Ur(e => e !== tu), Wo(1))) | |
| } | |
| function $w(n) { | |
| return function PD(...n) { | |
| return Rg(n) | |
| }(Qt(e => { | |
| if (Ki(e)) | |
| throw Lw(0, e) | |
| } | |
| ), Fe(e => !0 === e)) | |
| } | |
| const dg = { | |
| matched: !1, | |
| consumedSegments: [], | |
| remainingSegments: [], | |
| parameters: {}, | |
| positionalParamSegments: {} | |
| }; | |
| function Ww(n, e, t, r, i) { | |
| const o = hg(n, e, t); | |
| return o.matched ? function vU(n, e, t, r) { | |
| const i = e.canMatch; | |
| return i && 0 !== i.length ? le(i.map(s => { | |
| const a = Xo(s, n); | |
| return pi(function lU(n) { | |
| return n && Fa(n.canMatch) | |
| }(a) ? a.canMatch(e, t) : n.runInContext( () => a(e, t))) | |
| } | |
| )).pipe(Jo(), $w()) : le(!0) | |
| }(r = jw(e, r), e, t).pipe(Fe(s => !0 === s ? o : Object.assign({}, dg))) : le(o) | |
| } | |
| function hg(n, e, t) { | |
| var r; | |
| if ("" === e.path) | |
| return "full" === e.pathMatch && (n.hasChildren() || t.length > 0) ? Object.assign({}, dg) : { | |
| matched: !0, | |
| consumedSegments: [], | |
| remainingSegments: t, | |
| parameters: {}, | |
| positionalParamSegments: {} | |
| }; | |
| const o = (e.matcher || e3)(t, n, e); | |
| if (!o) | |
| return Object.assign({}, dg); | |
| const s = {}; | |
| Bt(o.posParams, (l, c) => { | |
| s[c] = l.path | |
| } | |
| ); | |
| const a = o.consumed.length > 0 ? Object.assign(Object.assign({}, s), o.consumed[o.consumed.length - 1].parameters) : s; | |
| return { | |
| matched: !0, | |
| consumedSegments: o.consumed, | |
| remainingSegments: t.slice(o.consumed.length), | |
| parameters: a, | |
| positionalParamSegments: null !== (r = o.posParams) && void 0 !== r ? r : {} | |
| } | |
| } | |
| function nu(n, e, t, r, i="corrected") { | |
| if (t.length > 0 && function TU(n, e, t) { | |
| return t.some(r => ru(n, e, r) && zn(r) !== De) | |
| }(n, t, r)) { | |
| const s = new Ie(e,function CU(n, e, t, r) { | |
| const i = {}; | |
| i[De] = r, | |
| r._sourceSegment = n, | |
| r._segmentIndexShift = e.length; | |
| for (const o of t) | |
| if ("" === o.path && zn(o) !== De) { | |
| const s = new Ie([],{}); | |
| s._sourceSegment = n, | |
| s._segmentIndexShift = e.length, | |
| i[zn(o)] = s | |
| } | |
| return i | |
| }(n, e, r, new Ie(t,n.children))); | |
| return s._sourceSegment = n, | |
| s._segmentIndexShift = e.length, | |
| { | |
| segmentGroup: s, | |
| slicedSegments: [] | |
| } | |
| } | |
| if (0 === t.length && function EU(n, e, t) { | |
| return t.some(r => ru(n, e, r)) | |
| }(n, t, r)) { | |
| const s = new Ie(n.segments,function bU(n, e, t, r, i, o) { | |
| const s = {}; | |
| for (const a of r) | |
| if (ru(n, t, a) && !i[zn(a)]) { | |
| const l = new Ie([],{}); | |
| l._sourceSegment = n, | |
| l._segmentIndexShift = "legacy" === o ? n.segments.length : e.length, | |
| s[zn(a)] = l | |
| } | |
| return Object.assign(Object.assign({}, i), s) | |
| }(n, e, t, r, n.children, i)); | |
| return s._sourceSegment = n, | |
| s._segmentIndexShift = e.length, | |
| { | |
| segmentGroup: s, | |
| slicedSegments: t | |
| } | |
| } | |
| const o = new Ie(n.segments,n.children); | |
| return o._sourceSegment = n, | |
| o._segmentIndexShift = e.length, | |
| { | |
| segmentGroup: o, | |
| slicedSegments: t | |
| } | |
| } | |
| function ru(n, e, t) { | |
| return (!(n.hasChildren() || e.length > 0) || "full" !== t.pathMatch) && "" === t.path | |
| } | |
| function Gw(n, e, t, r) { | |
| return !!(zn(n) === r || r !== De && ru(e, t, n)) && ("**" === n.path || hg(e, n, t).matched) | |
| } | |
| function qw(n, e, t) { | |
| return 0 === e.length && !n.children[t] | |
| } | |
| const iu = !1; | |
| class ou { | |
| constructor(e) { | |
| this.segmentGroup = e || null | |
| } | |
| } | |
| class Kw { | |
| constructor(e) { | |
| this.urlTree = e | |
| } | |
| } | |
| function Pa(n) { | |
| return ba(new ou(n)) | |
| } | |
| function Qw(n) { | |
| return ba(new Kw(n)) | |
| } | |
| class AU { | |
| constructor(e, t, r, i, o) { | |
| this.injector = e, | |
| this.configLoader = t, | |
| this.urlSerializer = r, | |
| this.urlTree = i, | |
| this.config = o, | |
| this.allowRedirects = !0 | |
| } | |
| apply() { | |
| const e = nu(this.urlTree.root, [], [], this.config).segmentGroup | |
| , t = new Ie(e.segments,e.children); | |
| return this.expandSegmentGroup(this.injector, this.config, t, De).pipe(Fe(o => this.createUrlTree(Yc(o), this.urlTree.queryParams, this.urlTree.fragment))).pipe(fi(o => { | |
| if (o instanceof Kw) | |
| return this.allowRedirects = !1, | |
| this.match(o.urlTree); | |
| throw o instanceof ou ? this.noMatchError(o) : o | |
| } | |
| )) | |
| } | |
| match(e) { | |
| return this.expandSegmentGroup(this.injector, this.config, e.root, De).pipe(Fe(i => this.createUrlTree(Yc(i), e.queryParams, e.fragment))).pipe(fi(i => { | |
| throw i instanceof ou ? this.noMatchError(i) : i | |
| } | |
| )) | |
| } | |
| noMatchError(e) { | |
| return new U(4002,iu) | |
| } | |
| createUrlTree(e, t, r) { | |
| const i = Qp(e); | |
| return new Gi(i,t,r) | |
| } | |
| expandSegmentGroup(e, t, r, i) { | |
| return 0 === r.segments.length && r.hasChildren() ? this.expandChildren(e, t, r).pipe(Fe(o => new Ie([],o))) : this.expandSegment(e, r, t, r.segments, i, !0) | |
| } | |
| expandChildren(e, t, r) { | |
| const i = []; | |
| for (const o of Object.keys(r.children)) | |
| "primary" === o ? i.unshift(o) : i.push(o); | |
| return wt(i).pipe(Wi(o => { | |
| const s = r.children[o] | |
| , a = Hw(t, o); | |
| return this.expandSegmentGroup(e, a, s, o).pipe(Fe(l => ({ | |
| segment: l, | |
| outlet: o | |
| }))) | |
| } | |
| ), cw( (o, s) => (o[s.outlet] = s.segment, | |
| o), {}), uw()) | |
| } | |
| expandSegment(e, t, r, i, o, s) { | |
| return wt(r).pipe(Wi(a => this.expandSegmentAgainstRoute(e, t, r, a, i, o, s).pipe(fi(c => { | |
| if (c instanceof ou) | |
| return le(null); | |
| throw c | |
| } | |
| ))), hi(a => !!a), fi( (a, l) => { | |
| if (ug(a)) | |
| return qw(t, i, o) ? le(new Ie([],{})) : Pa(t); | |
| throw a | |
| } | |
| )) | |
| } | |
| expandSegmentAgainstRoute(e, t, r, i, o, s, a) { | |
| return Gw(i, t, o, s) ? void 0 === i.redirectTo ? this.matchSegmentAgainstRoute(e, t, i, o, s) : a && this.allowRedirects ? this.expandSegmentAgainstRouteUsingRedirect(e, t, r, i, o, s) : Pa(t) : Pa(t) | |
| } | |
| expandSegmentAgainstRouteUsingRedirect(e, t, r, i, o, s) { | |
| return "**" === i.path ? this.expandWildCardWithParamsAgainstRouteUsingRedirect(e, r, i, s) : this.expandRegularSegmentAgainstRouteUsingRedirect(e, t, r, i, o, s) | |
| } | |
| expandWildCardWithParamsAgainstRouteUsingRedirect(e, t, r, i) { | |
| const o = this.applyRedirectCommands([], r.redirectTo, {}); | |
| return r.redirectTo.startsWith("/") ? Qw(o) : this.lineralizeSegments(r, o).pipe(Lt(s => { | |
| const a = new Ie(s,{}); | |
| return this.expandSegment(e, a, t, s, i, !1) | |
| } | |
| )) | |
| } | |
| expandRegularSegmentAgainstRouteUsingRedirect(e, t, r, i, o, s) { | |
| const {matched: a, consumedSegments: l, remainingSegments: c, positionalParamSegments: u} = hg(t, i, o); | |
| if (!a) | |
| return Pa(t); | |
| const d = this.applyRedirectCommands(l, i.redirectTo, u); | |
| return i.redirectTo.startsWith("/") ? Qw(d) : this.lineralizeSegments(i, d).pipe(Lt(h => this.expandSegment(e, t, r, h.concat(c), s, !1))) | |
| } | |
| matchSegmentAgainstRoute(e, t, r, i, o) { | |
| return "**" === r.path ? (e = jw(r, e), | |
| r.loadChildren ? (r._loadedRoutes ? le({ | |
| routes: r._loadedRoutes, | |
| injector: r._loadedInjector | |
| }) : this.configLoader.loadChildren(e, r)).pipe(Fe(a => (r._loadedRoutes = a.routes, | |
| r._loadedInjector = a.injector, | |
| new Ie(i,{})))) : le(new Ie(i,{}))) : Ww(t, r, i, e).pipe(vr( ({matched: s, consumedSegments: a, remainingSegments: l}) => { | |
| var c; | |
| return s ? (e = null !== (c = r._injector) && void 0 !== c ? c : e, | |
| this.getChildConfig(e, r, i).pipe(Lt(d => { | |
| var h; | |
| const f = null !== (h = d.injector) && void 0 !== h ? h : e | |
| , p = d.routes | |
| , {segmentGroup: _, slicedSegments: C} = nu(t, a, l, p) | |
| , S = new Ie(_.segments,_.children); | |
| if (0 === C.length && S.hasChildren()) | |
| return this.expandChildren(f, p, S).pipe(Fe(M => new Ie(a,M))); | |
| if (0 === p.length && 0 === C.length) | |
| return le(new Ie(a,{})); | |
| const R = zn(r) === o; | |
| return this.expandSegment(f, S, p, C, R ? De : o, !0).pipe(Fe(O => new Ie(a.concat(O.segments),O.children))) | |
| } | |
| ))) : Pa(t) | |
| } | |
| )) | |
| } | |
| getChildConfig(e, t, r) { | |
| return t.children ? le({ | |
| routes: t.children, | |
| injector: e | |
| }) : t.loadChildren ? void 0 !== t._loadedRoutes ? le({ | |
| routes: t._loadedRoutes, | |
| injector: t._loadedInjector | |
| }) : function yU(n, e, t, r) { | |
| const i = e.canLoad; | |
| return void 0 === i || 0 === i.length ? le(!0) : le(i.map(s => { | |
| const a = Xo(s, n); | |
| return pi(function iU(n) { | |
| return n && Fa(n.canLoad) | |
| }(a) ? a.canLoad(e, t) : n.runInContext( () => a(e, t))) | |
| } | |
| )).pipe(Jo(), $w()) | |
| }(e, t, r).pipe(Lt(i => i ? this.configLoader.loadChildren(e, t).pipe(Qt(o => { | |
| t._loadedRoutes = o.routes, | |
| t._loadedInjector = o.injector | |
| } | |
| )) : function DU(n) { | |
| return ba(Vw(iu, 3)) | |
| }())) : le({ | |
| routes: [], | |
| injector: e | |
| }) | |
| } | |
| lineralizeSegments(e, t) { | |
| let r = [] | |
| , i = t.root; | |
| for (; ; ) { | |
| if (r = r.concat(i.segments), | |
| 0 === i.numberOfChildren) | |
| return le(r); | |
| if (i.numberOfChildren > 1 || !i.children[De]) | |
| return ba(new U(4e3,iu)); | |
| i = i.children[De] | |
| } | |
| } | |
| applyRedirectCommands(e, t, r) { | |
| return this.applyRedirectCreateUrlTree(t, this.urlSerializer.parse(t), e, r) | |
| } | |
| applyRedirectCreateUrlTree(e, t, r, i) { | |
| const o = this.createSegmentGroup(e, t.root, r, i); | |
| return new Gi(o,this.createQueryParams(t.queryParams, this.urlTree.queryParams),t.fragment) | |
| } | |
| createQueryParams(e, t) { | |
| const r = {}; | |
| return Bt(e, (i, o) => { | |
| if ("string" == typeof i && i.startsWith(":")) { | |
| const a = i.substring(1); | |
| r[o] = t[a] | |
| } else | |
| r[o] = i | |
| } | |
| ), | |
| r | |
| } | |
| createSegmentGroup(e, t, r, i) { | |
| const o = this.createSegments(e, t.segments, r, i); | |
| let s = {}; | |
| return Bt(t.children, (a, l) => { | |
| s[l] = this.createSegmentGroup(e, a, r, i) | |
| } | |
| ), | |
| new Ie(o,s) | |
| } | |
| createSegments(e, t, r, i) { | |
| return t.map(o => o.path.startsWith(":") ? this.findPosParam(e, o, i) : this.findOrReturn(o, r)) | |
| } | |
| findPosParam(e, t, r) { | |
| const i = r[t.path.substring(1)]; | |
| if (!i) | |
| throw new U(4001,iu); | |
| return i | |
| } | |
| findOrReturn(e, t) { | |
| let r = 0; | |
| for (const i of t) { | |
| if (i.path === e.path) | |
| return t.splice(r), | |
| i; | |
| r++ | |
| } | |
| return e | |
| } | |
| } | |
| class SU { | |
| } | |
| class FU { | |
| constructor(e, t, r, i, o, s, a, l) { | |
| this.injector = e, | |
| this.rootComponentType = t, | |
| this.config = r, | |
| this.urlTree = i, | |
| this.url = o, | |
| this.paramsInheritanceStrategy = s, | |
| this.relativeLinkResolution = a, | |
| this.urlSerializer = l | |
| } | |
| recognize() { | |
| const e = nu(this.urlTree.root, [], [], this.config.filter(t => void 0 === t.redirectTo), this.relativeLinkResolution).segmentGroup; | |
| return this.processSegmentGroup(this.injector, this.config, e, De).pipe(Fe(t => { | |
| if (null === t) | |
| return null; | |
| const r = new Xc([],Object.freeze({}),Object.freeze(Object.assign({}, this.urlTree.queryParams)),this.urlTree.fragment,{},De,this.rootComponentType,null,this.urlTree.root,-1,{}) | |
| , i = new Hr(r,t) | |
| , o = new Nw(this.url,i); | |
| return this.inheritParamsAndData(o._root), | |
| o | |
| } | |
| )) | |
| } | |
| inheritParamsAndData(e) { | |
| const t = e.value | |
| , r = Ow(t, this.paramsInheritanceStrategy); | |
| t.params = Object.freeze(r.params), | |
| t.data = Object.freeze(r.data), | |
| e.children.forEach(i => this.inheritParamsAndData(i)) | |
| } | |
| processSegmentGroup(e, t, r, i) { | |
| return 0 === r.segments.length && r.hasChildren() ? this.processChildren(e, t, r) : this.processSegment(e, t, r, r.segments, i) | |
| } | |
| processChildren(e, t, r) { | |
| return wt(Object.keys(r.children)).pipe(Wi(i => { | |
| const o = r.children[i] | |
| , s = Hw(t, i); | |
| return this.processSegmentGroup(e, s, o, i) | |
| } | |
| ), cw( (i, o) => i && o ? (i.push(...o), | |
| i) : null), function ZB(n, e=!1) { | |
| return bt( (t, r) => { | |
| let i = 0; | |
| t.subscribe(pt(r, o => { | |
| const s = n(o, i++); | |
| (s || e) && r.next(o), | |
| !s && r.complete() | |
| } | |
| )) | |
| } | |
| ) | |
| }(i => null !== i), $c(null), uw(), Fe(i => { | |
| if (null === i) | |
| return null; | |
| const o = Yw(i); | |
| return function PU(n) { | |
| n.sort( (e, t) => e.value.outlet === De ? -1 : t.value.outlet === De ? 1 : e.value.outlet.localeCompare(t.value.outlet)) | |
| }(o), | |
| o | |
| } | |
| )) | |
| } | |
| processSegment(e, t, r, i, o) { | |
| return wt(t).pipe(Wi(s => { | |
| var a; | |
| return this.processSegmentAgainstRoute(null !== (a = s._injector) && void 0 !== a ? a : e, s, r, i, o) | |
| } | |
| ), hi(s => !!s), fi(s => { | |
| if (ug(s)) | |
| return qw(r, i, o) ? le([]) : le(null); | |
| throw s | |
| } | |
| )) | |
| } | |
| processSegmentAgainstRoute(e, t, r, i, o) { | |
| var s, a; | |
| if (t.redirectTo || !Gw(t, r, i, o)) | |
| return le(null); | |
| let l; | |
| if ("**" === t.path) { | |
| const c = i.length > 0 ? fw(i).parameters : {} | |
| , u = Xw(r) + i.length; | |
| l = le({ | |
| snapshot: new Xc(i,c,Object.freeze(Object.assign({}, this.urlTree.queryParams)),this.urlTree.fragment,eD(t),zn(t),null !== (a = null !== (s = t.component) && void 0 !== s ? s : t._loadedComponent) && void 0 !== a ? a : null,t,Zw(r),u,tD(t),u), | |
| consumedSegments: [], | |
| remainingSegments: [] | |
| }) | |
| } else | |
| l = Ww(r, t, i, e).pipe(Fe( ({matched: c, consumedSegments: u, remainingSegments: d, parameters: h}) => { | |
| var f, p; | |
| if (!c) | |
| return null; | |
| const _ = Xw(r) + u.length; | |
| return { | |
| snapshot: new Xc(u,h,Object.freeze(Object.assign({}, this.urlTree.queryParams)),this.urlTree.fragment,eD(t),zn(t),null !== (p = null !== (f = t.component) && void 0 !== f ? f : t._loadedComponent) && void 0 !== p ? p : null,t,Zw(r),_,tD(t),_), | |
| consumedSegments: u, | |
| remainingSegments: d | |
| } | |
| } | |
| )); | |
| return l.pipe(vr(c => { | |
| var u, d; | |
| if (null === c) | |
| return le(null); | |
| const {snapshot: h, consumedSegments: f, remainingSegments: p} = c; | |
| e = null !== (u = t._injector) && void 0 !== u ? u : e; | |
| const _ = null !== (d = t._loadedInjector) && void 0 !== d ? d : e | |
| , C = function OU(n) { | |
| return n.children ? n.children : n.loadChildren ? n._loadedRoutes : [] | |
| }(t) | |
| , {segmentGroup: S, slicedSegments: R} = nu(r, f, p, C.filter(O => void 0 === O.redirectTo), this.relativeLinkResolution); | |
| if (0 === R.length && S.hasChildren()) | |
| return this.processChildren(_, C, S).pipe(Fe(O => null === O ? null : [new Hr(h,O)])); | |
| if (0 === C.length && 0 === R.length) | |
| return le([new Hr(h,[])]); | |
| const v = zn(t) === o; | |
| return this.processSegment(_, C, S, R, v ? De : o).pipe(Fe(O => null === O ? null : [new Hr(h,O)])) | |
| } | |
| )) | |
| } | |
| } | |
| function NU(n) { | |
| const e = n.value.routeConfig; | |
| return e && "" === e.path && void 0 === e.redirectTo | |
| } | |
| function Yw(n) { | |
| const e = [] | |
| , t = new Set; | |
| for (const r of n) { | |
| if (!NU(r)) { | |
| e.push(r); | |
| continue | |
| } | |
| const i = e.find(o => r.value.routeConfig === o.value.routeConfig); | |
| void 0 !== i ? (i.children.push(...r.children), | |
| t.add(i)) : e.push(r) | |
| } | |
| for (const r of t) { | |
| const i = Yw(r.children); | |
| e.push(new Hr(r.value,i)) | |
| } | |
| return e.filter(r => !t.has(r)) | |
| } | |
| function Zw(n) { | |
| let e = n; | |
| for (; e._sourceSegment; ) | |
| e = e._sourceSegment; | |
| return e | |
| } | |
| function Xw(n) { | |
| var e, t; | |
| let r = n | |
| , i = null !== (e = r._segmentIndexShift) && void 0 !== e ? e : 0; | |
| for (; r._sourceSegment; ) | |
| r = r._sourceSegment, | |
| i += null !== (t = r._segmentIndexShift) && void 0 !== t ? t : 0; | |
| return i - 1 | |
| } | |
| function eD(n) { | |
| return n.data || {} | |
| } | |
| function tD(n) { | |
| return n.resolve || {} | |
| } | |
| function nD(n) { | |
| return "string" == typeof n.title || null === n.title | |
| } | |
| function fg(n) { | |
| return vr(e => { | |
| const t = n(e); | |
| return t ? wt(t).pipe(Fe( () => e)) : le(e) | |
| } | |
| ) | |
| } | |
| let rD = ( () => { | |
| class n { | |
| buildTitle(t) { | |
| var r; | |
| let i, o = t.root; | |
| for (; void 0 !== o; ) | |
| i = null !== (r = this.getResolvedTitleForRoute(o)) && void 0 !== r ? r : i, | |
| o = o.children.find(s => s.outlet === De); | |
| return i | |
| } | |
| getResolvedTitleForRoute(t) { | |
| return t.data[Ca] | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function() { | |
| return ot(iD) | |
| }, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )() | |
| , iD = ( () => { | |
| class n extends rD { | |
| constructor(t) { | |
| super(), | |
| this.title = t | |
| } | |
| updateTitle(t) { | |
| const r = this.buildTitle(t); | |
| void 0 !== r && this.title.setTitle(r) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(AC)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| class zU { | |
| } | |
| class WU extends class $U { | |
| shouldDetach(e) { | |
| return !1 | |
| } | |
| store(e, t) {} | |
| shouldAttach(e) { | |
| return !1 | |
| } | |
| retrieve(e) { | |
| return null | |
| } | |
| shouldReuseRoute(e, t) { | |
| return e.routeConfig === t.routeConfig | |
| } | |
| } | |
| { | |
| } | |
| const au = new ee("",{ | |
| providedIn: "root", | |
| factory: () => ({}) | |
| }) | |
| , pg = new ee("ROUTES"); | |
| let gg = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this.injector = t, | |
| this.compiler = r, | |
| this.componentLoaders = new WeakMap, | |
| this.childrenLoaders = new WeakMap | |
| } | |
| loadComponent(t) { | |
| if (this.componentLoaders.get(t)) | |
| return this.componentLoaders.get(t); | |
| if (t._loadedComponent) | |
| return le(t._loadedComponent); | |
| this.onLoadStartListener && this.onLoadStartListener(t); | |
| const r = pi(t.loadComponent()).pipe(Qt(o => { | |
| this.onLoadEndListener && this.onLoadEndListener(t), | |
| t._loadedComponent = o | |
| } | |
| ), Wp( () => { | |
| this.componentLoaders.delete(t) | |
| } | |
| )) | |
| , i = new aw(r, () => new un).pipe(zp()); | |
| return this.componentLoaders.set(t, i), | |
| i | |
| } | |
| loadChildren(t, r) { | |
| if (this.childrenLoaders.get(r)) | |
| return this.childrenLoaders.get(r); | |
| if (r._loadedRoutes) | |
| return le({ | |
| routes: r._loadedRoutes, | |
| injector: r._loadedInjector | |
| }); | |
| this.onLoadStartListener && this.onLoadStartListener(r); | |
| const o = this.loadModuleFactoryOrRoutes(r.loadChildren).pipe(Fe(a => { | |
| this.onLoadEndListener && this.onLoadEndListener(r); | |
| let l, c, u = !1; | |
| Array.isArray(a) ? c = a : (l = a.create(t).injector, | |
| c = hw(l.get(pg, [], he.Self | he.Optional))); | |
| return { | |
| routes: c.map(cg), | |
| injector: l | |
| } | |
| } | |
| ), Wp( () => { | |
| this.childrenLoaders.delete(r) | |
| } | |
| )) | |
| , s = new aw(o, () => new un).pipe(zp()); | |
| return this.childrenLoaders.set(r, s), | |
| s | |
| } | |
| loadModuleFactoryOrRoutes(t) { | |
| return pi(t()).pipe(Lt(r => r instanceof bb || Array.isArray(r) ? le(r) : wt(this.compiler.compileModuleAsync(r)))) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(On),Q(tf)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| class qU { | |
| } | |
| class KU { | |
| shouldProcessUrl(e) { | |
| return !0 | |
| } | |
| extract(e) { | |
| return e | |
| } | |
| merge(e, t) { | |
| return e | |
| } | |
| } | |
| function QU(n) { | |
| throw n | |
| } | |
| function YU(n, e, t) { | |
| return e.parse("/") | |
| } | |
| const ZU = { | |
| paths: "exact", | |
| fragment: "ignored", | |
| matrixParams: "ignored", | |
| queryParams: "exact" | |
| } | |
| , XU = { | |
| paths: "subset", | |
| fragment: "ignored", | |
| matrixParams: "ignored", | |
| queryParams: "subset" | |
| }; | |
| function sD() { | |
| var n, e; | |
| const t = ot(vw) | |
| , r = ot(Ia) | |
| , i = ot(_f) | |
| , o = ot(On) | |
| , s = ot(tf) | |
| , a = null !== (n = ot(pg, { | |
| optional: !0 | |
| })) && void 0 !== n ? n : [] | |
| , l = null !== (e = ot(au, { | |
| optional: !0 | |
| })) && void 0 !== e ? e : {} | |
| , c = ot(iD) | |
| , u = ot(rD, { | |
| optional: !0 | |
| }) | |
| , d = ot(qU, { | |
| optional: !0 | |
| }) | |
| , h = ot(zU, { | |
| optional: !0 | |
| }) | |
| , f = new Nt(null,t,r,i,o,s,hw(a)); | |
| return d && (f.urlHandlingStrategy = d), | |
| h && (f.routeReuseStrategy = h), | |
| f.titleStrategy = null != u ? u : c, | |
| function JU(n, e) { | |
| n.errorHandler && (e.errorHandler = n.errorHandler), | |
| n.malformedUriErrorHandler && (e.malformedUriErrorHandler = n.malformedUriErrorHandler), | |
| n.onSameUrlNavigation && (e.onSameUrlNavigation = n.onSameUrlNavigation), | |
| n.paramsInheritanceStrategy && (e.paramsInheritanceStrategy = n.paramsInheritanceStrategy), | |
| n.relativeLinkResolution && (e.relativeLinkResolution = n.relativeLinkResolution), | |
| n.urlUpdateStrategy && (e.urlUpdateStrategy = n.urlUpdateStrategy), | |
| n.canceledNavigationResolution && (e.canceledNavigationResolution = n.canceledNavigationResolution) | |
| }(l, f), | |
| f | |
| } | |
| let Nt = ( () => { | |
| class n { | |
| constructor(t, r, i, o, s, a, l) { | |
| this.rootComponentType = t, | |
| this.urlSerializer = r, | |
| this.rootContexts = i, | |
| this.location = o, | |
| this.config = l, | |
| this.lastSuccessfulNavigation = null, | |
| this.currentNavigation = null, | |
| this.disposed = !1, | |
| this.navigationId = 0, | |
| this.currentPageId = 0, | |
| this.isNgZoneEnabled = !1, | |
| this.events = new un, | |
| this.errorHandler = QU, | |
| this.malformedUriErrorHandler = YU, | |
| this.navigated = !1, | |
| this.lastSuccessfulId = -1, | |
| this.afterPreactivation = () => le(void 0), | |
| this.urlHandlingStrategy = new KU, | |
| this.routeReuseStrategy = new WU, | |
| this.onSameUrlNavigation = "ignore", | |
| this.paramsInheritanceStrategy = "emptyOnly", | |
| this.urlUpdateStrategy = "deferred", | |
| this.relativeLinkResolution = "corrected", | |
| this.canceledNavigationResolution = "replace", | |
| this.configLoader = s.get(gg), | |
| this.configLoader.onLoadEndListener = h => this.triggerEvent(new O3(h)), | |
| this.configLoader.onLoadStartListener = h => this.triggerEvent(new P3(h)), | |
| this.ngModule = s.get(ki), | |
| this.console = s.get(lP); | |
| const d = s.get(nt); | |
| this.isNgZoneEnabled = d instanceof nt && nt.isInAngularZone(), | |
| this.resetConfig(l), | |
| this.currentUrlTree = function n3() { | |
| return new Gi(new Ie([],{}),{},null) | |
| }(), | |
| this.rawUrlTree = this.currentUrlTree, | |
| this.browserUrlTree = this.currentUrlTree, | |
| this.routerState = Pw(this.currentUrlTree, this.rootComponentType), | |
| this.transitions = new Hn({ | |
| id: 0, | |
| targetPageId: 0, | |
| currentUrlTree: this.currentUrlTree, | |
| currentRawUrl: this.currentUrlTree, | |
| extractedUrl: this.urlHandlingStrategy.extract(this.currentUrlTree), | |
| urlAfterRedirects: this.urlHandlingStrategy.extract(this.currentUrlTree), | |
| rawUrl: this.currentUrlTree, | |
| extras: {}, | |
| resolve: null, | |
| reject: null, | |
| promise: Promise.resolve(!0), | |
| source: "imperative", | |
| restoredState: null, | |
| currentSnapshot: this.routerState.snapshot, | |
| targetSnapshot: null, | |
| currentRouterState: this.routerState, | |
| targetRouterState: null, | |
| guards: { | |
| canActivateChecks: [], | |
| canDeactivateChecks: [] | |
| }, | |
| guardsResult: null | |
| }), | |
| this.navigations = this.setupNavigations(this.transitions), | |
| this.processNavigations() | |
| } | |
| get browserPageId() { | |
| var t; | |
| return null === (t = this.location.getState()) || void 0 === t ? void 0 : t.\u0275routerPageId | |
| } | |
| setupNavigations(t) { | |
| const r = this.events; | |
| return t.pipe(Ur(i => 0 !== i.id), Fe(i => Object.assign(Object.assign({}, i), { | |
| extractedUrl: this.urlHandlingStrategy.extract(i.rawUrl) | |
| })), vr(i => { | |
| let o = !1 | |
| , s = !1; | |
| return le(i).pipe(Qt(a => { | |
| this.currentNavigation = { | |
| id: a.id, | |
| initialUrl: a.rawUrl, | |
| extractedUrl: a.extractedUrl, | |
| trigger: a.source, | |
| extras: a.extras, | |
| previousNavigation: this.lastSuccessfulNavigation ? Object.assign(Object.assign({}, this.lastSuccessfulNavigation), { | |
| previousNavigation: null | |
| }) : null | |
| } | |
| } | |
| ), vr(a => { | |
| const l = this.browserUrlTree.toString() | |
| , c = !this.navigated || a.extractedUrl.toString() !== l || l !== this.currentUrlTree.toString(); | |
| if (("reload" === this.onSameUrlNavigation || c) && this.urlHandlingStrategy.shouldProcessUrl(a.rawUrl)) | |
| return aD(a.source) && (this.browserUrlTree = a.extractedUrl), | |
| le(a).pipe(vr(d => { | |
| const h = this.transitions.getValue(); | |
| return r.next(new Jp(d.id,this.serializeUrl(d.extractedUrl),d.source,d.restoredState)), | |
| h !== this.transitions.getValue() ? Tr : Promise.resolve(d) | |
| } | |
| ), function IU(n, e, t, r) { | |
| return vr(i => function MU(n, e, t, r, i) { | |
| return new AU(n,e,t,r,i).apply() | |
| }(n, e, t, i.extractedUrl, r).pipe(Fe(o => Object.assign(Object.assign({}, i), { | |
| urlAfterRedirects: o | |
| })))) | |
| }(this.ngModule.injector, this.configLoader, this.urlSerializer, this.config), Qt(d => { | |
| this.currentNavigation = Object.assign(Object.assign({}, this.currentNavigation), { | |
| finalUrl: d.urlAfterRedirects | |
| }), | |
| i.urlAfterRedirects = d.urlAfterRedirects | |
| } | |
| ), function LU(n, e, t, r, i, o) { | |
| return Lt(s => function RU(n, e, t, r, i, o, s="emptyOnly", a="legacy") { | |
| return new FU(n,e,t,r,i,s,a,o).recognize().pipe(vr(l => null === l ? function xU(n) { | |
| return new vt(e => e.error(n)) | |
| }(new SU) : le(l))) | |
| }(n, e, t, s.urlAfterRedirects, r.serialize(s.urlAfterRedirects), r, i, o).pipe(Fe(a => Object.assign(Object.assign({}, s), { | |
| targetSnapshot: a | |
| })))) | |
| }(this.ngModule.injector, this.rootComponentType, this.config, this.urlSerializer, this.paramsInheritanceStrategy, this.relativeLinkResolution), Qt(d => { | |
| if (i.targetSnapshot = d.targetSnapshot, | |
| "eager" === this.urlUpdateStrategy) { | |
| if (!d.extras.skipLocationChange) { | |
| const f = this.urlHandlingStrategy.merge(d.urlAfterRedirects, d.rawUrl); | |
| this.setBrowserUrl(f, d) | |
| } | |
| this.browserUrlTree = d.urlAfterRedirects | |
| } | |
| const h = new I3(d.id,this.serializeUrl(d.extractedUrl),this.serializeUrl(d.urlAfterRedirects),d.targetSnapshot); | |
| r.next(h) | |
| } | |
| )); | |
| if (c && this.rawUrlTree && this.urlHandlingStrategy.shouldProcessUrl(this.rawUrlTree)) { | |
| const {id: h, extractedUrl: f, source: p, restoredState: _, extras: C} = a | |
| , S = new Jp(h,this.serializeUrl(f),p,_); | |
| r.next(S); | |
| const R = Pw(f, this.rootComponentType).snapshot; | |
| return le(i = Object.assign(Object.assign({}, a), { | |
| targetSnapshot: R, | |
| urlAfterRedirects: f, | |
| extras: Object.assign(Object.assign({}, C), { | |
| skipLocationChange: !1, | |
| replaceUrl: !1 | |
| }) | |
| })) | |
| } | |
| return this.rawUrlTree = a.rawUrl, | |
| a.resolve(null), | |
| Tr | |
| } | |
| ), Qt(a => { | |
| const l = new S3(a.id,this.serializeUrl(a.extractedUrl),this.serializeUrl(a.urlAfterRedirects),a.targetSnapshot); | |
| this.triggerEvent(l) | |
| } | |
| ), Fe(a => i = Object.assign(Object.assign({}, a), { | |
| guards: J3(a.targetSnapshot, a.currentSnapshot, this.rootContexts) | |
| })), function uU(n, e) { | |
| return Lt(t => { | |
| const {targetSnapshot: r, currentSnapshot: i, guards: {canActivateChecks: o, canDeactivateChecks: s}} = t; | |
| return 0 === s.length && 0 === o.length ? le(Object.assign(Object.assign({}, t), { | |
| guardsResult: !0 | |
| })) : function dU(n, e, t, r) { | |
| return wt(n).pipe(Lt(i => function _U(n, e, t, r, i) { | |
| const o = e && e.routeConfig ? e.routeConfig.canDeactivate : null; | |
| return o && 0 !== o.length ? le(o.map(a => { | |
| var l; | |
| const c = null !== (l = Sa(e)) && void 0 !== l ? l : i | |
| , u = Xo(a, c); | |
| return pi(function aU(n) { | |
| return n && Fa(n.canDeactivate) | |
| }(u) ? u.canDeactivate(n, e, t, r) : c.runInContext( () => u(n, e, t, r))).pipe(hi()) | |
| } | |
| )).pipe(Jo()) : le(!0) | |
| }(i.component, i.route, t, e, r)), hi(i => !0 !== i, !0)) | |
| }(s, r, i, n).pipe(Lt(a => a && function rU(n) { | |
| return "boolean" == typeof n | |
| }(a) ? function hU(n, e, t, r) { | |
| return wt(e).pipe(Wi(i => Uc(function pU(n, e) { | |
| return null !== n && e && e(new N3(n)), | |
| le(!0) | |
| }(i.route.parent, r), function fU(n, e) { | |
| return null !== n && e && e(new L3(n)), | |
| le(!0) | |
| }(i.route, r), function mU(n, e, t) { | |
| const r = e[e.length - 1] | |
| , o = e.slice(0, e.length - 1).reverse().map(s => function eU(n) { | |
| const e = n.routeConfig ? n.routeConfig.canActivateChild : null; | |
| return e && 0 !== e.length ? { | |
| node: n, | |
| guards: e | |
| } : null | |
| }(s)).filter(s => null !== s).map(s => sw( () => le(s.guards.map(l => { | |
| var c; | |
| const u = null !== (c = Sa(s.node)) && void 0 !== c ? c : t | |
| , d = Xo(l, u); | |
| return pi(function sU(n) { | |
| return n && Fa(n.canActivateChild) | |
| }(d) ? d.canActivateChild(r, n) : u.runInContext( () => d(r, n))).pipe(hi()) | |
| } | |
| )).pipe(Jo()))); | |
| return le(o).pipe(Jo()) | |
| }(n, i.path, t), function gU(n, e, t) { | |
| const r = e.routeConfig ? e.routeConfig.canActivate : null; | |
| if (!r || 0 === r.length) | |
| return le(!0); | |
| const i = r.map(o => sw( () => { | |
| var s; | |
| const a = null !== (s = Sa(e)) && void 0 !== s ? s : t | |
| , l = Xo(o, a); | |
| return pi(function oU(n) { | |
| return n && Fa(n.canActivate) | |
| }(l) ? l.canActivate(e, n) : a.runInContext( () => l(e, n))).pipe(hi()) | |
| } | |
| )); | |
| return le(i).pipe(Jo()) | |
| }(n, i.route, t))), hi(i => !0 !== i, !0)) | |
| }(r, o, n, e) : le(a)), Fe(a => Object.assign(Object.assign({}, t), { | |
| guardsResult: a | |
| }))) | |
| } | |
| ) | |
| }(this.ngModule.injector, a => this.triggerEvent(a)), Qt(a => { | |
| if (i.guardsResult = a.guardsResult, | |
| Ki(a.guardsResult)) | |
| throw Lw(0, a.guardsResult); | |
| const l = new x3(a.id,this.serializeUrl(a.extractedUrl),this.serializeUrl(a.urlAfterRedirects),a.targetSnapshot,!!a.guardsResult); | |
| this.triggerEvent(l) | |
| } | |
| ), Ur(a => !!a.guardsResult || (this.restoreHistory(a), | |
| this.cancelNavigationTransition(a, "", 3), | |
| !1)), fg(a => { | |
| if (a.guards.canActivateChecks.length) | |
| return le(a).pipe(Qt(l => { | |
| const c = new R3(l.id,this.serializeUrl(l.extractedUrl),this.serializeUrl(l.urlAfterRedirects),l.targetSnapshot); | |
| this.triggerEvent(c) | |
| } | |
| ), vr(l => { | |
| let c = !1; | |
| return le(l).pipe(function VU(n, e) { | |
| return Lt(t => { | |
| const {targetSnapshot: r, guards: {canActivateChecks: i}} = t; | |
| if (!i.length) | |
| return le(t); | |
| let o = 0; | |
| return wt(i).pipe(Wi(s => function BU(n, e, t, r) { | |
| const i = n.routeConfig | |
| , o = n._resolve; | |
| return void 0 !== (null == i ? void 0 : i.title) && !nD(i) && (o[Ca] = i.title), | |
| function UU(n, e, t, r) { | |
| const i = function jU(n) { | |
| return [...Object.keys(n), ...Object.getOwnPropertySymbols(n)] | |
| }(n); | |
| if (0 === i.length) | |
| return le({}); | |
| const o = {}; | |
| return wt(i).pipe(Lt(s => function HU(n, e, t, r) { | |
| var i; | |
| const o = null !== (i = Sa(e)) && void 0 !== i ? i : r | |
| , s = Xo(n, o); | |
| return pi(s.resolve ? s.resolve(e, t) : o.runInContext( () => s(e, t))) | |
| }(n[s], e, t, r).pipe(hi(), Qt(a => { | |
| o[s] = a | |
| } | |
| ))), $p(1), function XB(n) { | |
| return Fe( () => n) | |
| }(o), fi(s => ug(s) ? Tr : ba(s))) | |
| }(o, n, e, r).pipe(Fe(s => (n._resolvedData = s, | |
| n.data = Ow(n, t).resolve, | |
| i && nD(i) && (n.data[Ca] = i.title), | |
| null))) | |
| }(s.route, r, n, e)), Qt( () => o++), $p(1), Lt(s => o === i.length ? le(t) : Tr)) | |
| } | |
| ) | |
| }(this.paramsInheritanceStrategy, this.ngModule.injector), Qt({ | |
| next: () => c = !0, | |
| complete: () => { | |
| c || (this.restoreHistory(l), | |
| this.cancelNavigationTransition(l, "", 2)) | |
| } | |
| })) | |
| } | |
| ), Qt(l => { | |
| const c = new F3(l.id,this.serializeUrl(l.extractedUrl),this.serializeUrl(l.urlAfterRedirects),l.targetSnapshot); | |
| this.triggerEvent(c) | |
| } | |
| )) | |
| } | |
| ), fg(a => { | |
| const l = c => { | |
| var u; | |
| const d = []; | |
| (null === (u = c.routeConfig) || void 0 === u ? void 0 : u.loadComponent) && !c.routeConfig._loadedComponent && d.push(this.configLoader.loadComponent(c.routeConfig).pipe(Qt(h => { | |
| c.component = h | |
| } | |
| ), Fe( () => {} | |
| ))); | |
| for (const h of c.children) | |
| d.push(...l(h)); | |
| return d | |
| } | |
| ; | |
| return Up(l(a.targetSnapshot.root)).pipe($c(), Wo(1)) | |
| } | |
| ), fg( () => this.afterPreactivation()), Fe(a => { | |
| const l = function H3(n, e, t) { | |
| const r = Aa(n, e._root, t ? t._root : void 0); | |
| return new Fw(r,e) | |
| }(this.routeReuseStrategy, a.targetSnapshot, a.currentRouterState); | |
| return i = Object.assign(Object.assign({}, a), { | |
| targetRouterState: l | |
| }) | |
| } | |
| ), Qt(a => { | |
| this.currentUrlTree = a.urlAfterRedirects, | |
| this.rawUrlTree = this.urlHandlingStrategy.merge(a.urlAfterRedirects, a.rawUrl), | |
| this.routerState = a.targetRouterState, | |
| "deferred" === this.urlUpdateStrategy && (a.extras.skipLocationChange || this.setBrowserUrl(this.rawUrlTree, a), | |
| this.browserUrlTree = a.urlAfterRedirects) | |
| } | |
| ), ( (n, e, t) => Fe(r => (new X3(e,r.targetRouterState,r.currentRouterState,t).activate(n), | |
| r)))(this.rootContexts, this.routeReuseStrategy, a => this.triggerEvent(a)), Qt({ | |
| next() { | |
| o = !0 | |
| }, | |
| complete() { | |
| o = !0 | |
| } | |
| }), Wp( () => { | |
| var a; | |
| o || s || this.cancelNavigationTransition(i, "", 1), | |
| (null === (a = this.currentNavigation) || void 0 === a ? void 0 : a.id) === i.id && (this.currentNavigation = null) | |
| } | |
| ), fi(a => { | |
| var l; | |
| if (s = !0, | |
| Uw(a)) { | |
| Bw(a) || (this.navigated = !0, | |
| this.restoreHistory(i, !0)); | |
| const c = new Zc(i.id,this.serializeUrl(i.extractedUrl),a.message,a.cancellationCode); | |
| if (r.next(c), | |
| Bw(a)) { | |
| const u = this.urlHandlingStrategy.merge(a.url, this.rawUrlTree) | |
| , d = { | |
| skipLocationChange: i.extras.skipLocationChange, | |
| replaceUrl: "eager" === this.urlUpdateStrategy || aD(i.source) | |
| }; | |
| this.scheduleNavigation(u, "imperative", null, d, { | |
| resolve: i.resolve, | |
| reject: i.reject, | |
| promise: i.promise | |
| }) | |
| } else | |
| i.resolve(!1) | |
| } else { | |
| this.restoreHistory(i, !0); | |
| const c = new Sw(i.id,this.serializeUrl(i.extractedUrl),a,null !== (l = i.targetSnapshot) && void 0 !== l ? l : void 0); | |
| r.next(c); | |
| try { | |
| i.resolve(this.errorHandler(a)) | |
| } catch (u) { | |
| i.reject(u) | |
| } | |
| } | |
| return Tr | |
| } | |
| )) | |
| } | |
| )) | |
| } | |
| resetRootComponentType(t) { | |
| this.rootComponentType = t, | |
| this.routerState.root.component = this.rootComponentType | |
| } | |
| setTransition(t) { | |
| this.transitions.next(Object.assign(Object.assign({}, this.transitions.value), t)) | |
| } | |
| initialNavigation() { | |
| this.setUpLocationChangeListener(), | |
| 0 === this.navigationId && this.navigateByUrl(this.location.path(!0), { | |
| replaceUrl: !0 | |
| }) | |
| } | |
| setUpLocationChangeListener() { | |
| this.locationSubscription || (this.locationSubscription = this.location.subscribe(t => { | |
| const r = "popstate" === t.type ? "popstate" : "hashchange"; | |
| "popstate" === r && setTimeout( () => { | |
| var i; | |
| const o = { | |
| replaceUrl: !0 | |
| } | |
| , s = null !== (i = t.state) && void 0 !== i && i.navigationId ? t.state : null; | |
| if (s) { | |
| const l = Object.assign({}, s); | |
| delete l.navigationId, | |
| delete l.\u0275routerPageId, | |
| 0 !== Object.keys(l).length && (o.state = l) | |
| } | |
| const a = this.parseUrl(t.url); | |
| this.scheduleNavigation(a, r, s, o) | |
| } | |
| , 0) | |
| } | |
| )) | |
| } | |
| get url() { | |
| return this.serializeUrl(this.currentUrlTree) | |
| } | |
| getCurrentNavigation() { | |
| return this.currentNavigation | |
| } | |
| triggerEvent(t) { | |
| this.events.next(t) | |
| } | |
| resetConfig(t) { | |
| this.config = t.map(cg), | |
| this.navigated = !1, | |
| this.lastSuccessfulId = -1 | |
| } | |
| ngOnDestroy() { | |
| this.dispose() | |
| } | |
| dispose() { | |
| this.transitions.complete(), | |
| this.locationSubscription && (this.locationSubscription.unsubscribe(), | |
| this.locationSubscription = void 0), | |
| this.disposed = !0 | |
| } | |
| createUrlTree(t, r={}) { | |
| const {relativeTo: i, queryParams: o, fragment: s, queryParamsHandling: a, preserveFragment: l} = r | |
| , c = i || this.routerState.root | |
| , u = l ? this.currentUrlTree.fragment : s; | |
| let d = null; | |
| switch (a) { | |
| case "merge": | |
| d = Object.assign(Object.assign({}, this.currentUrlTree.queryParams), o); | |
| break; | |
| case "preserve": | |
| d = this.currentUrlTree.queryParams; | |
| break; | |
| default: | |
| d = o || null | |
| } | |
| return null !== d && (d = this.removeEmptyProps(d)), | |
| T3(c, this.currentUrlTree, t, d, null != u ? u : null) | |
| } | |
| navigateByUrl(t, r={ | |
| skipLocationChange: !1 | |
| }) { | |
| const i = Ki(t) ? t : this.parseUrl(t) | |
| , o = this.urlHandlingStrategy.merge(i, this.rawUrlTree); | |
| return this.scheduleNavigation(o, "imperative", null, r) | |
| } | |
| navigate(t, r={ | |
| skipLocationChange: !1 | |
| }) { | |
| return function ej(n) { | |
| for (let e = 0; e < n.length; e++) { | |
| if (null == n[e]) | |
| throw new U(4008,false) | |
| } | |
| }(t), | |
| this.navigateByUrl(this.createUrlTree(t, r), r) | |
| } | |
| serializeUrl(t) { | |
| return this.urlSerializer.serialize(t) | |
| } | |
| parseUrl(t) { | |
| let r; | |
| try { | |
| r = this.urlSerializer.parse(t) | |
| } catch (i) { | |
| r = this.malformedUriErrorHandler(i, this.urlSerializer, t) | |
| } | |
| return r | |
| } | |
| isActive(t, r) { | |
| let i; | |
| if (i = !0 === r ? Object.assign({}, ZU) : !1 === r ? Object.assign({}, XU) : r, | |
| Ki(t)) | |
| return gw(this.currentUrlTree, t, i); | |
| const o = this.parseUrl(t); | |
| return gw(this.currentUrlTree, o, i) | |
| } | |
| removeEmptyProps(t) { | |
| return Object.keys(t).reduce( (r, i) => { | |
| const o = t[i]; | |
| return null != o && (r[i] = o), | |
| r | |
| } | |
| , {}) | |
| } | |
| processNavigations() { | |
| this.navigations.subscribe(t => { | |
| var r; | |
| this.navigated = !0, | |
| this.lastSuccessfulId = t.id, | |
| this.currentPageId = t.targetPageId, | |
| this.events.next(new Qi(t.id,this.serializeUrl(t.extractedUrl),this.serializeUrl(this.currentUrlTree))), | |
| this.lastSuccessfulNavigation = this.currentNavigation, | |
| null === (r = this.titleStrategy) || void 0 === r || r.updateTitle(this.routerState.snapshot), | |
| t.resolve(!0) | |
| } | |
| , t => { | |
| this.console.warn(`Unhandled Navigation Error: ${t}`) | |
| } | |
| ) | |
| } | |
| scheduleNavigation(t, r, i, o, s) { | |
| var a, l; | |
| if (this.disposed) | |
| return Promise.resolve(!1); | |
| let c, u, d; | |
| s ? (c = s.resolve, | |
| u = s.reject, | |
| d = s.promise) : d = new Promise( (p, _) => { | |
| c = p, | |
| u = _ | |
| } | |
| ); | |
| const h = ++this.navigationId; | |
| let f; | |
| return "computed" === this.canceledNavigationResolution ? (0 === this.currentPageId && (i = this.location.getState()), | |
| f = i && i.\u0275routerPageId ? i.\u0275routerPageId : o.replaceUrl || o.skipLocationChange ? null !== (a = this.browserPageId) && void 0 !== a ? a : 0 : (null !== (l = this.browserPageId) && void 0 !== l ? l : 0) + 1) : f = 0, | |
| this.setTransition({ | |
| id: h, | |
| targetPageId: f, | |
| source: r, | |
| restoredState: i, | |
| currentUrlTree: this.currentUrlTree, | |
| currentRawUrl: this.rawUrlTree, | |
| rawUrl: t, | |
| extras: o, | |
| resolve: c, | |
| reject: u, | |
| promise: d, | |
| currentSnapshot: this.routerState.snapshot, | |
| currentRouterState: this.routerState | |
| }), | |
| d.catch(p => Promise.reject(p)) | |
| } | |
| setBrowserUrl(t, r) { | |
| const i = this.urlSerializer.serialize(t) | |
| , o = Object.assign(Object.assign({}, r.extras.state), this.generateNgRouterState(r.id, r.targetPageId)); | |
| this.location.isCurrentPathEqualTo(i) || r.extras.replaceUrl ? this.location.replaceState(i, "", o) : this.location.go(i, "", o) | |
| } | |
| restoreHistory(t, r=!1) { | |
| var i, o; | |
| if ("computed" === this.canceledNavigationResolution) { | |
| const s = this.currentPageId - t.targetPageId; | |
| "popstate" !== t.source && "eager" !== this.urlUpdateStrategy && this.currentUrlTree !== (null === (i = this.currentNavigation) || void 0 === i ? void 0 : i.finalUrl) || 0 === s ? this.currentUrlTree === (null === (o = this.currentNavigation) || void 0 === o ? void 0 : o.finalUrl) && 0 === s && (this.resetState(t), | |
| this.browserUrlTree = t.currentUrlTree, | |
| this.resetUrlToCurrentUrlTree()) : this.location.historyGo(s) | |
| } else | |
| "replace" === this.canceledNavigationResolution && (r && this.resetState(t), | |
| this.resetUrlToCurrentUrlTree()) | |
| } | |
| resetState(t) { | |
| this.routerState = t.currentRouterState, | |
| this.currentUrlTree = t.currentUrlTree, | |
| this.rawUrlTree = this.urlHandlingStrategy.merge(this.currentUrlTree, t.rawUrl) | |
| } | |
| resetUrlToCurrentUrlTree() { | |
| this.location.replaceState(this.urlSerializer.serialize(this.rawUrlTree), "", this.generateNgRouterState(this.lastSuccessfulId, this.currentPageId)) | |
| } | |
| cancelNavigationTransition(t, r, i) { | |
| const o = new Zc(t.id,this.serializeUrl(t.extractedUrl),r,i); | |
| this.triggerEvent(o), | |
| t.resolve(!1) | |
| } | |
| generateNgRouterState(t, r) { | |
| return "computed" === this.canceledNavigationResolution ? { | |
| navigationId: t, | |
| \u0275routerPageId: r | |
| } : { | |
| navigationId: t | |
| } | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| eh() | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: function() { | |
| return sD() | |
| }, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| function aD(n) { | |
| return "imperative" !== n | |
| } | |
| class lD { | |
| } | |
| let rj = ( () => { | |
| class n { | |
| constructor(t, r, i, o, s) { | |
| this.router = t, | |
| this.injector = i, | |
| this.preloadingStrategy = o, | |
| this.loader = s | |
| } | |
| setUpPreloading() { | |
| this.subscription = this.router.events.pipe(Ur(t => t instanceof Qi), Wi( () => this.preload())).subscribe( () => {} | |
| ) | |
| } | |
| preload() { | |
| return this.processRoutes(this.injector, this.router.config) | |
| } | |
| ngOnDestroy() { | |
| this.subscription && this.subscription.unsubscribe() | |
| } | |
| processRoutes(t, r) { | |
| var i, o, s; | |
| const a = []; | |
| for (const l of r) { | |
| l.providers && !l._injector && (l._injector = Bl(l.providers, t, `Route: ${l.path}`)); | |
| const c = null !== (i = l._injector) && void 0 !== i ? i : t | |
| , u = null !== (o = l._loadedInjector) && void 0 !== o ? o : c; | |
| l.loadChildren && !l._loadedRoutes && void 0 === l.canLoad || l.loadComponent && !l._loadedComponent ? a.push(this.preloadConfig(c, l)) : (l.children || l._loadedRoutes) && a.push(this.processRoutes(u, null !== (s = l.children) && void 0 !== s ? s : l._loadedRoutes)) | |
| } | |
| return wt(a).pipe(Zi()) | |
| } | |
| preloadConfig(t, r) { | |
| return this.preloadingStrategy.preload(r, () => { | |
| let i; | |
| i = r.loadChildren && void 0 === r.canLoad ? this.loader.loadChildren(t, r) : le(null); | |
| const o = i.pipe(Lt(s => { | |
| var a; | |
| return null === s ? le(void 0) : (r._loadedRoutes = s.routes, | |
| r._loadedInjector = s.injector, | |
| this.processRoutes(null !== (a = s.injector) && void 0 !== a ? a : t, s.routes)) | |
| } | |
| )); | |
| return r.loadComponent && !r._loadedComponent ? wt([o, this.loader.loadComponent(r)]).pipe(Zi()) : o | |
| } | |
| ) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(Nt),Q(tf),Q(ti),Q(lD),Q(gg)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac, | |
| providedIn: "root" | |
| }), | |
| n | |
| } | |
| )(); | |
| const yg = new ee(""); | |
| let cD = ( () => { | |
| class n { | |
| constructor(t, r, i={}) { | |
| this.router = t, | |
| this.viewportScroller = r, | |
| this.options = i, | |
| this.lastId = 0, | |
| this.lastSource = "imperative", | |
| this.restoredId = 0, | |
| this.store = {}, | |
| i.scrollPositionRestoration = i.scrollPositionRestoration || "disabled", | |
| i.anchorScrolling = i.anchorScrolling || "disabled" | |
| } | |
| init() { | |
| "disabled" !== this.options.scrollPositionRestoration && this.viewportScroller.setHistoryScrollRestoration("manual"), | |
| this.routerEventsSubscription = this.createScrollEvents(), | |
| this.scrollEventsSubscription = this.consumeScrollEvents() | |
| } | |
| createScrollEvents() { | |
| return this.router.events.subscribe(t => { | |
| t instanceof Jp ? (this.store[this.lastId] = this.viewportScroller.getScrollPosition(), | |
| this.lastSource = t.navigationTrigger, | |
| this.restoredId = t.restoredState ? t.restoredState.navigationId : 0) : t instanceof Qi && (this.lastId = t.id, | |
| this.scheduleScrollEvent(t, this.router.parseUrl(t.urlAfterRedirects).fragment)) | |
| } | |
| ) | |
| } | |
| consumeScrollEvents() { | |
| return this.router.events.subscribe(t => { | |
| t instanceof xw && (t.position ? "top" === this.options.scrollPositionRestoration ? this.viewportScroller.scrollToPosition([0, 0]) : "enabled" === this.options.scrollPositionRestoration && this.viewportScroller.scrollToPosition(t.position) : t.anchor && "enabled" === this.options.anchorScrolling ? this.viewportScroller.scrollToAnchor(t.anchor) : "disabled" !== this.options.scrollPositionRestoration && this.viewportScroller.scrollToPosition([0, 0])) | |
| } | |
| ) | |
| } | |
| scheduleScrollEvent(t, r) { | |
| this.router.triggerEvent(new xw(t,"popstate" === this.lastSource ? this.store[this.restoredId] : null,r)) | |
| } | |
| ngOnDestroy() { | |
| this.routerEventsSubscription && this.routerEventsSubscription.unsubscribe(), | |
| this.scrollEventsSubscription && this.scrollEventsSubscription.unsubscribe() | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| eh() | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| function es(n, e) { | |
| return { | |
| \u0275kind: n, | |
| \u0275providers: e | |
| } | |
| } | |
| function vg(n) { | |
| return [{ | |
| provide: pg, | |
| multi: !0, | |
| useValue: n | |
| }] | |
| } | |
| function dD() { | |
| const n = ot(On); | |
| return e => { | |
| var t, r; | |
| const i = n.get(Xs); | |
| if (e !== i.components[0]) | |
| return; | |
| const o = n.get(Nt) | |
| , s = n.get(hD); | |
| 1 === n.get(bg) && o.initialNavigation(), | |
| null === (t = n.get(fD, null, he.Optional)) || void 0 === t || t.setUpPreloading(), | |
| null === (r = n.get(yg, null, he.Optional)) || void 0 === r || r.init(), | |
| o.resetRootComponentType(i.componentTypes[0]), | |
| s.closed || (s.next(), | |
| s.unsubscribe()) | |
| } | |
| } | |
| const hD = new ee("",{ | |
| factory: () => new un | |
| }) | |
| , bg = new ee("",{ | |
| providedIn: "root", | |
| factory: () => 1 | |
| }); | |
| const fD = new ee(""); | |
| function aj(n) { | |
| return es(0, [{ | |
| provide: fD, | |
| useExisting: rj | |
| }, { | |
| provide: lD, | |
| useExisting: n | |
| }]) | |
| } | |
| const pD = new ee("ROUTER_FORROOT_GUARD") | |
| , lj = [_f, { | |
| provide: vw, | |
| useClass: qp | |
| }, { | |
| provide: Nt, | |
| useFactory: sD | |
| }, Ia, { | |
| provide: gi, | |
| useFactory: function uD(n) { | |
| return n.routerState.root | |
| }, | |
| deps: [Nt] | |
| }, gg]; | |
| function cj() { | |
| return new m0("Router",Nt) | |
| } | |
| let gD = ( () => { | |
| class n { | |
| constructor(t) {} | |
| static forRoot(t, r) { | |
| return { | |
| ngModule: n, | |
| providers: [lj, [], vg(t), { | |
| provide: pD, | |
| useFactory: fj, | |
| deps: [[Nt, new Es, new ws]] | |
| }, { | |
| provide: au, | |
| useValue: r || {} | |
| }, null != r && r.useHash ? { | |
| provide: ii, | |
| useClass: YP | |
| } : { | |
| provide: ii, | |
| useClass: j0 | |
| }, { | |
| provide: yg, | |
| useFactory: () => { | |
| const n = ot(Nt) | |
| , e = ot(gN) | |
| , t = ot(au); | |
| return t.scrollOffset && e.setOffset(t.scrollOffset), | |
| new cD(n,e,t) | |
| } | |
| }, null != r && r.preloadingStrategy ? aj(r.preloadingStrategy).\u0275providers : [], { | |
| provide: m0, | |
| multi: !0, | |
| useFactory: cj | |
| }, null != r && r.initialNavigation ? pj(r) : [], [{ | |
| provide: mD, | |
| useFactory: dD | |
| }, { | |
| provide: c0, | |
| multi: !0, | |
| useExisting: mD | |
| }]] | |
| } | |
| } | |
| static forChild(t) { | |
| return { | |
| ngModule: n, | |
| providers: [vg(t)] | |
| } | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(pD, 8)) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [ag] | |
| }), | |
| n | |
| } | |
| )(); | |
| function fj(n) { | |
| return "guarded" | |
| } | |
| function pj(n) { | |
| return ["disabled" === n.initialNavigation ? es(3, [{ | |
| provide: zl, | |
| multi: !0, | |
| useFactory: () => { | |
| const e = ot(Nt); | |
| return () => { | |
| e.setUpLocationChangeListener() | |
| } | |
| } | |
| }, { | |
| provide: bg, | |
| useValue: 2 | |
| }]).\u0275providers : [], "enabledBlocking" === n.initialNavigation ? es(2, [{ | |
| provide: bg, | |
| useValue: 0 | |
| }, { | |
| provide: zl, | |
| multi: !0, | |
| deps: [On], | |
| useFactory: e => { | |
| const t = e.get(KP, Promise.resolve()); | |
| let r = !1; | |
| return () => t.then( () => new Promise(o => { | |
| const s = e.get(Nt) | |
| , a = e.get(hD); | |
| (function i(o) { | |
| e.get(Nt).events.pipe(Ur(a => a instanceof Qi || a instanceof Zc || a instanceof Sw), Fe(a => a instanceof Qi || a instanceof Zc && (0 === a.code || 1 === a.code) && null), Ur(a => null !== a), Wo(1)).subscribe( () => { | |
| o() | |
| } | |
| ) | |
| } | |
| )( () => { | |
| o(!0), | |
| r = !0 | |
| } | |
| ), | |
| s.afterPreactivation = () => (o(!0), | |
| r || a.closed ? le(void 0) : a), | |
| s.initialNavigation() | |
| } | |
| )) | |
| } | |
| }]).\u0275providers : []] | |
| } | |
| const mD = new ee("") | |
| , mj = []; | |
| let _j = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({ | |
| imports: [gD.forRoot(mj), gD] | |
| }), | |
| n | |
| } | |
| )() | |
| , yj = ( () => { | |
| class n { | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275mod = gt({ | |
| type: n | |
| }), | |
| n.\u0275inj = lt({}), | |
| n | |
| } | |
| )(); | |
| var dt, $n, n, T, kt, ts, pe, et; | |
| !function(n) { | |
| n.degreeToRadian = function e(h) { | |
| return h * Math.PI / 180 | |
| } | |
| , | |
| n.radianToDegree = function t(h) { | |
| return 180 * h / Math.PI | |
| } | |
| , | |
| n.isPowerOf2 = function r(h) { | |
| return 0 == (h & h - 1) | |
| } | |
| , | |
| n.EPSILON = 1e-8, | |
| n.equals = function i(h, f, p) { | |
| return p = void 0 !== p ? p : n.EPSILON, | |
| Math.abs(h - f) <= p * Math.max(1, Math.abs(h), Math.abs(f)) | |
| } | |
| , | |
| n.RANDOM = Math.random, | |
| n.lerp = function o(h, f, p) { | |
| return h + p * (f - h) | |
| } | |
| , | |
| n.bezierControlPointCoefficients = new Map([["linear", [0, 1]], ["ease", [.25, .25]], ["ease-in", [.42, 0]], ["ease-out", [0, .58]], ["ease-in-out", [.42, .58]], ["sin", [1 / 3, 1]], ["cos", [0, 2 / 3]]]), | |
| n.bezp = function s(h, f, p, _) { | |
| const C = n.bezierControlPointCoefficients.get(void 0 === _ ? "ease-in-out" : _); | |
| return Math.pow(1 - p, 3) * h + 3 * Math.pow(1 - p, 2) * p * (h + (f - h) * C[0]) + 3 * (1 - p) * Math.pow(p, 2) * (h + (f - h) * C[1]) + Math.pow(p, 3) * f | |
| } | |
| , | |
| n.carp = function a(h, f, p, _, C) { | |
| const R = p[1] | |
| , v = (1 - _) / 2; | |
| return p[0] * (-v * Math.pow(C, 3) + 2 * v * Math.pow(C, 2) - v * C) + h * ((2 - v) * Math.pow(C, 3) + (v - 3) * Math.pow(C, 2) + 1) + f * ((v - 2) * Math.pow(C, 3) + (3 - 2 * v) * Math.pow(C, 2) + v * C) + R * (v * Math.pow(C, 3) - v * Math.pow(C, 2)) | |
| } | |
| ; | |
| let l = []; | |
| for (let h = 0; h < 256; h++) | |
| l[h] = (h < 16 ? "0" : "") + h.toString(16); | |
| let c = 1234567; | |
| n.seedRandom = function u(h) { | |
| return null !== h && (c = h), | |
| c = (9301 * c + 49297) % 233280, | |
| c / 233280 | |
| } | |
| , | |
| n.generateUUID = function d() { | |
| const h = 4294967295 * Math.random() | 0 | |
| , f = 4294967295 * Math.random() | 0 | |
| , p = 4294967295 * Math.random() | 0 | |
| , _ = 4294967295 * Math.random() | 0; | |
| return (l[255 & h] + l[h >> 8 & 255] + l[h >> 16 & 255] + l[h >> 24 & 255] + "-" + l[255 & f] + l[f >> 8 & 255] + "-" + l[f >> 16 & 15 | 64] + l[f >> 24 & 255] + "-" + l[63 & p | 128] + l[p >> 8 & 255] + "-" + l[p >> 16 & 255] + l[p >> 24 & 255] + l[255 & _] + l[_ >> 8 & 255] + l[_ >> 16 & 255] + l[_ >> 24 & 255]).toUpperCase() | |
| } | |
| }(dt || (dt = {})), | |
| (n = $n || ($n = {})).create = function e() { | |
| return [0, 0] | |
| } | |
| , | |
| n.fromValues = function t(a, l) { | |
| return [a, l] | |
| } | |
| , | |
| n.fromTypedArray = function r(a) { | |
| return [a[0], a[1]] | |
| } | |
| , | |
| n.fromTypedArrayWithIndices = function i(a, l, c) { | |
| return [a[l * (c = c || 2)], a[l * c + 1]] | |
| } | |
| , | |
| n.scale = function o(a, l) { | |
| return [a[0] * l, a[1] * l] | |
| } | |
| , | |
| n.add = function s(a, l) { | |
| return [a[0] + l[0], a[1] + l[1]] | |
| } | |
| , | |
| function(n) { | |
| function v(y, E) { | |
| return [y[0] + E[0], y[1] + E[1], y[2] + E[2]] | |
| } | |
| function F(y, E, b) { | |
| const w = y[0] | |
| , I = y[1] | |
| , P = y[2]; | |
| return [w + b * (E[0] - w), I + b * (E[1] - I), P + b * (E[2] - P)] | |
| } | |
| n.create = function e() { | |
| return [0, 0, 0] | |
| } | |
| , | |
| n.fromValues = function t(y, E, b) { | |
| return [y, E, b] | |
| } | |
| , | |
| n.fromTypedArray = function r(y) { | |
| return [y[0], y[1], y[2]] | |
| } | |
| , | |
| n.fromTypedArrayWithIndices = function i(y, E, b) { | |
| return [y[E * (b = b || 3)], y[E * b + 1], y[E * b + 2]] | |
| } | |
| , | |
| n.fromVec4 = function o(y) { | |
| return [y[0], y[1], y[2]] | |
| } | |
| , | |
| n.clone = function s(y) { | |
| return [y[0], y[1], y[2]] | |
| } | |
| , | |
| n.negate = function a(y) { | |
| return [-y[0], -y[1], -y[2]] | |
| } | |
| , | |
| n.inverse = function l(y) { | |
| return [1 / y[0], 1 / y[1], 1 / y[2]] | |
| } | |
| , | |
| n.length = function c(y) { | |
| return Math.hypot(y[0], y[1], y[2]) | |
| } | |
| , | |
| n.squaredLength = function u(y) { | |
| const E = y[0] | |
| , b = y[1] | |
| , w = y[2]; | |
| return E * E + b * b + w * w | |
| } | |
| , | |
| n.distance = function d(y, E) { | |
| return Math.hypot(E[0] - y[0], E[1] - y[1], E[2] - y[2]) | |
| } | |
| , | |
| n.squaredDistance = function h(y, E) { | |
| const b = E[0] - y[0] | |
| , w = E[1] - y[1] | |
| , I = E[2] - y[2]; | |
| return b * b + w * w + I * I | |
| } | |
| , | |
| n.normalize = function f(y) { | |
| let E = [0, 0, 0]; | |
| const b = Math.hypot(y[0], y[1], y[2]); | |
| return b > 1e-5 && (E[0] = y[0] / b, | |
| E[1] = y[1] / b, | |
| E[2] = y[2] / b), | |
| E | |
| } | |
| , | |
| n.scale = function p(y, E) { | |
| return [y[0] * E, y[1] * E, y[2] * E] | |
| } | |
| , | |
| n.exactEquals = function _(y, E) { | |
| return y[0] === E[0] && y[1] === E[1] && y[2] === E[2] | |
| } | |
| , | |
| n.equals = function C(y, E, b) { | |
| b = void 0 !== b ? b : dt.EPSILON; | |
| const w = y[0] | |
| , I = y[1] | |
| , P = y[2] | |
| , L = E[0] | |
| , G = E[1] | |
| , m = E[2]; | |
| return Math.abs(w - L) <= b * Math.max(1, Math.abs(w), Math.abs(L)) && Math.abs(I - G) <= b * Math.max(1, Math.abs(I), Math.abs(G)) && Math.abs(P - m) <= b * Math.max(1, Math.abs(P), Math.abs(m)) | |
| } | |
| , | |
| n.min = function S(y, E) { | |
| return [Math.min(y[0], E[0]), Math.min(y[1], E[1]), Math.min(y[2], E[2])] | |
| } | |
| , | |
| n.max = function R(y, E) { | |
| return [Math.max(y[0], E[0]), Math.max(y[1], E[1]), Math.max(y[2], E[2])] | |
| } | |
| , | |
| n.add = v, | |
| n.subtract = function O(y, E) { | |
| return [y[0] - E[0], y[1] - E[1], y[2] - E[2]] | |
| } | |
| , | |
| n.dot = function M(y, E) { | |
| return y[0] * E[0] + y[1] * E[1] + y[2] * E[2] | |
| } | |
| , | |
| n.cross = function N(y, E) { | |
| const b = y[0] | |
| , w = y[1] | |
| , I = y[2] | |
| , P = E[0] | |
| , L = E[1] | |
| , G = E[2]; | |
| return [w * G - I * L, I * P - b * G, b * L - w * P] | |
| } | |
| , | |
| n.lerp = F, | |
| n.transformMat3 = function $(y, E) { | |
| const b = y[0] | |
| , w = y[1] | |
| , I = y[2]; | |
| return [b * E[0] + w * E[3] + I * E[6], b * E[1] + w * E[4] + I * E[7], b * E[2] + w * E[5] + I * E[8]] | |
| } | |
| , | |
| n.transformMat4 = function q(y, E) { | |
| const b = y[0] | |
| , w = y[1] | |
| , I = y[2] | |
| , L = E[3] * b + E[7] * w + E[11] * I + E[15] || 1; | |
| return [(E[0] * b + E[4] * w + E[8] * I + E[12]) / L, (E[1] * b + E[5] * w + E[9] * I + E[13]) / L, (E[2] * b + E[6] * w + E[10] * I + E[14]) / L] | |
| } | |
| , | |
| n.transformQuat = function K(y, E) { | |
| const b = y[0] | |
| , w = y[1] | |
| , I = y[2] | |
| , P = E[0] | |
| , L = E[1] | |
| , G = E[2]; | |
| let x = L * I - G * w | |
| , D = G * b - P * I | |
| , k = P * w - L * b | |
| , V = L * k - G * D | |
| , z = G * x - P * k | |
| , j = P * D - L * x; | |
| const Y = 2 * E[3]; | |
| return x *= Y, | |
| D *= Y, | |
| k *= Y, | |
| V *= 2, | |
| z *= 2, | |
| j *= 2, | |
| [b + x + V, w + D + z, I + k + j] | |
| } | |
| , | |
| n.rotateRodrigues = function X(y, E, b) { | |
| return v(v(n.scale(y, Math.cos(b)), n.scale(E, (1 - Math.cos(b)) * n.dot(y, E))), n.scale(n.cross(E, y), Math.sin(b))) | |
| } | |
| , | |
| n.bezier = function ie(y, E, b, w) { | |
| const I = y | |
| , P = E | |
| , L = F(I, P, dt.bezierControlPointCoefficients.get(w = void 0 === w ? "ease-in-out" : w)[0]) | |
| , G = F(I, P, dt.bezierControlPointCoefficients.get(w)[1]) | |
| , m = F(I, L, b) | |
| , x = F(L, G, b) | |
| , D = F(G, P, b) | |
| , k = F(m, x, b) | |
| , V = F(x, D, b); | |
| return F(k, V, b) | |
| } | |
| , | |
| n.quard = function g(y, E, b, w) { | |
| const I = y | |
| , P = E | |
| , L = F(I, P, dt.bezierControlPointCoefficients.get(w = void 0 === w ? "ease-in-out" : w)[0]) | |
| , G = F(I, P, dt.bezierControlPointCoefficients.get(w)[1]) | |
| , m = F(I, P, b) | |
| , x = F(L, G, b); | |
| return F(m, x, 2 * b * (1 - b)) | |
| } | |
| }(T || (T = {})), | |
| function(n) { | |
| n.create = function e() { | |
| return [0, 0, 0, 0] | |
| } | |
| , | |
| n.fromValues = function t(p, _, C, S) { | |
| return [p, _, C, S] | |
| } | |
| , | |
| n.fromTypedArray = function r(p) { | |
| return [p[0], p[1], p[2], p[3]] | |
| } | |
| , | |
| n.fromTypedArrayWithIndices = function i(p, _, C) { | |
| return [p[_ * (C = C || 4)], p[_ * C + 1], p[_ * C + 2], p[_ * C + 3]] | |
| } | |
| , | |
| n.fromVec3 = function o(p, _) { | |
| return [p[0], p[1], p[2], _] | |
| } | |
| , | |
| n.normalize = function s(p) { | |
| let _ = [0, 0, 0, 0]; | |
| const C = Math.hypot(p[0], p[1], p[2], p[3]); | |
| return C > 1e-5 && (_[0] = p[0] / C, | |
| _[1] = p[1] / C, | |
| _[2] = p[2] / C, | |
| _[3] = p[3] / C), | |
| _ | |
| } | |
| , | |
| n.scale = function a(p, _) { | |
| return [p[0] * _, p[1] * _, p[2] * _, p[3] * _] | |
| } | |
| , | |
| n.transformMat4 = function l(p, _) { | |
| const C = p[0] | |
| , S = p[1] | |
| , R = p[2] | |
| , v = p[3]; | |
| return [_[0] * C + _[4] * S + _[8] * R + _[12] * v, _[1] * C + _[5] * S + _[9] * R + _[13] * v, _[2] * C + _[6] * S + _[10] * R + _[14] * v, _[3] * C + _[7] * S + _[11] * R + _[15] * v] | |
| } | |
| , | |
| n.transformQuat = function c(p, _) { | |
| const C = p[0] | |
| , S = p[1] | |
| , R = p[2] | |
| , v = _[0] | |
| , O = _[1] | |
| , M = _[2] | |
| , N = _[3] | |
| , F = N * C + O * R - M * S | |
| , $ = N * S + M * C - v * R | |
| , q = N * R + v * S - O * C | |
| , K = -v * C - O * S - M * R; | |
| return [F * N + K * -v + $ * -M - q * -O, $ * N + K * -O + q * -v - F * -M, q * N + K * -M + F * -O - $ * -v, p[3]] | |
| } | |
| , | |
| n.add = function u(p, _) { | |
| return [p[0] + _[0], p[1] + _[1], p[2] + _[2], p[3] + _[3]] | |
| } | |
| , | |
| n.exactEquals = function d(p, _) { | |
| return p[0] === _[0] && p[1] === _[1] && p[2] === _[2] && p[3] === _[3] | |
| } | |
| , | |
| n.equals = function h(p, _, C) { | |
| C = void 0 !== C ? C : dt.EPSILON; | |
| const S = p[0] | |
| , R = p[1] | |
| , v = p[2] | |
| , O = p[3] | |
| , M = _[0] | |
| , N = _[1] | |
| , F = _[2] | |
| , $ = _[3]; | |
| return Math.abs(S - M) <= C * Math.max(1, Math.abs(S), Math.abs(M)) && Math.abs(R - N) <= C * Math.max(1, Math.abs(R), Math.abs(N)) && Math.abs(v - F) <= C * Math.max(1, Math.abs(v), Math.abs(F)) && Math.abs(O - $) <= C * Math.max(1, Math.abs(O), Math.abs($)) | |
| } | |
| , | |
| n.lerp = function f(p, _, C) { | |
| let S = p[0] | |
| , R = p[1] | |
| , v = p[2] | |
| , O = p[3]; | |
| return [S + C * (_[0] - S), R + C * (_[1] - R), v + C * (_[2] - v), O + C * (_[3] - O)] | |
| } | |
| }(kt || (kt = {})), | |
| function(n) { | |
| n.create = function e() { | |
| return [1, 0, 0, 0, 1, 0, 0, 0, 1] | |
| } | |
| , | |
| n.fromValues = function t(o, s, a, l, c, u, d, h, f) { | |
| return [o, s, a, l, c, u, d, h, f] | |
| } | |
| , | |
| n.fromMat4 = function r(o) { | |
| return [o[0], o[1], o[2], o[4], o[5], o[6], o[8], o[9], o[10]] | |
| } | |
| , | |
| n.normalFromMat4 = function i(o) { | |
| const s = o[0] | |
| , a = o[1] | |
| , l = o[2] | |
| , c = o[3] | |
| , u = o[4] | |
| , d = o[5] | |
| , h = o[6] | |
| , f = o[7] | |
| , p = o[8] | |
| , _ = o[9] | |
| , C = o[10] | |
| , S = o[11] | |
| , R = o[12] | |
| , v = o[13] | |
| , O = o[14] | |
| , M = o[15] | |
| , N = s * d - a * u | |
| , F = s * h - l * u | |
| , $ = s * f - c * u | |
| , q = a * h - l * d | |
| , K = a * f - c * d | |
| , X = l * f - c * h | |
| , ie = p * v - _ * R | |
| , g = p * O - C * R | |
| , y = p * M - S * R | |
| , E = _ * O - C * v | |
| , b = _ * M - S * v | |
| , w = C * M - S * O | |
| , I = N * w - F * b + $ * E + q * y - K * g + X * ie; | |
| if (!I) | |
| return null; | |
| const P = 1 / I; | |
| return [(d * w - h * b + f * E) * P, (h * y - u * w - f * g) * P, (u * b - d * y + f * ie) * P, (l * b - a * w - c * E) * P, (s * w - l * y + c * g) * P, (a * y - s * b - c * ie) * P, (v * X - O * K + M * q) * P, (O * $ - R * X - M * F) * P, (R * K - v * $ + M * N) * P] | |
| } | |
| }(ts || (ts = {})), | |
| function(n) { | |
| function O(g, y, E) { | |
| const b = y[0] | |
| , w = y[1] | |
| , I = y[2] | |
| , P = y[3] | |
| , L = b + b | |
| , G = w + w | |
| , m = I + I | |
| , x = b * L | |
| , D = b * G | |
| , k = b * m | |
| , V = w * G | |
| , z = w * m | |
| , j = I * m | |
| , Y = P * L | |
| , ae = P * G | |
| , ne = P * m | |
| , ce = E[0] | |
| , Re = E[1] | |
| , Me = E[2]; | |
| return [(1 - (V + j)) * ce, (D + ne) * ce, (k - ae) * ce, 0, (D - ne) * Re, (1 - (x + j)) * Re, (z + Y) * Re, 0, (k + ae) * Me, (z - Y) * Me, (1 - (x + V)) * Me, 0, g[0], g[1], g[2], 1] | |
| } | |
| function F(g) { | |
| const w = g[4] | |
| , I = g[5] | |
| , P = g[6] | |
| , L = g[8] | |
| , G = g[9] | |
| , m = g[10]; | |
| return [Math.hypot(g[0], g[1], g[2]), Math.hypot(w, I, P), Math.hypot(L, G, m)] | |
| } | |
| n.create = function e() { | |
| return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1] | |
| } | |
| , | |
| n.clone = function t(g) { | |
| return [g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7], g[8], g[9], g[10], g[11], g[12], g[13], g[14], g[15]] | |
| } | |
| , | |
| n.fromValues = function r(g, y, E, b, w, I, P, L, G, m, x, D, k, V, z, j) { | |
| return [g, y, E, b, w, I, P, L, G, m, x, D, k, V, z, j] | |
| } | |
| , | |
| n.fromFloat32Array = function i(g) { | |
| return [g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7], g[8], g[9], g[10], g[11], g[12], g[13], g[14], g[15]] | |
| } | |
| , | |
| n.fromMat3 = function o(g) { | |
| return [g[0], g[1], g[2], 0, g[3], g[4], g[5], 0, g[6], g[7], g[8], 0, 0, 0, 0, 1] | |
| } | |
| , | |
| n.determinant = function s(g) { | |
| const y = g[0] | |
| , E = g[1] | |
| , b = g[2] | |
| , w = g[3] | |
| , I = g[4] | |
| , P = g[5] | |
| , L = g[6] | |
| , G = g[7] | |
| , m = g[8] | |
| , x = g[9] | |
| , D = g[10] | |
| , k = g[11] | |
| , V = g[12] | |
| , z = g[13] | |
| , j = g[14] | |
| , Y = g[15]; | |
| return (y * P - E * I) * (D * Y - k * j) - (y * L - b * I) * (x * Y - k * z) + (y * G - w * I) * (x * j - D * z) + (E * L - b * P) * (m * Y - k * V) - (E * G - w * P) * (m * j - D * V) + (b * G - w * L) * (m * z - x * V) | |
| } | |
| , | |
| n.transpose = function a(g) { | |
| return [g[0], g[4], g[8], g[12], g[1], g[5], g[9], g[13], g[2], g[6], g[10], g[14], g[3], g[7], g[11], g[15]] | |
| } | |
| , | |
| n.invert = function l(g) { | |
| const y = g[0] | |
| , E = g[1] | |
| , b = g[2] | |
| , w = g[3] | |
| , I = g[4] | |
| , P = g[5] | |
| , L = g[6] | |
| , G = g[7] | |
| , m = g[8] | |
| , x = g[9] | |
| , D = g[10] | |
| , k = g[11] | |
| , V = g[12] | |
| , z = g[13] | |
| , j = g[14] | |
| , Y = g[15] | |
| , ae = y * P - E * I | |
| , ne = y * L - b * I | |
| , ce = y * G - w * I | |
| , Re = E * L - b * P | |
| , Me = E * G - w * P | |
| , Le = b * G - w * L | |
| , rt = m * z - x * V | |
| , Qe = m * j - D * V | |
| , st = m * Y - k * V | |
| , ht = x * j - D * z | |
| , at = x * Y - k * z | |
| , ft = D * Y - k * j | |
| , Yt = ae * ft - ne * at + ce * ht + Re * st - Me * Qe + Le * rt; | |
| if (!Yt) | |
| return null; | |
| const Ve = 1 / Yt; | |
| return [(P * ft - L * at + G * ht) * Ve, (b * at - E * ft - w * ht) * Ve, (z * Le - j * Me + Y * Re) * Ve, (D * Me - x * Le - k * Re) * Ve, (L * st - I * ft - G * Qe) * Ve, (y * ft - b * st + w * Qe) * Ve, (j * ce - V * Le - Y * ne) * Ve, (m * Le - D * ce + k * ne) * Ve, (I * at - P * st + G * rt) * Ve, (E * st - y * at - w * rt) * Ve, (V * Me - z * ce + Y * ae) * Ve, (x * ce - m * Me - k * ae) * Ve, (P * Qe - I * ht - L * rt) * Ve, (y * ht - E * Qe + b * rt) * Ve, (z * ne - V * Re - j * ae) * Ve, (m * Re - x * ne + D * ae) * Ve] | |
| } | |
| , | |
| n.multiplyScalar = function c(g, y) { | |
| return [g[0] * y, g[1] * y, g[2] * y, g[3] * y, g[4] * y, g[5] * y, g[6] * y, g[7] * y, g[8] * y, g[9] * y, g[10] * y, g[11] * y, g[12] * y, g[13] * y, g[14] * y, g[15] * y] | |
| } | |
| , | |
| n.multiply = function u(g, y) { | |
| const E = g[0] | |
| , b = g[1] | |
| , w = g[2] | |
| , I = g[3] | |
| , P = g[4] | |
| , L = g[5] | |
| , G = g[6] | |
| , m = g[7] | |
| , x = g[8] | |
| , D = g[9] | |
| , k = g[10] | |
| , V = g[11] | |
| , z = g[12] | |
| , j = g[13] | |
| , Y = g[14] | |
| , ae = g[15] | |
| , ne = y[0] | |
| , ce = y[1] | |
| , Re = y[2] | |
| , Me = y[3] | |
| , Le = y[4] | |
| , rt = y[5] | |
| , Qe = y[6] | |
| , st = y[7] | |
| , ht = y[8] | |
| , at = y[9] | |
| , ft = y[10] | |
| , Yt = y[11] | |
| , Ve = y[12] | |
| , $r = y[13] | |
| , Wr = y[14] | |
| , Gr = y[15]; | |
| return [ne * E + ce * P + Re * x + Me * z, ne * b + ce * L + Re * D + Me * j, ne * w + ce * G + Re * k + Me * Y, ne * I + ce * m + Re * V + Me * ae, Le * E + rt * P + Qe * x + st * z, Le * b + rt * L + Qe * D + st * j, Le * w + rt * G + Qe * k + st * Y, Le * I + rt * m + Qe * V + st * ae, ht * E + at * P + ft * x + Yt * z, ht * b + at * L + ft * D + Yt * j, ht * w + at * G + ft * k + Yt * Y, ht * I + at * m + ft * V + Yt * ae, Ve * E + $r * P + Wr * x + Gr * z, Ve * b + $r * L + Wr * D + Gr * j, Ve * w + $r * G + Wr * k + Gr * Y, Ve * I + $r * m + Wr * V + Gr * ae] | |
| } | |
| , | |
| n.translate = function d(g, y) { | |
| const E = y[0] | |
| , b = y[1] | |
| , w = y[2] | |
| , I = g[0] | |
| , P = g[1] | |
| , L = g[2] | |
| , G = g[3] | |
| , m = g[4] | |
| , x = g[5] | |
| , D = g[6] | |
| , k = g[7] | |
| , V = g[8] | |
| , z = g[9] | |
| , j = g[10] | |
| , Y = g[11]; | |
| return [I, P, L, G, m, x, D, k, V, z, j, Y, I * E + m * b + V * w + g[12], P * E + x * b + z * w + g[13], L * E + D * b + j * w + g[14], G * E + k * b + Y * w + g[15]] | |
| } | |
| , | |
| n.rotate = function h(g, y) { | |
| const E = y[0] | |
| , b = y[1] | |
| , w = y[2] | |
| , I = y[3] | |
| , P = E + E | |
| , L = b + b | |
| , G = w + w | |
| , m = E * P | |
| , x = E * L | |
| , D = E * G | |
| , k = b * L | |
| , V = b * G | |
| , z = w * G | |
| , j = I * P | |
| , Y = I * L | |
| , ae = I * G | |
| , ne = g[0] | |
| , ce = g[1] | |
| , Re = g[2] | |
| , Me = g[3] | |
| , Le = g[4] | |
| , rt = g[5] | |
| , Qe = g[6] | |
| , st = g[7] | |
| , ht = g[8] | |
| , at = g[9] | |
| , ft = g[10] | |
| , Yt = g[11] | |
| , Ve = 1 - (k + z) | |
| , $r = x + ae | |
| , Wr = D - Y | |
| , Gr = x - ae | |
| , gu = 1 - (m + z) | |
| , mu = V + j | |
| , _u = D + Y | |
| , yu = V - j | |
| , vu = 1 - (m + k); | |
| return [ne * Ve + Le * $r + ht * Wr, ce * Ve + rt * $r + at * Wr, Re * Ve + Qe * $r + ft * Wr, Me * Ve + st * $r + Yt * Wr, ne * Gr + Le * gu + ht * mu, ce * Gr + rt * gu + at * mu, Re * Gr + Qe * gu + ft * mu, Me * Gr + st * gu + Yt * mu, ne * _u + Le * yu + ht * vu, ce * _u + rt * yu + at * vu, Re * _u + Qe * yu + ft * vu, Me * _u + st * yu + Yt * vu, g[12], g[13], g[14], g[15]] | |
| } | |
| , | |
| n.rotateAxisAngle = function f(g, y, E) { | |
| let b = E[0] | |
| , w = E[1] | |
| , I = E[2] | |
| , P = Math.hypot(b, w, I); | |
| if (P < dt.EPSILON) | |
| return null; | |
| P = 1 / P, | |
| b *= P, | |
| w *= P, | |
| I *= P; | |
| const L = Math.sin(y) | |
| , G = Math.cos(y) | |
| , m = 1 - G | |
| , x = g[0] | |
| , D = g[1] | |
| , k = g[2] | |
| , V = g[3] | |
| , z = g[4] | |
| , j = g[5] | |
| , Y = g[6] | |
| , ae = g[7] | |
| , ne = g[8] | |
| , ce = g[9] | |
| , Re = g[10] | |
| , Me = g[11] | |
| , Le = b * b * m + G | |
| , rt = w * b * m + I * L | |
| , Qe = I * b * m - w * L | |
| , st = b * w * m - I * L | |
| , ht = w * w * m + G | |
| , at = I * w * m + b * L | |
| , ft = b * I * m + w * L | |
| , Yt = w * I * m - b * L | |
| , Ve = I * I * m + G; | |
| return [x * Le + z * rt + ne * Qe, D * Le + j * rt + ce * Qe, k * Le + Y * rt + Re * Qe, V * Le + ae * rt + Me * Qe, x * st + z * ht + ne * at, D * st + j * ht + ce * at, k * st + Y * ht + Re * at, V * st + ae * ht + Me * at, x * ft + z * Yt + ne * Ve, D * ft + j * Yt + ce * Ve, k * ft + Y * Yt + Re * Ve, V * ft + ae * Yt + Me * Ve, g[12], g[13], g[14], g[15]] | |
| } | |
| , | |
| n.scale = function p(g, y) { | |
| const E = y[0] | |
| , b = y[1] | |
| , w = y[2]; | |
| return [g[0] * E, g[1] * E, g[2] * E, g[3] * E, g[4] * b, g[5] * b, g[6] * b, g[7] * b, g[8] * w, g[9] * w, g[10] * w, g[11] * w, g[12], g[13], g[14], g[15]] | |
| } | |
| , | |
| n.fromTranslation = function _(g) { | |
| return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, g[0], g[1], g[2], 1] | |
| } | |
| , | |
| n.fromRotation = function C(g) { | |
| const y = g[0] | |
| , E = g[1] | |
| , b = g[2] | |
| , w = g[3] | |
| , I = y + y | |
| , P = E + E | |
| , L = b + b | |
| , G = y * I | |
| , m = y * P | |
| , x = y * L | |
| , D = E * P | |
| , k = E * L | |
| , V = b * L | |
| , z = w * I | |
| , j = w * P | |
| , Y = w * L; | |
| return [1 - (D + V), m + Y, x - j, 0, m - Y, 1 - (G + V), k + z, 0, x + j, k - z, 1 - (G + D), 0, 0, 0, 0, 1] | |
| } | |
| , | |
| n.fromRotationAxisAngle = function S(g, y) { | |
| let E = y[0] | |
| , b = y[1] | |
| , w = y[2] | |
| , I = Math.hypot(E, b, w); | |
| if (I < dt.EPSILON) | |
| return null; | |
| I = 1 / I, | |
| E *= I, | |
| b *= I, | |
| w *= I; | |
| const P = Math.sin(g) | |
| , L = Math.cos(g) | |
| , G = 1 - L; | |
| return [E * E * G + L, b * E * G + w * P, w * E * G - b * P, 0, E * b * G - w * P, b * b * G + L, w * b * G + E * P, 0, E * w * G + b * P, b * w * G - E * P, w * w * G + L, 0, 0, 0, 0, 1] | |
| } | |
| , | |
| n.fromScale = function R(g) { | |
| return [g[0], 0, 0, 0, 0, g[1], 0, 0, 0, 0, g[2], 0, 0, 0, 0, 1] | |
| } | |
| , | |
| n.fromRotationTranslation = function v(g, y) { | |
| const E = y[0] | |
| , b = y[1] | |
| , w = y[2] | |
| , I = y[3] | |
| , P = E + E | |
| , L = b + b | |
| , G = w + w | |
| , m = E * P | |
| , x = E * L | |
| , D = E * G | |
| , k = b * L | |
| , V = b * G | |
| , z = w * G | |
| , j = I * P | |
| , Y = I * L | |
| , ae = I * G; | |
| return [1 - (k + z), x + ae, D - Y, 0, x - ae, 1 - (m + z), V + j, 0, D + Y, V - j, 1 - (m + k), 0, g[0], g[1], g[2], 1] | |
| } | |
| , | |
| n.fromScaleRotationTranslation = O, | |
| n.getTranslation = function M(g) { | |
| return [g[12], g[13], g[14]] | |
| } | |
| , | |
| n.getRotation = function N(g) { | |
| const y = F(g) | |
| , E = 1 / y[0] | |
| , b = 1 / y[1] | |
| , w = 1 / y[2] | |
| , I = g[0] * E | |
| , P = g[1] * b | |
| , L = g[2] * w | |
| , G = g[4] * E | |
| , m = g[5] * b | |
| , x = g[6] * w | |
| , D = g[8] * E | |
| , k = g[9] * b | |
| , V = g[10] * w | |
| , z = I + m + V; | |
| if (z > 0) { | |
| const j = 2 * Math.sqrt(z + 1); | |
| return kt.fromValues((x - k) / j, (D - L) / j, (P - G) / j, .25 * j) | |
| } | |
| if (I > m && I > V) { | |
| const j = 2 * Math.sqrt(1 + I - m - V); | |
| return kt.fromValues(.25 * j, (P + G) / j, (D + L) / j, (x - k) / j) | |
| } | |
| if (m > V) { | |
| const j = 2 * Math.sqrt(1 + m - I - V); | |
| return kt.fromValues((P + G) / j, .25 * j, (x + k) / j, (D - L) / j) | |
| } | |
| { | |
| const j = 2 * Math.sqrt(1 + V - I - m); | |
| return kt.fromValues((D + L) / j, (x + k) / j, .25 * j, (P - G) / j) | |
| } | |
| } | |
| , | |
| n.getScale = F, | |
| n.lookAt = function $(g, y, E) { | |
| let b, w, I, P, L, G, m, x, D, k; | |
| const V = g[0] | |
| , z = g[1] | |
| , j = g[2] | |
| , Y = y[0] | |
| , ae = y[1] | |
| , ne = y[2] | |
| , ce = E[0] | |
| , Re = E[1] | |
| , Me = E[2]; | |
| return m = V - Y, | |
| x = z - ae, | |
| D = j - ne, | |
| Math.abs(V - Y) < dt.EPSILON && Math.abs(z - ae) < dt.EPSILON && Math.abs(j - ne) < dt.EPSILON && (D = 1), | |
| k = 1 / Math.hypot(m, x, D), | |
| m *= k, | |
| x *= k, | |
| D *= k, | |
| b = Re * D - Me * x, | |
| w = Me * m - ce * D, | |
| I = ce * x - Re * m, | |
| k = Math.hypot(b, w, I), | |
| k || (1 === Math.abs(Me) ? m += 1e-4 : D += 1e-4, | |
| k = 1 / Math.hypot(m, x, D), | |
| m *= k, | |
| x *= k, | |
| D *= k, | |
| b = Re * D - Me * x, | |
| w = Me * m - ce * D, | |
| I = ce * x - Re * m), | |
| k = 1 / k, | |
| b *= k, | |
| w *= k, | |
| I *= k, | |
| P = x * I - D * w, | |
| L = D * b - m * I, | |
| G = m * w - x * b, | |
| [b, P, m, 0, w, L, x, 0, I, G, D, 0, -(b * V + w * z + I * j), -(P * V + L * z + G * j), -(m * V + x * z + D * j), 1] | |
| } | |
| , | |
| n.targetTo = function q(g, y, E) { | |
| const b = g[0] | |
| , w = g[1] | |
| , I = g[2] | |
| , P = E[0] | |
| , L = E[1] | |
| , G = E[2]; | |
| let m = b - y[0] | |
| , x = w - y[1] | |
| , D = I - y[2] | |
| , k = Math.hypot(m, x, D); | |
| k > 0 && (k = 1 / k, | |
| m *= k, | |
| x *= k, | |
| D *= k); | |
| let V = L * D - G * x | |
| , z = G * m - P * D | |
| , j = P * x - L * m; | |
| return k = Math.hypot(m, x, D), | |
| k > 0 && (k = 1 / k, | |
| V *= k, | |
| z *= k, | |
| j *= k), | |
| [V, z, j, 0, x * j - D * z, D * V - m * j, m * z - x * V, 0, m, x, D, 0, b, w, I, 1] | |
| } | |
| , | |
| n.ortho = function K(g, y, E, b, w, I) { | |
| const P = 1 / (g - y) | |
| , L = 1 / (E - b) | |
| , G = 1 / (w - I); | |
| return [-2 * P, 0, 0, 0, 0, -2 * L, 0, 0, 0, 0, 2 * G, 0, (g + y) * P, (b + E) * L, (I + w) * G, 1] | |
| } | |
| , | |
| n.perspective = function X(g, y, E, b) { | |
| const w = 1 / Math.tan(g / 2); | |
| if (null != b && b !== 1 / 0) { | |
| const I = 1 / (E - b); | |
| return [w / y, 0, 0, 0, 0, w, 0, 0, 0, 0, (b + E) * I, -1, 0, 0, 2 * b * E * I, 0] | |
| } | |
| return [w / y, 0, 0, 0, 0, w, 0, 0, 0, 0, -1, -1, 0, 0, -2 * E, 0] | |
| } | |
| , | |
| n.compose = O, | |
| n.decompose = function ie(g) { | |
| let y = T.length(T.fromValues(g[0], g[1], g[2])); | |
| const E = T.length(T.fromValues(g[4], g[5], g[6])) | |
| , b = T.length(T.fromValues(g[8], g[9], g[10])); | |
| n.determinant(g) < 0 && (y = -y); | |
| const w = 1 / y | |
| , I = 1 / E | |
| , P = 1 / b | |
| , L = ts.fromValues(g[0] * w, g[1] * w, g[2] * w, g[4] * I, g[5] * I, g[6] * I, g[8] * P, g[9] * P, g[10] * P); | |
| return { | |
| translation: T.fromValues(g[12], g[13], g[14]), | |
| rotation: kt.normalize(et.fromMat3(L)), | |
| scale: T.fromValues(y, E, b) | |
| } | |
| } | |
| }(pe || (pe = {})), | |
| function(n) { | |
| function i(M) { | |
| const N = M[0] | |
| , F = M[1] | |
| , $ = M[2] | |
| , q = M[3] | |
| , K = Math.hypot(N, F, $) | |
| , X = Math.exp(q) | |
| , ie = K > 0 ? X * Math.sin(K) / K : 0; | |
| return [N * ie, F * ie, $ * ie, X * Math.cos(K)] | |
| } | |
| function o(M) { | |
| const N = M[0] | |
| , F = M[1] | |
| , $ = M[2] | |
| , q = M[3] | |
| , K = Math.hypot(N, F, $) | |
| , X = K > 0 ? Math.atan2(K, q) / K : 0; | |
| return [N * X, F * X, $ * X, .5 * Math.log(N * N + F * F + $ * $ + q * q)] | |
| } | |
| function s(M, N) { | |
| return [M[0] * N, M[1] * N, M[2] * N, M[3] * N] | |
| } | |
| function R(M, N, F) { | |
| const $ = M[0] | |
| , q = M[1] | |
| , K = M[2] | |
| , X = M[3]; | |
| let b, w, I, P, L, ie = N[0], g = N[1], y = N[2], E = N[3]; | |
| return I = $ * ie + q * g + K * y + X * E, | |
| I < 0 && (I = -I, | |
| ie = -ie, | |
| g = -g, | |
| y = -y, | |
| E = -E), | |
| 1 - I > dt.EPSILON ? (w = Math.sqrt(1 - I * I), | |
| b = Math.atan2(w, I), | |
| P = Math.sin((1 - F) * b) / w, | |
| L = Math.sin(F * b) / w) : (P = 1 - F, | |
| L = F), | |
| kt.normalize([P * $ + L * ie, P * q + L * g, P * K + L * y, P * X + L * E]) | |
| } | |
| n.create = function e() { | |
| return [0, 0, 0, 1] | |
| } | |
| , | |
| n.invert = function t(M) { | |
| const N = M[0] | |
| , F = M[1] | |
| , $ = M[2] | |
| , q = M[3] | |
| , K = N * N + F * F + $ * $ + q * q | |
| , X = K ? 1 / K : 0; | |
| return [-N * X, -F * X, -$ * X, q * X] | |
| } | |
| , | |
| n.conjugate = function r(M) { | |
| return [-M[0], -M[1], -M[2], M[3]] | |
| } | |
| , | |
| n.exp = i, | |
| n.ln = o, | |
| n.normalize = kt.normalize, | |
| n.add = kt.add, | |
| n.scale = s, | |
| n.pow = function a(M, N) { | |
| let F = [0, 0, 0, 1]; | |
| return F = o(M), | |
| F = s(F, N), | |
| F = i(F), | |
| F | |
| } | |
| , | |
| n.multiply = function l(M, N) { | |
| const F = M[0] | |
| , $ = M[1] | |
| , q = M[2] | |
| , K = M[3] | |
| , X = N[0] | |
| , ie = N[1] | |
| , g = N[2] | |
| , y = N[3]; | |
| return [F * y + K * X + $ * g - q * ie, $ * y + K * ie + q * X - F * g, q * y + K * g + F * ie - $ * X, K * y - F * X - $ * ie - q * g] | |
| } | |
| , | |
| n.setAxisAngle = function c(M, N) { | |
| N *= .5; | |
| const F = Math.sin(N); | |
| return [F * M[0], F * M[1], F * M[2], Math.cos(N)] | |
| } | |
| , | |
| n.rotateX = function u(M, N) { | |
| N *= .5; | |
| const F = M[0] | |
| , $ = M[1] | |
| , q = M[2] | |
| , K = M[3] | |
| , X = Math.sin(N) | |
| , ie = Math.cos(N); | |
| return [F * ie + K * X, $ * ie + q * X, q * ie - $ * X, K * ie - F * X] | |
| } | |
| , | |
| n.rotateY = function d(M, N) { | |
| N *= .5; | |
| const F = M[0] | |
| , $ = M[1] | |
| , q = M[2] | |
| , K = M[3] | |
| , X = Math.sin(N) | |
| , ie = Math.cos(N); | |
| return [F * ie - q * X, $ * ie + K * X, q * ie + F * X, K * ie - $ * X] | |
| } | |
| , | |
| n.rotateZ = function h(M, N) { | |
| N *= .5; | |
| const F = M[0] | |
| , $ = M[1] | |
| , q = M[2] | |
| , K = M[3] | |
| , X = Math.sin(N) | |
| , ie = Math.cos(N); | |
| return [F * ie + $ * X, $ * ie - F * X, q * ie + K * X, K * ie - q * X] | |
| } | |
| , | |
| n.calculateW = function f(M) { | |
| const N = M[0] | |
| , F = M[1] | |
| , $ = M[2]; | |
| return [N, F, $, Math.sqrt(Math.abs(1 - N * N - F * F - $ * $))] | |
| } | |
| , | |
| n.fromMat3 = function p(M) { | |
| const N = M[0] + M[4] + M[8]; | |
| let F, $ = [0, 0, 0, 1]; | |
| if (N > 0) | |
| F = Math.sqrt(N + 1), | |
| $[3] = .5 * F, | |
| F = .5 / F, | |
| $[0] = (M[5] - M[7]) * F, | |
| $[1] = (M[6] - M[2]) * F, | |
| $[2] = (M[1] - M[3]) * F; | |
| else { | |
| let q = 0; | |
| M[4] > M[0] && (q = 1), | |
| M[8] > M[3 * q + q] && (q = 2); | |
| let K = (q + 1) % 3 | |
| , X = (q + 2) % 3; | |
| F = Math.sqrt(M[3 * q + q] - M[3 * K + K] - M[3 * X + X] + 1), | |
| $[q] = .5 * F, | |
| F = .5 / F, | |
| $[3] = (M[3 * K + X] - M[3 * X + K]) * F, | |
| $[K] = (M[3 * K + q] + M[3 * q + K]) * F, | |
| $[X] = (M[3 * X + q] + M[3 * q + X]) * F | |
| } | |
| return $ | |
| } | |
| , | |
| n.fromEuler = function _(M, N, F) { | |
| M *= .5, | |
| N *= .5, | |
| F *= .5; | |
| const $ = Math.sin(M) | |
| , q = Math.cos(M) | |
| , K = Math.sin(N) | |
| , X = Math.cos(N) | |
| , ie = Math.sin(F) | |
| , g = Math.cos(F); | |
| return [$ * X * g - q * K * ie, q * K * g + $ * X * ie, q * X * ie - $ * K * g, q * X * g + $ * K * ie] | |
| } | |
| , | |
| n.getEuler = function C(M) { | |
| const N = M[0] | |
| , F = M[1] | |
| , $ = M[2] | |
| , q = M[3]; | |
| return [Math.atan2(2 * (q * $ + N * F), 1 - 2 * (N * N + $ * $)), Math.asin(2 * (q * N - F * $)), Math.atan2(2 * (q * F + $ * N), 1 - 2 * (N * N + F * F))] | |
| } | |
| , | |
| n.nlerp = function S(M, N, F) { | |
| return n.normalize(n.add(n.scale(M, 1 - F), n.scale(N, F))) | |
| } | |
| , | |
| n.slerp = R, | |
| n.sbezier = function v(M, N, F, $) { | |
| const q = M | |
| , K = N | |
| , X = R(q, K, dt.bezierControlPointCoefficients.get($ = void 0 === $ ? "ease-in-out" : $)[0]) | |
| , ie = R(q, K, dt.bezierControlPointCoefficients.get($)[1]) | |
| , g = R(q, X, F) | |
| , y = R(X, ie, F) | |
| , E = R(ie, K, F) | |
| , b = R(g, y, F) | |
| , w = R(y, E, F); | |
| return R(b, w, F) | |
| } | |
| , | |
| n.squard = function O(M, N, F, $) { | |
| const q = M | |
| , K = N | |
| , X = R(q, K, dt.bezierControlPointCoefficients.get($ = void 0 === $ ? "ease-in-out" : $)[0]) | |
| , ie = R(q, K, dt.bezierControlPointCoefficients.get($)[1]) | |
| , g = R(q, K, F) | |
| , y = R(X, ie, F); | |
| return R(g, y, 2 * F * (1 - F)) | |
| } | |
| }(et || (et = {})); | |
| const Cg = new Map([["blue", T.fromValues(0, 93, 255)], ["green", T.fromValues(0, 198, 179)], ["yellow", T.fromValues(243, 209, 0)], ["red", T.fromValues(255, 71, 87)]]) | |
| , _D = Cg.get("blue"); | |
| let vj = ( () => { | |
| class n { | |
| constructor() { | |
| this.setColourEvent = new Se | |
| } | |
| ngOnInit() {} | |
| getCurrentColour() { | |
| Array.from(document.getElementsByName("colours")).forEach(t => { | |
| t.checked && this.setColourEvent.emit(this.colourNameToColourRGB(t.id)) | |
| } | |
| ) | |
| } | |
| resetCurrentColor() { | |
| document.getElementById("blue").checked = !0 | |
| } | |
| colourNameToColourRGB(t) { | |
| if (Cg.has(t)) | |
| return Cg.get(t); | |
| throw new Error(`NOKEY ERROR: no colour RGB value for colour ${t}`) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275cmp = dn({ | |
| type: n, | |
| selectors: [["app-colour-picker"]], | |
| outputs: { | |
| setColourEvent: "setColourEvent" | |
| }, | |
| decls: 8, | |
| vars: 0, | |
| consts: [[1, "colour-picker-wrapper"], [1, "colour-picker", 3, "change"], ["type", "radio", "name", "colours", "id", "blue", "checked", ""], ["type", "radio", "name", "colours", "id", "green"], ["type", "radio", "name", "colours", "id", "yellow"], ["type", "radio", "name", "colours", "id", "red"]], | |
| template: function(t, r) { | |
| 1 & t && (re(0, "div", 0)(1, "div", 1), | |
| _e("change", function() { | |
| return r.getCurrentColour() | |
| }), | |
| re(2, "p"), | |
| $e(3, "\u6807\u8bb0\u989c\u8272"), | |
| oe(), | |
| Ct(4, "input", 2)(5, "input", 3)(6, "input", 4)(7, "input", 5), | |
| oe()()) | |
| }, | |
| styles: [".colour-picker-wrapper[_ngcontent-%COMP%]{display:flex}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%]{display:flex;flex-direction:row;justify-content:space-evenly;align-items:center;width:353px;height:64px;padding:15px;border-radius:30px;background:#FFFFFF;box-shadow:0 8px 20px #20295233}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] p[_ngcontent-%COMP%]{background:#FFFFFF;color:#3c464f;font-weight:500;font-size:16px;letter-spacing:0;line-height:24px;text-align:center}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] input[_ngcontent-%COMP%]{position:relative;width:34px;height:34px;margin:0;border-radius:50%;border-color:#fff;-webkit-appearance:none;appearance:none;outline:none;transition:.2s all linear}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] input[_ngcontent-%COMP%]:focus{outline:none;box-shadow:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #blue[_ngcontent-%COMP%]{background:#005DFF}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #blue[_ngcontent-%COMP%]:hover{background:#0011FF;outline:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #blue[_ngcontent-%COMP%]:checked{border:5px solid #005DFF;box-shadow:inset 0 0 0 4px #fff;outline:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #green[_ngcontent-%COMP%]{background:#00C6B3}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #green[_ngcontent-%COMP%]:hover{background:#00A8C6;outline:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #green[_ngcontent-%COMP%]:checked{border:5px solid #00C6B3;box-shadow:inset 0 0 0 4px #fff;outline:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #yellow[_ngcontent-%COMP%]{background:#F3D100}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #yellow[_ngcontent-%COMP%]:hover{background:#F3BA00;outline:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #yellow[_ngcontent-%COMP%]:checked{border:5px solid #F3D100;box-shadow:inset 0 0 0 4px #fff;outline:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #red[_ngcontent-%COMP%]{background:#FF4757}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #red[_ngcontent-%COMP%]:hover{background:#D13A47;outline:none}.colour-picker-wrapper[_ngcontent-%COMP%] .colour-picker[_ngcontent-%COMP%] #red[_ngcontent-%COMP%]:checked{border:5px solid #FF4757;box-shadow:inset 0 0 0 4px #fff;outline:none}"] | |
| }), | |
| n | |
| } | |
| )(); | |
| var mi = ( () => (function(n) { | |
| n[n.Clip = 0] = "Clip", | |
| n[n.Span = 1] = "Span", | |
| n[n.View = 2] = "View" | |
| }(mi || (mi = {})), | |
| mi))() | |
| , ns = ( () => (function(n) { | |
| n[n.Succeed = 1] = "Succeed", | |
| n[n.Unauthenticated = 401] = "Unauthenticated", | |
| n[n.Unauthorized = 403] = "Unauthorized", | |
| n[n.NetworkError = -404] = "NetworkError" | |
| }(ns || (ns = {})), | |
| ns))() | |
| , _i = ( () => (function(n) { | |
| n[n.Default = 0] = "Default", | |
| n[n.UpSide = 1] = "UpSide", | |
| n[n.DownSide = 2] = "DownSide" | |
| }(_i || (_i = {})), | |
| _i))() | |
| , zr = ( () => (function(n) { | |
| n.Linear = "linear", | |
| n.Ease = "ease", | |
| n.EaseIn = "ease-in", | |
| n.EaseOut = "ease-out", | |
| n.EaseInOut = "ease-in-out", | |
| n.Sin = "sin", | |
| n.Cos = "cos" | |
| }(zr || (zr = {})), | |
| zr))(); | |
| class bj { | |
| constructor() { | |
| this.isView = !1, | |
| this.type = mi.Clip, | |
| this.model = null, | |
| this.clip = { | |
| isBase: !0, | |
| isManual: !1 | |
| }, | |
| this.span = { | |
| isBase: !0, | |
| isPreview: !1, | |
| isFolded: !1, | |
| currentColor: _D | |
| }, | |
| this.view = {} | |
| } | |
| get isClip() { | |
| return this.type === mi.Clip | |
| } | |
| get isSpan() { | |
| return this.type === mi.Span | |
| } | |
| } | |
| class Cj { | |
| constructor(e, t, r, i, o) { | |
| this.xTranslation = e, | |
| this.yTranslation = t, | |
| this.zTranslation = r, | |
| this.xRotation = i, | |
| this.zRotation = o | |
| } | |
| } | |
| class Ut { | |
| constructor(e, t, r) { | |
| this.translation = e || T.create(), | |
| this.rotation = t || et.create(), | |
| this.scale = r || T.fromValues(1, 1, 1) | |
| } | |
| get transform() { | |
| return pe.fromScaleRotationTranslation(this.translation, this.rotation, this.scale) | |
| } | |
| fromMatrix(e) { | |
| const t = pe.decompose(e); | |
| return this.translation = t.translation, | |
| this.rotation = t.rotation, | |
| this.scale = t.scale, | |
| this | |
| } | |
| } | |
| var W = ( () => (function(n) { | |
| n[n.TEXTURE0 = 33984] = "TEXTURE0", | |
| n[n.DYNAMIC_DRAW = 35048] = "DYNAMIC_DRAW", | |
| n[n.ARRAY_BUFFER = 34962] = "ARRAY_BUFFER", | |
| n[n.ELEMENT_ARRAY_BUFFER = 34963] = "ELEMENT_ARRAY_BUFFER", | |
| n[n.UNIFORM_BUFFER = 35345] = "UNIFORM_BUFFER", | |
| n[n.TRANSFORM_FEEDBACK_BUFFER = 35982] = "TRANSFORM_FEEDBACK_BUFFER", | |
| n[n.TRANSFORM_FEEDBACK = 36386] = "TRANSFORM_FEEDBACK", | |
| n[n.COMPILE_STATUS = 35713] = "COMPILE_STATUS", | |
| n[n.LINK_STATUS = 35714] = "LINK_STATUS", | |
| n[n.FRAGMENT_SHADER = 35632] = "FRAGMENT_SHADER", | |
| n[n.VERTEX_SHADER = 35633] = "VERTEX_SHADER", | |
| n[n.SEPARATE_ATTRIBS = 35981] = "SEPARATE_ATTRIBS", | |
| n[n.ACTIVE_UNIFORMS = 36230] = "ACTIVE_UNIFORMS", | |
| n[n.ACTIVE_ATTRIBUTES = 35721] = "ACTIVE_ATTRIBUTES", | |
| n[n.TRANSFORM_FEEDBACK_VARYINGS = 35971] = "TRANSFORM_FEEDBACK_VARYINGS", | |
| n[n.ACTIVE_UNIFORM_BLOCKS = 35382] = "ACTIVE_UNIFORM_BLOCKS", | |
| n[n.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 35396] = "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER", | |
| n[n.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 35398] = "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER", | |
| n[n.UNIFORM_BLOCK_DATA_SIZE = 35392] = "UNIFORM_BLOCK_DATA_SIZE", | |
| n[n.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 35395] = "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", | |
| n[n.INT = 5124] = "INT", | |
| n[n.INT_VEC2 = 35667] = "INT_VEC2", | |
| n[n.INT_VEC3 = 35668] = "INT_VEC3", | |
| n[n.INT_VEC4 = 35669] = "INT_VEC4", | |
| n[n.UNSIGNED_INT = 5125] = "UNSIGNED_INT", | |
| n[n.UNSIGNED_INT_VEC2 = 36294] = "UNSIGNED_INT_VEC2", | |
| n[n.UNSIGNED_INT_VEC3 = 36295] = "UNSIGNED_INT_VEC3", | |
| n[n.UNSIGNED_INT_VEC4 = 36296] = "UNSIGNED_INT_VEC4", | |
| n[n.FLOAT = 5126] = "FLOAT", | |
| n[n.FLOAT_VEC2 = 35664] = "FLOAT_VEC2", | |
| n[n.FLOAT_VEC3 = 35665] = "FLOAT_VEC3", | |
| n[n.FLOAT_VEC4 = 35666] = "FLOAT_VEC4", | |
| n[n.FLOAT_MAT2 = 35674] = "FLOAT_MAT2", | |
| n[n.FLOAT_MAT3 = 35675] = "FLOAT_MAT3", | |
| n[n.FLOAT_MAT4 = 35676] = "FLOAT_MAT4", | |
| n[n.FLOAT_MAT2x3 = 35685] = "FLOAT_MAT2x3", | |
| n[n.FLOAT_MAT2x4 = 35686] = "FLOAT_MAT2x4", | |
| n[n.FLOAT_MAT3x2 = 35687] = "FLOAT_MAT3x2", | |
| n[n.FLOAT_MAT3x4 = 35688] = "FLOAT_MAT3x4", | |
| n[n.FLOAT_MAT4x2 = 35689] = "FLOAT_MAT4x2", | |
| n[n.FLOAT_MAT4x3 = 35690] = "FLOAT_MAT4x3", | |
| n[n.BOOL = 35670] = "BOOL", | |
| n[n.BOOL_VEC2 = 35671] = "BOOL_VEC2", | |
| n[n.BOOL_VEC3 = 35672] = "BOOL_VEC3", | |
| n[n.BOOL_VEC4 = 35673] = "BOOL_VEC4", | |
| n[n.SAMPLER_2D = 35678] = "SAMPLER_2D", | |
| n[n.SAMPLER_2D_SHADOW = 35682] = "SAMPLER_2D_SHADOW", | |
| n[n.SAMPLER_2D_ARRAY = 36289] = "SAMPLER_2D_ARRAY", | |
| n[n.SAMPLER_2D_ARRAY_SHADOW = 36292] = "SAMPLER_2D_ARRAY_SHADOW", | |
| n[n.SAMPLER_3D = 35679] = "SAMPLER_3D", | |
| n[n.SAMPLER_CUBE = 35680] = "SAMPLER_CUBE", | |
| n[n.SAMPLER_CUBE_SHADOW = 36293] = "SAMPLER_CUBE_SHADOW", | |
| n[n.INT_SAMPLER_2D = 36298] = "INT_SAMPLER_2D", | |
| n[n.INT_SAMPLER_2D_ARRAY = 36303] = "INT_SAMPLER_2D_ARRAY", | |
| n[n.INT_SAMPLER_3D = 36299] = "INT_SAMPLER_3D", | |
| n[n.INT_SAMPLER_CUBE = 36300] = "INT_SAMPLER_CUBE", | |
| n[n.UNSIGNED_INT_SAMPLER_2D = 36306] = "UNSIGNED_INT_SAMPLER_2D", | |
| n[n.UNSIGNED_INT_SAMPLER_2D_ARRAY = 36311] = "UNSIGNED_INT_SAMPLER_2D_ARRAY", | |
| n[n.UNSIGNED_INT_SAMPLER_3D = 36307] = "UNSIGNED_INT_SAMPLER_3D", | |
| n[n.UNSIGNED_INT_SAMPLER_CUBE = 36308] = "UNSIGNED_INT_SAMPLER_CUBE", | |
| n[n.TEXTURE_2D = 3553] = "TEXTURE_2D", | |
| n[n.TEXTURE_2D_ARRAY = 35866] = "TEXTURE_2D_ARRAY", | |
| n[n.TEXTURE_3D = 32879] = "TEXTURE_3D", | |
| n[n.TEXTURE_CUBE_MAP = 34067] = "TEXTURE_CUBE_MAP" | |
| }(W || (W = {})), | |
| W))(); | |
| const Tj = ["VERTEX_SHADER", "FRAGMENT_SHADER"] | |
| , yD = new Map([[W.INT, { | |
| type: Int32Array, | |
| size: 4, | |
| setter: yi | |
| }], [W.INT_VEC2, { | |
| type: Int32Array, | |
| size: 8, | |
| setter: yi | |
| }], [W.INT_VEC3, { | |
| type: Int32Array, | |
| size: 12, | |
| setter: yi | |
| }], [W.INT_VEC4, { | |
| type: Int32Array, | |
| size: 16, | |
| setter: yi | |
| }], [W.UNSIGNED_INT, { | |
| type: Uint32Array, | |
| size: 4, | |
| setter: du | |
| }], [W.UNSIGNED_INT_VEC2, { | |
| type: Uint32Array, | |
| size: 8, | |
| setter: du | |
| }], [W.UNSIGNED_INT_VEC3, { | |
| type: Uint32Array, | |
| size: 12, | |
| setter: du | |
| }], [W.UNSIGNED_INT_VEC4, { | |
| type: Uint32Array, | |
| size: 16, | |
| setter: du | |
| }], [W.FLOAT, { | |
| type: Float32Array, | |
| size: 4, | |
| setter: hu | |
| }], [W.FLOAT_VEC2, { | |
| type: Float32Array, | |
| size: 8, | |
| setter: hu | |
| }], [W.FLOAT_VEC3, { | |
| type: Float32Array, | |
| size: 12, | |
| setter: hu | |
| }], [W.FLOAT_VEC4, { | |
| type: Float32Array, | |
| size: 16, | |
| setter: hu | |
| }], [W.FLOAT_MAT2, { | |
| type: Float32Array, | |
| size: 4, | |
| setter: Tg, | |
| count: 2 | |
| }], [W.FLOAT_MAT3, { | |
| type: Float32Array, | |
| size: 9, | |
| setter: Tg, | |
| count: 3 | |
| }], [W.FLOAT_MAT4, { | |
| type: Float32Array, | |
| size: 16, | |
| setter: Tg, | |
| count: 4 | |
| }], [W.BOOL, { | |
| type: Int32Array, | |
| size: 4, | |
| setter: yi | |
| }], [W.BOOL_VEC2, { | |
| type: Int32Array, | |
| size: 8, | |
| setter: yi | |
| }], [W.BOOL_VEC3, { | |
| type: Int32Array, | |
| size: 12, | |
| setter: yi | |
| }], [W.BOOL_VEC4, { | |
| type: Int32Array, | |
| size: 16, | |
| setter: yi | |
| }]]) | |
| , Oa = new Map([[W.INT, { | |
| type: Int32Array, | |
| size: 4, | |
| setter: (n, e) => t => { | |
| n.uniform1i(e, t) | |
| } | |
| , | |
| arraySetter: (n, e) => t => { | |
| n.uniform1iv(e, t) | |
| } | |
| }], [W.INT_VEC2, { | |
| type: Int32Array, | |
| size: 8, | |
| cols: 2, | |
| setter: (n, e) => t => { | |
| n.uniform2iv(e, t) | |
| } | |
| }], [W.INT_VEC3, { | |
| type: Int32Array, | |
| size: 12, | |
| cols: 3, | |
| setter: (n, e) => t => { | |
| n.uniform3iv(e, t) | |
| } | |
| }], [W.INT_VEC4, { | |
| type: Int32Array, | |
| size: 16, | |
| cols: 4, | |
| setter: (n, e) => t => { | |
| n.uniform4iv(e, t) | |
| } | |
| }], [W.UNSIGNED_INT, { | |
| type: Uint32Array, | |
| size: 4, | |
| setter: (n, e) => t => { | |
| n.uniform1ui(e, t) | |
| } | |
| , | |
| arraySetter: (n, e) => t => { | |
| n.uniform1uiv(e, t) | |
| } | |
| }], [W.UNSIGNED_INT_VEC2, { | |
| type: Uint32Array, | |
| size: 8, | |
| cols: 2, | |
| setter: (n, e) => t => { | |
| n.uniform2uiv(e, t) | |
| } | |
| }], [W.UNSIGNED_INT_VEC3, { | |
| type: Uint32Array, | |
| size: 12, | |
| cols: 3, | |
| setter: (n, e) => t => { | |
| n.uniform3uiv(e, t) | |
| } | |
| }], [W.UNSIGNED_INT_VEC4, { | |
| type: Uint32Array, | |
| size: 16, | |
| cols: 4, | |
| setter: (n, e) => t => { | |
| n.uniform4uiv(e, t) | |
| } | |
| }], [W.FLOAT, { | |
| type: Float32Array, | |
| size: 4, | |
| setter: (n, e) => t => { | |
| n.uniform1f(e, t) | |
| } | |
| , | |
| arraySetter: (n, e) => t => { | |
| n.uniform1fv(e, t) | |
| } | |
| }], [W.FLOAT_VEC2, { | |
| type: Float32Array, | |
| size: 8, | |
| cols: 2, | |
| setter: (n, e) => t => { | |
| n.uniform2fv(e, t) | |
| } | |
| }], [W.FLOAT_VEC3, { | |
| type: Float32Array, | |
| size: 12, | |
| cols: 3, | |
| setter: (n, e) => t => { | |
| n.uniform3fv(e, t) | |
| } | |
| }], [W.FLOAT_VEC4, { | |
| type: Float32Array, | |
| size: 16, | |
| cols: 4, | |
| setter: (n, e) => t => { | |
| n.uniform4fv(e, t) | |
| } | |
| }], [W.FLOAT_MAT2, { | |
| type: Float32Array, | |
| size: 32, | |
| rows: 2, | |
| cols: 2, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix2fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT3, { | |
| type: Float32Array, | |
| size: 48, | |
| rows: 3, | |
| cols: 3, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix3fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT4, { | |
| type: Float32Array, | |
| size: 64, | |
| rows: 4, | |
| cols: 4, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix4fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT2x3, { | |
| type: Float32Array, | |
| size: 32, | |
| rows: 2, | |
| cols: 3, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix2x3fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT2x4, { | |
| type: Float32Array, | |
| size: 32, | |
| rows: 2, | |
| cols: 4, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix2x4fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT3x2, { | |
| type: Float32Array, | |
| size: 48, | |
| rows: 3, | |
| cols: 2, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix3x2fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT3x4, { | |
| type: Float32Array, | |
| size: 48, | |
| rows: 3, | |
| cols: 4, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix3x4fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT4x2, { | |
| type: Float32Array, | |
| size: 64, | |
| rows: 4, | |
| cols: 2, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix4x3fv(e, !1, t) | |
| } | |
| }], [W.FLOAT_MAT4x3, { | |
| type: Float32Array, | |
| size: 64, | |
| rows: 4, | |
| cols: 3, | |
| setter: (n, e) => t => { | |
| n.uniformMatrix4x3fv(e, !1, t) | |
| } | |
| }], [W.BOOL, { | |
| type: Int32Array, | |
| size: 4, | |
| setter: (n, e) => t => { | |
| n.uniform1i(e, t) | |
| } | |
| , | |
| arraySetter: (n, e) => t => { | |
| n.uniform1iv(e, t) | |
| } | |
| }], [W.BOOL_VEC2, { | |
| type: Int32Array, | |
| size: 8, | |
| cols: 2, | |
| setter: (n, e) => t => { | |
| n.uniform2iv(e, t) | |
| } | |
| }], [W.BOOL_VEC3, { | |
| type: Int32Array, | |
| size: 12, | |
| cols: 3, | |
| setter: (n, e) => t => { | |
| n.uniform3iv(e, t) | |
| } | |
| }], [W.BOOL_VEC4, { | |
| type: Int32Array, | |
| size: 16, | |
| cols: 4, | |
| setter: (n, e) => t => { | |
| n.uniform4iv(e, t) | |
| } | |
| }], [W.SAMPLER_2D, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D | |
| }], [W.SAMPLER_2D_SHADOW, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D | |
| }], [W.SAMPLER_2D_ARRAY, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D_ARRAY | |
| }], [W.SAMPLER_2D_ARRAY_SHADOW, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D_ARRAY | |
| }], [W.SAMPLER_3D, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_3D | |
| }], [W.SAMPLER_CUBE, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_CUBE_MAP | |
| }], [W.SAMPLER_CUBE_SHADOW, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_CUBE_MAP | |
| }], [W.INT_SAMPLER_2D, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D | |
| }], [W.INT_SAMPLER_2D_ARRAY, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D_ARRAY | |
| }], [W.INT_SAMPLER_3D, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_3D | |
| }], [W.INT_SAMPLER_CUBE, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_CUBE_MAP | |
| }], [W.UNSIGNED_INT_SAMPLER_2D, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D | |
| }], [W.UNSIGNED_INT_SAMPLER_2D_ARRAY, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_2D_ARRAY | |
| }], [W.UNSIGNED_INT_SAMPLER_3D, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_3D | |
| }], [W.UNSIGNED_INT_SAMPLER_CUBE, { | |
| type: null, | |
| size: 0, | |
| setter: ln, | |
| arraySetter: cn, | |
| bindPoint: W.TEXTURE_CUBE_MAP | |
| }]]); | |
| function yi(n, e) { | |
| return function(t) { | |
| if (t.value) { | |
| if (n.disableVertexAttribArray(e), | |
| 4 !== t.value.length) | |
| throw new Error("The length of an integer constant value must be 4!"); | |
| n.vertexAttribI4iv(e, t.value) | |
| } else | |
| n.bindBuffer(W.ARRAY_BUFFER, t.buffer), | |
| n.enableVertexAttribArray(e), | |
| n.vertexAttribIPointer(e, t.numComponents || t.size, t.type || W.INT, t.stride || 0, t.offset || 0), | |
| void 0 !== t.divisor && n.vertexAttribDivisor(e, t.divisor) | |
| } | |
| } | |
| function du(n, e) { | |
| return function(t) { | |
| if (t.value) { | |
| if (n.disableVertexAttribArray(e), | |
| 4 !== t.value.length) | |
| throw new Error("The length of an integer constant value must be 4!"); | |
| n.vertexAttribI4uiv(e, t.value) | |
| } else | |
| n.bindBuffer(W.ARRAY_BUFFER, t.buffer), | |
| n.enableVertexAttribArray(e), | |
| n.vertexAttribIPointer(e, t.numComponents || t.size, t.type || W.UNSIGNED_INT, t.stride || 0, t.offset || 0), | |
| void 0 !== t.divisor && n.vertexAttribDivisor(e, t.divisor) | |
| } | |
| } | |
| function hu(n, e) { | |
| return t => { | |
| if (t.value) | |
| switch (n.disableVertexAttribArray(e), | |
| t.value.length) { | |
| case 4: | |
| n.vertexAttrib4fv(e, t.value); | |
| break; | |
| case 3: | |
| n.vertexAttrib3fv(e, t.value); | |
| break; | |
| case 2: | |
| n.vertexAttrib2fv(e, t.value); | |
| break; | |
| case 1: | |
| n.vertexAttrib1fv(e, t.value); | |
| break; | |
| default: | |
| throw new Error(`TYPEERROR: Wrong attribute info: The length of a float constant cannot be ${t.value.length}`) | |
| } | |
| else | |
| n.bindBuffer(W.ARRAY_BUFFER, t.buffer), | |
| n.enableVertexAttribArray(e), | |
| n.vertexAttribPointer(e, t.numComponents || t.size, t.type || W.FLOAT, t.normalize || !1, t.stride || 0, t.offset || 0), | |
| void 0 !== t.divisor && n.vertexAttribDivisor(e, t.divisor) | |
| } | |
| } | |
| function Tg(n, e, t) { | |
| return function(r) { | |
| n.bindBuffer(W.ARRAY_BUFFER, r.buffer); | |
| const i = t.count | |
| , o = r.numComponents || r.size || t.size | |
| , s = o / i | |
| , a = r.type || W.FLOAT | |
| , l = Oa.get(a).size * o | |
| , c = r.offset || 0 | |
| , u = l / i | |
| , d = r.normalize || !1; | |
| for (let h = 0; h < i; h++) | |
| n.enableVertexAttribArray(e + 1), | |
| n.vertexAttribPointer(e + 1, s, a, d, l, c + u * h), | |
| void 0 !== r.divisor && n.vertexAttribDivisor(e + h, r.divisor) | |
| } | |
| } | |
| function ln(n, e, t, r) { | |
| return (i, o) => { | |
| n.uniform1i(e, r), | |
| n.activeTexture(W.TEXTURE0 + r), | |
| n.bindTexture(Oa.get(t).bindPoint, i), | |
| n.bindSampler(r, o) | |
| } | |
| } | |
| function cn(n, e, t, r, i) { | |
| const o = new Int32Array(i); | |
| return o.forEach( (s, a) => {} | |
| ), | |
| (s, a) => { | |
| n.uniform1iv(e, o); | |
| for (let l = 0; l < Math.min(s.length, a.length); l++) | |
| n.activeTexture(W.TEXTURE0 + o[l]), | |
| n.bindTexture(Oa.get(t).bindPoint, s[l]), | |
| n.bindSampler(r, a[l]) | |
| } | |
| } | |
| var Pt; | |
| !function(n) { | |
| const t = /^[ \t]*\n/ | |
| , a = /\[\d+\]\.$/; | |
| function c(m) { | |
| console.error(m) | |
| } | |
| function d(m, x, D, k) { | |
| const V = k || c | |
| , z = m.createShader(D); | |
| return t.test(x) && (x = x.replace(t, "")), | |
| m.shaderSource(z, x), | |
| m.compileShader(z), | |
| m.getShaderParameter(z, m.COMPILE_STATUS) ? z : (V("*** Error compiling shader '" + z + "':" + m.getShaderInfoLog(z) + "\n" + x.split("\n").map( (ne, ce) => `${ce + 1}: ${ne}`).join("\n")), | |
| m.deleteShader(z), | |
| null) | |
| } | |
| function h(m, x, D) { | |
| const k = D.errorCallback || c | |
| , V = m.createProgram(); | |
| if (x.forEach(j => { | |
| m.attachShader(V, j) | |
| } | |
| ), | |
| D.attributeLoations && Object.keys(D.attributeLoations).forEach( (j, Y) => { | |
| m.bindAttribLocation(V, D.attributeLoations[Y], j) | |
| } | |
| ), | |
| D.transformFeedbackVaryings) { | |
| const j = Object.keys(D.transformFeedbackVaryings.attribs); | |
| m.transformFeedbackVaryings(V, j, D.transformFeedbackMode || W.SEPARATE_ATTRIBS) | |
| } | |
| return m.linkProgram(V), | |
| m.getProgramParameter(V, m.LINK_STATUS) ? V : (k("Error in program linking:" + m.getProgramInfoLog(V)), | |
| m.deleteProgram(V), | |
| x.forEach(Y => { | |
| m.deleteShader(Y) | |
| } | |
| ), | |
| null) | |
| } | |
| function f(m, x, D) { | |
| const k = []; | |
| for (let V = 0; V < x.length; V++) | |
| k.push(d(m, x[V], m[Tj[V]], D.errorCallback)); | |
| return h(m, k, D) | |
| } | |
| function _(m, x) { | |
| const D = {} | |
| , k = m.getProgramParameter(x, m.ACTIVE_ATTRIBUTES); | |
| for (let V = 0; V < k; V++) { | |
| const z = m.getActiveAttrib(x, V); | |
| if (!z) | |
| break; | |
| const j = m.getAttribLocation(x, z.name) | |
| , Y = yD.get(z.type); | |
| D[z.name] = yD.get(z.type).setter(m, j, Y) | |
| } | |
| return D | |
| } | |
| function C(m, x) { | |
| let D = 0; | |
| function k(j, Y) { | |
| const ae = j.name.endsWith("[0]") | |
| , ne = j.type | |
| , ce = Oa.get(ne); | |
| if (void 0 === ce) | |
| throw new Error(`TYPEERROR: Unknown type: 0x${ne.toString(16)}`); | |
| if (void 0 === ce.bindPoint) | |
| return ae && void 0 !== ce.arraySetter ? ce.arraySetter(m, Y) : ce.setter(m, Y); | |
| { | |
| const Re = D; | |
| return D += j.size, | |
| ae ? ce.arraySetter(m, Y, ne, Re, j.size) : ce.setter(m, Y, ne, Re, j.size) | |
| } | |
| } | |
| const V = {} | |
| , z = m.getProgramParameter(x, m.ACTIVE_UNIFORMS); | |
| for (let j = 0; j < z; j++) { | |
| const Y = m.getActiveUniform(x, j); | |
| if (!Y) | |
| break; | |
| let ae = Y.name; | |
| ae.endsWith("[0]") && (ae = ae.slice(0, ae.length - 3)); | |
| let ne = m.getUniformLocation(x, Y.name); | |
| if (ne) { | |
| const ce = k(Y, ne); | |
| V[ae] = ce | |
| } | |
| } | |
| return V | |
| } | |
| function R(m, x) { | |
| Object.keys(x).forEach(D => { | |
| const k = m.attribSetters[D]; | |
| k && k(x[D]) | |
| } | |
| ) | |
| } | |
| function N(m, x, D, k) { | |
| const V = m.createVertexArray(); | |
| return m.bindVertexArray(V), | |
| R(x, D), | |
| k && m.bindBuffer(m.ELEMENT_ARRAY_BUFFER, k), | |
| m.bindVertexArray(null), | |
| V | |
| } | |
| function q(m, x, D) { | |
| for (let k in D.attribs) { | |
| const V = x.transformFeedbackInfo[k]; | |
| if (V) { | |
| const z = D[k]; | |
| z.offset ? m.bindBufferRange(W.TRANSFORM_FEEDBACK_BUFFER, V.index, z.buffer, z.offset, z.size) : m.bindBufferBase(W.TRANSFORM_FEEDBACK_BUFFER, V.index, z.buffer) | |
| } | |
| } | |
| } | |
| function g(m, x, D, k) { | |
| if (x || void 0 !== D) { | |
| k = k || 1; | |
| const z = m.length / 4; | |
| return j => { | |
| let Y = 0 | |
| , ae = 0; | |
| for (let ne = 0; ne < z; ne++) { | |
| for (let ce = 0; ce < k; ce++) | |
| m[Y++] = j[ae++]; | |
| Y += 4 - k | |
| } | |
| } | |
| } | |
| return V => { | |
| Array.isArray(V) ? m.set(V) : m[0] = V | |
| } | |
| } | |
| function E(m, x, D) { | |
| const k = void 0 !== x.uniformBlockSpec ? x.uniformBlockSpec.blockSpecs[D.name] : void 0; | |
| return void 0 !== k && (m.bindBufferRange(W.UNIFORM_BUFFER, k.index, D.buffer, D.offset || 0, D.array.byteLength), | |
| !0) | |
| } | |
| function L(m, x, D) { | |
| m.bindTexture(m.TEXTURE_2D, x), | |
| m.pixelStorei(m.UNPACK_FLIP_Y_WEBGL, !1), | |
| m.texParameteri(m.TEXTURE_2D, m.TEXTURE_MAG_FILTER, m.NEAREST), | |
| m.texParameteri(m.TEXTURE_2D, m.TEXTURE_MIN_FILTER, m.NEAREST), | |
| m.texParameteri(m.TEXTURE_2D, m.TEXTURE_WRAP_S, m.CLAMP_TO_EDGE), | |
| m.texParameteri(m.TEXTURE_2D, m.TEXTURE_WRAP_T, m.CLAMP_TO_EDGE), | |
| "colour" === D ? (m.texStorage2D(m.TEXTURE_2D, 1, m.RGBA16F, m.drawingBufferWidth, m.drawingBufferHeight), | |
| m.framebufferTexture2D(m.FRAMEBUFFER, m.COLOR_ATTACHMENT0, m.TEXTURE_2D, x, 0)) : "alpha" === D ? (m.texStorage2D(m.TEXTURE_2D, 1, m.R16F, m.drawingBufferWidth, m.drawingBufferHeight), | |
| m.framebufferTexture2D(m.FRAMEBUFFER, m.COLOR_ATTACHMENT1, m.TEXTURE_2D, x, 0)) : "depth" === D && (m.texStorage2D(m.TEXTURE_2D, 1, m.DEPTH_COMPONENT16, m.drawingBufferWidth, m.drawingBufferHeight), | |
| m.framebufferTexture2D(m.FRAMEBUFFER, m.DEPTH_ATTACHMENT, m.TEXTURE_2D, x, 0)) | |
| } | |
| n.glEnumToString = function l(m, x) { | |
| const D = {}; | |
| return Object.keys(m).forEach(k => { | |
| "number" == typeof m[k] && (D[m[k]] = k) | |
| } | |
| ), | |
| D[x] || "0x" + x.toString(16) | |
| } | |
| , | |
| n.loadShader = d, | |
| n.createProgram = h, | |
| n.createProgramFromSources = f, | |
| n.getBindPointForSamplerType = function p(m, x) { | |
| return x === m.SAMPLER_2D ? m.TEXTURE_2D : x === m.SAMPLER_CUBE ? m.TEXTURE_CUBE_MAP : void 0 | |
| } | |
| , | |
| n.createAttributeSetters = _, | |
| n.createUniformSetters = C, | |
| n.createProgramInfo = function S(m, x, D) { | |
| const k = f(m, x, D = void 0 !== D ? D : {}); | |
| return k ? { | |
| program: k, | |
| attribSetters: _(m, k), | |
| uniformSetters: C(m, k) | |
| } : null | |
| } | |
| , | |
| n.setAttributes = R, | |
| n.setUniforms = function v(m, x) { | |
| Object.keys(x).forEach(D => { | |
| const k = m.uniformSetters[D]; | |
| k && k(x[D]) | |
| } | |
| ) | |
| } | |
| , | |
| n.setBuffersAndAttributes = function O(m, x, D) { | |
| void 0 !== D.buffer ? R(x, D.buffer.attribs) : void 0 !== D.vertexArrayInfo && (m.bindVertexArray(D.vertexArrayInfo.vertexArrayObject), | |
| D.buffer.indices && m.bindBuffer(m.ELEMENT_ARRAY_BUFFER, D.buffer.indices)) | |
| } | |
| , | |
| n.createVertexArrayInfo = function M(m, x, D) { | |
| const k = m.createVertexArray(); | |
| return m.bindVertexArray(k), | |
| x.forEach(V => { | |
| R(V, D.attribs), | |
| D.indices && m.bindBuffer(m.ELEMENT_ARRAY_BUFFER, D.indices) | |
| } | |
| ), | |
| m.bindVertexArray(null), | |
| { | |
| numElements: D.numElements, | |
| elementType: D.elementType, | |
| vertexArrayObject: k | |
| } | |
| } | |
| , | |
| n.createVAOAndSetAttributes = N, | |
| n.createVAOFromBufferInfo = function F(m, x, D) { | |
| return N(m, x, D.attribs, D.indices) | |
| } | |
| , | |
| n.createTransformFeedbackInfo = function $(m, x) { | |
| var D = {}; | |
| const k = m.getProgramParameter(x, W.TRANSFORM_FEEDBACK_VARYINGS); | |
| for (let V = 0; V < k; V++) { | |
| const z = m.getTransformFeedbackVarying(x, V); | |
| D[z.name] = { | |
| index: V, | |
| type: z.type, | |
| size: z.size | |
| } | |
| } | |
| return D | |
| } | |
| , | |
| n.bindTransformFeedbackInfo = q, | |
| n.createTransformFeedback = function K(m, x, D) { | |
| const k = m.createTransformFeedback(); | |
| return m.bindTransformFeedback(W.TRANSFORM_FEEDBACK, k), | |
| m.useProgram(x.program), | |
| void 0 !== D && q(m, x, D), | |
| m.bindTransformFeedback(W.TRANSFORM_FEEDBACK, null), | |
| k | |
| } | |
| , | |
| n.createUniformBlockSpecFromProgram = function X(m, x) { | |
| const D = x.program | |
| , k = m.getProgramParameter(D, W.ACTIVE_UNIFORMS) | |
| , V = new Array(k) | |
| , z = []; | |
| V.forEach( (ne, ce) => {} | |
| ); | |
| const j = { | |
| type: m.getActiveUniforms(D, V, m.UNIFORM_TYPE), | |
| size: m.getActiveUniforms(D, V, m.UNIFORM_SIZE), | |
| blockIndex: m.getActiveUniforms(D, V, m.UNIFORM_BLOCK_INDEX), | |
| offset: m.getActiveUniforms(D, V, m.UNIFORM_OFFSET) | |
| }; | |
| for (let ne = 0; ne < k; ne++) | |
| z.push({ | |
| name: m.getActiveUniform(D, ne).name, | |
| type: j.type[ne], | |
| size: j.size[ne], | |
| blockIndex: j.blockIndex[ne], | |
| offset: j.offset[ne] | |
| }); | |
| const Y = {} | |
| , ae = m.getProgramParameter(D, W.ACTIVE_UNIFORM_BLOCKS); | |
| for (let ne = 0; ne < ae; ne++) { | |
| const ce = m.getActiveUniformBlockName(D, ne) | |
| , Re = m.getActiveUniformBlockParameter(D, ne, W.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER) | |
| , Me = m.getActiveUniformBlockParameter(D, ne, W.UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER); | |
| Y[ce] = { | |
| index: m.getUniformBlockIndex(D, ce), | |
| size: m.getActiveUniformBlockParameter(D, ne, W.UNIFORM_BLOCK_DATA_SIZE), | |
| uniformIndices: m.getActiveUniformBlockParameter(D, ne, W.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES), | |
| usedByVertexShader: Re, | |
| usedByFragmentShader: Me, | |
| used: Re || Me | |
| } | |
| } | |
| return { | |
| blockSpecs: Y, | |
| uniformData: z | |
| } | |
| } | |
| , | |
| n.createUniformBlockUniformSetter = g, | |
| n.createUniformBlockInfoFromProgram = function y(m, x, D) { | |
| const k = x.program | |
| , V = void 0 !== x.uniformBlockSpec ? x.uniformBlockSpec.blockSpecs[D] : void 0 | |
| , z = void 0 !== x.uniformBlockSpec ? x.uniformBlockSpec.uniformData : void 0; | |
| if (void 0 === V) | |
| return function u(m) { | |
| console.warn(m) | |
| }(`WARN: CANNOT find uniform block object named: ${D}.`), | |
| { | |
| name: D, | |
| array: null, | |
| buffer: null | |
| }; | |
| const j = new ArrayBuffer(V.size) | |
| , Y = m.createBuffer(); | |
| m.bindBuffer(W.UNIFORM_BUFFER, Y), | |
| m.uniformBlockBinding(k, V.index, V.index); | |
| let ae = D + "."; | |
| a.test(ae) && (ae = ae.replace(a, ".")); | |
| const ne = {} | |
| , ce = {}; | |
| return V.uniformIndices.forEach(Re => { | |
| const Me = z[Re]; | |
| let Le = Me.name; | |
| Le.startsWith(ae) && (Le = Le.slice(ae.length)); | |
| const rt = Le.endsWith("[0]"); | |
| rt && (Le = Le.slice(0, Le.length - 3)); | |
| const Qe = Oa.get(Me.type) | |
| , st = Qe.type | |
| , ht = rt ? function ie(m, x) { | |
| return ((m + (x - 1)) / x | 0) * x | |
| }(Qe.size, 16) * Me.size : Qe.size * Me.size | |
| , at = new st(j,Me.offset,ht / st.BYTES_PER_ELEMENT); | |
| ne[Le] = at; | |
| const ft = g(at, rt, Qe.rows, Qe.cols); | |
| ce[Le] = ft | |
| } | |
| ), | |
| { | |
| name: D, | |
| array: j, | |
| buffer: Y, | |
| uniforms: ne, | |
| setters: ce | |
| } | |
| } | |
| , | |
| n.bindUniformBlock = E, | |
| n.setUniformBlock = function b(m, x, D) { | |
| E(m, x, D) && m.bufferData(W.UNIFORM_BUFFER, D.array, W.DYNAMIC_DRAW) | |
| } | |
| , | |
| n.resizeCanvasToDisplaySize = function w(m, x) { | |
| const D = m.clientWidth * (x = x || 1) | 0 | |
| , k = m.clientHeight * x | 0; | |
| return (m.width !== D || m.height !== k) && (m.width = D, | |
| m.height = k, | |
| !0) | |
| } | |
| , | |
| n.createWOITBufferInfo = function P(m) { | |
| const x = m.createBuffer(); | |
| return m.bindBuffer(m.ARRAY_BUFFER, x), | |
| m.bufferData(m.ARRAY_BUFFER, new Float32Array([-1, 1, 1, -1, 1, 1, -1, 1, -1, -1, 1, -1]), m.STATIC_DRAW), | |
| m.bindBuffer(m.ARRAY_BUFFER, null), | |
| { | |
| numElements: 6, | |
| attribs: { | |
| a_position: { | |
| numComponents: 2, | |
| buffer: x, | |
| type: m.FLOAT | |
| } | |
| } | |
| } | |
| } | |
| , | |
| n.bindWOITTextures = function G(m, x, D, k) { | |
| m.bindFramebuffer(m.FRAMEBUFFER, k), | |
| m.activeTexture(m.TEXTURE0), | |
| L(m, x, "colour"), | |
| L(m, D, "alpha"), | |
| m.drawBuffers([m.COLOR_ATTACHMENT0, m.COLOR_ATTACHMENT1]), | |
| m.bindFramebuffer(m.FRAMEBUFFER, null), | |
| m.activeTexture(m.TEXTURE1), | |
| m.bindTexture(m.TEXTURE_2D, x), | |
| m.activeTexture(m.TEXTURE2), | |
| m.bindTexture(m.TEXTURE_2D, D) | |
| } | |
| }(Pt || (Pt = {})); | |
| const He = { | |
| VS: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\t\n\tuniform mat4 u_worldMatrix;\n\t\n\tvoid main() {\n\t\tgl_Position = u_worldMatrix * a_position;\n\t\t// DO NOT REMOVE THIS LINE! ITS A TRICK FOR CALIBRATION IN SPECIFIC ANGLER\n\t\tgl_Position.z -= 0.0001;\n\t}", | |
| FS: "\n\t#version 300 es\n\tprecision highp float;\n\t\n\tuniform vec4 u_color;\n\t\n\tout vec4 v_fragmentColor;\n\t\n\tvoid main() {\n\t\tv_fragmentColor = u_color;\n\t}", | |
| VSWithPLight: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\tin vec3 a_normal;\n\t\n\tuniform mat4 u_worldMatrix;\n\tuniform mat4 u_modelITMatrix;\n\t\n\tout highp vec3 v_normal;\n\t\n\tvoid main() {\n\t\tgl_Position = u_worldMatrix * a_position;\n\t\tv_normal = mat3(u_modelITMatrix) * a_normal;\n\t}", | |
| FSWithPLight: "\n\t#version 300 es\n\tprecision highp float;\n\t\n\tin highp vec3 v_normal;\n\n\tuniform vec4 u_color;\n\tuniform vec3 u_lightNormal;\n\tuniform vec3 u_lightColor;\n\tuniform float u_shininess;\n\n\tout vec4 v_fragmentColor;\n\t\n\tvoid main() {\n\t\tfloat light = dot(normalize(v_normal), u_lightNormal) * 0.5 + 0.5;\n\t\tv_fragmentColor = u_color;\n\t\tv_fragmentColor.rgb = v_fragmentColor.rgb + (vec3(1.0, 1.0, 1.0) - v_fragmentColor.rgb) * pow(light, u_shininess) * u_lightColor;\n\t\tv_fragmentColor.a = u_color.a;\n\t}", | |
| VSWithDLight: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\tin vec3 a_normal;\n\t\n\tuniform mat4 u_worldMatrix;\n\tuniform mat4 u_modelITMatrix;\n\n\tuniform mat4 u_lightPosition;\n\t\n\tout highp vec3 v_normal;\n\tout highp vec3 v_lightPosition;\n\tout highp vec3 v_surfaceToLight;\n\t\n\tvoid main() {\n\t\tgl_Position = u_worldMatrix * a_position;\n\t\tv_normal = mat3(u_modelITMatrix) * a_normal;\n\t\tv_lightPosition = mat3(u_worldMatrix) * u_lightPosition;\n\t\tv_surfaceToLight = (u_lightPosition - u_worldMatrix * a_position).xyz\n\t}", | |
| FSWithDLight: "\n\t#version 300 es\n\tprecision highp float;\n\t\n\tin highp vec3 v_normal;\n\tin highp vec3 v_lightPosition\n\n\tuniform vec4 u_color;\n\tuniform vec3 u_lightNormal;\n\tuniform vec3 u_lightColor;\n\tuniform float u_shininess;\n\n\tout vec4 v_fragmentColor;\n\t\n\tvoid main() {\n\t\tfloat light = dot(normalize(v_normal), u_lightNormal) * 0.5 + 0.5;\n\t\tv_fragmentColor = u_color;\n\t\tv_fragmentColor.rgb = v_fragmentColor.rgb + (vec3(1.0, 1.0, 1.0) - v_fragmentColor.rgb) * pow(light, u_shininess) * u_lightColor;\n\t\tv_fragmentColor.a = u_color.a;\n\t}", | |
| VSWithClipping: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\t\n\tuniform mat4 u_modelViewMatrix;\n\tuniform mat4 u_worldMatrix;\n\t\n\tout vec3 v_modelViewPosition;\n\t\n\tvoid main() {\n\t\tv_modelViewPosition = (u_modelViewMatrix * a_position).xyz;\n\t\tgl_Position = u_worldMatrix * a_position;\n\t}", | |
| FSWithClipping: "\n\t#version 300 es\n\tprecision highp float;\n\n\tin vec3 v_modelViewPosition;\n\t\n\tuniform mat4 u_viewMatrix;\n\tuniform mat3 u_viewNormalMatrix;\n\tuniform vec4 u_planeEquation;\n\tuniform vec4 u_color;\n\n\tout vec4 v_fragmentColor;\n\n\tvec4 planeToEC(vec4 plane, mat4 viewMatrix, mat3 viewNormalMatrix) {\n\t\tvec3 normal = vec3(plane.x, plane.y, plane.z);\n\t\tvec3 pointInWC = normal * -plane.w;\n\t\tvec3 pointInEC = (viewMatrix * vec4(pointInWC.xyz, 1.0)).xyz;\n\t\tvec3 normalInEC = normalize(viewNormalMatrix * normal);\n\t\treturn vec4(normalInEC, -dot(normalInEC, pointInEC));\n\t}\n\n\tfloat calDistance(vec4 plane, vec3 position) {\n\t\tfloat distance = dot(vec3(plane.x, plane.y, plane.z), position) + plane.w;\n\t\treturn distance;\n\t}\n\t\n\tvoid main() {\n\t\tvec4 planeInEC = planeToEC(u_planeEquation, u_viewMatrix, u_viewNormalMatrix);\n\t\tfloat distance = calDistance(planeInEC, v_modelViewPosition);\n\t\tif (sign(planeInEC.z) * distance > 1e-4) {\n\t\t\tdiscard;\n\t\t}\n\t\tv_fragmentColor = u_color;\n\t}", | |
| VSWithTexture: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\tin vec2 a_texcoord;\n\n\tuniform mat4 u_worldMatrix;\n\t\n\tout mediump vec2 v_texcoord;\n\t\n\tvoid main() {\n\t\tgl_Position = u_worldMatrix * a_position;\n\t\tv_texcoord = a_texcoord;\n\t}", | |
| FSWithTexture: "\n\t#version 300 es\n\tprecision highp float;\n\n\tin mediump vec2 v_texcoord;\n\t\n\tuniform vec4 u_color;\n\tuniform sampler2D u_texture;\n\t\n\tout vec4 v_fragmentColor;\n\n\tvoid main() {\n\t\tv_fragmentColor = u_color * texture(u_texture, v_texcoord);\n\t}", | |
| VSWithWOIT: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\t\n\tvoid main() {\n\t\tgl_Position = a_position;\n\t}", | |
| FSWithWOIT: "\n\t#version 300 es\n\tprecision highp float;\n\n\tuniform sampler2D u_accumulateColor;\n\tuniform sampler2D u_accumulateAlpha;\n\t\n\tout vec4 v_fragmentColor;\n\n\tbool isZero(vec4 v) {\n\t\tfloat epsilon = 1e-5;\n\t\treturn abs(v.x) < epsilon && abs(v.y) < epsilon && abs(v.z) < epsilon && abs(v.w) < epsilon;\n\t}\n\n\tvoid main() {\n\t\tivec2\tfragCoord\t= ivec2(gl_FragCoord.xy);\n\t\tvec4\taccumulate\t= texelFetch(u_accumulateColor, fragCoord, 0);\n\t\tif (isZero(accumulate)) {\n\t\t\tv_fragmentColor\t\t= vec4(0.0);\n\t\t} else {\n\t\t\tfloat\talpha\t\t= 1.0 - accumulate.a;\n\t\t\taccumulate.a\t\t= texelFetch(u_accumulateAlpha, fragCoord, 0).r;\n\t\t\tv_fragmentColor\t\t= vec4(alpha * accumulate.rgb / clamp(accumulate.a, 0.001, 50000.0), alpha);\n\t\t}\t\t\n\t}", | |
| VSWithAccum: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\t\n\tuniform mat4 u_worldMatrix;\n\n\tvoid main() {\n\t\tgl_Position = u_worldMatrix * a_position;\n\t}", | |
| FSWithAccum: "\n\t#version 300 es\n\tprecision highp float;\n\n\tuniform vec4 u_color;\n\t\n\tlayout(location=0) out vec4 accumColor;\n\tlayout(location=1) out float accumAlpha;\n\n\tfloat calWeight(float z, float a) {\n\t\treturn clamp(pow(min(1.0, a * 10.0) + 0.01, 3.0) * 1e8 * pow(1.0 - z * 0.9, 3.0), 1e-2, 3e3);\n\t}\n\n\tvoid main() {\n\t\tvec4 color\t\t= u_color;\n\t\tfloat weight\t= calWeight(gl_FragCoord.z, color.a);\n\t\taccumColor\t\t= vec4(color.rgb * weight, color.a);\n\t\taccumAlpha\t\t= color.a * weight;\n\t}", | |
| VSWithAccumAndPLight: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\tin vec3 a_normal;\n\t\n\tuniform mat4 u_worldMatrix;\n\tuniform mat4 u_modelITMatrix; \n\t\n\tout vec3 v_normal;\n\n\tvoid main() {\n\t\tgl_Position = u_worldMatrix * a_position;\n\t\tv_normal = mat3(u_modelITMatrix) * a_normal;\n\t}", | |
| FSWithAccumAndPLight: "\n\t#version 300 es\n\tprecision highp float;\n\n\tin vec3 v_normal;\n\n\tuniform vec4 u_color;\n\tuniform vec3 u_lightNormal;\n\tuniform vec3 u_lightColor;\n\tuniform float u_shininess;\n\t\n\tlayout(location=0) out vec4 accumColor;\n\tlayout(location=1) out float accumAlpha;\n\n\tfloat calWeight(float z, float a) {\n\t\treturn clamp(pow(min(1.0, a * 10.0) + 0.01, 3.0) * 1e8 * pow(1.0 - z * 0.9, 3.0), 1e-2, 3e3);\n\t}\n\n\tvoid main() {\n\t\tfloat light\t\t= dot(normalize(v_normal), u_lightNormal.xyz) * 0.5 + 0.5;\n\t\tvec4 color\t\t= vec4((u_color.rgb + (vec3(1.0, 1.0, 1.0) - u_color.rgb) * pow(light, u_shininess) * u_lightColor.xyz) * u_color.a, u_color.a);\n\t\tfloat weight\t= calWeight(gl_FragCoord.z, color.a);\n\t\taccumColor\t\t= vec4(color.rgb * weight, color.a);\n\t\taccumAlpha\t\t= color.a * weight;\n\t}", | |
| VSWithAccumAndTexture: "\n\t#version 300 es\n\n\tin vec4 a_position;\n\tin vec2 a_texcoord;\n\t\n\tuniform mat4 u_worldMatrix;\n\t\n\tout mediump vec2 v_texcoord;\n\n\tvoid main() {\n\t\tgl_Position = u_worldMatrix * a_position;\n\t\tv_texcoord = a_texcoord;\n\t}\n\t", | |
| FSWithAccumAndTexture: "\n\t#version 300 es\n\tprecision highp float;\n\n\tin mediump vec2 v_texcoord;\n\n\tuniform vec4 u_color;\n\tuniform sampler2D u_texture;\n\t\n\tlayout(location=0) out vec4 accumColor;\n\tlayout(location=1) out float accumAlpha;\n\n\tfloat calWeight(float z, float a) {\n\t\treturn clamp(pow(min(1.0, a * 10.0) + 0.01, 3.0) * 1e8 * pow(1.0 - z * 0.9, 3.0), 1e-2, 3e3);\n\t}\n\n\tvoid main() {\n\t\tvec4 color\t\t= u_color * texture(u_texture, v_texcoord);\n\t\tfloat weight\t= calWeight(gl_FragCoord.z, color.a);\n\t\taccumColor\t\t= vec4(color.rgb * weight, color.a);\n\t\taccumAlpha\t\t= color.a * weight;\n\t}\n\t" | |
| } | |
| , Ej = location.hostname.includes("fenbilantian.cn") ? `${location.protocol}//webapi.fenbilantian.cn/doc/api/cos/private/gltf` : `${location.protocol}//webapi.fenbi.com/doc/api/cos/private/gltf`; | |
| var jt, fu = ( () => (function(n) { | |
| n[n.POINTS = 0] = "POINTS", | |
| n[n.LINES = 1] = "LINES", | |
| n[n.LINE_LOOP = 2] = "LINE_LOOP", | |
| n[n.LINE_STRIP = 3] = "LINE_STRIP", | |
| n[n.TRIANGLES = 4] = "TRIANGLES", | |
| n[n.TRIANGLE_STRIP = 5] = "TRIANGLE_STRIP", | |
| n[n.TRIANGLE_FAN = 6] = "TRIANGLE_FAN" | |
| }(fu || (fu = {})), | |
| fu))(), vi = ( () => (function(n) { | |
| n[n.ARRAY_BUFFER = 34962] = "ARRAY_BUFFER", | |
| n[n.ELEMENT_ARRAY_BUFFER = 34963] = "ELEMENT_ARRAY_BUFFER" | |
| }(vi || (vi = {})), | |
| vi))(), Na = ( () => (function(n) { | |
| n[n.CLAMP_TO_EDGE = 33071] = "CLAMP_TO_EDGE", | |
| n[n.MIRRORED_REPEAT = 33648] = "MIRRORED_REPEAT", | |
| n[n.REPEAT = 10497] = "REPEAT" | |
| }(Na || (Na = {})), | |
| Na))(); | |
| class wj { | |
| constructor(e, t) { | |
| const r = e.nodes.length; | |
| this.nodes = []; | |
| for (let i = 0; i < r; i++) | |
| this.nodes.push(t.nodes[e.nodes[i]]); | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.boundingBox = null | |
| } | |
| } | |
| class rs { | |
| constructor(e, t, r) { | |
| e = e || T.fromValues(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY), | |
| t = t || T.fromValues(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY), | |
| !0 === r ? (this.min = T.clone(e), | |
| this.max = T.clone(t)) : (this.min = e, | |
| this.max = t), | |
| this.transform = pe.create() | |
| } | |
| updateBoundingBox(e) { | |
| return this.min = T.min(this.min, e.min), | |
| this.max = T.max(this.max, e.max), | |
| this | |
| } | |
| calculateTransform() { | |
| return this.transform[0] = this.max[0] - this.min[0], | |
| this.transform[5] = this.max[1] - this.min[1], | |
| this.transform[10] = this.max[2] - this.min[2], | |
| this.transform[12] = this.min[0], | |
| this.transform[13] = this.min[1], | |
| this.transform[14] = this.min[2], | |
| this | |
| } | |
| getAABBFromOBB(e) { | |
| let t = T.fromValues(e[0], e[1], e[2]) | |
| , r = T.fromValues(e[4], e[5], e[6]) | |
| , i = T.fromValues(e[8], e[9], e[10]) | |
| , o = T.create() | |
| , s = T.create() | |
| , a = T.fromValues(e[12], e[13], e[14]) | |
| , l = T.clone(a); | |
| return o = T.scale(t, this.min[0]), | |
| s = T.scale(t, this.max[0]), | |
| t = T.min(o, s), | |
| a = T.add(a, t), | |
| t = T.max(o, s), | |
| l = T.add(l, t), | |
| o = T.scale(r, this.min[1]), | |
| s = T.scale(r, this.max[1]), | |
| r = T.min(o, s), | |
| a = T.add(a, r), | |
| r = T.max(o, s), | |
| l = T.add(l, r), | |
| o = T.scale(i, this.min[2]), | |
| s = T.scale(i, this.max[2]), | |
| i = T.min(o, s), | |
| a = T.add(a, i), | |
| i = T.max(o, s), | |
| l = T.add(l, i), | |
| new rs(a,l).calculateTransform() | |
| } | |
| } | |
| class Dj { | |
| constructor(e, t) { | |
| this.bufferView = t, | |
| this.byteOffset = void 0 !== e.byteOffset ? e.byteOffset : 0, | |
| this.componentType = e.componentType, | |
| this.normalized = void 0 !== e.normalized && e.normalized, | |
| this.count = e.count, | |
| this.type = e.type, | |
| this.max = e.max, | |
| this.min = e.min, | |
| this.sparse = void 0 !== e.sparse ? e.sparse : null, | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| prepareVertexAttribute(e, t) { | |
| e.vertexAttribPointer(t, jt.accessorTypeToNumComponents(this.type), this.componentType, this.normalized, this.bufferView.byteStride, this.byteOffset), | |
| e.enableVertexAttribArray(t) | |
| } | |
| } | |
| class Mj { | |
| constructor(e, t) { | |
| this.buffer = null, | |
| this.byteOffset = void 0 !== e.byteOffset ? e.byteOffset : 0, | |
| this.byteLength = e.byteLength, | |
| this.byteStride = void 0 !== e.byteStride ? e.byteStride : 0, | |
| this.target = void 0 !== e.target ? e.target : vi.ARRAY_BUFFER, | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.data = t.slice(this.byteOffset, this.byteOffset + this.byteLength) | |
| } | |
| createBuffer(e) { | |
| this.buffer = e.createBuffer() | |
| } | |
| bindData(e) { | |
| const t = this.target || vi.ARRAY_BUFFER; | |
| e.bindBuffer(t, this.buffer), | |
| e.bufferData(t, this.data, e.STATIC_DRAW), | |
| e.bindBuffer(t, null) | |
| } | |
| } | |
| class Aj { | |
| constructor(e) { | |
| this.orthographic = void 0 !== e.orthographic ? e.orthographic : null, | |
| this.perspective = void 0 !== e.perspective ? e.perspective : null, | |
| this.type = e.type, | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class Ij { | |
| constructor(e, t, r) { | |
| this.camera = void 0 !== e.camera ? e.camera : null, | |
| this.children = [], | |
| this.skin = null, | |
| this.translation = void 0 !== e.translation ? e.translation : T.create(), | |
| this.rotation = void 0 !== e.rotation ? e.rotation : et.create(), | |
| this.scale = void 0 !== e.scale ? e.scale : T.fromValues(1, 1, 1), | |
| this.matrix = void 0 !== e.matrix ? pe.clone(e.matrix) : pe.fromScaleRotationTranslation(this.translation, this.rotation, this.scale), | |
| this.mesh = void 0 !== e.mesh ? r.glTF.meshes[e.mesh] : null, | |
| this.weights = void 0 !== e.weights ? e.weights : null, | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.nodeID = t, | |
| this.childrenID = void 0 !== e.children ? e.children : [], | |
| this.parent = null, | |
| this.modelMatrix = pe.clone(this.matrix), | |
| this.worldMatrix = pe.clone(this.matrix), | |
| void 0 !== e.extensions && (this.skinLink = void 0 !== e.extensions.gl_avatar && !0 === r.enableGLAvatar ? new Lj(r.skeletonGLTF.skins[r._glTF.extensions.gl_avatar.skins[e.extensions.gl_avatar.skin.name]],r.glTF,e.extensions.gl_avatar.skin.inverseBindMatrices) : null), | |
| this.aabb = null, | |
| this.bvh = new rs | |
| } | |
| traverse(e, t) { | |
| e(this, t = void 0 === t ? null : t); | |
| for (let r = 0, i = this.children.length; r < i; r++) | |
| this.children[r].traverse(e, this) | |
| } | |
| traversePostOrder(e, t) { | |
| t = void 0 === t ? null : t; | |
| for (var r = 0, i = this.children.length; r < i; r++) | |
| this.children[r].traversePostOrder(e, this); | |
| e(this, t) | |
| } | |
| traverseTwoFunction(e, t, r) { | |
| e(this, r = void 0 === r ? null : r); | |
| for (let i = 0, o = this.children.length; i < o; i++) | |
| this.children[i].traverseTwoFunction(e, t, this); | |
| t(this, r) | |
| } | |
| } | |
| class Sj { | |
| constructor(e, t, r) { | |
| let i, o; | |
| this.primitives = [], | |
| this.weights = void 0 !== e.weights ? e.weights : null, | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.boundingBox = null; | |
| for (let s = 0; s < e.primitives.length; s++) | |
| i = e.primitives[s], | |
| o = new xj(i,r.glTF,r), | |
| this.primitives.push(o), | |
| o.boundingBox && (this.boundingBox || (this.boundingBox = new rs), | |
| this.boundingBox.updateBoundingBox(o.boundingBox)); | |
| this.boundingBox && this.boundingBox.calculateTransform(), | |
| this.meshID = t | |
| } | |
| } | |
| class xj { | |
| constructor(e, t, r) { | |
| if (this.attributesID = e.attributes, | |
| void 0 !== e.extensions && void 0 !== e.extensions.gl_avatar && !0 === r.enableGLAvatar && e.extensions.gl_avatar.attributes) | |
| for (let i in e.extensions.gl_avatar.attributes) | |
| this.attributesID[i] = e.extensions.gl_avatar.attributeName[i]; | |
| this.attributes = { | |
| POSITION: null, | |
| NORMAL: null, | |
| TEXCOORD_0: null | |
| }; | |
| for (let i in this.attributesID) | |
| this.attributes[i] = t.accessors[this.attributesID[i]]; | |
| if (void 0 !== this.attributes.POSITION) { | |
| let i = this.attributes.POSITION; | |
| i.max && "VEC3" === i.type && (this.boundingBox = new rs(T.fromValues(i.min[0], i.min[1], i.min[2]),T.fromValues(i.max[0], i.max[1], i.max[2])), | |
| this.boundingBox.calculateTransform()) | |
| } | |
| this.indicesID = void 0 !== e.indices ? e.indices : null, | |
| null !== this.indicesID ? this.indices = t.accessors[this.indicesID] : this.drawIndices = t.accessors[this.attributesID.POSITION], | |
| this.material = void 0 !== e.material ? t.materials[e.material] : null, | |
| this.mode = void 0 !== e.mode ? e.mode : fu.TRIANGLES, | |
| this.targetsID = void 0 !== e.targets ? e.targets : null; | |
| for (let i in this.targetsID) | |
| ; | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.vertexArray = null, | |
| this.vertexBuffer = null, | |
| this.shader = null | |
| } | |
| } | |
| class Rj { | |
| constructor(e, t) { | |
| this.sampler = void 0 !== e.sampler ? t.glTF.samplers[e.sampler] : null, | |
| this.source = void 0 !== e.sampler ? t.glTF.images[e.source] : null, | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.texture = null | |
| } | |
| createTexture(e) { | |
| this.texture && e.deleteTexture(this.texture), | |
| this.texture = e.createTexture(), | |
| e.bindTexture(e.TEXTURE_2D, this.texture), | |
| e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, this.source), | |
| e.generateMipmap(e.TEXTURE_2D), | |
| e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR_MIPMAP_LINEAR), | |
| e.bindTexture(e.TEXTURE_2D, null) | |
| } | |
| createCubeTexture(e, t) { | |
| this.texture && e.deleteTexture(this.texture), | |
| this.texture = e.createTexture(), | |
| e.bindTexture(e.TEXTURE_CUBE_MAP, this.texture), | |
| e.texImage2D(t, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, this.source), | |
| e.generateMipmap(e.TEXTURE_CUBE_MAP), | |
| e.texParameteri(e.TEXTURE_CUBE_MAP, e.TEXTURE_MIN_FILTER, e.LINEAR_MIPMAP_LINEAR), | |
| e.bindTexture(e.TEXTURE_2D, null) | |
| } | |
| } | |
| class Fj { | |
| constructor(e) { | |
| this.magFilter = void 0 !== e.magFilter ? e.magFilter : null, | |
| this.minFilter = void 0 !== e.minFilter ? e.minFilter : null, | |
| this.wrapS = void 0 !== e.wrapS ? e.wrapS : Na.REPEAT, | |
| this.wrapT = void 0 !== e.wrapT ? e.wrapT : Na.REPEAT, | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.sampler = null | |
| } | |
| createSampler(e) { | |
| this.sampler = e.createSampler(), | |
| e.samplerParameteri(this.sampler, e.TEXTURE_MIN_FILTER, this.minFilter ? this.minFilter : e.NEAREST_MIPMAP_LINEAR), | |
| e.samplerParameteri(this.sampler, e.TEXTURE_MAG_FILTER, this.magFilter ? this.magFilter : e.LINEAR), | |
| e.samplerParameteri(this.sampler, e.TEXTURE_WRAP_S, this.wrapS), | |
| e.samplerParameteri(this.sampler, e.TEXTURE_WRAP_T, this.wrapT) | |
| } | |
| } | |
| class Eg { | |
| constructor(e) { | |
| this.index = e.index, | |
| this.texCoord = void 0 !== e.texCoord ? e.texCoord : 0, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class Pj { | |
| constructor(e) { | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.pbrMetallicRoughness = new vD(void 0 !== e.pbrMetallicRoughness ? e.pbrMetallicRoughness : { | |
| baseColorFactor: [1, 1, 1, 1], | |
| baseColorTexture: null, | |
| metallicFactor: 1, | |
| roughnessFactor: 1, | |
| metallicRoughnessTexture: null | |
| }), | |
| this.normalTexture = void 0 !== e.normalTexture ? new Oj(e.normalTexture) : null, | |
| this.occlusionTexture = void 0 !== e.occlusionTexture ? new Nj(e.occlusionTexture) : null, | |
| this.emissiveTexture = void 0 !== e.emissiveTexture ? new Eg(e.emissiveTexture) : null, | |
| this.emissiveFactor = void 0 !== e.emissiveFactor ? e.emissiveFactor : [0, 0, 0], | |
| this.alphaMode = void 0 !== e.alphaMode ? e.alphaMode : "OPAQUE", | |
| this.alphaCutoff = void 0 !== e.alphaCutoff ? e.alphaCutoff : .5, | |
| this.doubleSided = !!e.doubleSided | |
| } | |
| } | |
| class vD { | |
| constructor(e) { | |
| this.baseColorFactor = void 0 !== e.baseColorFactor ? e.baseColorFactor : [1, 1, 1, 1], | |
| this.baseColorTexture = void 0 !== e.baseColorTexture ? new Eg(e.baseColorTexture) : null, | |
| this.metallicFactor = void 0 !== e.metallicFactor ? e.metallicFactor : 1, | |
| this.roughnessFactor = void 0 !== e.roughnessFactor ? e.roughnessFactor : 1, | |
| this.metallicRoughnessTexture = void 0 !== e.metallicRoughnessTexture ? new Eg(e.metallicRoughnessTexture) : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class Oj { | |
| constructor(e) { | |
| this.index = void 0 !== e.index ? e.index : 0, | |
| this.texCoord = void 0 !== e.texCoord ? e.texCoord : 0, | |
| this.scale = void 0 !== e.scale ? e.scale : 1, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class Nj { | |
| constructor(e) { | |
| this.index = void 0 !== e.index ? e.index : 0, | |
| this.texCoord = void 0 !== e.texCoord ? e.texCoord : 0, | |
| this.strength = void 0 !== e.strength ? e.strength : 1, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class kj { | |
| constructor(e, t) { | |
| this.inverseBindMatrices = void 0 !== e.inverseBindMatrices ? t.accessors[e.inverseBindMatrices] : null, | |
| this.skeleton = void 0 !== e.skeleton ? t.nodes[e.skeleton] : null, | |
| this.joints = []; | |
| for (let r = 0; r < e.joints.length; r++) | |
| this.joints.push(t.nodes[e.joints[r]]); | |
| if (this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.isLink = !1, | |
| this.inverseBindMatrices) { | |
| this.inverseBindMatricesData = jt.getAccessorData(this.inverseBindMatrices), | |
| this.inverseBindMatrix = []; | |
| for (let r = 0; r < this.inverseBindMatricesData.length; r += 16) | |
| this.inverseBindMatrix.push(pe.fromValues(this.inverseBindMatricesData[r], this.inverseBindMatricesData[r + 1], this.inverseBindMatricesData[r + 2], this.inverseBindMatricesData[r + 3], this.inverseBindMatricesData[r + 4], this.inverseBindMatricesData[r + 5], this.inverseBindMatricesData[r + 6], this.inverseBindMatricesData[r + 7], this.inverseBindMatricesData[r + 8], this.inverseBindMatricesData[r + 9], this.inverseBindMatricesData[r + 10], this.inverseBindMatricesData[r + 11], this.inverseBindMatricesData[r + 12], this.inverseBindMatricesData[r + 13], this.inverseBindMatricesData[r + 14], this.inverseBindMatricesData[r + 15])) | |
| } | |
| } | |
| } | |
| class Lj { | |
| constructor(e, t, r) { | |
| if (t.skins || (t.skins = []), | |
| t.skins.push(this), | |
| this.inverseBindMatrices = void 0 !== r ? t.accessors[r] : null, | |
| this.skeleton = e.skeleton, | |
| this.joints = e.joints, | |
| this.name = e.name, | |
| this.extensions = e.extensions, | |
| this.extras = e.extras, | |
| this.isLink = !0, | |
| this.inverseBindMatrices) { | |
| this.inverseBindMatricesData = jt.getAccessorData(this.inverseBindMatrices), | |
| this.inverseBindMatrix = []; | |
| for (let i = 0; i < this.inverseBindMatricesData.length; i += 16) | |
| this.inverseBindMatrix.push(pe.fromValues(this.inverseBindMatricesData[i], this.inverseBindMatricesData[i + 1], this.inverseBindMatricesData[i + 2], this.inverseBindMatricesData[i + 3], this.inverseBindMatricesData[i + 4], this.inverseBindMatricesData[i + 5], this.inverseBindMatricesData[i + 6], this.inverseBindMatricesData[i + 7], this.inverseBindMatricesData[i + 8], this.inverseBindMatricesData[i + 9], this.inverseBindMatricesData[i + 10], this.inverseBindMatricesData[i + 11], this.inverseBindMatricesData[i + 12], this.inverseBindMatricesData[i + 13], this.inverseBindMatricesData[i + 14], this.inverseBindMatricesData[i + 15])) | |
| } | |
| } | |
| } | |
| class Vj { | |
| constructor(e, t) { | |
| this.samplers = []; | |
| for (let r = 0; r < e.samplers.length; r++) | |
| this.samplers.push(new jj(e.samplers[r],t)); | |
| this.channels = []; | |
| for (let r = 0; r < e.channels.length; r++) | |
| this.channels.push(new Bj(e.channels[r],this)); | |
| this.name = void 0 !== e.name ? e.name : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class Bj { | |
| constructor(e, t) { | |
| this.sampler = t.samplers[e.sampler], | |
| this.target = new Uj(e.target), | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class Uj { | |
| constructor(e) { | |
| this.nodeID = e.node, | |
| this.path = e.path, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class jj { | |
| constructor(e, t) { | |
| this.input = t.accessors[e.input], | |
| this.interpolation = void 0 !== e.interpolation ? e.interpolation : "LINEAR", | |
| this.output = t.accessors[e.output], | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null, | |
| this.keyFrameIndices = jt.getAccessorData(this.input), | |
| this.keyFrameRaw = jt.getAccessorData(this.output), | |
| this.keyFrames = { | |
| src: null, | |
| dst: null | |
| }, | |
| this.currentIndex = 0, | |
| this.startTime = this.keyFrameIndices[0], | |
| this.endTime = this.keyFrameIndices[this.keyFrameIndices.length - 1], | |
| this.duration = this.endTime - this.startTime | |
| } | |
| updateKeyFrames(e) { | |
| for (let r = 0; r < this.keyFrameIndices.length - 1; r++) | |
| e > this.keyFrameIndices[r] && e < this.keyFrameIndices[r + 1] && (this.currentIndex = r); | |
| const t = jt.accessorTypeToNumComponents(this.output.type); | |
| this.keyFrames.src = this.keyFrameRaw.slice(this.currentIndex * t, (this.currentIndex + 1) * t), | |
| this.keyFrames.dst = this.keyFrameRaw.slice((this.currentIndex + 1) * t, (this.currentIndex + 2) * t) | |
| } | |
| } | |
| class Hj { | |
| constructor(e) { | |
| this.asset = e.asset, | |
| this.scene = null, | |
| this.scenes = void 0 !== e.scenes ? [] : null, | |
| this.nodes = void 0 !== e.nodes ? [] : null, | |
| this.meshes = void 0 !== e.meshes ? [] : null, | |
| this.accessors = void 0 !== e.accessors ? [] : null, | |
| this.bufferViews = void 0 !== e.bufferViews ? [] : null, | |
| this.buffers = void 0 !== e.buffers ? [] : null, | |
| this.animations = void 0 !== e.animations ? [] : null, | |
| this.cameras = void 0 !== e.cameras ? [] : null, | |
| this.textures = void 0 !== e.textures ? [] : null, | |
| this.images = void 0 !== e.images ? [] : null, | |
| this.samplers = void 0 !== e.samplers ? [] : null, | |
| this.materials = void 0 !== e.materials ? [] : null, | |
| this.skins = void 0 !== e.skins ? [] : null, | |
| this.extensions = void 0 !== e.extensions ? e.extensions : null, | |
| this.extensionsUsed = void 0 !== e.extensionsUsed ? e.extensionsUsed : null, | |
| this.extensionsRequired = void 0 !== e.extensionsRequired ? e.extensionsRequired : null, | |
| this.extras = void 0 !== e.extras ? e.extras : null | |
| } | |
| } | |
| class ka { | |
| constructor(e) { | |
| this.glTF = null, | |
| this.enableGLAvatar = !1, | |
| this.skeletonGLTF = null, | |
| this.gl = e | |
| } | |
| getBaseUri(e) { | |
| let t = ""; | |
| return -1 !== e.lastIndexOf("/") && (t = e.substring(0, e.lastIndexOf("/") + 1)), | |
| t | |
| } | |
| inferBufferViewTarget() { | |
| this._glTF.meshes.forEach(e => { | |
| e.primitives.forEach(t => { | |
| for (const [r,i] of Object.entries(t.attributes)) | |
| ("POSITION" === r || "NORMAL" === r || "TEXCOORD_0" === r) && (this._glTF.bufferViews[this._glTF.accessors[i].bufferView].target = vi.ARRAY_BUFFER); | |
| if (void 0 !== t.indices) { | |
| const r = this._glTF.bufferViews[this._glTF.accessors[t.indices].bufferView]; | |
| void 0 !== r.target ? r.target !== vi.ELEMENT_ARRAY_BUFFER && console.warn("BufferView " + t.indices + " should have a target equal to ELEMENT_ARRAY_BUFFER") : r.target = vi.ELEMENT_ARRAY_BUFFER | |
| } | |
| } | |
| ) | |
| } | |
| ) | |
| } | |
| postProcess() { | |
| if (this.inferBufferViewTarget(), | |
| void 0 !== this._glTF.bufferViews) | |
| for (let e = 0; e < this._glTF.bufferViews.length; e++) { | |
| const t = new Mj(this._glTF.bufferViews[e],this.glTF.buffers[this._glTF.bufferViews[e].buffer]); | |
| t.createBuffer(this.gl), | |
| t.bindData(this.gl), | |
| this.glTF.bufferViews.push(t) | |
| } | |
| if (void 0 !== this._glTF.accessors) | |
| for (let e = 0; e < this._glTF.accessors.length; e++) | |
| this.glTF.accessors.push(new Dj(this._glTF.accessors[e],this.glTF.bufferViews[this._glTF.accessors[e].bufferView])); | |
| if (void 0 !== this._glTF.cameras) | |
| for (let e = 0; e < this._glTF.cameras.length; e++) | |
| this.glTF.cameras.push(new Aj(this._glTF.cameras[e])); | |
| if (void 0 !== this._glTF.materials) | |
| for (let e = 0; e < this._glTF.materials.length; e++) | |
| this.glTF.materials.push(new Pj(this._glTF.materials[e])); | |
| if (void 0 !== this._glTF.samplers) | |
| for (let e = 0; e < this._glTF.samplers.length; e++) | |
| this.glTF.samplers.push(new Fj(this._glTF.samplers[e])); | |
| if (void 0 !== this._glTF.textures) | |
| for (let e = 0; e < this._glTF.textures.length; e++) | |
| this.glTF.textures.push(new Rj(this._glTF.textures[e],this)), | |
| this.glTF.textures[e].createTexture(this.gl); | |
| if (void 0 !== this._glTF.meshes) | |
| for (let e = 0; e < this._glTF.meshes.length; e++) | |
| this.glTF.meshes.push(new Sj(this._glTF.meshes[e],e,this)); | |
| if (void 0 !== this._glTF.nodes) { | |
| for (let e = 0; e < this._glTF.nodes.length; e++) | |
| this.glTF.nodes.push(new Ij(this._glTF.nodes[e],e,this)); | |
| if (this.glTF.nodes.forEach(e => { | |
| for (let t = 0; t < e.childrenID.length; t++) | |
| e.children[t] = this.glTF.nodes[e.childrenID[t]], | |
| e.children[t].parent = e | |
| } | |
| ), | |
| void 0 !== this._glTF.scenes) { | |
| for (let e = 0; e < this._glTF.scenes.length; e++) { | |
| this.glTF.scenes[e] = new wj(this._glTF.scenes[e],this.glTF), | |
| this.glTF.scenes[e].boundingBox = new rs; | |
| const t = new Array(this.glTF.nodes.length); | |
| for (let r = 0; r < this.glTF.scenes[e].nodes.length; r++) | |
| this.glTF.scenes[e].nodes[r].traverseTwoFunction( (i, o) => { | |
| t[i.nodeID] = null !== o ? pe.multiply(t[o.nodeID], i.modelMatrix) : pe.clone(i.modelMatrix) | |
| } | |
| , (i, o) => { | |
| i.mesh && (i.worldMatrix = pe.clone(t[i.nodeID]), | |
| i.mesh.boundingBox && (i.aabb = i.mesh.boundingBox.getAABBFromOBB(t[i.nodeID]), | |
| 0 === i.children.length && (i.bvh.min = T.clone(i.aabb.min), | |
| i.bvh.max = T.clone(i.aabb.max)))), | |
| null !== o ? (o.bvh.min = T.min(o.bvh.min, i.bvh.min), | |
| o.bvh.max = T.max(o.bvh.max, i.bvh.max)) : (this.glTF.scenes[e].boundingBox.min = T.min(this.glTF.scenes[e].boundingBox.min, i.bvh.min), | |
| this.glTF.scenes[e].boundingBox.max = T.max(this.glTF.scenes[e].boundingBox.max, i.bvh.max)) | |
| } | |
| ); | |
| this.glTF.scenes[e].boundingBox.calculateTransform() | |
| } | |
| this.glTF.scene = void 0 !== this._glTF.scene ? this.glTF.scenes[this._glTF.scene] : this.glTF.scenes[0] | |
| } | |
| for (let e = 0; e < this.glTF.nodes.length; e++) | |
| null !== this.glTF.nodes[e].bvh && this.glTF.nodes[e].bvh.calculateTransform() | |
| } | |
| if (this._glTF.animations) | |
| for (let e = 0; e < this._glTF.animations.length; e++) | |
| this.glTF.animations.push(new Vj(this._glTF.animations[e],this.glTF)), | |
| this.glTF.animations[e].channels.forEach(t => { | |
| t.target.node = this.glTF.nodes[t.target.nodeID] | |
| } | |
| ); | |
| if (this._glTF.skins) { | |
| for (let e = 0; e < this._glTF.skins.length; e++) | |
| this.glTF.skins.push(new kj(this._glTF.skins[e],this.glTF)); | |
| for (let e = 0; e < this.glTF.nodes.length; e++) | |
| null !== this.glTF.nodes[e].skin && (this.glTF.nodes[e].skin = this.glTF.skins[this._glTF.nodes[this.glTF.nodes[e].nodeID].skin]) | |
| } | |
| } | |
| getAssetUrl(e, t) { | |
| return Ht(this, void 0, void 0, function*() { | |
| const r = new URL(`${Ej}/url/${e.id}`); | |
| r.searchParams.append("name", t || e.value); | |
| const i = yield wg(r, { | |
| method: "GET", | |
| credentials: "include" | |
| }); | |
| if (i.code === ns.Succeed) | |
| return i.data.url; | |
| throw new Error("Asset not found: " + r.href) | |
| }) | |
| } | |
| loadGLTF(e) { | |
| return Ht(this, void 0, void 0, function*() { | |
| try { | |
| const i = yield this.getAssetUrl(e, `${e.value}.gltf`) | |
| , o = yield fetch(new Request(i)).then(s => { | |
| if (s.ok) | |
| return s.json(); | |
| throw Error("LoadingError: Error occurred in loading glTF JSON.") | |
| } | |
| ); | |
| this._glTF = o, | |
| this.glTF = new Hj(o) | |
| } catch (i) { | |
| console.error(i) | |
| } | |
| const t = new Promise(i => Ht(this, void 0, void 0, function*() { | |
| if (this._glTF.buffers) { | |
| const o = []; | |
| for (const s of this._glTF.buffers) | |
| try { | |
| const a = yield this.getAssetUrl(e, s.uri); | |
| o.push(fetch(new Request(a)).then(l => { | |
| if (l.ok) | |
| return l.arrayBuffer(); | |
| throw Error("LoadingError: Error occurred in loading buffers.") | |
| } | |
| )) | |
| } catch (a) { | |
| console.error(a) | |
| } | |
| for (const [s,a] of o.entries()) | |
| this.glTF.buffers[s] = yield a, | |
| console.log(`buffer ${s} complete`) | |
| } | |
| i(!0) | |
| })) | |
| , r = new Promise(i => Ht(this, void 0, void 0, function*() { | |
| if (this._glTF.images) { | |
| const o = []; | |
| for (const s of this._glTF.images) | |
| try { | |
| const a = yield this.getAssetUrl(e, s.uri); | |
| o.push(fetch(new Request(a)).then(l => { | |
| if (l.ok) | |
| return l.blob(); | |
| throw Error("LoadingError: Error occurred in loading images.") | |
| } | |
| ).then(l => createImageBitmap(l))) | |
| } catch (a) { | |
| console.error(a) | |
| } | |
| for (const [s,a] of o.entries()) | |
| this.glTF.images[s] = yield a, | |
| console.log(`image ${s} complete`) | |
| } | |
| i(!0) | |
| })); | |
| return yield t, | |
| yield r, | |
| this.postProcess(), | |
| this.glTF | |
| }) | |
| } | |
| } | |
| !function(n) { | |
| const e = new Map([["SCALAR", 1], ["VEC2", 2], ["VEC3", 3], ["VEC4", 4], ["MAT2", 4], ["MAT3", 9], ["MAT4", 16]]) | |
| , t = new Map([[5120, Int8Array], [5121, Uint8Array], [5122, Int16Array], [5123, Uint16Array], [5124, Int32Array], [5125, Uint32Array], [5126, Float32Array]]); | |
| n.accessorTypeToNumComponents = function r(s) { | |
| if (e.has(s)) | |
| return e.get(s); | |
| throw new Error(`NOKEY ERROR: no numComponents for accessorType ${s}`) | |
| } | |
| , | |
| n.glTypeToTypedArray = function i(s) { | |
| if (t.has(s)) | |
| return t.get(s); | |
| throw new Error(`NOKEY ERROR: no typedArray for glType ${s}`) | |
| } | |
| , | |
| n.getAccessorData = function o(s) { | |
| return new (n.glTypeToTypedArray(s.componentType))(s.bufferView.data,s.byteOffset,s.count * n.accessorTypeToNumComponents(s.type)) | |
| } | |
| }(jt || (jt = {})); | |
| class bD { | |
| constructor(e, t) { | |
| this.animationQueue = [], | |
| this.parentReference = e, | |
| this.animationQueue = [], | |
| this.lastAnimation = { | |
| camera: this.parentReference.getTransformInfo("camera"), | |
| plane: this.parentReference.getTransformInfo("plane"), | |
| polyhedron: this.parentReference.getTransformInfo("polyhedron") | |
| }, | |
| this.isPlaying = !1, | |
| this.time = 0, | |
| this.timeScale = void 0 !== t ? t : 1 | |
| } | |
| setTransformInfoHandler(e, t) { | |
| let r; | |
| "camera" === e ? r = new Ut(this.lastAnimation.camera.translation,t.rotation) : ("plane" === e || "polyhedron" === e) && (r = t), | |
| this.parentReference.setTransformInfo(e, r) | |
| } | |
| add(e) { | |
| this.animationQueue.push(e) | |
| } | |
| clear() { | |
| this.animationQueue = [] | |
| } | |
| start() { | |
| this.isPlaying || (this.lastAnimation = { | |
| camera: this.parentReference.getTransformInfo("camera"), | |
| plane: this.parentReference.getTransformInfo("plane"), | |
| polyhedron: this.parentReference.getTransformInfo("polyhedron") | |
| }), | |
| this.isPlaying = !0, | |
| this.parentReference.requestRender() | |
| } | |
| stop() { | |
| this.isPlaying = !1 | |
| } | |
| step(e) { | |
| if (this.isPlaying) | |
| if (0 === this.animationQueue.length) | |
| this.isPlaying = !1, | |
| this.time = 0; | |
| else { | |
| const t = e * this.timeScale + this.time | |
| , r = this.animationQueue[0]; | |
| if (t >= r.duration) | |
| this.time = 0, | |
| this.setTransformInfoHandler(r.type, r.transformInfo), | |
| this.lastAnimation[r.type] = r.transformInfo, | |
| this.animationQueue.shift(), | |
| 0 === this.animationQueue.length && (console.info("Animation: Animations end"), | |
| this.isPlaying = !1); | |
| else { | |
| this.time = t; | |
| const o = this.animationInterpolate(this.lastAnimation[r.type], r.transformInfo, t / r.duration, r.interpolateType); | |
| this.setTransformInfoHandler(r.type, o) | |
| } | |
| this.parentReference.requestRender() | |
| } | |
| } | |
| animationInterpolate(e, t, r, i) { | |
| const o = T.quard(e.translation, t.translation, r, i = i || "linear") | |
| , s = et.squard(e.rotation, t.rotation, r, i); | |
| return new Ut(o,s) | |
| } | |
| } | |
| class zj { | |
| constructor(e, t) { | |
| this.parentReference = e, | |
| this.animationQueue = [], | |
| this.isPlaying = !1, | |
| this.time = 0, | |
| this.timeScale = void 0 !== t ? t : 1 | |
| } | |
| add(e) { | |
| this.animationQueue.push(e) | |
| } | |
| clear() { | |
| this.isPlaying = !1, | |
| this.time = 0, | |
| this.animationQueue.forEach(e => { | |
| e.samplers.forEach(t => { | |
| t.currentIndex = 0 | |
| } | |
| ) | |
| } | |
| ), | |
| this.animationQueue = [] | |
| } | |
| start() { | |
| this.isPlaying = !0, | |
| this.parentReference.requestRender() | |
| } | |
| pause() { | |
| this.isPlaying = !1 | |
| } | |
| step(e) { | |
| if (e /= 1e3, | |
| this.isPlaying) | |
| if (0 === this.animationQueue.length) | |
| this.isPlaying = !1, | |
| this.time = 0; | |
| else { | |
| const t = this.animationQueue[0] | |
| , r = t.channels[0].sampler.duration | |
| , i = e * this.timeScale + this.time; | |
| i >= r ? (this.time = 0, | |
| this.parentReference.stepAnimation(this.getAnimationInfo(t, r)), | |
| this.animationQueue.shift(), | |
| 0 === this.animationQueue.length && (console.info("Animation: Animations end"), | |
| this.isPlaying = !1)) : (this.time = i, | |
| this.parentReference.stepAnimation(this.getAnimationInfo(t, i))), | |
| this.parentReference.requestRender() | |
| } | |
| } | |
| setTimeScale(e) { | |
| this.timeScale = e | |
| } | |
| getAnimationInfo(e, t) { | |
| const r = new Map; | |
| return e.channels.forEach(i => { | |
| const o = i.target.node; | |
| let s; | |
| s = r.has(o.nodeID) ? r.get(o.nodeID) : { | |
| translation: void 0, | |
| rotation: void 0, | |
| scale: void 0 | |
| }, | |
| "translation" === i.target.path ? s.translation = this.interpolate(i.sampler, t) : "rotation" === i.target.path ? s.rotation = this.interpolate(i.sampler, t) : "scale" === i.target.path && (s.scale = this.interpolate(i.sampler, t)), | |
| r.set(o.nodeID, s) | |
| } | |
| ), | |
| r | |
| } | |
| interpolate(e, t) { | |
| e.updateKeyFrames(t); | |
| const r = Math.min(1, Math.max(0, t - e.keyFrameIndices[e.currentIndex]) / (e.keyFrameIndices[e.currentIndex + 1] - e.keyFrameIndices[e.currentIndex])); | |
| if ("SCALAR" === e.output.type) { | |
| if ("LINEAR" === e.interpolation) | |
| return dt.lerp(Number(e.keyFrames.src), Number(e.keyFrames.dst), r); | |
| if ("STEP" === e.interpolation) | |
| return Number(e.keyFrames.dst); | |
| if ("CUBICSPLINE" === e.interpolation) | |
| return dt.bezp(Number(e.keyFrames.src), Number(e.keyFrames.dst), r) | |
| } else if ("VEC3" === e.output.type) { | |
| if ("LINEAR" === e.interpolation) | |
| return T.lerp(T.fromTypedArray(e.keyFrames.src), T.fromTypedArray(e.keyFrames.dst), r); | |
| if ("STEP" === e.interpolation) | |
| return T.fromTypedArray(e.keyFrames.dst); | |
| if ("CUBICSPLINE" === e.interpolation) | |
| return T.bezier(T.fromTypedArray(e.keyFrames.src), T.fromTypedArray(e.keyFrames.dst), r) | |
| } else if ("VEC4" === e.output.type) { | |
| if ("LINEAR" === e.interpolation) | |
| return et.slerp(kt.fromTypedArray(e.keyFrames.src), kt.fromTypedArray(e.keyFrames.dst), r); | |
| if ("STEP" === e.interpolation) | |
| return kt.fromTypedArray(e.keyFrames.dst); | |
| if ("CUBICSPLINE" === e.interpolation) | |
| return et.sbezier(kt.fromTypedArray(e.keyFrames.src), kt.fromTypedArray(e.keyFrames.dst), r) | |
| } | |
| } | |
| } | |
| class $j { | |
| constructor(e, t, r) { | |
| if (this.a = T.clone(e), | |
| this.b = T.clone(t), | |
| this.c = T.clone(r), | |
| T.equals(this.normal, T.create())) | |
| return null | |
| } | |
| get edgeAB() { | |
| return T.subtract(this.b, this.a) | |
| } | |
| get edgeAC() { | |
| return T.subtract(this.c, this.a) | |
| } | |
| get edgeBC() { | |
| return T.subtract(this.c, this.b) | |
| } | |
| get normal() { | |
| return T.normalize(T.cross(this.edgeAB, this.edgeAC)) | |
| } | |
| getBaryCoord(e) { | |
| const t = T.dot(this.edgeAC, this.edgeAC) | |
| , r = T.dot(this.edgeAC, this.edgeAB) | |
| , i = T.dot(this.edgeAC, T.subtract(e, this.a)) | |
| , o = T.dot(this.edgeAB, this.edgeAB) | |
| , s = T.dot(this.edgeAB, T.subtract(e, this.a)) | |
| , a = t * o - r * r; | |
| if (0 === a) | |
| return T.fromValues(-2, -1, -1); | |
| const l = 1 / a | |
| , c = (o * i - r * s) * l | |
| , u = (t * s - r * i) * l; | |
| return T.fromValues(1 - c - u, u, c) | |
| } | |
| getTexCoord(e, t) { | |
| const r = this.getBaryCoord(e); | |
| return $n.add($n.add($n.scale(t.a, r[0]), $n.scale(t.b, r[1])), $n.scale(t.c, r[2])) | |
| } | |
| } | |
| class pu { | |
| constructor(e, t) { | |
| this.origin = e || T.create(), | |
| this.direction = t || T.fromValues(0, 0, 1) | |
| } | |
| set(e, t) { | |
| return this.origin = T.clone(e), | |
| this.direction = T.clone(t), | |
| this | |
| } | |
| copy(e) { | |
| return this.origin = T.clone(e.origin), | |
| this.direction = T.clone(e.direction), | |
| this | |
| } | |
| clone() { | |
| return (new pu).copy(this) | |
| } | |
| at(e) { | |
| return T.add(this.origin, T.scale(this.direction, e)) | |
| } | |
| fromWorldToNode(e) { | |
| return this.origin = T.transformMat4(this.origin, e), | |
| this.direction = T.normalize(T.transformMat3(this.direction, ts.fromMat4(e))), | |
| this | |
| } | |
| squaredDistanceToPoint(e) { | |
| const t = T.dot(T.subtract(e, this.origin), this.direction); | |
| return T.squaredDistance(t < 0 ? this.origin : T.add(T.scale(this.direction, t), this.origin), e) | |
| } | |
| squaredDistanceToSegment(e, t, r, i) { | |
| const o = T.scale(T.add(e, t), .5) | |
| , s = T.normalize(T.subtract(t, e)) | |
| , a = T.subtract(this.origin, o) | |
| , l = .5 * T.distance(e, t); | |
| let f, p, _, c = -T.dot(this.direction, s), u = T.dot(a, this.direction), d = T.dot(a, s), h = T.squaredLength(a); | |
| if (1 - Math.abs(c) > 1e-5) { | |
| let C = Math.abs(1 - c * c) | |
| , S = l * C; | |
| d = -T.dot(a, s), | |
| f = c * d - u, | |
| p = c * u - d, | |
| f >= 0 ? p >= -S ? p <= S ? (f /= C, | |
| p /= C, | |
| _ = f * (f + c * p + 2 * u) + p * (c * f + p + 2 * d) + h) : (p = l, | |
| f = Math.max(-(c * p + u), 0), | |
| _ = -f * f + p * (p + 2 * d) + h) : (p = -l, | |
| f = Math.max(-(c * p + u), 0), | |
| _ = -f * f + p * (p + 2 * d) + h) : p <= -S ? (f = -(-c * l + u), | |
| f > 0 ? p = -l : (f = 0, | |
| p = -d, | |
| p < -l ? p = -l : p > l && (p = l)), | |
| _ = -f * f + p * (p + 2 * d) + h) : p <= S ? (f = 0, | |
| p = -d, | |
| p < -l ? p = -l : p > l && (p = l), | |
| _ = p * (p + 2 * d) + h) : (f = -(-c * l + u), | |
| f > 0 ? p = l : (f = 0, | |
| p = -d, | |
| p < -l ? p = -l : p > l && (p = l)), | |
| _ = -f * f + p * (p + 2 * d) + h) | |
| } else | |
| p = c > 0 ? -l : l, | |
| f = Math.max(-(c * p + u), 0), | |
| _ = -f * f + p * (p + 2 * d) + h; | |
| return r && (r = T.scale(this.direction, f), | |
| r = T.add(r, this.origin)), | |
| i && (i = T.scale(s, p), | |
| i = T.add(o, i)), | |
| _ | |
| } | |
| intersectSphere(e) { | |
| const t = T.subtract(e.center, this.origin) | |
| , r = T.dot(t, this.direction) | |
| , i = T.squaredLength(t) - r * r | |
| , o = e.radius * e.radius; | |
| if (i > o) | |
| return null; | |
| const s = Math.sqrt(o - i) | |
| , a = r - s | |
| , l = r + s; | |
| return a < 0 && l < 0 ? null : this.at(a < 0 ? l : a) | |
| } | |
| intersectBoundingBox(e) { | |
| const t = e.min | |
| , r = e.max; | |
| let i, o, s, a, l, c; | |
| const u = 1 / this.direction[0] | |
| , d = 1 / this.direction[1] | |
| , h = 1 / this.direction[2] | |
| , f = this.origin; | |
| return u >= 0 ? (i = (t[0] - f[0]) * u, | |
| o = (r[0] - f[0]) * u) : (i = (r[0] - f[0]) * u, | |
| o = (t[0] - f[0]) * u), | |
| d >= 0 ? (s = (t[1] - f[1]) * d, | |
| a = (r[1] - f[1]) * d) : (s = (r[1] - f[1]) * d, | |
| a = (t[1] - f[1]) * d), | |
| i > a || s > o || ((s > i || i != i) && (i = s), | |
| (a < o || o != o) && (o = a), | |
| h >= 0 ? (l = (t[2] - f[2]) * h, | |
| c = (r[2] - f[2]) * h) : (l = (r[2] - f[2]) * h, | |
| c = (t[2] - f[2]) * h), | |
| i > c || l > o) || ((l > i || i != i) && (i = l), | |
| (c < o || o != o) && (o = c), | |
| o < 0) ? null : this.at(i >= 0 ? i : o) | |
| } | |
| intersectPlane(e) { | |
| let t; | |
| const r = T.dot(e.normal, this.direction); | |
| return 0 === r ? (T.dot(e.normal, this.origin) + e.constant === 0 && (t = 0), | |
| null) : (t = -(T.dot(e.normal, this.origin) + e.constant) / r, | |
| t < 0 ? null : this.at(t)) | |
| } | |
| intersectTriangle(e, t) { | |
| const r = T.subtract(e.b, e.a) | |
| , i = T.subtract(e.c, e.a) | |
| , o = T.cross(r, i); | |
| let s = T.dot(this.direction, o); | |
| const a = Math.sign(s); | |
| if (s > 0) { | |
| if (t) | |
| return null | |
| } else { | |
| if (!(s < 0)) | |
| return null; | |
| s = -s | |
| } | |
| const l = T.subtract(this.origin, e.a) | |
| , c = a * T.dot(this.direction, T.cross(l, i)); | |
| if (c < 0) | |
| return null; | |
| const u = a * T.dot(this.direction, T.cross(r, l)); | |
| if (u < 0 || c + u > s) | |
| return null; | |
| const d = -a * T.dot(l, o); | |
| return d < 0 ? null : this.at(d / s) | |
| } | |
| } | |
| class Wj { | |
| constructor(e, t, r) { | |
| this.near = e ? e.nearOffset : 1, | |
| this.far = e ? e.farOffset : 100, | |
| this.ray = new pu(t,r), | |
| this.params = { | |
| lineThreshold: 3 | |
| }, | |
| this.intersections = [] | |
| } | |
| clearIntersections() { | |
| this.intersections = [] | |
| } | |
| fromOrthographic(e, t) { | |
| const r = pe.getRotation(pe.lookAt(t.cameraPosition, t.targetCoordinate, t.upNormal)) | |
| , i = et.setAxisAngle(T.normalize(T.cross(T.fromValues(0, 0, 1), t.cameraNormal)), Math.acos(T.dot(T.fromValues(0, 0, 1), t.cameraNormal))); | |
| this.ray.origin = T.transformMat4(T.transformMat4(T.fromValues(e.x, e.y, (t.nearOffset + t.farOffset) / (t.nearOffset - t.farOffset)), pe.invert(pe.ortho(-t.horizontalOffset, t.horizontalOffset, -t.verticalOffset, t.verticalOffset, t.nearOffset, t.farOffset))), pe.multiply(pe.fromTranslation(t.cameraPosition), pe.transpose(pe.fromRotation(r)))), | |
| this.ray.direction = T.normalize(T.transformQuat(T.fromValues(0, 0, -1), i)) | |
| } | |
| fromPerspective(e, t) { | |
| this.ray.origin = t.cameraPosition, | |
| this.ray.direction = T.normalize(T.subtract(T.transformMat4(T.transformMat4(T.fromValues(e.x, e.y, .5), pe.invert(pe.perspective(5 * Math.PI / 18, 1, this.near, this.far))), t.transformInfo.transform), this.ray.origin)) | |
| } | |
| intersectSegments(e) { | |
| const t = this.params.lineThreshold * this.params.lineThreshold | |
| , r = this.ray; | |
| let i = []; | |
| for (let o = 0; o < e.length; o++) { | |
| const s = e[o]; | |
| let a = T.create() | |
| , l = T.create(); | |
| const c = r.squaredDistanceToSegment(s.start, s.end, a, l); | |
| if (c < 0 || c > t) | |
| continue; | |
| const u = T.distance(r.origin, a); | |
| u < this.near || u > this.far || i.push({ | |
| distance: u, | |
| rayPoint: a, | |
| segPoint: l, | |
| index: o | |
| }) | |
| } | |
| return i.sort( (o, s) => o.distance - s.distance), | |
| i | |
| } | |
| intersectNodes(e, t) { | |
| t = null === t || t, | |
| this.intersections = this.intersections.concat(this.rayCastNode(e)), | |
| t && e.children.forEach(r => { | |
| this.intersectNodes(r, !0) | |
| } | |
| ), | |
| this.intersections.sort( (r, i) => r.distance - i.distance) | |
| } | |
| rayCastNode(e) { | |
| const t = []; | |
| return e.mesh ? (e.mesh.primitives.forEach(r => { | |
| const i = (new pu).copy(this.ray).fromWorldToNode(pe.invert(e.worldMatrix)); | |
| if (null !== r.indices) { | |
| const o = r.indices | |
| , s = jt.accessorTypeToNumComponents(o.type) | |
| , a = new (jt.glTypeToTypedArray(o.componentType))(r.indices.bufferView.data); | |
| for (let l = o.byteOffset; l < o.count; l += 3) { | |
| const c = T.fromTypedArrayWithIndices(a, l, s) | |
| , u = this.checkBufferIntersection(i, e, r, c); | |
| u && (u.faceIndex = Math.floor(l / 3), | |
| t.push(u)) | |
| } | |
| } else if (r.attributes.POSITION) { | |
| const o = r.attributes.POSITION | |
| , s = r.drawIndices; | |
| for (let a = s.byteOffset; a < Math.min(o.count, s.byteOffset + s.count); a += 3) { | |
| const l = T.fromValues(a, a + 1, a + 2) | |
| , c = this.checkBufferIntersection(i, e, r, l); | |
| c && (c.faceIndex = Math.floor(a / 3), | |
| t.push(c)) | |
| } | |
| } | |
| } | |
| ), | |
| t) : [] | |
| } | |
| checkBufferIntersection(e, t, r, i) { | |
| const o = new (jt.glTypeToTypedArray(r.attributes.POSITION.componentType))(r.attributes.POSITION.bufferView.data) | |
| , s = r.attributes.POSITION.bufferView.byteStride / jt.glTypeToTypedArray(r.attributes.POSITION.componentType).BYTES_PER_ELEMENT | |
| , a = new $j(T.fromTypedArrayWithIndices(o, i[0], s),T.fromTypedArrayWithIndices(o, i[1], s),T.fromTypedArrayWithIndices(o, i[2], s)) | |
| , l = this.checkIntersection(e, t, r, a); | |
| if (l && r.attributes.TEXCOORD_0) { | |
| const c = new (jt.glTypeToTypedArray(r.attributes.TEXCOORD_0.componentType))(r.attributes.TEXCOORD_0.bufferView.data) | |
| , u = { | |
| a: $n.fromTypedArrayWithIndices(c, i[0], 2), | |
| b: $n.fromTypedArrayWithIndices(c, i[1], 2), | |
| c: $n.fromTypedArrayWithIndices(c, i[2], 2) | |
| }; | |
| l.texCoord = a.getTexCoord(l.point, u) | |
| } | |
| return l | |
| } | |
| checkIntersection(e, t, r, i) { | |
| const o = e.intersectTriangle(i, null !== r.material && !r.material.doubleSided); | |
| if (null === o) | |
| return null; | |
| const s = T.transformMat4(o, t.worldMatrix) | |
| , a = T.distance(this.ray.origin, s); | |
| return a < this.near || a > this.far ? null : { | |
| distance: a, | |
| point: s, | |
| face: i, | |
| nodeID: t.nodeID, | |
| nodeName: t.name | |
| } | |
| } | |
| } | |
| function wg(n, e) { | |
| return Ht(this, void 0, void 0, function*() { | |
| return yield fetch(new Request(n,e)).then(r => Ht(this, void 0, void 0, function*() { | |
| if (r.ok) | |
| return r.json(); | |
| { | |
| const i = (yield r.json()).msg; | |
| return JSON.parse(`{ "code": ${r.status}, "msg": "${i}" }`) | |
| } | |
| })).catch( () => JSON.parse('{ "code": 0 }')) | |
| }) | |
| } | |
| class Dg { | |
| constructor(e, t, r) { | |
| t = t || {}, | |
| r = r || {}, | |
| this.canvasWidth = e.clientWidth, | |
| this.canvasHeight = e.clientHeight, | |
| this.canvasNear = 0, | |
| this.canvasFar = 100, | |
| this.zoomIndex = void 0 !== t.zoomIndex ? t.zoomIndex : 75, | |
| this.cameraDistance = void 0 !== t.cameraDistance ? t.cameraDistance : 50, | |
| this.targetCoordinate = void 0 !== t.targetCoordinate ? t.targetCoordinate : T.fromValues(0, 0, 0), | |
| this.defaultNormal = void 0 !== t.defaultNormal ? t.defaultNormal : T.normalize(T.fromValues(2, 2, 5)), | |
| this.upNormal = T.fromValues(0, 1, 0), | |
| this.transformInfo = this.defaultInfo, | |
| this.viewMode = _i.Default, | |
| this.animationMode = zr.Sin, | |
| this.shininess = void 0 !== r.shininess ? r.shininess : 1.2, | |
| this.lightColor = void 0 !== r.lightColor ? r.lightColor : T.fromValues(1, 1, 1), | |
| this.defaultLightNormal = void 0 !== r.defaultLightNormal ? r.defaultLightNormal : T.normalize(T.fromValues(0, 4, 2)) | |
| } | |
| get horizontalOffset() { | |
| return this.canvasWidth / this.zoomIndex | |
| } | |
| get verticalOffset() { | |
| return this.canvasHeight / this.zoomIndex | |
| } | |
| get nearOffset() { | |
| return this.canvasNear | |
| } | |
| get farOffset() { | |
| return this.canvasFar | |
| } | |
| setCameraOffset(e) { | |
| return this.canvasWidth = e.clientWidth, | |
| this.canvasHeight = e.clientHeight, | |
| this | |
| } | |
| get defaultInfo() { | |
| return new Ut(T.create(),et.create()) | |
| } | |
| get cameraPosition() { | |
| return T.transformMat4(T.scale(this.defaultNormal, this.cameraDistance), this.transformInfo.transform) | |
| } | |
| get cameraNormal() { | |
| return T.normalize(this.cameraPosition) | |
| } | |
| get lightNormal() { | |
| return T.transformQuat(this.cameraNormal, et.setAxisAngle([0, 1, 0], -Math.acos(this.defaultNormal[0] * this.defaultLightNormal[0] + this.defaultNormal[2] * this.defaultLightNormal[2]))) | |
| } | |
| } | |
| class Gj { | |
| constructor() { | |
| this.shaderUniforms = { | |
| self: { | |
| u_color: [1, 60 / 255, 60 / 255, .16] | |
| }, | |
| edge: { | |
| u_color: [1, 137 / 255, 137 / 255, 1] | |
| }, | |
| clip: { | |
| u_color: [1, 60 / 255, 60 / 255, .5] | |
| } | |
| }, | |
| this.transformInfo = this.defaultInfo, | |
| this.animationMode = zr.Sin | |
| } | |
| set defaultInfo(e) { | |
| this._defaultInfo = e | |
| } | |
| get defaultInfo() { | |
| return this._defaultInfo | |
| } | |
| get normal() { | |
| return T.normalize(T.transformQuat(T.fromValues(1, 0, 0), this.transformInfo.rotation)) | |
| } | |
| get equation() { | |
| return kt.transformMat4(kt.fromValues(1, 0, 0, 0), pe.invert(pe.transpose(this.transformInfo.transform))) | |
| } | |
| fromGLTF(e) { | |
| e.forEach(t => { | |
| const r = {} | |
| , i = t.mesh.primitives[0] | |
| , o = i.indices; | |
| for (let[s,a] of Object.entries(i.attributes)) | |
| r["a_" + s.toLowerCase().split("_", 1)[0]] = { | |
| buffer: a.bufferView.buffer, | |
| numComponents: jt.accessorTypeToNumComponents(a.type), | |
| type: a.componentType, | |
| offset: a.byteOffset, | |
| stride: a.bufferView.byteStride | |
| }; | |
| t.name.includes("plane") ? (this.bufferInfo = { | |
| attribs: r, | |
| numElements: o.count, | |
| indices: o.bufferView.buffer, | |
| elementType: o.componentType | |
| }, | |
| this.defaultInfo = (new Ut).fromMatrix(t.worldMatrix), | |
| this.transformInfo = this.defaultInfo) : t.name.includes("edge") && (this.edgeBufferInfo = { | |
| attribs: r, | |
| numElements: o.count, | |
| indices: o.bufferView.buffer, | |
| elementType: o.componentType | |
| }) | |
| } | |
| ) | |
| } | |
| } | |
| class CD { | |
| constructor(e) { | |
| return this.shaderUniforms = { | |
| self: { | |
| u_color: [155 / 255, 162 / 255, 176 / 255, .95] | |
| }, | |
| edge: { | |
| u_color: [0, 0, 0, 1] | |
| }, | |
| clip: {}, | |
| woit: {} | |
| }, | |
| this.defaultInfo = new Ut(T.create(),et.create()), | |
| this.transformInfo = this.defaultInfo, | |
| this.length = 10, | |
| this.woitBufferInfo = Pt.createWOITBufferInfo(e), | |
| this | |
| } | |
| set defaultInfo(e) { | |
| this._defaultInfo = e | |
| } | |
| get defaultInfo() { | |
| return this._defaultInfo | |
| } | |
| fromGLTF(e) { | |
| return e.forEach(t => { | |
| const r = {} | |
| , i = t.mesh.primitives[0] | |
| , o = i.indices; | |
| for (let[s,a] of Object.entries(i.attributes)) | |
| r["a_" + s.toLowerCase().split("_", 1)[0]] = { | |
| buffer: a.bufferView.buffer, | |
| numComponents: jt.accessorTypeToNumComponents(a.type), | |
| type: a.componentType, | |
| offset: a.byteOffset, | |
| stride: a.bufferView.byteStride | |
| }; | |
| t.name.includes("polyhedron") ? (this.bufferInfo = { | |
| attribs: r, | |
| numElements: o.count, | |
| indices: o.bufferView.buffer, | |
| elementType: o.componentType | |
| }, | |
| this.defaultInfo = (new Ut).fromMatrix(t.worldMatrix), | |
| this.transformInfo = this.defaultInfo) : t.name.includes("edge") && (this.edgeBufferInfo = { | |
| attribs: r, | |
| numElements: o.count, | |
| indices: o.bufferView.buffer, | |
| elementType: o.componentType | |
| }) | |
| } | |
| ), | |
| this | |
| } | |
| } | |
| class TD { | |
| constructor(e) { | |
| this.nodeID = e.nodeID, | |
| e.name.includes("dian") ? this.type = "vertex" : e.name.includes("xian") ? this.type = "edge" : e.name.includes("mian") && (this.type = "face"); | |
| const t = {} | |
| , r = e.mesh.primitives[0] | |
| , i = r.indices; | |
| for (let[o,s] of Object.entries(r.attributes)) | |
| t["a_" + o.toLowerCase().split("_", 1)[0]] = { | |
| buffer: s.bufferView.buffer, | |
| numComponents: jt.accessorTypeToNumComponents(s.type), | |
| type: s.componentType, | |
| offset: s.byteOffset, | |
| stride: s.bufferView.byteStride | |
| }; | |
| return this.bufferInfo = { | |
| attribs: t, | |
| numElements: i.count, | |
| indices: i.bufferView.buffer, | |
| elementType: i.componentType | |
| }, | |
| this.transformInfo = (new Ut).fromMatrix(e.worldMatrix), | |
| "face" === this.type && (this.textureID = r.material && r.material.pbrMetallicRoughness.baseColorTexture ? r.material.pbrMetallicRoughness.baseColorTexture.index : void 0), | |
| this.shaderUniforms = { | |
| u_color: void 0, | |
| u_worldMatrix: void 0 | |
| }, | |
| this.resetColour(), | |
| this | |
| } | |
| setColour(e) { | |
| for (let t = 0; t < 3; t++) | |
| this.shaderUniforms.u_color[t] = e[t] / 255; | |
| return this | |
| } | |
| resetColour() { | |
| return this.shaderUniforms.u_color = "vertex" === this.type ? [187 / 255, 194 / 255, 208 / 255, 1] : "edge" === this.type ? [.22, .22, .22, 1] : "face" === this.type ? [1, 1, 1, .98] : [0, 0, 1, .8], | |
| this | |
| } | |
| } | |
| class qj { | |
| constructor(e) { | |
| const t = {} | |
| , r = e.mesh.primitives[0] | |
| , i = r.indices; | |
| for (let[o,s] of Object.entries(r.attributes)) | |
| t["a_" + o.toLowerCase().split("_", 1)[0]] = { | |
| buffer: s.bufferView.buffer, | |
| numComponents: jt.accessorTypeToNumComponents(s.type), | |
| type: s.componentType, | |
| offset: s.byteOffset, | |
| stride: s.bufferView.byteStride | |
| }; | |
| return this.bufferInfo = { | |
| attribs: t, | |
| numElements: i.count, | |
| indices: i.bufferView.buffer, | |
| elementType: i.componentType | |
| }, | |
| this.transformInfo = (new Ut).fromMatrix(e.worldMatrix), | |
| this.shaderUniforms = { | |
| u_color: void 0, | |
| u_worldMatrix: void 0 | |
| }, | |
| this.resetColour(), | |
| this | |
| } | |
| loadTexture(e, t) { | |
| return this.texture = t.createTexture(), | |
| t.bindTexture(t.TEXTURE_2D, this.texture), | |
| t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, t.RGBA, t.UNSIGNED_BYTE, e), | |
| t.generateMipmap(t.TEXTURE_2D), | |
| t.bindTexture(t.TEXTURE_2D, null), | |
| this | |
| } | |
| setColour(e) { | |
| return this.shaderUniforms.u_color = kt.fromVec3(e, 1), | |
| this | |
| } | |
| resetColour() { | |
| return this.shaderUniforms.u_color = [1, 1, 1, 1], | |
| this | |
| } | |
| } | |
| class Kj { | |
| constructor(e, t) { | |
| if (this.canvas = e, | |
| this.drawSceneBound = this.render.bind(this), | |
| this.gl = e.getContext("webgl2", { | |
| stencil: !0, | |
| antialias: !0, | |
| premultipliedAlpha: !1, | |
| alpha: !0 | |
| }), | |
| !this.gl) | |
| throw alert("\u60a8\u4f7f\u7528\u7684\u6d4f\u89c8\u5668\u4e0d\u652f\u6301WebGL2 \u8bf7\u5347\u7ea7\u6d4f\u89c8\u5668"), | |
| new Error("GLERROR: Failed to initiate WebGL2."); | |
| if (!this.gl.getExtension("EXT_color_buffer_float")) | |
| throw alert("\u60a8\u4f7f\u7528\u7684\u6d4f\u89c8\u5668\u4e0d\u652f\u6301WebGL2\u7684\u6269\u5c55 \u8bf7\u5347\u7ea7\u6d4f\u89c8\u5668"), | |
| new Error("GLERROR: Failed to initiate FLOAT_COLOR_BUFFER extension on WebGL2"); | |
| (23 !== this.gl.getShaderPrecisionFormat(this.gl.VERTEX_SHADER, this.gl.HIGH_FLOAT).precision || 23 !== this.gl.getShaderPrecisionFormat(this.gl.FRAGMENT_SHADER, this.gl.HIGH_FLOAT).precision) && (He.VS.replace("/highp/g", "mediump"), | |
| He.FS.replace("/highp/g", "mediump"), | |
| He.VSWithClipping.replace("/highp/g", "mediump"), | |
| He.FSWithClipping.replace("/highp/g", "mediump"), | |
| He.VSWithWOIT.replace("/highp/g", "mediump"), | |
| He.FSWithWOIT.replace("/highp/g", "mediump"), | |
| He.VSWithAccumAndPLight.replace("/highp/g", "mediump"), | |
| He.FSWithAccumAndPLight.replace("/highp/g", "mediump")), | |
| this.programInfos = new Map([["program", Pt.createProgramInfo(this.gl, [He.VS, He.FS])], ["programWithClip", Pt.createProgramInfo(this.gl, [He.VSWithClipping, He.FSWithClipping])], ["programWithWOIT", Pt.createProgramInfo(this.gl, [He.VSWithWOIT, He.FSWithWOIT])], ["programWithAccum", Pt.createProgramInfo(this.gl, [He.VSWithAccumAndPLight, He.FSWithAccumAndPLight])]]), | |
| this.accumFrameBuffer = this.gl.createFramebuffer(), | |
| this.camera = new Dg(e,{ | |
| zoomIndex: e.width / 960 * 75 | |
| }), | |
| this.plane = new Gj, | |
| this.polyhedron = new CD(this.gl), | |
| this.animation = new bD(this), | |
| this.clips = new Map, | |
| this.runtimeConstant = { | |
| mouseFactor: .01, | |
| dragThreshold: 1e-4 | |
| }, | |
| this.drawCallbackId = 0, | |
| this.lastTimeStamp = 0, | |
| this.planeInfo = { | |
| id: 25, | |
| value: "plane", | |
| tag: "\u5e73\u9762", | |
| clipInfo: { | |
| isBase: !0 | |
| }, | |
| previewUrl: "" | |
| }, | |
| this.isAssetsLoaded = !1, | |
| this.loadPolyhedron(t) | |
| } | |
| reset() { | |
| this.camera.transformInfo = this.camera.defaultInfo, | |
| this.plane.transformInfo = this.plane.defaultInfo, | |
| this.polyhedron.transformInfo = this.polyhedron.defaultInfo, | |
| this.requestRender() | |
| } | |
| destroy() { | |
| this.gl.deleteFramebuffer(this.accumFrameBuffer), | |
| this.programInfos.forEach(e => { | |
| const t = e.program; | |
| this.gl.getAttachedShaders(t).forEach(i => { | |
| this.gl.deleteShader(i) | |
| } | |
| ), | |
| this.gl.deleteProgram(t) | |
| } | |
| ), | |
| this.clips.forEach(e => { | |
| Object.entries(e.bufferInfo.attribs).forEach(t => { | |
| this.gl.deleteBuffer(t[1].buffer) | |
| } | |
| ), | |
| e.bufferInfo.indices && this.gl.deleteBuffer(e.bufferInfo.indices) | |
| } | |
| ), | |
| this.clips.clear(), | |
| this.gl.getExtension("WEBGL_lose_context").loseContext() | |
| } | |
| resize(e, t) { | |
| this.canvas.width = e, | |
| this.canvas.height = t, | |
| this.gl.viewport(0, 0, e, t), | |
| this.requestRender() | |
| } | |
| loadPolyhedron(e) { | |
| Promise.all([new ka(this.gl).loadGLTF(e), new ka(this.gl).loadGLTF(this.planeInfo)]).then(t => { | |
| this.polyhedron.fromGLTF(t[0].nodes), | |
| this.plane.fromGLTF(t[1].nodes), | |
| this.clips = this.createObjectsMap(), | |
| this.requestRender(), | |
| this.isAssetsLoaded = !0 | |
| } | |
| ).catch(t => { | |
| throw alert("\u52a0\u8f7d\u6587\u4ef6\u51fa\u9519 \u8bf7\u68c0\u67e5\u7f51\u7edc\u8fde\u63a5"), | |
| console.error(t), | |
| new Error("GLTFERROR: Failed to load glTF file(s).") | |
| } | |
| ) | |
| } | |
| onManual(e) { | |
| this.clips.get("accumulationPlane").renderConfig.isHide = !e, | |
| this.clips.get("accumulationPlaneEdge").renderConfig.isHide = !e, | |
| this.clips.get("drawPlaneEdge").renderConfig.isHide = !e, | |
| this.clips.get("drawOuterPlane").renderConfig.isHide = !e | |
| } | |
| computeWorldMatrix(e, t) { | |
| return pe.multiply(e, t.transform) | |
| } | |
| convertNormalTransformToQuat(e, t) { | |
| let r, i; | |
| if (T.equals(e, t)) | |
| r = T.create(), | |
| i = 0; | |
| else if (T.equals(e, T.negate(t))) { | |
| const o = e[0] | |
| , s = e[1] | |
| , a = Math.hypot(o, s); | |
| r = T.fromValues(-s / a, o / a, 0), | |
| i = Math.PI | |
| } else | |
| r = T.normalize(T.cross(e, t)), | |
| i = Math.acos(Math.min(T.dot(e, t), 1)), | |
| T.dot(t, T.cross(r, e)) < 0 && (r = T.negate(r)); | |
| return et.setAxisAngle(r, i) | |
| } | |
| setCameraAnimation(e) { | |
| this.camera.viewMode = e; | |
| const t = this.camera.cameraNormal; | |
| let r; | |
| if (e === _i.Default) | |
| r = this.camera.defaultNormal; | |
| else { | |
| const s = this.plane.normal; | |
| r = e === _i.UpSide ? s : T.negate(s), | |
| Math.abs(r[1]) - 1 < this.runtimeConstant.dragThreshold && Math.abs(r[0]) < this.runtimeConstant.dragThreshold && Math.abs(r[2]) < this.runtimeConstant.dragThreshold && (r[0] = 0, | |
| r[1] = 1 * Math.sign(r[1]), | |
| r[2] = this.runtimeConstant.dragThreshold, | |
| r = T.normalize(r)) | |
| } | |
| const i = this.convertNormalTransformToQuat(t, r) | |
| , o = et.multiply(i, this.camera.transformInfo.rotation); | |
| this.animation.add({ | |
| duration: 500, | |
| type: "camera", | |
| transformInfo: new Ut(this.camera.transformInfo.translation,o), | |
| interpolateType: zr.Sin | |
| }), | |
| this.lastTimeStamp = 0, | |
| this.animation.start() | |
| } | |
| setModelAnimation(e, t, r) { | |
| const i = T.add(t.translation, this[e].defaultInfo.translation) | |
| , o = et.multiply(t.rotation, this[e].defaultInfo.rotation); | |
| r ? (this[e].transformInfo = new Ut(i,o), | |
| this.requestRender()) : (this.animation.add({ | |
| duration: 500, | |
| type: e, | |
| transformInfo: new Ut(i,o), | |
| interpolateType: zr.Sin | |
| }), | |
| this.lastTimeStamp = 0, | |
| this.animation.start()) | |
| } | |
| rotateCamera(e, t) { | |
| const r = this.camera.cameraNormal | |
| , i = Math.acos(r[1]) | |
| , o = Math.atan2(r[0], r[2]); | |
| let s = i - t * this.runtimeConstant.mouseFactor; | |
| s = Math.max(s, this.runtimeConstant.dragThreshold), | |
| s = Math.min(s, Math.PI - this.runtimeConstant.dragThreshold); | |
| let a = o - e * this.runtimeConstant.mouseFactor; | |
| const l = T.fromValues(Math.sin(s) * Math.sin(a), Math.cos(s), Math.sin(s) * Math.cos(a)) | |
| , c = this.convertNormalTransformToQuat(r, l); | |
| this.camera.transformInfo.rotation = et.multiply(c, this.camera.transformInfo.rotation), | |
| this.requestRender() | |
| } | |
| createObjectsMap() { | |
| const e = this.gl | |
| , t = this.programInfos | |
| , r = this.polyhedron | |
| , i = this.plane; | |
| return new Map([["accumulationObject", { | |
| programInfo: t.get("programWithAccum"), | |
| bufferInfo: r.bufferInfo, | |
| uniforms: r.shaderUniforms.self, | |
| renderConfig: { | |
| disableDepth: !1, | |
| disableDepthWrite: !1, | |
| initWOIT: !0 | |
| } | |
| }], ["accumulationObjectEdge", { | |
| programInfo: t.get("programWithAccum"), | |
| bufferInfo: r.edgeBufferInfo, | |
| uniforms: r.shaderUniforms.edge, | |
| renderConfig: { | |
| disableDepth: !1 | |
| } | |
| }], ["accumulationPlane", { | |
| programInfo: t.get("programWithAccum"), | |
| bufferInfo: i.bufferInfo, | |
| uniforms: i.shaderUniforms.self, | |
| renderConfig: { | |
| disableDepth: !1, | |
| isHide: !0 | |
| } | |
| }], ["accumulationPlaneEdge", { | |
| programInfo: t.get("programWithAccum"), | |
| bufferInfo: i.edgeBufferInfo, | |
| uniforms: i.shaderUniforms.edge, | |
| renderConfig: { | |
| isHide: !0 | |
| } | |
| }], ["woit", { | |
| programInfo: t.get("programWithWOIT"), | |
| bufferInfo: r.woitBufferInfo, | |
| uniforms: r.shaderUniforms.woit, | |
| renderConfig: { | |
| disableDepth: !0, | |
| disableDepthWrite: !0, | |
| drawWOIT: !0 | |
| } | |
| }], ["fillModelBuffer", { | |
| programInfo: t.get("programWithClip"), | |
| bufferInfo: r.bufferInfo, | |
| uniforms: r.shaderUniforms.clip, | |
| renderConfig: { | |
| clearDepth: !0, | |
| disableDepth: !0, | |
| useStencil: !0, | |
| stencilWrite: !0, | |
| disableColor: !0, | |
| stencilBackOp: [e.KEEP, e.KEEP, e.DECR_WRAP], | |
| stencilFrontOp: [e.KEEP, e.KEEP, e.INCR_WRAP], | |
| stencilFunc: [e.ALWAYS, 1, 255] | |
| } | |
| }], ["drawClippingPlane", { | |
| programInfo: t.get("program"), | |
| bufferInfo: i.bufferInfo, | |
| uniforms: i.shaderUniforms.clip, | |
| renderConfig: { | |
| clearDepth: !0, | |
| depthFunc: e.ALWAYS, | |
| blendFunc: [e.SRC_ALPHA, e.ONE_MINUS_SRC_ALPHA, e.ONE, e.ONE_MINUS_SRC_ALPHA], | |
| useStencil: !0, | |
| stencilOp: [e.KEEP, e.KEEP, e.KEEP], | |
| stencilFunc: [e.EQUAL, 128, 128] | |
| } | |
| }], ["fillDepthBuffer", { | |
| programInfo: t.get("program"), | |
| bufferInfo: r.bufferInfo, | |
| uniforms: r.shaderUniforms.self, | |
| renderConfig: { | |
| clearDepth: !0, | |
| disableDepth: !1, | |
| disableColor: !0 | |
| } | |
| }], ["drawObjectEdge", { | |
| programInfo: t.get("program"), | |
| bufferInfo: r.edgeBufferInfo, | |
| uniforms: r.shaderUniforms.edge, | |
| renderConfig: { | |
| disableDepth: !1, | |
| depthFunc: e.LEQUAL | |
| } | |
| }], ["drawPlaneEdge", { | |
| programInfo: t.get("program"), | |
| bufferInfo: i.edgeBufferInfo, | |
| uniforms: i.shaderUniforms.edge, | |
| renderConfig: { | |
| isHide: !0 | |
| } | |
| }], ["drawOuterPlane", { | |
| programInfo: t.get("program"), | |
| bufferInfo: i.bufferInfo, | |
| uniforms: i.shaderUniforms.self, | |
| renderConfig: { | |
| isHide: !0, | |
| useStencil: !0, | |
| stencilOp: [e.KEEP, e.KEEP, e.KEEP], | |
| stencilFunc: [e.NOTEQUAL, 1, 255] | |
| } | |
| }]]) | |
| } | |
| setRenderOptions(e) { | |
| const t = this.gl; | |
| if (e.disableDepth ? t.disable(t.DEPTH_TEST) : t.enable(t.DEPTH_TEST), | |
| e.clearDepth && (t.depthMask(!0), | |
| t.clear(t.DEPTH_BUFFER_BIT)), | |
| t.depthMask(!e.disableDepthWrite), | |
| t.depthFunc(e.depthFunc ? e.depthFunc : t.LESS), | |
| e.blendFunc) { | |
| const r = e.blendFunc; | |
| t.enable(t.BLEND), | |
| t.blendFuncSeparate(r[0], r[1], r[2], r[3]) | |
| } | |
| if (e.disableColor ? t.colorMask(!1, !1, !1, !1) : t.colorMask(!0, !0, !0, !0), | |
| e.cullFace ? (t.enable(t.CULL_FACE), | |
| t.cullFace(e.cullFace)) : t.disable(t.CULL_FACE), | |
| e.useStencil ? t.enable(t.STENCIL_TEST) : t.disable(t.STENCIL_TEST), | |
| e.stencilClear && (t.stencilMask(255), | |
| t.clear(t.STENCIL_BUFFER_BIT)), | |
| t.stencilMask(e.stencilWrite ? 255 : 0), | |
| e.stencilOp) { | |
| const r = e.stencilOp; | |
| t.stencilOp(r[0], r[1], r[2]) | |
| } | |
| if (e.stencilFrontOp) { | |
| const r = e.stencilFrontOp; | |
| t.stencilOpSeparate(t.FRONT, r[0], r[1], r[2]) | |
| } | |
| if (e.stencilBackOp) { | |
| const r = e.stencilBackOp; | |
| t.stencilOpSeparate(t.BACK, r[0], r[1], r[2]) | |
| } | |
| if (e.stencilFunc) { | |
| const r = e.stencilFunc; | |
| t.stencilFunc(r[0], r[1], r[2]) | |
| } | |
| e.initWOIT && (t.blendFuncSeparate(t.ONE, t.ONE, t.ZERO, t.ONE_MINUS_SRC_ALPHA), | |
| t.clear(t.COLOR_BUFFER_BIT)), | |
| e.drawWOIT && (t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA), | |
| t.clear(t.COLOR_BUFFER_BIT)) | |
| } | |
| render(e) { | |
| const t = this.gl; | |
| this.drawCallbackId = 0, | |
| this.lastTimeStamp || (this.lastTimeStamp = e); | |
| const r = e - this.lastTimeStamp; | |
| let i, o; | |
| this.lastTimeStamp = e, | |
| this.animation.step(r), | |
| t.enable(t.BLEND), | |
| t.blendFuncSeparate(t.SRC_ALPHA, t.ONE_MINUS_SRC_ALPHA, t.ONE, t.ONE_MINUS_SRC_ALPHA), | |
| t.enable(t.DEPTH_TEST), | |
| t.depthMask(!0), | |
| t.colorMask(!0, !0, !0, !0), | |
| t.clearColor(0, 0, 0, 0), | |
| t.clear(t.COLOR_BUFFER_BIT | t.DEPTH_BUFFER_BIT | t.STENCIL_BUFFER_BIT); | |
| const s = this.camera | |
| , a = this.polyhedron | |
| , l = this.plane | |
| , c = this.accumFrameBuffer | |
| , u = t.createTexture() | |
| , d = t.createTexture() | |
| , h = a.transformInfo.transform | |
| , f = pe.lookAt(s.cameraPosition, s.targetCoordinate, s.upNormal) | |
| , p = pe.ortho(-s.horizontalOffset, s.horizontalOffset, -s.verticalOffset, s.verticalOffset, s.nearOffset, s.farOffset) | |
| , _ = this.computeWorldMatrix(pe.multiply(p, f), a.transformInfo) | |
| , C = ts.normalFromMat4(f) | |
| , S = pe.fromMat3(ts.normalFromMat4(a.transformInfo.transform)); | |
| a.shaderUniforms.self.u_worldMatrix = _, | |
| a.shaderUniforms.self.u_modelITMatrix = S, | |
| a.shaderUniforms.self.u_lightNormal = s.lightNormal, | |
| a.shaderUniforms.self.u_lightColor = s.lightColor, | |
| a.shaderUniforms.self.u_shininess = s.shininess, | |
| a.shaderUniforms.edge.u_worldMatrix = _, | |
| a.shaderUniforms.clip.u_modelMatrix = h, | |
| a.shaderUniforms.clip.u_viewMatrix = f, | |
| a.shaderUniforms.clip.u_modelViewMatrix = pe.multiply(f, h), | |
| a.shaderUniforms.clip.u_worldMatrix = _, | |
| a.shaderUniforms.clip.u_viewNormalMatrix = C, | |
| a.shaderUniforms.clip.u_planeEquation = l.equation, | |
| a.shaderUniforms.woit.u_accumulateColor = u, | |
| a.shaderUniforms.woit.u_accumulateAlpha = d; | |
| const R = this.computeWorldMatrix(pe.multiply(p, f), l.transformInfo); | |
| l.shaderUniforms.self.u_worldMatrix = R, | |
| l.shaderUniforms.edge.u_worldMatrix = R, | |
| l.shaderUniforms.clip.u_worldMatrix = R, | |
| this.clips.forEach(v => { | |
| const O = v.programInfo | |
| , M = v.bufferInfo | |
| , N = v.renderConfig; | |
| let F = !1; | |
| !M || N.isHide || (O !== i && (i = O, | |
| O === this.programInfos.get("programWithAccum") ? (Pt.bindWOITTextures(t, u, d, c), | |
| t.bindFramebuffer(t.FRAMEBUFFER, c)) : O === this.programInfos.get("programWithWOIT") ? t.bindFramebuffer(t.FRAMEBUFFER, null) : (t.deleteTexture(u), | |
| t.deleteTexture(d)), | |
| t.useProgram(O.program), | |
| F = !0), | |
| (F || M !== o) && (o = M, | |
| Pt.setAttributes(O, M.attribs), | |
| M.indices && t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, M.indices)), | |
| Pt.setUniforms(O, v.uniforms), | |
| this.setRenderOptions(N), | |
| M.indices ? t.drawElements(t.TRIANGLES, M.numElements, t.UNSIGNED_SHORT, 0) : t.drawArrays(t.TRIANGLES, 0, M.numElements)) | |
| } | |
| ) | |
| } | |
| getTransformInfo(e) { | |
| return this[e].transformInfo | |
| } | |
| setTransformInfo(e, t) { | |
| this[e].transformInfo = t | |
| } | |
| requestRender() { | |
| this.drawCallbackId || (this.drawCallbackId = requestAnimationFrame(this.drawSceneBound)) | |
| } | |
| } | |
| class Qj { | |
| constructor(e, t) { | |
| if (this.canvas = e, | |
| this.drawSceneBound = this.render.bind(this), | |
| this.gl = e.getContext("webgl2", { | |
| stencil: !0, | |
| antialias: !0, | |
| premultipliedAlpha: !1, | |
| alpha: !0 | |
| }), | |
| !this.gl) | |
| throw alert("\u60a8\u4f7f\u7528\u7684\u6d4f\u89c8\u5668\u4e0d\u652f\u6301WebGL2 \u8bf7\u5347\u7ea7\u6d4f\u89c8\u5668"), | |
| new Error("GLERROR: Failed to initiate WebGL2."); | |
| if (!this.gl.getExtension("EXT_color_buffer_float")) | |
| throw alert("\u60a8\u4f7f\u7528\u7684\u6d4f\u89c8\u5668\u4e0d\u652f\u6301WebGL2\u7684\u6269\u5c55 \u8bf7\u5347\u7ea7\u6d4f\u89c8\u5668"), | |
| new Error("GLERROR: Failed to initiate FLOAT_COLOR_BUFFER extension on WebGL2"); | |
| (23 !== this.gl.getShaderPrecisionFormat(this.gl.VERTEX_SHADER, this.gl.HIGH_FLOAT).precision || 23 !== this.gl.getShaderPrecisionFormat(this.gl.FRAGMENT_SHADER, this.gl.HIGH_FLOAT).precision) && (He.VS.replace("/highp/g", "mediump"), | |
| He.FS.replace("/highp/g", "mediump"), | |
| He.VSWithTexture.replace("/highp/g", "mediump"), | |
| He.FSWithTexture.replace("/highp/g", "mediump")), | |
| this.programInfos = new Map([["program", Pt.createProgramInfo(this.gl, [He.VS, He.FS])], ["programWithTexture", Pt.createProgramInfo(this.gl, [He.VSWithTexture, He.FSWithTexture])], ["programWithWOIT", Pt.createProgramInfo(this.gl, [He.VSWithWOIT, He.FSWithWOIT])], ["programWithAccum", Pt.createProgramInfo(this.gl, [He.VSWithAccum, He.FSWithAccum])], ["programWithAccumAndTexture", Pt.createProgramInfo(this.gl, [He.VSWithAccumAndTexture, He.FSWithAccumAndTexture])]]), | |
| this.accumFrameBuffer = this.gl.createFramebuffer(), | |
| this.camera = new Dg(e,{ | |
| zoomIndex: e.width / 960 * 40, | |
| defaultNormal: T.normalize(T.fromValues(0, 0, 1)) | |
| }), | |
| this.spans = [], | |
| this.numberMarkers = [], | |
| this.cameraAnimation = new bD(this,.2), | |
| this.spanAnimation = new zj(this,.5), | |
| this.rayCaster = new Wj, | |
| this.runtimeConstant = { | |
| mouseFactor: .01, | |
| dragThreshold: 1e-4, | |
| rayCastThreshold: .05, | |
| numberMarkerCount: 8 | |
| }, | |
| this.drawCallbackId = 0, | |
| this.lastTimeStamp = 0, | |
| this.markedSpans = [], | |
| this.numberMarkerInfo = { | |
| id: 26, | |
| value: "number", | |
| tag: "\u6570\u5b57", | |
| clipInfo: { | |
| isBase: !0 | |
| }, | |
| previewUrl: "" | |
| }, | |
| this.numberMarkerTexUrl = r => `//nodestatic.fbstatic.cn/webtools/png/number${++r}.png`, | |
| this.isAssetsLoaded = !1, | |
| this.loadSpan(t) | |
| } | |
| reset() { | |
| this.camera.transformInfo = this.camera.defaultInfo, | |
| this.glTF.scene.nodes.forEach(e => { | |
| e.traverse( (t, r) => { | |
| t.translation = pe.getTranslation(t.matrix), | |
| t.rotation = pe.getRotation(t.matrix), | |
| t.scale = pe.getScale(t.matrix), | |
| t.modelMatrix = t.matrix, | |
| t.worldMatrix = null !== r ? pe.multiply(r.worldMatrix, t.modelMatrix) : pe.clone(t.modelMatrix) | |
| } | |
| ) | |
| } | |
| ), | |
| this.spans.forEach(e => { | |
| e.transformInfo = (new Ut).fromMatrix(this.glTF.nodes[e.nodeID].worldMatrix), | |
| e.resetColour() | |
| } | |
| ), | |
| this.markedSpans = [], | |
| this.lastTimeStamp = 0, | |
| this.cameraAnimation.clear(), | |
| this.spanAnimation.clear(), | |
| this.glTF.animations.forEach(e => { | |
| e.samplers.forEach(t => { | |
| t.updateKeyFrames(t.duration) | |
| } | |
| ) | |
| } | |
| ), | |
| this.requestRender() | |
| } | |
| destroy() { | |
| this.gl.deleteFramebuffer(this.accumFrameBuffer), | |
| this.programInfos.forEach(e => { | |
| const t = e.program; | |
| this.gl.getAttachedShaders(t).forEach(i => { | |
| this.gl.deleteShader(i) | |
| } | |
| ), | |
| this.gl.deleteProgram(t) | |
| } | |
| ), | |
| this.spans.forEach(e => { | |
| Object.entries(e.bufferInfo.attribs).forEach(t => { | |
| this.gl.deleteBuffer(t[1].buffer) | |
| } | |
| ), | |
| e.bufferInfo.indices && this.gl.deleteBuffer(e.bufferInfo.indices), | |
| void 0 !== e.textureID && this.gl.deleteTexture(this.glTF.textures[e.textureID].texture) | |
| } | |
| ), | |
| this.spans = [], | |
| this.markedSpans = [], | |
| this.glTF = null, | |
| this.gl.getExtension("WEBGL_lose_context").loseContext() | |
| } | |
| resize(e, t) { | |
| this.canvas.width = e, | |
| this.canvas.height = t, | |
| this.gl.viewport(0, 0, e, t) | |
| } | |
| loadSpan(e) { | |
| this.spans = [], | |
| Promise.all([new ka(this.gl).loadGLTF(e), new ka(this.gl).loadGLTF(this.numberMarkerInfo)]).then(t => Ht(this, void 0, void 0, function*() { | |
| this.glTF = t[0], | |
| this.glTF.nodes.forEach(i => { | |
| i.mesh && this.spans.push(new TD(i)) | |
| } | |
| ), | |
| this.requestRender(), | |
| yield new Promise(i => Ht(this, void 0, void 0, function*() { | |
| const o = []; | |
| for (let s = 0; s < this.runtimeConstant.numberMarkerCount; s++) | |
| try { | |
| o.push(fetch(new Request(this.numberMarkerTexUrl(s))).then(a => { | |
| if (a.ok) | |
| return a.blob(); | |
| throw Error("LoadingError: Error occurred in loading number marker texture.") | |
| } | |
| ).then(a => createImageBitmap(a))) | |
| } catch (a) { | |
| console.error(a) | |
| } | |
| for (const s of o) | |
| this.numberMarkers.push(new qj(t[1].nodes[0]).loadTexture(yield s, this.gl)); | |
| i(!0) | |
| })), | |
| this.isAssetsLoaded = !0 | |
| })).catch(t => { | |
| throw alert("\u52a0\u8f7d\u6587\u4ef6\u51fa\u9519 \u8bf7\u68c0\u67e5\u7f51\u7edc\u8fde\u63a5"), | |
| console.error(t), | |
| new Error("GLTFERROR: Failed to load glTF file(s).") | |
| } | |
| ) | |
| } | |
| reloadSpan(e) { | |
| this.isAssetsLoaded = !1, | |
| this.spans = [], | |
| new ka(this.gl).loadGLTF(e).then(t => { | |
| this.glTF = t, | |
| this.glTF.nodes.forEach(r => { | |
| r.mesh && this.spans.push(new TD(r)) | |
| } | |
| ), | |
| this.isAssetsLoaded = !0 | |
| } | |
| ).then( () => { | |
| this.resetMarkers(), | |
| this.requestRender() | |
| } | |
| ).catch(t => { | |
| throw alert("\u52a0\u8f7d\u6587\u4ef6\u51fa\u9519 \u8bf7\u68c0\u67e5\u7f51\u7edc\u8fde\u63a5"), | |
| console.error(t), | |
| new Error("GLTFERROR: Failed to load glTF file(s).") | |
| } | |
| ) | |
| } | |
| setMarkers(e, t) { | |
| const r = this.getSpanFromNodeID(e) | |
| , i = T.scale(T.fromVec4(r.shaderUniforms.u_color), 255); | |
| "face" === r.type ? t = T.scale(t, 1.2) : "edge" === r.type && (t = T.scale(t, .8)), | |
| T.equals(t, i) ? (r.resetColour(), | |
| "edge" === r.type && -1 !== this.markedSpans.indexOf(r) && this.markedSpans.splice(this.markedSpans.indexOf(r), 1)) : (r.setColour(t), | |
| "edge" === r.type && -1 === this.markedSpans.indexOf(r) && this.markedSpans.length < this.runtimeConstant.numberMarkerCount && this.markedSpans.push(r)) | |
| } | |
| resetMarkers() { | |
| this.spans.forEach(e => { | |
| e.resetColour() | |
| } | |
| ), | |
| this.numberMarkers.forEach(e => { | |
| e.resetColour() | |
| } | |
| ), | |
| this.markedSpans = [] | |
| } | |
| getIntersections(e, t) { | |
| if (this.rayCaster.clearIntersections(), | |
| this.rayCaster.fromOrthographic({ | |
| x: e, | |
| y: t | |
| }, this.camera), | |
| this.glTF && (this.glTF.scene.nodes.forEach(r => { | |
| this.rayCaster.intersectNodes(r, !0) | |
| } | |
| ), | |
| 0 !== this.rayCaster.intersections.length)) { | |
| const r = this.rayCaster.intersections[0].distance | |
| , i = this.rayCaster.intersections[0].nodeName.slice(0, 4) | |
| , o = []; | |
| return this.rayCaster.intersections.forEach(s => { | |
| s.nodeName.includes(i) && Math.abs(s.distance - r) < this.runtimeConstant.rayCastThreshold && o.push(s.nodeID) | |
| } | |
| ), | |
| o | |
| } | |
| return null | |
| } | |
| rotateCamera(e, t) { | |
| const r = this.camera.cameraNormal | |
| , i = Math.acos(r[1]) | |
| , o = Math.atan2(r[0], r[2]); | |
| let s = i - t * this.runtimeConstant.mouseFactor; | |
| s = Math.max(s, this.runtimeConstant.dragThreshold), | |
| s = Math.min(s, Math.PI - this.runtimeConstant.dragThreshold); | |
| let a = o - e * this.runtimeConstant.mouseFactor; | |
| const l = T.fromValues(Math.sin(s) * Math.sin(a), Math.cos(s), Math.sin(s) * Math.cos(a)) | |
| , c = this.convertNormalTransformToQuat(r, l); | |
| this.camera.transformInfo.rotation = et.multiply(c, this.camera.transformInfo.rotation), | |
| this.requestRender() | |
| } | |
| setAnimation(e, t) { | |
| const r = this.camera.cameraNormal | |
| , i = t ? this.camera.defaultNormal : T.normalize(T.fromValues(.75, .5, 1)) | |
| , o = et.multiply(this.convertNormalTransformToQuat(r, i), this.camera.transformInfo.rotation) | |
| , s = 1e3 * this.glTF.animations[e].channels[0].sampler.duration; | |
| this.cameraAnimation.add({ | |
| duration: t ? s / 6 : s / 3, | |
| type: "camera", | |
| transformInfo: new Ut(T.create(),t ? et.create() : o), | |
| interpolateType: zr.Sin | |
| }), | |
| this.cameraAnimation.add({ | |
| duration: t ? s / 3 : s / 6, | |
| type: "camera", | |
| transformInfo: new Ut(T.create(),o), | |
| interpolateType: zr.Sin | |
| }), | |
| this.lastTimeStamp = 0, | |
| this.cameraAnimation.start(), | |
| this.spanAnimation.add(this.glTF.animations[e]), | |
| this.lastTimeStamp = 0, | |
| this.spanAnimation.start() | |
| } | |
| stepAnimation(e) { | |
| e.forEach( (t, r) => { | |
| const i = this.glTF.nodes[r]; | |
| i.translation = t.translation ? t.translation : i.translation, | |
| i.rotation = t.rotation ? t.rotation : i.rotation, | |
| i.scale = t.scale ? t.scale : i.scale; | |
| const o = pe.fromScaleRotationTranslation(i.translation, i.rotation, i.scale); | |
| i.worldMatrix = i.parent ? pe.multiply(i.parent.worldMatrix, o) : pe.clone(o), | |
| i.traverse( (s, a) => { | |
| a && s !== i && (s.worldMatrix = pe.multiply(a.worldMatrix, s.modelMatrix)) | |
| } | |
| , i) | |
| } | |
| ), | |
| this.spans.forEach(t => { | |
| t.transformInfo = (new Ut).fromMatrix(this.glTF.nodes[t.nodeID].worldMatrix) | |
| } | |
| ) | |
| } | |
| toAnimationFrame(e, t) { | |
| const r = this.glTF.animations[Number(t)]; | |
| this.stepAnimation(this.spanAnimation.getAnimationInfo(r, e * r.channels[0].sampler.duration)), | |
| this.requestRender() | |
| } | |
| setAnimationTimeScale(e) { | |
| this.spanAnimation.setTimeScale(e) | |
| } | |
| convertNormalTransformToQuat(e, t) { | |
| let r, i; | |
| if (T.equals(e, t)) | |
| r = T.create(), | |
| i = 0; | |
| else if (T.equals(e, T.negate(t))) { | |
| const o = e[0] | |
| , s = e[1] | |
| , a = Math.hypot(o, s); | |
| r = T.fromValues(-s / a, o / a, 0), | |
| i = Math.PI | |
| } else | |
| r = T.normalize(T.cross(e, t)), | |
| i = Math.acos(Math.min(T.dot(e, t), 1)), | |
| T.dot(t, T.cross(r, e)) < 0 && (r = T.negate(r)); | |
| return et.setAxisAngle(r, i) | |
| } | |
| getTransformInfo(e) { | |
| return this.camera.transformInfo | |
| } | |
| setTransformInfo(e, t) { | |
| this.camera.transformInfo = t | |
| } | |
| getSpanFromNodeID(e) { | |
| return this.spans.filter(t => t.nodeID === e).shift() | |
| } | |
| getCubeSpanTypeFromNodeID(e) { | |
| return this.spans.filter(t => t.nodeID === e).shift().type | |
| } | |
| computeWorldMatrix(e, t) { | |
| return pe.multiply(e, t.transform) | |
| } | |
| getNumberMarkerIndexOffset(e, t) { | |
| const r = T.fromValues(0, 1.5, 0) | |
| , i = T.fromValues(-1.5, 0, 0); | |
| return dt.equals(T.transformQuat(T.fromValues(0, 1, 0), e)[1], 0, 1e-4) ? t ? T.negate(r) : r : t ? T.negate(i) : i | |
| } | |
| render(e) { | |
| const t = this.gl; | |
| this.drawCallbackId = 0, | |
| this.lastTimeStamp || (this.lastTimeStamp = e); | |
| const r = e - this.lastTimeStamp; | |
| this.lastTimeStamp = e, | |
| this.cameraAnimation.step(r), | |
| this.spanAnimation.step(r); | |
| const i = this.programInfos; | |
| let o, s, a = !0; | |
| t.enable(t.BLEND), | |
| t.blendFuncSeparate(t.SRC_ALPHA, t.ONE_MINUS_SRC_ALPHA, t.ONE, t.ONE_MINUS_SRC_ALPHA), | |
| t.enable(t.DEPTH_TEST), | |
| t.depthMask(!0), | |
| t.colorMask(!0, !0, !0, !0), | |
| t.clearColor(0, 0, 0, 0), | |
| t.clear(t.COLOR_BUFFER_BIT | t.DEPTH_BUFFER_BIT | t.STENCIL_BUFFER_BIT); | |
| const l = this.camera | |
| , c = this.spans | |
| , u = this.numberMarkers.slice(0, this.markedSpans.length) | |
| , d = this.accumFrameBuffer | |
| , h = t.createTexture() | |
| , f = t.createTexture() | |
| , p = pe.lookAt(l.cameraPosition, l.targetCoordinate, l.upNormal) | |
| , _ = pe.ortho(-l.horizontalOffset, l.horizontalOffset, -l.verticalOffset, l.verticalOffset, l.nearOffset, l.farOffset) | |
| , C = pe.multiply(_, p); | |
| function R(v, O, M, N, F) { | |
| !O || (v !== o && (o = v, | |
| v === i.get("programWithAccum") || v === i.get("programWithAccumAndTexture") ? (Pt.bindWOITTextures(t, h, f, d), | |
| t.bindFramebuffer(t.FRAMEBUFFER, d)) : v === i.get("programWithWOIT") ? t.bindFramebuffer(t.FRAMEBUFFER, null) : (t.deleteTexture(h), | |
| t.deleteTexture(f)), | |
| t.useProgram(v.program), | |
| N = !0), | |
| (N || O !== s) && (s = O, | |
| Pt.setAttributes(v, O.attribs), | |
| O.indices && t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, O.indices)), | |
| Pt.setUniforms(v, M), | |
| function S(v) { | |
| if ((v = v || {}).disableDepth ? t.disable(t.DEPTH_TEST) : t.enable(t.DEPTH_TEST), | |
| v.clearDepth && (t.depthMask(!0), | |
| t.clear(t.DEPTH_BUFFER_BIT)), | |
| t.depthMask(!v.disableDepthWrite), | |
| t.depthFunc(v.depthFunc ? v.depthFunc : t.LESS), | |
| v.disableBlend ? t.disable(t.BLEND) : t.enable(t.BLEND), | |
| v.blendFunc) { | |
| const O = v.blendFunc; | |
| t.enable(t.BLEND), | |
| t.blendFuncSeparate(O[0], O[1], O[2], O[3]) | |
| } | |
| v.disableColor ? t.colorMask(!1, !1, !1, !1) : t.colorMask(!0, !0, !0, !0), | |
| v.initWOIT && (t.blendFuncSeparate(t.ONE, t.ONE, t.ZERO, t.ONE_MINUS_SRC_ALPHA), | |
| t.clear(t.COLOR_BUFFER_BIT)), | |
| v.drawWOIT && (t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA), | |
| t.clear(t.COLOR_BUFFER_BIT)) | |
| }(F), | |
| O.indices ? t.drawElements(t.TRIANGLES, O.numElements, t.UNSIGNED_SHORT, 0) : t.drawArrays(t.TRIANGLES, 0, O.numElements)) | |
| } | |
| c.some(v => void 0 !== v.textureID) ? c.forEach(v => { | |
| v.shaderUniforms.u_worldMatrix = this.computeWorldMatrix(C, v.transformInfo), | |
| v.shaderUniforms.u_texture = void 0 === v.textureID ? void 0 : this.glTF.textures[v.textureID].texture, | |
| R(i.get(void 0 === v.textureID ? "program" : "programWithTexture"), v.bufferInfo, v.shaderUniforms, !1, { | |
| disableBlend: !0 | |
| }) | |
| } | |
| ) : (c.forEach(v => { | |
| v.shaderUniforms.u_worldMatrix = this.computeWorldMatrix(C, v.transformInfo); | |
| const O = i.get("programWithAccum"); | |
| let F = {}; | |
| a && (a = !1, | |
| F = { | |
| disableDepth: !1, | |
| disableDepthWrite: !1, | |
| initWOIT: !0 | |
| }), | |
| R(O, v.bufferInfo, v.shaderUniforms, !1, F) | |
| } | |
| ), | |
| 0 !== c.length && (R(i.get("programWithWOIT"), Pt.createWOITBufferInfo(t), { | |
| u_accumulateColor: h, | |
| u_accumulateAlpha: f | |
| }, !0, { | |
| disableDepth: !0, | |
| drawWOIT: !0 | |
| }), | |
| t.depthMask(!0), | |
| t.clear(t.DEPTH_BUFFER_BIT)), | |
| c.filter(v => "face" === v.type).forEach(v => { | |
| v.shaderUniforms.u_worldMatrix = this.computeWorldMatrix(C, v.transformInfo), | |
| R(this.programInfos.get("program"), v.bufferInfo, v.shaderUniforms, !0, { | |
| disableColor: !0 | |
| }) | |
| } | |
| ), | |
| c.filter(v => "face" !== v.type).forEach(v => { | |
| v.shaderUniforms.u_worldMatrix = this.computeWorldMatrix(C, v.transformInfo), | |
| R(this.programInfos.get("program"), v.bufferInfo, v.shaderUniforms, !0, { | |
| depthFunc: t.LEQUAL | |
| }) | |
| } | |
| )), | |
| u.forEach( (v, O) => { | |
| const M = this.programInfos.get("programWithTexture") | |
| , N = v.bufferInfo | |
| , F = v.shaderUniforms | |
| , K = this.markedSpans[O] | |
| , X = K.transformInfo; | |
| v.setColour(T.scale(T.fromVec4(K.shaderUniforms.u_color), 1.5)); | |
| const g = this.markedSpans.some( (w, I) => I < O && T.equals(w.transformInfo.translation, X.translation, 1e-4)) | |
| , y = T.add(X.translation, this.getNumberMarkerIndexOffset(X.rotation, g)) | |
| , E = et.getEuler(l.transformInfo.rotation) | |
| , b = et.fromEuler(E[1], E[2], 0); | |
| F.u_worldMatrix = pe.multiply(C, pe.fromScaleRotationTranslation(T.add(y, v.transformInfo.translation), et.multiply(b, v.transformInfo.rotation), v.transformInfo.scale)), | |
| F.u_texture = v.texture, | |
| R(M, N, F, !1, { | |
| disableDepth: !0 | |
| }) | |
| } | |
| ) | |
| } | |
| requestRender() { | |
| this.drawCallbackId || (this.drawCallbackId = requestAnimationFrame(this.drawSceneBound)) | |
| } | |
| } | |
| let Mg = ( () => { | |
| class n { | |
| constructor(t, r) { | |
| this.location = t, | |
| this.router = r, | |
| this.apiPrefix = "", | |
| this.cdnPrefix = "", | |
| this.authPrefix = "", | |
| this.init() | |
| } | |
| get isOnline() { | |
| return window.location.hostname.includes("fenbi.com") | |
| } | |
| get isTest() { | |
| return window.location.hostname.includes("fenbilantian.com") | |
| } | |
| get isLocal() { | |
| return this.location.getBaseHref().length <= 1 | |
| } | |
| init() { | |
| this.apiPrefix = `//webapi.${this.isOnline ? "fenbi.com" : "fenbilantian.cn"}/doc/api/cos/private/gltf`, | |
| this.cdnPrefix = "//nodestatic.fbstatic.cn", | |
| this.authPrefix = `//keapi.${this.isOnline ? "fenbi.com" : "fenbilantian.cn"}/primelecture/api/user_prime_lectures/has_prime_lecture` | |
| } | |
| getApiUrl(t) { | |
| return this.apiPrefix + t | |
| } | |
| getCdnUrl(t) { | |
| return this.cdnPrefix + t | |
| } | |
| getAuthUrl(t) { | |
| return this.authPrefix + t | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(Q(ii),Q(Nt)) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )() | |
| , ED = ( () => { | |
| class n { | |
| constructor() {} | |
| toast(t, r) { | |
| return new Xj(t,r) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275prov = se({ | |
| token: n, | |
| factory: n.\u0275fac | |
| }), | |
| n | |
| } | |
| )(); | |
| class Xj { | |
| constructor(e, t) { | |
| this.toastWrapper = null, | |
| this.toastMessage = e.replace(/\n/g, "<br>"), | |
| this.toastDuration = t || 1e3, | |
| this.init() | |
| } | |
| init() { | |
| this.toastWrapper = document.createElement("div"), | |
| this.toastWrapper.innerHTML = "<span>" + this.toastMessage + "</span>", | |
| this.toastWrapper.classList.add("toast"), | |
| this.toastWrapper.classList.add("toast-show"), | |
| document.body.appendChild(this.toastWrapper), | |
| this.toastDuration > 0 && setTimeout( () => { | |
| this.toastWrapper.classList.replace("toast-show", "toast-hide"), | |
| setTimeout( () => { | |
| this.destroy() | |
| } | |
| , 400) | |
| } | |
| , this.toastDuration) | |
| } | |
| destroy() { | |
| !this.toastWrapper || (document.body.removeChild(this.toastWrapper), | |
| this.toastWrapper = null) | |
| } | |
| } | |
| function Jj(n, e) { | |
| if (1 & n) { | |
| const t = Ln(); | |
| re(0, "div", 2), | |
| _e("click", function() { | |
| const o = Ue(t).$implicit; | |
| return je(be().clickModel(o)) | |
| }), | |
| Ct(1, "img", 3), | |
| re(2, "p", 4), | |
| $e(3), | |
| oe()() | |
| } | |
| if (2 & n) { | |
| const t = e.$implicit; | |
| Ee(1), | |
| Ae("src", t.previewUrl, ei), | |
| Ee(2), | |
| pr(t.tag) | |
| } | |
| } | |
| let eH = ( () => { | |
| class n { | |
| constructor(t, r, i) { | |
| this.hrefService = t, | |
| this.toastService = r, | |
| this.route = i, | |
| this.selectModel = new Se, | |
| this.models = [], | |
| this.userId = 0 | |
| } | |
| ngOnInit() { | |
| return Ht(this, void 0, void 0, function*() {}) | |
| } | |
| ngOnChanges() {} | |
| ngDoCheck() { | |
| this.config.type !== this.lastType && (this.lastType = this.config.type, | |
| this.configChangeHandler(this.config)) | |
| } | |
| configChangeHandler(t) { | |
| return Ht(this, void 0, void 0, function*() { | |
| yield this.getModels(), | |
| this.models.forEach(r => Ht(this, void 0, void 0, function*() { | |
| r.previewUrl = this.hrefService.getCdnUrl(`/imgs/icons/${r.value}.png`) | |
| })) | |
| }) | |
| } | |
| clickModel(t) { | |
| var r, i; | |
| return Ht(this, void 0, void 0, function*() { | |
| const o = yield this.checkAuthorization(); | |
| (null === (r = t.clipInfo) || void 0 === r ? void 0 : r.isBase) || (null === (i = t.spanInfo) || void 0 === i ? void 0 : i.isBase) || 200 === o ? this.selectModel.emit(t) : this.toastService.toast(401 === o ? "\u60a8\u8fd8\u6ca1\u6709\u767b\u5f55" : "\u7cbe\u54c1\u73ed\u5b66\u5458\u4e13\u5c5e\u9898\u76ee") | |
| }) | |
| } | |
| checkAuthorization() { | |
| return Ht(this, void 0, void 0, function*() { | |
| if (this.hrefService.isLocal) | |
| return 200; | |
| const t = yield wg(this.hrefService.getAuthUrl(""), { | |
| method: "GET", | |
| credentials: "include" | |
| }); | |
| return t.code === ns.Succeed ? !0 === (null == t ? void 0 : t.data) ? 200 : 403 : 401 | |
| }) | |
| } | |
| getModels() { | |
| return Ht(this, void 0, void 0, function*() { | |
| const t = yield wg(this.hrefService.getApiUrl(`/list/${this.config.type}`), { | |
| method: "GET", | |
| credentials: "include" | |
| }); | |
| t.code === ns.Succeed && (this.models = [], | |
| t.datas.sort( (r, i) => r.id - i.id).forEach(r => { | |
| if (!r.is_hidden) { | |
| const i = { | |
| id: r.id, | |
| value: r.value, | |
| tag: r.tag, | |
| previewUrl: "" | |
| }; | |
| this.config.isClip ? i.clipInfo = { | |
| isBase: r.isBase | |
| } : i.spanInfo = { | |
| animations: [1, 0], | |
| isBase: r.isBase, | |
| isPreview: 0 !== r.previewStyle | |
| }, | |
| this.models.push(i) | |
| } | |
| } | |
| )) | |
| }) | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n)(B(Mg),B(ED),B(gi)) | |
| } | |
| , | |
| n.\u0275cmp = dn({ | |
| type: n, | |
| selectors: [["app-polyhedron-selector"]], | |
| inputs: { | |
| config: "config" | |
| }, | |
| outputs: { | |
| selectModel: "selectModel" | |
| }, | |
| features: [Tn], | |
| decls: 2, | |
| vars: 1, | |
| consts: [[1, "polyhedron-selector-wrapper"], ["class", "polyhedron-selector-container", 3, "click", 4, "ngFor", "ngForOf"], [1, "polyhedron-selector-container", 3, "click"], [1, "polyhedron-selector-preview", 3, "src"], [1, "polyhedron-selector-tag"]], | |
| template: function(t, r) { | |
| 1 & t && (re(0, "div", 0), | |
| Ke(1, Jj, 4, 2, "div", 1), | |
| oe()), | |
| 2 & t && (Ee(1), | |
| Ae("ngForOf", r.models)) | |
| }, | |
| dependencies: [Af], | |
| styles: [".polyhedron-selector-wrapper[_ngcontent-%COMP%]{display:grid;grid-template-columns:repeat(auto-fill,360px);justify-content:center;align-items:center;width:100%;padding:60px 0 60px 60px;background:#E9E9E9}.polyhedron-selector-wrapper[_ngcontent-%COMP%] .polyhedron-selector-container[_ngcontent-%COMP%]{width:360px;height:480px;padding:30px 40px}.polyhedron-selector-wrapper[_ngcontent-%COMP%] .polyhedron-selector-container[_ngcontent-%COMP%] .polyhedron-selector-preview[_ngcontent-%COMP%]{width:280px;height:280px;border:#FFFFFF solid 40px;border-radius:30px;background:white}.polyhedron-selector-wrapper[_ngcontent-%COMP%] .polyhedron-selector-container[_ngcontent-%COMP%] .polyhedron-selector-tag[_ngcontent-%COMP%]{height:110px;margin:30px 0;text-align:center;font-size:28px;color:#3c464f;letter-spacing:1.56px;font-weight:500}"] | |
| }), | |
| n | |
| } | |
| )() | |
| , tH = ( () => { | |
| class n { | |
| constructor() { | |
| this.change = new Se, | |
| this.x = 0, | |
| this.y = 0, | |
| this.minX = -8, | |
| this.minY = -8, | |
| this.maxX = 8, | |
| this.maxY = 8, | |
| this.borderWidth = 4, | |
| this.isDragging = !1 | |
| } | |
| computeXY(t) { | |
| const r = t.target | |
| , i = r.getBoundingClientRect(); | |
| let o = (t.clientX - i.left - this.borderWidth) / r.clientWidth | |
| , s = (t.clientY - i.top - this.borderWidth) / r.clientHeight; | |
| o = Math.min(1, Math.max(0, o)), | |
| s = Math.min(1, Math.max(0, s)), | |
| this.x = o * (this.maxX - this.minX) + this.minX, | |
| this.y = s * (this.maxY - this.minY) + this.minY, | |
| this.change.emit({ | |
| x: this.x, | |
| y: this.y | |
| }) | |
| } | |
| mouseDown(t) { | |
| this.isDragging = !0, | |
| this.computeXY(t) | |
| } | |
| mouseMove(t) { | |
| this.isDragging && (t.preventDefault(), | |
| this.computeXY(t)) | |
| } | |
| mouseUp() { | |
| this.isDragging = !1 | |
| } | |
| } | |
| return n.\u0275fac = function(t) { | |
| return new (t || n) | |
| } | |
| , | |
| n.\u0275cmp = dn({ | |
| type: n, | |
| selectors: [["app-horizontal-control"]], | |
| outputs: { | |
| change: "change" | |
| }, | |
| decls: 4, | |
| vars: 4, | |
| consts: [[1, "horizontal-control", 3, "pointerdown", "pointermove", "pointerup", "pointerleave"], ["id", "horizontal-control-dot"], ["id", "horizontal-control-vdelim"], ["id", "horizontal-control-hdelim"]], | |
| template: function(t, r) { | |
| 1 & t && (re(0, "div", 0), | |
| _e("pointerdown", function(o) { | |
| return r.mouseDown(o) | |
| })("pointermove", function(o) { | |
| return r.mouseMove(o) | |
| })("pointerup", function() { | |
| return r.mouseUp() | |
| })("pointerleave", function() { | |
| return r.mouseUp() | |
| }), | |
| Ct(1, "div", 1)(2, "div", 2)(3, "div", 3), | |
| oe()), | |
| 2 & t && (Ee(1), | |
| Sh("left", (r.x - r.minX) / (r.maxX - r.minX) * 100 + "%")("top", (r.y - r.minY) / (r.maxY - r.minY) * 100 + "%")) | |
| }, | |
| styles: ["[_nghost-%COMP%]{display:inline-block}[_nghost-%COMP%] .horizontal-control[_ngcontent-%COMP%]{width:200px;border:4px solid #C9CFDB;height:200px;overflow:hidden;touch-action:none}[_nghost-%COMP%] #horizontal-control-vdelim[_ngcontent-%COMP%]{position:relative;width:2px;height:100%;margin:0 auto;background:#C9CFDB;pointer-events:none}[_nghost-%COMP%] #horizontal-control-hdelim[_ngcontent-%COMP%]{position:relative;width:100%;height:2px;margin:calc(-50% - 1px) 0;background:#C9CFDB;pointer-events:none}[_nghost-%COMP%] #horizontal-control-dot[_ngcontent-%COMP%]{position:relative;float:left;transform:translate(-7px,-7px);width:14px;height:14px;z-index:100;border-radius:50%;background:#3C7CFC;pointer-events:none;cursor:grab}"] | |
| }), | |
| n | |
| } | |
| )(); | |
| const nH = ["cubeCanvas"]; | |
| function rH(n, e) { | |
| 1 & n && (re(0, "div", 3), | |
| Ct(1, "div", 4), | |
| oe()) | |
| } | |
| let iH = ( () => { | |
| class n { | |
| constructor() { | |
| this.onCanvasEvent = new Se | |
| } | |
| resizeEvent(t) { | |
| const r = document.getElementById("polyhedron-canvas") | |
| , {width: i, height: o} = r.getBoundingClientRect(); | |
| this.glClip && this.glClip.resize(i, o), | |
| this.glSpan && this.glSpan.resize(i, o) | |
| } | |
| get isAssetsLoading() { | |
| return this.glClip ? !this.glClip.isAssetsLoaded : !this.glSpan || !this.glSpan.isAssetsLoaded | |
| } | |
| ngOnInit() { | |
| this.mouseDrag = !1, | |
| this.mouseDown = !1, | |
| this.mousePosition = [0, 0], | |
| this.cameraMode = _i.Default | |
| } | |
| ngOnDestroy() { | |
| var t, r; | |
| null === (t = this.glClip) || void 0 === t || t.destroy(), | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment