1335 lines
124 KiB
JavaScript
1335 lines
124 KiB
JavaScript
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('d3-random'), require('d3-selection'), require('d3-shape'), require('@angular/platform-browser')) :
|
|
typeof define === 'function' && define.amd ? define('nls-guilloche', ['exports', '@angular/core', 'd3-random', 'd3-selection', 'd3-shape', '@angular/platform-browser'], factory) :
|
|
(factory((global['nls-guilloche'] = {}),global.ng.core,null,null,null,global.ng.platformBrowser));
|
|
}(this, (function (exports,core,Random,Selection,Shape,platformBrowser) { 'use strict';
|
|
|
|
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** */
|
|
var __assign = function () {
|
|
__assign = Object.assign || function __assign(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s)
|
|
if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
function __generator(thisArg, body) {
|
|
var _ = { label: 0, sent: function () { if (t[0] & 1)
|
|
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f)
|
|
throw new TypeError("Generator is already executing.");
|
|
while (_)
|
|
try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
|
|
return t;
|
|
if (y = 0, t)
|
|
op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0:
|
|
case 1:
|
|
t = op;
|
|
break;
|
|
case 4:
|
|
_.label++;
|
|
return { value: op[1], done: false };
|
|
case 5:
|
|
_.label++;
|
|
y = op[1];
|
|
op = [0];
|
|
continue;
|
|
case 7:
|
|
op = _.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
|
|
_ = 0;
|
|
continue;
|
|
}
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
|
|
_.label = op[1];
|
|
break;
|
|
}
|
|
if (op[0] === 6 && _.label < t[1]) {
|
|
_.label = t[1];
|
|
t = op;
|
|
break;
|
|
}
|
|
if (t && _.label < t[2]) {
|
|
_.label = t[2];
|
|
_.ops.push(op);
|
|
break;
|
|
}
|
|
if (t[2])
|
|
_.ops.pop();
|
|
_.trys.pop();
|
|
continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
}
|
|
catch (e) {
|
|
op = [6, e];
|
|
y = 0;
|
|
}
|
|
finally {
|
|
f = t = 0;
|
|
}
|
|
if (op[0] & 5)
|
|
throw op[1];
|
|
return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
}
|
|
function __read(o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m)
|
|
return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
|
|
ar.push(r.value);
|
|
}
|
|
catch (error) {
|
|
e = { error: error };
|
|
}
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"]))
|
|
m.call(i);
|
|
}
|
|
finally {
|
|
if (e)
|
|
throw e.error;
|
|
}
|
|
}
|
|
return ar;
|
|
}
|
|
function __spread() {
|
|
for (var ar = [], i = 0; i < arguments.length; i++)
|
|
ar = ar.concat(__read(arguments[i]));
|
|
return ar;
|
|
}
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
var NlsCanvasService = (function () {
|
|
function NlsCanvasService(rendererFactory) {
|
|
this.rendererFactory = rendererFactory;
|
|
this.renderer = rendererFactory.createRenderer(null, null);
|
|
}
|
|
Object.defineProperty(NlsCanvasService.prototype, "get", {
|
|
get: /**
|
|
* @return {?}
|
|
*/ function () {
|
|
return this.canvas;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @param {?} el
|
|
* @return {?}
|
|
*/
|
|
NlsCanvasService.prototype.set = /**
|
|
* @param {?} el
|
|
* @return {?}
|
|
*/
|
|
function (el) {
|
|
this.canvas = el;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsCanvasService.prototype.adjustToWindow = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
if (this.canvas) {
|
|
this.renderer.setStyle(this.canvas, 'width', this.canvas.innerWidth);
|
|
this.renderer.setStyle(this.canvas, 'height', this.canvas.innerHeight);
|
|
}
|
|
};
|
|
NlsCanvasService.decorators = [
|
|
{ type: core.Injectable },
|
|
];
|
|
/** @nocollapse */
|
|
NlsCanvasService.ctorParameters = function () {
|
|
return [
|
|
{ type: core.RendererFactory2 }
|
|
];
|
|
};
|
|
return NlsCanvasService;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
var NlsHistoryService = (function () {
|
|
function NlsHistoryService() {
|
|
this.history = [];
|
|
}
|
|
/**
|
|
* @param {?} graphs
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
NlsHistoryService.prototype.save = /**
|
|
* @param {?} graphs
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
function (graphs, config) {
|
|
this.history.push({
|
|
date: new Date(),
|
|
graphs: graphs,
|
|
config: config,
|
|
hash: this.hash(graphs)
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} graphs
|
|
* @return {?}
|
|
*/
|
|
NlsHistoryService.prototype.hash = /**
|
|
* @param {?} graphs
|
|
* @return {?}
|
|
*/
|
|
function (graphs) {
|
|
return btoa(JSON.stringify(graphs));
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsHistoryService.prototype.list = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.history;
|
|
};
|
|
NlsHistoryService.decorators = [
|
|
{ type: core.Injectable },
|
|
];
|
|
/** @nocollapse */
|
|
NlsHistoryService.ctorParameters = function () { return []; };
|
|
return NlsHistoryService;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
var NlsMathService = (function () {
|
|
function NlsMathService() {
|
|
}
|
|
/**
|
|
* Calculate distance between to points with coordinates.
|
|
* @param {?} a
|
|
* @param {?} b
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.Δ = /**
|
|
* Calculate distance between to points with coordinates.
|
|
* @param {?} a
|
|
* @param {?} b
|
|
* @return {?}
|
|
*/
|
|
function (a, b) {
|
|
return Math.pow(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2), 0.5);
|
|
};
|
|
/**
|
|
* @param {?} point
|
|
* @param {?} matrix
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.getClosestCenter = /**
|
|
* @param {?} point
|
|
* @param {?} matrix
|
|
* @return {?}
|
|
*/
|
|
function (point, matrix) {
|
|
if (this.Δ(point, matrix.start) < this.Δ(point, matrix.end)) {
|
|
return matrix.start;
|
|
}
|
|
else {
|
|
return matrix.end;
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} point
|
|
* @param {?} matrix
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.getFarestCenter = /**
|
|
* @param {?} point
|
|
* @param {?} matrix
|
|
* @return {?}
|
|
*/
|
|
function (point, matrix) {
|
|
if (this.Δ(point, matrix.start) > this.Δ(point, matrix.end)) {
|
|
return matrix.start;
|
|
}
|
|
else {
|
|
return matrix.end;
|
|
}
|
|
};
|
|
/**
|
|
* @param {?} matrix
|
|
* @param {?} overlap
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.randomPoint = /**
|
|
* @param {?} matrix
|
|
* @param {?} overlap
|
|
* @return {?}
|
|
*/
|
|
function (matrix, overlap) {
|
|
/** @type {?} */
|
|
var x = {
|
|
min: matrix.center.x - matrix.width * overlap,
|
|
max: matrix.center.x + matrix.width * overlap
|
|
};
|
|
/** @type {?} */
|
|
var y = {
|
|
min: matrix.center.y - matrix.height * overlap,
|
|
max: matrix.center.y + matrix.height * overlap
|
|
};
|
|
return {
|
|
x: Random.randomUniform(x.min, x.max)(),
|
|
y: Random.randomUniform(y.min, y.max)()
|
|
};
|
|
};
|
|
/**
|
|
* @param {?} width
|
|
* @param {?} height
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.centerOfArea = /**
|
|
* @param {?} width
|
|
* @param {?} height
|
|
* @return {?}
|
|
*/
|
|
function (width, height) {
|
|
return {
|
|
x: width * 0.5,
|
|
y: height * 0.5
|
|
};
|
|
};
|
|
/**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.centerOfPoints = /**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
function (p1, p2) {
|
|
return {
|
|
x: (p1.x + p2.x) * 0.5,
|
|
y: (p1.y + p2.y) * 0.5
|
|
};
|
|
};
|
|
/**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.centerOfCurve = /**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
function (curve) {
|
|
/** @type {?} */
|
|
var genMedian = this.medianPoint(curve);
|
|
/** @type {?} */
|
|
var p1 = genMedian.next().value;
|
|
/** @type {?} */
|
|
var p2 = genMedian.next().value;
|
|
/** @type {?} */
|
|
var radians = this.angleRadians(p1, p2);
|
|
return Object.assign(this.centerOfPoints(p1, p2), { ascent: radians });
|
|
};
|
|
/**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.medianOfCurve = /**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
function (curve) {
|
|
/** @type {?} */
|
|
var genMedian = this.medianPoint(curve);
|
|
/** @type {?} */
|
|
var p1 = genMedian.next().value;
|
|
/** @type {?} */
|
|
var p2 = genMedian.next().value;
|
|
/** @type {?} */
|
|
var p3 = genMedian.next().value;
|
|
/** @type {?} */
|
|
var radians = this.angleRadians(p2, p3);
|
|
// const radians = Math.round(Math.random() * 10000) / 1000;
|
|
// @todo if nodes are less than 5 error occures
|
|
return Object.assign(p1, { ascent: radians });
|
|
};
|
|
/**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.angleRadians = /**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
function (p1, p2) {
|
|
return Math.atan2(p2.y - p1.y, p2.x - p1.x);
|
|
};
|
|
/**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.angleDegree = /**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
function (p1, p2) {
|
|
return this.angleRadians(p1, p2) * 180 / Math.PI;
|
|
};
|
|
/**
|
|
* @param {?} list
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.medianIndex = /**
|
|
* @param {?} list
|
|
* @return {?}
|
|
*/
|
|
function (list) {
|
|
return Math.floor(list.length * 0.5);
|
|
};
|
|
/**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.medianPoint = /**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
function (points) {
|
|
var index, list;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
list = points.slice();
|
|
_a.label = 1;
|
|
case 1:
|
|
if (!list)
|
|
return [3 /*break*/, 3];
|
|
index = this.medianIndex(points);
|
|
return [4 /*yield*/, list[index]];
|
|
case 2:
|
|
_a.sent();
|
|
list.splice(index, 1);
|
|
return [3 /*break*/, 1];
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* Generator for sine bounce
|
|
*
|
|
* @param {?=} amplitude default to 1 indicates the amplitude in positive as well
|
|
* in negative range
|
|
* @param {?=} decimals amount of decimal places
|
|
* @param {?=} start 0 indicates to initiate with positive numbers, 1 indicates to
|
|
* start with negative numbers first
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.bounce = /**
|
|
* Generator for sine bounce
|
|
*
|
|
* @param {?=} amplitude default to 1 indicates the amplitude in positive as well
|
|
* in negative range
|
|
* @param {?=} decimals amount of decimal places
|
|
* @param {?=} start 0 indicates to initiate with positive numbers, 1 indicates to
|
|
* start with negative numbers first
|
|
* @return {?}
|
|
*/
|
|
function (amplitude, decimals, start) {
|
|
if (amplitude === void 0) {
|
|
amplitude = 1;
|
|
}
|
|
if (decimals === void 0) {
|
|
decimals = 1;
|
|
}
|
|
if (start === void 0) {
|
|
start = 0;
|
|
}
|
|
var power, step, index, radians;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
power = Math.pow(10, decimals);
|
|
step = 2 / (power);
|
|
index = 0;
|
|
_a.label = 1;
|
|
case 1:
|
|
radians = Math.PI * step * index + start;
|
|
return [4 /*yield*/, Math.round((Math.sin(radians) * amplitude) * power) / power];
|
|
case 2:
|
|
_a.sent();
|
|
index++;
|
|
return [3 /*break*/, 1];
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
NlsMathService.prototype.flipSign = /**
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
function (startPositive) {
|
|
if (startPositive === void 0) {
|
|
startPositive = true;
|
|
}
|
|
var sign;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
sign = startPositive ? 1 : -1;
|
|
_a.label = 1;
|
|
case 1:
|
|
return [4 /*yield*/, sign = sign * (-1)];
|
|
case 2:
|
|
_a.sent();
|
|
return [3 /*break*/, 1];
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
};
|
|
NlsMathService.decorators = [
|
|
{ type: core.Injectable },
|
|
];
|
|
return NlsMathService;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
var NlsGraphService = (function () {
|
|
function NlsGraphService(math) {
|
|
this.math = math;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphService.prototype.get = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
return this.graphs;
|
|
};
|
|
/**
|
|
* @param {?} newGraphs
|
|
* @return {?}
|
|
*/
|
|
NlsGraphService.prototype.set = /**
|
|
* @param {?} newGraphs
|
|
* @return {?}
|
|
*/
|
|
function (newGraphs) {
|
|
this.graphs = newGraphs;
|
|
};
|
|
Object.defineProperty(NlsGraphService.prototype, "isAnimated", {
|
|
get: /**
|
|
* @return {?}
|
|
*/ function () {
|
|
return this.animation;
|
|
},
|
|
enumerable: true,
|
|
configurable: true
|
|
});
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphService.prototype.startAnimation = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.animation = true;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphService.prototype.stopAnimation = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.animation = false;
|
|
};
|
|
/**
|
|
* @param {?} start
|
|
* @param {?} spacing
|
|
* @return {?}
|
|
*/
|
|
NlsGraphService.prototype.spreadOrthogonal = /**
|
|
* @param {?} start
|
|
* @param {?} spacing
|
|
* @return {?}
|
|
*/
|
|
function (start, spacing) {
|
|
var sign, currentPoint, i, currentSpacing;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
sign = this.math.flipSign();
|
|
currentPoint = start;
|
|
i = 0;
|
|
_a.label = 1;
|
|
case 1:
|
|
currentSpacing = sign.next().value * spacing * i;
|
|
currentPoint = this.shiftPoint(currentPoint, start.ascent, currentSpacing);
|
|
return [4 /*yield*/, currentPoint];
|
|
case 2:
|
|
_a.sent();
|
|
i++;
|
|
return [3 /*break*/, 1];
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} point
|
|
* @param {?} radians
|
|
* @param {?} spacing
|
|
* @return {?}
|
|
*/
|
|
NlsGraphService.prototype.shiftPoint = /**
|
|
* @param {?} point
|
|
* @param {?} radians
|
|
* @param {?} spacing
|
|
* @return {?}
|
|
*/
|
|
function (point, radians, spacing) {
|
|
return {
|
|
x: Math.sin(radians * Math.PI) * spacing + point.x,
|
|
y: Math.cos(radians * Math.PI) * spacing + point.y
|
|
};
|
|
};
|
|
NlsGraphService.decorators = [
|
|
{ type: core.Injectable },
|
|
];
|
|
/** @nocollapse */
|
|
NlsGraphService.ctorParameters = function () {
|
|
return [
|
|
{ type: NlsMathService }
|
|
];
|
|
};
|
|
return NlsGraphService;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
var RESIZING_TIMEOUT = 800;
|
|
var NlsGraphsComponent = (function () {
|
|
function NlsGraphsComponent(canvasService, historyService, math, graphService) {
|
|
this.canvasService = canvasService;
|
|
this.historyService = historyService;
|
|
this.math = math;
|
|
this.graphService = graphService;
|
|
this.svgChange = new core.EventEmitter();
|
|
this.graphChange = new core.EventEmitter();
|
|
this.genLoadedAllGraphs = this.countLoadedGraphs();
|
|
this.resizingWindow = false;
|
|
}
|
|
/**
|
|
* @param {?} event
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.onResize = /**
|
|
* @param {?} event
|
|
* @return {?}
|
|
*/
|
|
function (event) {
|
|
var _this = this;
|
|
clearTimeout(this.resizingWindow);
|
|
this.resizingWindow = setTimeout(function () {
|
|
_this.canvas = _this.adjustCanvas();
|
|
_this.matrix = _this.calcMatrix();
|
|
_this.updateGraphs();
|
|
}, RESIZING_TIMEOUT);
|
|
};
|
|
/**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.ngOnChanges = /**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
function (changes) {
|
|
this.canvas = this.adjustCanvas();
|
|
this.matrix = this.calcMatrix();
|
|
if (changes["config"]) {
|
|
this.updateGraphs();
|
|
}
|
|
if (this.restoredHistory && this.restoredHistory.hash !== this.hash) {
|
|
this.restoreGraph();
|
|
}
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.restoreGraph = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.graphs = this.restoredHistory.graphs;
|
|
this.hash = this.restoredHistory.hash;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.saveHistory = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.hash = this.historyService.hash(this.graphs);
|
|
this.historyService.save(this.graphs, this.config);
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.saveGraph = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.graphService.set(this.graphs);
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.updateGraphs = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var _this = this;
|
|
/** @type {?} */
|
|
var genShiftStart = this.shiftPoint(this.matrix.start, this.config.vectors.start);
|
|
/** @type {?} */
|
|
var genShiftEnd = this.shiftPoint(this.matrix.end, this.config.vectors.end, false);
|
|
console.log(this.matrix);
|
|
/** @type {?} */
|
|
var curveList = [
|
|
{
|
|
color: this.config.colors.primary,
|
|
start: genShiftStart.next().value,
|
|
end: genShiftEnd.next().value
|
|
},
|
|
{
|
|
color: this.config.colors.secondary,
|
|
start: genShiftEnd.next().value,
|
|
end: genShiftStart.next().value
|
|
}
|
|
];
|
|
this.graphs = curveList.map(function (curve) {
|
|
return __assign({}, _this.adjustGraph(curve), { spread: _this.config.spread, interval: _this.config.interval });
|
|
});
|
|
this.hash = this.historyService.hash(this.graphs);
|
|
this.saveHistory();
|
|
this.saveGraph();
|
|
};
|
|
/**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.adjustGraph = /**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
function (curve) {
|
|
return Object.assign(curve, {
|
|
stroke: this.config.stroke,
|
|
start: Object.assign(curve.start, {
|
|
direction: this.genVectorPoint(curve.start.point, curve.start.vector)
|
|
}),
|
|
end: Object.assign(curve.end, {
|
|
direction: this.genVectorPoint(curve.end.point, curve.end.vector)
|
|
}),
|
|
nodes: this.genRandomPoints(this.config.nodes)
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} num
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.genRandomPoints = /**
|
|
* @param {?} num
|
|
* @return {?}
|
|
*/
|
|
function (num) {
|
|
/** @type {?} */
|
|
var generatedPoints = [];
|
|
for (var i = 0; i < this.config.nodes; i++) {
|
|
generatedPoints.push(this.math.randomPoint(this.matrix, this.config.overlap));
|
|
}
|
|
return generatedPoints;
|
|
};
|
|
/**
|
|
* @param {?} x
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.flipflop = /**
|
|
* @param {?} x
|
|
* @return {?}
|
|
*/
|
|
function (x) {
|
|
return (x === 'start') ? 'end' : 'start';
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.adjustCanvas = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.canvasService.set(this.canvas);
|
|
this.canvasService.adjustToWindow();
|
|
return this.svgElementRef.nativeElement;
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.calcMatrix = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
/** @type {?} */
|
|
var canvasWidth = this.canvas.getBoundingClientRect().width;
|
|
/** @type {?} */
|
|
var canvasHeight = this.canvas.getBoundingClientRect().height;
|
|
/** @type {?} */
|
|
var totalCenter = this.math.centerOfArea(canvasWidth, canvasHeight);
|
|
return {
|
|
start: {
|
|
x: 0,
|
|
y: canvasHeight - this.config.vectors.spacing - this.config.margin.y
|
|
},
|
|
end: {
|
|
x: canvasWidth - this.config.vectors.spacing - this.config.margin.x,
|
|
y: 0
|
|
},
|
|
width: canvasWidth,
|
|
height: canvasHeight,
|
|
center: totalCenter
|
|
};
|
|
};
|
|
/**
|
|
* @param {?} point
|
|
* @param {?} vector
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.genVectorPoint = /**
|
|
* @param {?} point
|
|
* @param {?} vector
|
|
* @return {?}
|
|
*/
|
|
function (point, vector) {
|
|
/** @type {?} */
|
|
var range = this.math.Δ(this.matrix.start, this.matrix.end) * this.config.vectors.range;
|
|
return {
|
|
x: range * Math.sin(Math.PI * vector) + point.x,
|
|
y: range * Math.cos(Math.PI * vector) + point.y
|
|
};
|
|
};
|
|
/**
|
|
* @param {?} point
|
|
* @param {?} vector
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.shiftPoint = /**
|
|
* @param {?} point
|
|
* @param {?} vector
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
function (point, vector, startPositive) {
|
|
if (startPositive === void 0) {
|
|
startPositive = true;
|
|
}
|
|
var genShiftX, genShiftY;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
genShiftX = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
|
|
genShiftY = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
|
|
_a.label = 1;
|
|
case 1:
|
|
return [4 /*yield*/, {
|
|
point: {
|
|
x: Math.cos(Math.PI * vector) * genShiftX.next().value + point.x,
|
|
y: Math.sin(Math.PI * vector) * genShiftY.next().value + point.y,
|
|
},
|
|
vector: vector
|
|
}];
|
|
case 2:
|
|
_a.sent();
|
|
return [3 /*break*/, 1];
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} space
|
|
* @param {?} vector
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.shiftNumber = /**
|
|
* @param {?} space
|
|
* @param {?} vector
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
function (space, vector, startPositive) {
|
|
if (startPositive === void 0) {
|
|
startPositive = true;
|
|
}
|
|
var current, index, sign;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
current = 0;
|
|
index = 0;
|
|
sign = this.math.flipSign(startPositive);
|
|
_a.label = 1;
|
|
case 1:
|
|
return [4 /*yield*/, current = sign.next().value * index * space + current];
|
|
case 2:
|
|
_a.sent();
|
|
index++;
|
|
return [3 /*break*/, 1];
|
|
case 3: return [2 /*return*/];
|
|
}
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} guillocheElement
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.prepareGuillocheExport = /**
|
|
* @param {?} guillocheElement
|
|
* @return {?}
|
|
*/
|
|
function (guillocheElement) {
|
|
if (this.genLoadedAllGraphs.next().value) {
|
|
this.svgChange.emit(this.svgElementRef);
|
|
}
|
|
};
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGraphsComponent.prototype.countLoadedGraphs = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
var cycles;
|
|
return __generator(this, function (_a) {
|
|
switch (_a.label) {
|
|
case 0:
|
|
cycles = 1;
|
|
_a.label = 1;
|
|
case 1:
|
|
if (!(cycles < this.graphs.length))
|
|
return [3 /*break*/, 3];
|
|
return [4 /*yield*/, false];
|
|
case 2:
|
|
_a.sent();
|
|
cycles++;
|
|
return [3 /*break*/, 5];
|
|
case 3: return [4 /*yield*/, true];
|
|
case 4:
|
|
_a.sent();
|
|
cycles = 1;
|
|
_a.label = 5;
|
|
case 5: return [3 /*break*/, 1];
|
|
case 6: return [2 /*return*/];
|
|
}
|
|
});
|
|
};
|
|
NlsGraphsComponent.decorators = [
|
|
{ type: core.Component, args: [{
|
|
selector: 'nls-graphs',
|
|
template: "<svg #svg width=\"100%\" height=\"100%\" xmlns=\"http://www.w3.org/2000/svg\"\nversion=\"1.1\" shape-rendering=\"geometricPrecision\">\n <g nlsGuilloche *ngFor=\"let graph of graphs\" [graph]=\"graph\" [animation]=\"animation\"></g>\n</svg>\n",
|
|
styles: [":host{position:absolute;width:100%;height:100%;top:0;left:0;overflow:hidden}"]
|
|
},] },
|
|
];
|
|
/** @nocollapse */
|
|
NlsGraphsComponent.ctorParameters = function () {
|
|
return [
|
|
{ type: NlsCanvasService },
|
|
{ type: NlsHistoryService },
|
|
{ type: NlsMathService },
|
|
{ type: NlsGraphService }
|
|
];
|
|
};
|
|
NlsGraphsComponent.propDecorators = {
|
|
config: [{ type: core.Input }],
|
|
restoredHistory: [{ type: core.Input }],
|
|
animation: [{ type: core.Input }],
|
|
svgChange: [{ type: core.Output }],
|
|
graphChange: [{ type: core.Output }],
|
|
svgElementRef: [{ type: core.ViewChild, args: ['svg',] }],
|
|
onResize: [{ type: core.HostListener, args: ['window:resize', ['$event'],] }]
|
|
};
|
|
return NlsGraphsComponent;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
var NlsGuillocheDirective = (function () {
|
|
function NlsGuillocheDirective(canvasService, el, math, graphService) {
|
|
this.canvasService = canvasService;
|
|
this.el = el;
|
|
this.math = math;
|
|
this.graphService = graphService;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
NlsGuillocheDirective.prototype.ngOnDestroy = /**
|
|
* @return {?}
|
|
*/
|
|
function () {
|
|
this.group.selectAll('*').remove();
|
|
};
|
|
/**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
NlsGuillocheDirective.prototype.ngOnChanges = /**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
function (changes) {
|
|
var _this = this;
|
|
this.group = Selection.select(this.el.nativeElement);
|
|
this.canvas = Selection.select(this.canvasService.get);
|
|
// @todo modify graph here instead of in graphs.component.ts
|
|
this.initialNodes = this.graph.nodes.slice();
|
|
this.initialCurve = __spread([
|
|
this.graph.start.point,
|
|
this.graph.start.direction
|
|
], this.graph.nodes.slice(), [
|
|
this.graph.end.direction,
|
|
this.graph.end.point
|
|
]);
|
|
this.medianPoint = this.math.medianOfCurve(this.initialCurve);
|
|
this.medianIndex = this.math.medianIndex(this.initialCurve);
|
|
if (this.animation) {
|
|
this.graph.nodes = this.graph.nodes.slice().map(function (node, i) {
|
|
return {
|
|
x: node.x,
|
|
y: node.y,
|
|
// ascent: Math.round(Math.random() * 100) / 100
|
|
ascent: _this.medianPoint.ascent + i * 0.5
|
|
};
|
|
});
|
|
this.bounces = this.initialNodes.map(function (node) {
|
|
/** @type {?} */
|
|
var bounceAmplitude = Math.round(Math.random() * 150);
|
|
return _this.math.bounce(bounceAmplitude, 3);
|
|
});
|
|
/** @type {?} */
|
|
var i_1 = 0;
|
|
this.animationInterval = setInterval(function () {
|
|
_this.animateGraph(i_1++ % 1000 / 10000);
|
|
}, this.graph.interval);
|
|
}
|
|
else {
|
|
if (this.animationInterval) {
|
|
this.bounce = null;
|
|
clearInterval(this.animationInterval);
|
|
}
|
|
}
|
|
this.group.selectAll('*').remove();
|
|
this.pathElements = [];
|
|
/** @type {?} */
|
|
var graphs = this.spreadLines(__spread([
|
|
this.graph.start.point,
|
|
this.graph.start.direction
|
|
], this.graph.nodes, [
|
|
this.graph.end.direction,
|
|
this.graph.end.point,
|
|
])).forEach(function (points, index) { return _this.drawGraph(points); });
|
|
};
|
|
/**
|
|
* @param {?} x
|
|
* @return {?}
|
|
*/
|
|
NlsGuillocheDirective.prototype.animateGraph = /**
|
|
* @param {?} x
|
|
* @return {?}
|
|
*/
|
|
function (x) {
|
|
var _this = this;
|
|
/** @type {?} */
|
|
var graphs = this.spreadLines(__spread([
|
|
this.graph.start.point,
|
|
this.graph.start.direction
|
|
], this.graph.nodes.map(function (point, i) {
|
|
/** @type {?} */
|
|
var ascent = point.ascent * Math.sin(Math.PI * x);
|
|
return _this.graphService.shiftPoint(point, ascent, _this.bounces[i].next().value);
|
|
}), [
|
|
this.graph.end.direction,
|
|
this.graph.end.point,
|
|
]));
|
|
graphs.forEach(function (points, i) { return _this.updateGraph(points, i); });
|
|
};
|
|
/**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
NlsGuillocheDirective.prototype.spreadLines = /**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
function (points) {
|
|
var _this = this;
|
|
/** @type {?} */
|
|
var shiftedMedians = [];
|
|
/** @type {?} */
|
|
var genshiftedMedians = this.graphService.spreadOrthogonal(this.medianPoint, this.graph.spread.spacing);
|
|
for (var i = 0; i < this.graph.spread.amount; i++) {
|
|
shiftedMedians.push(genshiftedMedians.next().value);
|
|
}
|
|
return shiftedMedians.map(function (median) {
|
|
/** @type {?} */
|
|
var shiftedPoints = points.slice();
|
|
shiftedPoints.splice(_this.medianIndex, 1, median);
|
|
return shiftedPoints;
|
|
});
|
|
};
|
|
/**
|
|
* @param {?} points
|
|
* @param {?} index
|
|
* @return {?}
|
|
*/
|
|
NlsGuillocheDirective.prototype.updateGraph = /**
|
|
* @param {?} points
|
|
* @param {?} index
|
|
* @return {?}
|
|
*/
|
|
function (points, index) {
|
|
this.pathElements[index]
|
|
.attr('d', Shape.line()
|
|
.x(function (p) { return p.x; })
|
|
.y(function (p) { return p.y; })
|
|
.curve(Shape.curveBasis)(points));
|
|
};
|
|
/**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
NlsGuillocheDirective.prototype.drawGraph = /**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
function (points) {
|
|
this.group
|
|
.attr('stroke', this.graph.color)
|
|
.attr('stroke-width', this.graph.stroke)
|
|
.attr('fill', 'none');
|
|
this.pathElements.push(this.group.append('path')
|
|
.attr('d', Shape.line()
|
|
.x(function (p) { return p.x; })
|
|
.y(function (p) { return p.y; })
|
|
.curve(Shape.curveBasis)(points)));
|
|
};
|
|
/**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
NlsGuillocheDirective.prototype.debugGraph = /**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
function (points) {
|
|
var _this = this;
|
|
points.forEach(function (point, index) {
|
|
/** @type {?} */
|
|
var circle = _this.group.append('g');
|
|
circle.append('circle')
|
|
.attr('cx', point.x)
|
|
.attr('cy', point.y)
|
|
.attr('r', 3)
|
|
.attr('fill-opacity', 0.6)
|
|
.attr('fill', _this.graph.color);
|
|
circle.append('text')
|
|
.attr('x', point.x)
|
|
.attr('y', point.y)
|
|
.attr('dx', 8)
|
|
.attr('dy', 15)
|
|
.attr('fill', _this.graph.color)
|
|
.text(index);
|
|
});
|
|
};
|
|
NlsGuillocheDirective.decorators = [
|
|
{ type: core.Directive, args: [{
|
|
selector: '[nlsGuilloche]'
|
|
},] },
|
|
];
|
|
/** @nocollapse */
|
|
NlsGuillocheDirective.ctorParameters = function () {
|
|
return [
|
|
{ type: NlsCanvasService },
|
|
{ type: core.ElementRef },
|
|
{ type: NlsMathService },
|
|
{ type: NlsGraphService }
|
|
];
|
|
};
|
|
NlsGuillocheDirective.propDecorators = {
|
|
graph: [{ type: core.Input }],
|
|
animation: [{ type: core.Input }]
|
|
};
|
|
return NlsGuillocheDirective;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
var NlsAnimationService = (function () {
|
|
// public genAnimation: any;
|
|
// private timer: Observable<number>;
|
|
// private subscribtion: any;
|
|
function NlsAnimationService(math, historyService) {
|
|
this.math = math;
|
|
this.historyService = historyService;
|
|
}
|
|
/**
|
|
* @param {?} initialGraph
|
|
* @return {?}
|
|
*/
|
|
NlsAnimationService.prototype.animate = /**
|
|
* @param {?} initialGraph
|
|
* @return {?}
|
|
*/
|
|
function (initialGraph) {
|
|
/** @type {?} */
|
|
var newGraph = Object.assign({}, initialGraph);
|
|
/** @type {?} */
|
|
var indexMiddle = Math.floor(newGraph.nodes.length * 0.5);
|
|
/** @type {?} */
|
|
var pointMiddle = newGraph.nodes[indexMiddle];
|
|
newGraph.nodes.splice(indexMiddle, 1, {
|
|
x: pointMiddle.x - 2,
|
|
y: pointMiddle.y + 2,
|
|
});
|
|
return newGraph;
|
|
// });
|
|
};
|
|
NlsAnimationService.decorators = [
|
|
{ type: core.Injectable },
|
|
];
|
|
/** @nocollapse */
|
|
NlsAnimationService.ctorParameters = function () {
|
|
return [
|
|
{ type: NlsMathService },
|
|
{ type: NlsHistoryService }
|
|
];
|
|
};
|
|
return NlsAnimationService;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
var NlsGuillocheModule = (function () {
|
|
function NlsGuillocheModule() {
|
|
}
|
|
NlsGuillocheModule.decorators = [
|
|
{ type: core.NgModule, args: [{
|
|
imports: [
|
|
platformBrowser.BrowserModule
|
|
],
|
|
declarations: [
|
|
NlsGraphsComponent,
|
|
NlsGuillocheDirective
|
|
],
|
|
providers: [
|
|
NlsHistoryService,
|
|
NlsCanvasService,
|
|
NlsMathService,
|
|
NlsGraphService,
|
|
],
|
|
exports: [
|
|
NlsGraphsComponent,
|
|
NlsGuillocheDirective
|
|
]
|
|
},] },
|
|
];
|
|
return NlsGuillocheModule;
|
|
}());
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
|
|
exports.NlsGraphsComponent = NlsGraphsComponent;
|
|
exports.NlsGuillocheDirective = NlsGuillocheDirective;
|
|
exports.NlsAnimationService = NlsAnimationService;
|
|
exports.NlsCanvasService = NlsCanvasService;
|
|
exports.NlsGraphService = NlsGraphService;
|
|
exports.NlsHistoryService = NlsHistoryService;
|
|
exports.NlsMathService = NlsMathService;
|
|
exports.NlsGuillocheModule = NlsGuillocheModule;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"nls-guilloche.umd.js.map","sources":[null,"ng://nls-guilloche/nls/services/canvas.service.ts","ng://nls-guilloche/nls/services/history.service.ts","ng://nls-guilloche/nls/services/math.service.ts","ng://nls-guilloche/nls/services/graph.service.ts","ng://nls-guilloche/nls/components/graphs.component.ts","ng://nls-guilloche/nls/directives/guilloche.directive.ts","ng://nls-guilloche/nls/services/animation.service.ts","ng://nls-guilloche/nls/nls-guilloche.module.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Renderer2, RendererFactory2 } from '@angular/core';\nimport * as Selection from 'd3-selection';\n\n@Injectable()\nexport class NlsCanvasService {\n  private renderer: Renderer2;\n\n  public canvas: any;\n\n  constructor(\n    private rendererFactory: RendererFactory2\n  ) {\n    this.renderer = rendererFactory.createRenderer(null, null);\n  }\n\n  public get get() {\n    return this.canvas;\n  }\n\n  public set(el) {\n    this.canvas = el;\n  }\n\n  public adjustToWindow() {\n    if (this.canvas) {\n      this.renderer.setStyle(\n        this.canvas,\n        'width',\n        this.canvas.innerWidth\n      );\n      this.renderer.setStyle(\n        this.canvas,\n        'height',\n        this.canvas.innerHeight\n      );\n    }\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Optional, ViewChild } from '@angular/core';\nimport * as Selection from 'd3-selection';\n\nimport { Graph } from '../models/graph.model';\n\n@Injectable()\nexport class NlsHistoryService {\n\n  public history: any[];\n\n  constructor() {\n    this.history = [];\n  }\n\n  public save(graphs: Graph[], config) {\n    this.history.push({\n      date: new Date(),\n      graphs: graphs,\n      config: config,\n      hash: this.hash(graphs)\n    });\n  }\n\n  public hash(graphs) {\n    return btoa(JSON.stringify(graphs));\n  }\n\n  public list() {\n    return this.history;\n  }\n}\n\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable } from '@angular/core';\nimport * as Selection from 'd3-selection';\nimport * as Random from 'd3-random';\n\nimport { Point } from './../models/point.model';\nimport { Graph } from './../models/graph.model';\n\n@Injectable()\nexport class NlsMathService {\n\n  /**\n   * Calculate distance between to points with coordinates.\n   * @param a\n   * @param b\n   */\n  public Î(a: Point, b: Point) {\n    return Math.pow(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2), 0.5);\n  }\n\n  public getClosestCenter(point: Point, matrix: any) {\n    if (this.Î(point, matrix.start) < this.Î(point, matrix.end)) {\n      return matrix.start;\n    } else {\n      return matrix.end;\n    }\n  }\n\n  public getFarestCenter(point: Point, matrix: any) {\n    if (this.Î(point, matrix.start) > this.Î(point, matrix.end)) {\n      return matrix.start;\n    } else {\n      return matrix.end;\n    }\n  }\n\n  public randomPoint(matrix: any, overlap: number) {\n    const x = {\n      min: matrix.center.x - matrix.width * overlap,\n      max: matrix.center.x + matrix.width * overlap\n    };\n    const y = {\n      min: matrix.center.y - matrix.height * overlap,\n      max: matrix.center.y + matrix.height * overlap\n    };\n\n    return {\n      x: Random.randomUniform(x.min, x.max)(),\n      y: Random.randomUniform(y.min, y.max)()\n    };\n  }\n\n  public centerOfArea(width, height): Point {\n    return {\n      x: width * 0.5,\n      y: height * 0.5\n    };\n  }\n\n  public centerOfPoints(p1: Point, p2: Point) {\n    return {\n      x: (p1.x + p2.x) * 0.5,\n      y: (p1.y + p2.y) * 0.5\n    };\n  }\n\n  public centerOfCurve(curve: Point[]) {\n    const genMedian = this.medianPoint(curve);\n    const p1 = genMedian.next().value;\n    const p2 = genMedian.next().value;\n    const radians = this.angleRadians(p1, p2);\n\n    return Object.assign(this.centerOfPoints(p1, p2), { ascent: radians });\n  }\n\n  public medianOfCurve(curve: Point[]) {\n    const genMedian = this.medianPoint(curve);\n    const p1 = genMedian.next().value;\n    const p2 = genMedian.next().value;\n    const p3 = genMedian.next().value;\n    const radians = this.angleRadians(p2, p3);\n    // const radians = Math.round(Math.random() * 10000) / 1000;\n    // @todo if nodes are less than 5 error occures\n    return Object.assign(p1, { ascent: radians });\n  }\n\n  public angleRadians(p1: Point, p2: Point) {\n    return Math.atan2(p2.y - p1.y, p2.x - p1.x);\n  }\n\n  public angleDegree(p1: Point, p2: Point) {\n    return this.angleRadians(p1, p2) * 180 / Math.PI;\n  }\n\n  public medianIndex(list: any): number {\n    return Math.floor(list.length * 0.5);\n  }\n\n  public *medianPoint(points: Point[]) {\n    let index: number;\n    const list: Point[] = points.slice();\n\n    while (list) {\n      index = this.medianIndex(points);\n      yield list[index];\n\n      list.splice(index, 1);\n    }\n  }\n\n  /**\n   * Generator for sine bounce\n   *\n   * @param start 0 indicates to initiate with positive numbers, 1 indicates to\n   * start with negative numbers first\n   * @param amplitude default to 1 indicates the amplitude in positive as well\n   * in negative range\n   * @param decimals amount of decimal places\n   */\n\n  public *bounce(\n    amplitude: number = 1,\n    decimals: number = 1,\n    start: number = 0\n  ) {\n    const power = Math.pow(10, decimals);\n    const step = 2 / (power);\n    let index = 0;\n\n    while (true) {\n      const radians = Math.PI * step * index + start;\n      yield Math.round((Math.sin(radians) * amplitude) * power) / power;\n\n      index++;\n    }\n  }\n\n  public *flipSign(startPositive: boolean = true) {\n    let sign = startPositive ? 1 : -1;\n\n    while (true) {\n      yield sign = sign * (-1);\n    }\n  }\n}\n","import { Validators } from '@angular/forms';\n/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Renderer2, RendererFactory2 } from '@angular/core';\nimport * as Selection from 'd3-selection';\n\nimport { NlsMathService } from './math.service';\nimport { Graph } from './../models/graph.model';\nimport { Point } from './../models/point.model';\n\n@Injectable()\nexport class NlsGraphService {\n  private graphs: Graph[];\n  private animation: boolean | null;\n\n  constructor(\n    private math: NlsMathService\n  ) {}\n\n  public get() {\n    return this.graphs;\n  }\n\n  public set(newGraphs: Graph[]) {\n    this.graphs = newGraphs;\n  }\n\n  public get isAnimated() {\n    return this.animation;\n  }\n\n  public startAnimation() {\n    this.animation = true;\n  }\n\n  public stopAnimation() {\n    this.animation = false;\n  }\n\n  public *spreadOrthogonal(start: Point, spacing: number) {\n    const sign = this.math.flipSign();\n    let currentPoint = start;\n    let i = 0;\n\n    while (true) {\n      const currentSpacing = sign.next().value * spacing * i;\n      currentPoint = this.shiftPoint(currentPoint, start.ascent, currentSpacing);\n\n      yield currentPoint;\n\n      i++;\n    }\n  }\n\n  public shiftPoint(point: Point, radians: number, spacing: number): Point {\n    return {\n      x: Math.sin(radians * Math.PI) * spacing + point.x,\n      y: Math.cos(radians * Math.PI) * spacing + point.y\n    };\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { ViewChild, Component, Input, Output, SimpleChanges, OnChanges, EventEmitter, HostListener } from '@angular/core';\nimport { Observable, interval } from 'rxjs';\nimport * as Selection from 'd3-selection';\nimport * as Shape from 'd3-shape';\nimport * as Random from 'd3-random';\nimport * as Drag from 'd3-drag';\n\nimport { Graph } from './../models/graph.model';\nimport { Config } from './../models/config.model';\nimport { Point } from './../models/point.model';\nimport { NlsCanvasService } from './../services/canvas.service';\nimport { NlsHistoryService } from './../services/history.service';\nimport { NlsMathService } from './../services/math.service';\nimport { NlsGuillocheDirective } from './../directives/guilloche.directive';\nimport { NlsGraphService } from './../services/graph.service';\n\nconst RESIZING_TIMEOUT = 800;\n\n@Component({\n  selector: 'nls-graphs',\n  template: `<svg #svg width=\"100%\" height=\"100%\" xmlns=\"http://www.w3.org/2000/svg\"\nversion=\"1.1\" shape-rendering=\"geometricPrecision\">\n  <g nlsGuilloche *ngFor=\"let graph of graphs\" [graph]=\"graph\" [animation]=\"animation\"></g>\n</svg>\n`,\n  styles: [`:host{position:absolute;width:100%;height:100%;top:0;left:0;overflow:hidden}`]\n})\nexport class NlsGraphsComponent implements OnChanges {\n\n  public canvas: any | null;\n  public matrix: any | null;\n  public graphs: Graph[];\n  public windowHeight: number | null;\n  public windowWidth: number | null;\n\n  private genShiftPoint: any | null;\n  private genLoadedAllGraphs: any | null;\n  private hash: string;\n  private resizingWindow: any;\n\n  @Input() config: Config;\n  @Input() restoredHistory: any;\n  @Input() animation: boolean;\n  @Output() svgChange = new EventEmitter();\n  @Output() graphChange = new EventEmitter();\n  @ViewChild('svg') svgElementRef;\n\n  @HostListener('window:resize', ['$event'])\n  onResize(event) {\n    clearTimeout(this.resizingWindow);\n\n    this.resizingWindow = setTimeout(() => {\n      this.canvas = this.adjustCanvas();\n      this.matrix = this.calcMatrix();\n      this.updateGraphs();\n    }, RESIZING_TIMEOUT);\n  }\n\n  constructor(\n    private canvasService: NlsCanvasService,\n    private historyService: NlsHistoryService,\n    private math: NlsMathService,\n    private graphService: NlsGraphService\n  ) {\n    this.genLoadedAllGraphs = this.countLoadedGraphs();\n    this.resizingWindow = false;\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.canvas = this.adjustCanvas();\n    this.matrix = this.calcMatrix();\n\n    if (changes.config) {\n      this.updateGraphs();\n    }\n\n    if (this.restoredHistory && this.restoredHistory.hash !== this.hash) {\n      this.restoreGraph();\n    }\n  }\n\n  private restoreGraph() {\n    this.graphs = this.restoredHistory.graphs;\n    this.hash = this.restoredHistory.hash;\n  }\n\n  private saveHistory() {\n    this.hash = this.historyService.hash(this.graphs);\n    this.historyService.save(this.graphs, this.config);\n  }\n\n  private saveGraph() {\n    this.graphService.set(this.graphs);\n  }\n\n  private updateGraphs(): void {\n    const genShiftStart = this.shiftPoint(this.matrix.start, this.config.vectors.start);\n    const genShiftEnd = this.shiftPoint(this.matrix.end, this.config.vectors.end, false);\n\n    console.log(this.matrix);\n\n    const curveList = [\n      {\n        color: this.config.colors.primary,\n        start: genShiftStart.next().value,\n        end: genShiftEnd.next().value\n        // start: {\n        //   point: this.matrix.start,\n        //   vector: this.config.vectors.start\n        // },\n        // end: {\n        //   point: this.matrix.end,\n        //   vector: this.config.vectors.end\n        // }\n      },\n      {\n        color: this.config.colors.secondary,\n        start: genShiftEnd.next().value,\n        end: genShiftStart.next().value\n        // end: {\n        //   point: this.matrix.start,\n        //   vector: this.config.vectors.start\n        // },\n        // start: {\n        //   point: this.matrix.end,\n        //   vector: this.config.vectors.end\n        // }\n      }\n    ];\n\n    this.graphs = curveList.map(curve => {\n      return {\n        ...this.adjustGraph(curve),\n        spread: this.config.spread,\n        interval: this.config.interval\n      };\n    });\n    this.hash = this.historyService.hash(this.graphs);\n    this.saveHistory();\n    this.saveGraph();\n  }\n\n  private adjustGraph(curve) {\n    return Object.assign(curve, {\n      stroke: this.config.stroke,\n      start: Object.assign(curve.start, {\n        direction: this.genVectorPoint(curve.start.point, curve.start.vector)\n      }),\n      end: Object.assign(curve.end, {\n        direction: this.genVectorPoint(curve.end.point, curve.end.vector)\n      }),\n      nodes: this.genRandomPoints(this.config.nodes)\n    });\n  }\n\n  private genRandomPoints(num: number) {\n    const generatedPoints = [];\n\n    for (let i = 0; i < this.config.nodes; i++) {\n      generatedPoints.push(this.math.randomPoint(this.matrix, this.config.overlap));\n    }\n\n    return generatedPoints;\n  }\n\n  private flipflop(x: string) {\n    return (x === 'start') ? 'end' : 'start';\n  }\n\n  private adjustCanvas(): void {\n    this.canvasService.set(this.canvas);\n    this.canvasService.adjustToWindow();\n\n    return this.svgElementRef.nativeElement;\n  }\n\n  private calcMatrix() {\n    const canvasWidth = this.canvas.getBoundingClientRect().width;\n    const canvasHeight = this.canvas.getBoundingClientRect().height;\n    const totalArea = Math.abs(canvasWidth * canvasHeight);\n    const totalCenter = this.math.centerOfArea(canvasWidth, canvasHeight);\n\n    return {\n      start: {\n        x: 0,\n        y: canvasHeight - this.config.vectors.spacing - this.config.margin.y\n      },\n      end: {\n        x: canvasWidth - this.config.vectors.spacing - this.config.margin.x,\n        y: 0\n      },\n      width: canvasWidth,\n      height: canvasHeight,\n      center: totalCenter\n    };\n  }\n\n  private genVectorPoint(point: Point, vector: number) {\n    const range = this.math.Î(this.matrix.start, this.matrix.end) * this.config.vectors.range;\n\n    return {\n      x: range * Math.sin(Math.PI * vector) + point.x,\n      y: range * Math.cos(Math.PI * vector) + point.y\n    };\n  }\n\n  private *shiftPoint(point: Point, vector: number, startPositive: boolean = true) {\n    const genShiftX = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);\n    const genShiftY = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);\n\n    while (true) {\n      yield {\n        point: {\n          x: Math.cos(Math.PI * vector) * genShiftX.next().value + point.x,\n          y: Math.sin(Math.PI * vector) * genShiftY.next().value + point.y,\n        },\n        vector: vector\n      };\n    }\n  }\n\n  private *shiftNumber(space: number, vector: number, startPositive: boolean = true) {\n    let current = 0;\n    let index = 0;\n    const sign = this.math.flipSign(startPositive);\n\n    while (true) {\n      yield current = sign.next().value * index * space + current;\n      index++;\n    }\n  }\n\n  public prepareGuillocheExport(guillocheElement) {\n    if (this.genLoadedAllGraphs.next().value) {\n      this.svgChange.emit(this.svgElementRef);\n    }\n  }\n\n  private *countLoadedGraphs() {\n    let cycles = 1;\n\n    while (true) {\n      if (cycles < this.graphs.length) {\n        yield false;\n        cycles++;\n      } else {\n        yield true;\n        cycles = 1;\n      }\n    }\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { ElementRef, HostListener, Input, Directive, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';\nimport * as Selection from 'd3-selection';\nimport * as Shape from 'd3-shape';\nimport * as Random from 'd3-random';\nimport * as Drag from 'd3-drag';\nimport * as Ease from 'd3-ease';\nimport * as Timer from 'd3-timer';\n\nimport { Graph } from './../models/graph.model';\nimport { Point } from './../models/point.model';\nimport { NlsCanvasService } from './../services/canvas.service';\nimport { NlsMathService } from './../services/math.service';\nimport { NlsGraphService } from '../services/graph.service';\n\n@Directive({\n  selector: '[nlsGuilloche]'\n})\nexport class NlsGuillocheDirective implements OnChanges, OnDestroy {\n\n  private canvas: any;\n  private group: any;\n  private bounce: any | null;\n  private bounces: any | null;\n  private initialNodes: any;\n  private initialCurve: any;\n  private animationInterval: any;\n  private medianPoint: Point;\n  private medianIndex: number;\n  private pathElements: any;\n\n  @Input() graph: Graph;\n  @Input() animation: boolean;\n\n  constructor(\n    private canvasService: NlsCanvasService,\n    private el: ElementRef,\n    private math: NlsMathService,\n    private graphService: NlsGraphService\n  ) {\n  }\n\n  ngOnDestroy() {\n    this.group.selectAll('*').remove();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.group = Selection.select(this.el.nativeElement);\n    this.canvas = Selection.select(this.canvasService.get);\n    // @todo modify graph here instead of in graphs.component.ts\n    this.initialNodes = this.graph.nodes.slice();\n    this.initialCurve = [\n      this.graph.start.point,\n      this.graph.start.direction,\n      ...this.graph.nodes.slice(),\n      this.graph.end.direction,\n      this.graph.end.point\n    ];\n    this.medianPoint = this.math.medianOfCurve(this.initialCurve);\n    this.medianIndex = this.math.medianIndex(this.initialCurve);\n\n    if (this.animation) {\n      this.graph.nodes = this.graph.nodes.slice().map((node, i) => {\n        return {\n          x: node.x,\n          y: node.y,\n          // ascent: Math.round(Math.random() * 100) / 100\n          ascent: this.medianPoint.ascent + i * 0.5\n        };\n      });\n      this.bounces = this.initialNodes.map(node => {\n        const bounceAmplitude = Math.round(Math.random() * 150);\n        return this.math.bounce(bounceAmplitude, 3);\n      });\n      let i = 0;\n      this.animationInterval = setInterval(() => {\n        this.animateGraph(i++ % 1000 / 10000);\n      }, this.graph.interval);\n    } else {\n      if (this.animationInterval) {\n        this.bounce = null;\n        clearInterval(this.animationInterval);\n      }\n    }\n\n    this.group.selectAll('*').remove();\n    this.pathElements = [];\n\n    const graphs = this.spreadLines([\n      this.graph.start.point,\n      this.graph.start.direction,\n      ...this.graph.nodes,\n      this.graph.end.direction,\n      this.graph.end.point,\n    ]).forEach((points, index) => this.drawGraph(points));\n  }\n\n  private animateGraph(x) {\n    const graphs = this.spreadLines([\n      this.graph.start.point,\n      this.graph.start.direction,\n      ...this.graph.nodes.map((point, i) => {\n        const ascent = point.ascent * Math.sin(Math.PI * x);\n        return this.graphService.shiftPoint(point, ascent, this.bounces[i].next().value);\n      }),\n      this.graph.end.direction,\n      this.graph.end.point,\n    ]);\n\n    graphs.forEach((points, i) => this.updateGraph(points, i));\n  }\n\n  private spreadLines(points: Point[]) {\n    const shiftedMedians = [];\n    const genshiftedMedians = this.graphService.spreadOrthogonal(this.medianPoint, this.graph.spread.spacing);\n\n    for (let i = 0; i < this.graph.spread.amount; i++) {\n      shiftedMedians.push(genshiftedMedians.next().value);\n    }\n\n    return shiftedMedians.map(median => {\n      const shiftedPoints = points.slice();\n      shiftedPoints.splice(this.medianIndex, 1, median);\n      return shiftedPoints;\n    });\n  }\n\n  private updateGraph(points: Point[], index: number): void {\n    this.pathElements[index]\n      .attr('d', Shape.line()\n        .x(p => p.x)\n        .y(p => p.y)\n        .curve(Shape.curveBasis)(points));\n  }\n\n  private drawGraph(points: Point[]): void {\n    this.group\n      .attr('stroke', this.graph.color)\n      .attr('stroke-width', this.graph.stroke)\n      .attr('fill', 'none');\n\n    this.pathElements.push(\n      this.group.append('path')\n        .attr('d', Shape.line()\n          .x(p => p.x)\n          .y(p => p.y)\n          .curve(Shape.curveBasis)(points)));\n  }\n\n  private debugGraph(points: Point[]) {\n    points.forEach((point, index) => {\n      const circle = this.group.append('g');\n\n      circle.append('circle')\n        .attr('cx', point.x)\n        .attr('cy', point.y)\n        .attr('r', 3)\n        .attr('fill-opacity', 0.6)\n        .attr('fill', this.graph.color);\n\n      circle.append('text')\n        .attr('x', point.x)\n        .attr('y', point.y)\n        .attr('dx', 8)\n        .attr('dy', 15)\n        .attr('fill', this.graph.color)\n        .text(index);\n    });\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Optional, ViewChild } from '@angular/core';\nimport { interval, Observable } from 'rxjs';\nimport * as Selection from 'd3-selection';\n\nimport { Graph } from '../models/graph.model';\nimport { NlsMathService } from './math.service';\nimport { NlsHistoryService } from './history.service';\n\n@Injectable()\nexport class NlsAnimationService {\n\n  public graphs: Graph[];\n  public speed: number;\n  public range: number;\n  // public genAnimation: any;\n  // private timer: Observable<number>;\n  // private subscribtion: any;\n\n  constructor(\n    private math: NlsMathService,\n    private historyService: NlsHistoryService,\n  ) {\n  }\n\n  // public animate(initialGraphs: Graph[]) {\n  public animate(initialGraph: Graph) {\n    // const newGraphs = initialGraphs.slice();\n\n    // return newGraphs.map(graph => {\n\n      const newGraph = Object.assign({}, initialGraph);\n      const indexMiddle = Math.floor(newGraph.nodes.length * 0.5);\n      const pointMiddle = newGraph.nodes[indexMiddle];\n\n      newGraph.nodes.splice(indexMiddle, 1, {\n        x: pointMiddle.x - 2,\n        y: pointMiddle.y + 2,\n      });\n\n      return newGraph;\n  //   });\n  }\n}\n\n","import { BrowserModule } from '@angular/platform-browser';\nimport { NgModule } from '@angular/core';\n\nimport { NlsGraphsComponent } from './components/graphs.component';\nimport { NlsGuillocheDirective } from './directives/guilloche.directive';\nimport { NlsHistoryService } from './services/history.service';\nimport { NlsCanvasService } from './services/canvas.service';\nimport { NlsMathService } from './services/math.service';\nimport { NlsGraphService } from './services/graph.service';\n\n@NgModule({\n  imports: [\n    BrowserModule\n  ],\n  declarations: [\n    NlsGraphsComponent,\n    NlsGuillocheDirective\n  ],\n  providers: [\n    NlsHistoryService,\n    NlsCanvasService,\n    NlsMathService,\n    NlsGraphService,\n  ],\n  exports: [\n    NlsGraphsComponent,\n    NlsGuillocheDirective\n  ]\n})\nexport class NlsGuillocheModule {}\n"],"names":["Injectable","RendererFactory2","Random.randomUniform","EventEmitter","Component","Input","Output","ViewChild","HostListener","Selection.select","Shape.line","Shape.curveBasis","Directive","ElementRef","NgModule","BrowserModule"],"mappings":";;;;;;IAAA;;;;;;;;;;;;;;AAcA,IAeO,IAAI,QAAQ,GAAG;QAClB,QAAQ,GAAG,MAAM,CAAC,MAAM,IAAI,kBAAkB,CAAC;YAC3C,KAAK,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;gBACjD,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;gBACjB,KAAK,IAAI,CAAC,IAAI,CAAC;oBAAE,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;wBAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;aAChF;YACD,OAAO,CAAC,CAAC;SACZ,CAAA;QACD,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC3C,CAAC,CAAA;AAED,yBAkC4B,OAAO,EAAE,IAAI;QACrC,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,cAAa,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;gBAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACjH,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,OAAO,MAAM,KAAK,UAAU,KAAK,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,cAAa,OAAO,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACzJ,cAAc,CAAC,IAAI,OAAO,UAAU,CAAC,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE;QAClE,cAAc,EAAE;YACZ,IAAI,CAAC;gBAAE,MAAM,IAAI,SAAS,CAAC,iCAAiC,CAAC,CAAC;YAC9D,OAAO,CAAC;gBAAE,IAAI;oBACV,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI;wBAAE,OAAO,CAAC,CAAC;oBAC7J,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;wBAAE,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;oBACxC,QAAQ,EAAE,CAAC,CAAC,CAAC;wBACT,KAAK,CAAC,CAAC;wBAAC,KAAK,CAAC;4BAAE,CAAC,GAAG,EAAE,CAAC;4BAAC,MAAM;wBAC9B,KAAK,CAAC;4BAAE,CAAC,CAAC,KAAK,EAAE,CAAC;4BAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;wBACxD,KAAK,CAAC;4BAAE,CAAC,CAAC,KAAK,EAAE,CAAC;4BAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;4BAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;4BAAC,SAAS;wBACjD,KAAK,CAAC;4BAAE,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;4BAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;4BAAC,SAAS;wBACjD;4BACI,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE;gCAAE,CAAC,GAAG,CAAC,CAAC;gCAAC,SAAS;6BAAE;4BAC5G,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;gCAAE,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;gCAAC,MAAM;6BAAE;4BACtF,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;gCAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gCAAC,CAAC,GAAG,EAAE,CAAC;gCAAC,MAAM;6BAAE;4BACrE,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;gCAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gCAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;gCAAC,MAAM;6BAAE;4BACnE,IAAI,CAAC,CAAC,CAAC,CAAC;gCAAE,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;4BACtB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;4BAAC,SAAS;qBAC9B;oBACD,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;iBAC9B;gBAAC,OAAO,CAAC,EAAE;oBAAE,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;oBAAC,CAAC,GAAG,CAAC,CAAC;iBAAE;wBAAS;oBAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;iBAAE;YAC1D,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;gBAAE,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;YAAC,OAAO,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;SACpF;IACL,CAAC;AAED,oBAeuB,CAAC,EAAE,CAAC;QACvB,IAAI,CAAC,GAAG,OAAO,MAAM,KAAK,UAAU,IAAI,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC3D,IAAI,CAAC,CAAC;YAAE,OAAO,CAAC,CAAC;QACjB,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;QACjC,IAAI;YACA,OAAO,CAAC,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,IAAI;gBAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;SAC9E;QACD,OAAO,KAAK,EAAE;YAAE,CAAC,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;SAAE;gBAC/B;YACJ,IAAI;gBACA,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC;oBAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACpD;oBACO;gBAAE,IAAI,CAAC;oBAAE,MAAM,CAAC,CAAC,KAAK,CAAC;aAAE;SACpC;QACD,OAAO,EAAE,CAAC;IACd,CAAC;AAED;QACI,KAAK,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE;YAC9C,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACzC,OAAO,EAAE,CAAC;IACd,CAAC;;;;;;;QCjHC,0BACU;YAAA,oBAAe,GAAf,eAAe;YAEvB,IAAI,CAAC,QAAQ,GAAG,eAAe,CAAC,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;SAC5D;8BAEU,iCAAG;;;;gBACZ,OAAO,IAAI,CAAC,MAAM,CAAC;;;;;;;;;QAGd,8BAAG;;;;sBAAC,EAAE;gBACX,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;;;;;QAGZ,yCAAc;;;;gBACnB,IAAI,IAAI,CAAC,MAAM,EAAE;oBACf,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,MAAM,EACX,OAAO,EACP,IAAI,CAAC,MAAM,CAAC,UAAU,CACvB,CAAC;oBACF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CACpB,IAAI,CAAC,MAAM,EACX,QAAQ,EACR,IAAI,CAAC,MAAM,CAAC,WAAW,CACxB,CAAC;iBACH;;;oBAhCJA,eAAU;;;;;wBAH6BC,qBAAgB;;;+BAhBxD;;;;;;;;QC0BE;YACE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;SACnB;;;;;;QAEM,gCAAI;;;;;sBAAC,MAAe,EAAE,MAAM;gBACjC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;oBAChB,IAAI,EAAE,IAAI,IAAI,EAAE;oBAChB,MAAM,EAAE,MAAM;oBACd,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;iBACxB,CAAC,CAAC;;;;;;QAGE,gCAAI;;;;sBAAC,MAAM;gBAChB,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;;;;;QAG/B,gCAAI;;;;gBACT,OAAO,IAAI,CAAC,OAAO,CAAC;;;oBAvBvBD,eAAU;;;;gCArBX;;;;;;;;;;;;;;;;QC+BS,0BAAC;;;;;;sBAAC,CAAQ,EAAE,CAAQ;gBACzB,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;;;;;;;QAGjE,yCAAgB;;;;;sBAAC,KAAY,EAAE,MAAW;gBAC/C,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE;oBAC3D,OAAO,MAAM,CAAC,KAAK,CAAC;iBACrB;qBAAM;oBACL,OAAO,MAAM,CAAC,GAAG,CAAC;iBACnB;;;;;;;QAGI,wCAAe;;;;;sBAAC,KAAY,EAAE,MAAW;gBAC9C,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE;oBAC3D,OAAO,MAAM,CAAC,KAAK,CAAC;iBACrB;qBAAM;oBACL,OAAO,MAAM,CAAC,GAAG,CAAC;iBACnB;;;;;;;QAGI,oCAAW;;;;;sBAAC,MAAW,EAAE,OAAe;;gBAC7C,IAAM,CAAC,GAAG;oBACR,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,GAAG,OAAO;oBAC7C,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,GAAG,OAAO;iBAC9C,CAAC;;gBACF,IAAM,CAAC,GAAG;oBACR,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,OAAO;oBAC9C,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,OAAO;iBAC/C,CAAC;gBAEF,OAAO;oBACL,CAAC,EAAEE,oBAAoB,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE;oBACvC,CAAC,EAAEA,oBAAoB,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE;iBACxC,CAAC;;;;;;;QAGG,qCAAY;;;;;sBAAC,KAAK,EAAE,MAAM;gBAC/B,OAAO;oBACL,CAAC,EAAE,KAAK,GAAG,GAAG;oBACd,CAAC,EAAE,MAAM,GAAG,GAAG;iBAChB,CAAC;;;;;;;QAGG,uCAAc;;;;;sBAAC,EAAS,EAAE,EAAS;gBACxC,OAAO;oBACL,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,GAAG;oBACtB,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,GAAG;iBACvB,CAAC;;;;;;QAGG,sCAAa;;;;sBAAC,KAAc;;gBACjC,IAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;;gBAC1C,IAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;;gBAClC,IAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;;gBAClC,IAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBAE1C,OAAO,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;;;;;;QAGlE,sCAAa;;;;sBAAC,KAAc;;gBACjC,IAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;;gBAC1C,IAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;;gBAClC,IAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;;gBAClC,IAAM,EAAE,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;;gBAClC,IAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;;;gBAG1C,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;;;;;;;QAGzC,qCAAY;;;;;sBAAC,EAAS,EAAE,EAAS;gBACtC,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;;;;;;;QAGvC,oCAAW;;;;;sBAAC,EAAS,EAAE,EAAS;gBACrC,OAAO,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC,EAAE,CAAC;;;;;;QAG5C,oCAAW;;;;sBAAC,IAAS;gBAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;;;;;;QAG/B,oCAAW;;;;sBAAC,MAAe;;;;;4BAE3B,IAAI,GAAY,MAAM,CAAC,KAAK,EAAE,CAAC;;;iCAE9B,IAAI;;4BACT,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;4BACjC,qBAAM,IAAI,CAAC,KAAK,CAAC,EAAA;;4BAAjB,SAAiB,CAAC;4BAElB,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;QAclB,+BAAM;;;;;;;;;;sBACZ,SAAqB,EACrB,QAAoB,EACpB,KAAiB;gBAFjB,0BAAA;oBAAA,aAAqB;;gBACrB,yBAAA;oBAAA,YAAoB;;gBACpB,sBAAA;oBAAA,SAAiB;;;;;;4BAEX,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;4BAC/B,IAAI,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC;4BACrB,KAAK,GAAG,CAAC,CAAC;;;4BAGN,OAAO,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;4BAC/C,qBAAM,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,SAAS,IAAI,KAAK,CAAC,GAAG,KAAK,EAAA;;4BAAjE,SAAiE,CAAC;4BAElE,KAAK,EAAE,CAAC;;;;;;;;;;QAIJ,iCAAQ;;;;sBAAC,aAA6B;gBAA7B,8BAAA;oBAAA,oBAA6B;;;;;;4BACxC,IAAI,GAAG,aAAa,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;;;4BAGhC,qBAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAA;;4BAAxB,SAAwB,CAAC;;;;;;;oBArI9BF,eAAU;;6BAvBX;;;;;;;;QC6BE,yBACU;YAAA,SAAI,GAAJ,IAAI;SACV;;;;QAEG,6BAAG;;;;gBACR,OAAO,IAAI,CAAC,MAAM,CAAC;;;;;;QAGd,6BAAG;;;;sBAAC,SAAkB;gBAC3B,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;;8BAGf,uCAAU;;;;gBACnB,OAAO,IAAI,CAAC,SAAS,CAAC;;;;;;;;QAGjB,wCAAc;;;;gBACnB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;;;;;QAGjB,uCAAa;;;;gBAClB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;;;;;;;QAGjB,0CAAgB;;;;;sBAAC,KAAY,EAAE,OAAe;;;;;4BAC9C,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;4BAC9B,YAAY,GAAG,KAAK,CAAC;4BACrB,CAAC,GAAG,CAAC,CAAC;;;4BAGF,cAAc,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,OAAO,GAAG,CAAC,CAAC;4BACvD,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,KAAK,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;4BAE3E,qBAAM,YAAY,EAAA;;4BAAlB,SAAkB,CAAC;4BAEnB,CAAC,EAAE,CAAC;;;;;;;;;;;;QAID,oCAAU;;;;;;sBAAC,KAAY,EAAE,OAAe,EAAE,OAAe;gBAC9D,OAAO;oBACL,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC,CAAC;oBAClD,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC,CAAC;iBACnD,CAAC;;;oBAhDLA,eAAU;;;;;wBAJF,cAAc;;;8BApBvB;;;;;;;;ICgCA,IAAM,gBAAgB,GAAG,GAAG,CAAC;;QA0C3B,4BACU,eACA,gBACA,MACA;YAHA,kBAAa,GAAb,aAAa;YACb,mBAAc,GAAd,cAAc;YACd,SAAI,GAAJ,IAAI;YACJ,iBAAY,GAAZ,YAAY;6BAnBA,IAAIG,iBAAY,EAAE;+BAChB,IAAIA,iBAAY,EAAE;YAoBxC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACnD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;SAC7B;;;;;QAlBD,qCAAQ;;;;YADR,UACS,KAAK;gBADd,iBASC;gBAPC,YAAY,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;gBAElC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAC;oBAC/B,KAAI,CAAC,MAAM,GAAG,KAAI,CAAC,YAAY,EAAE,CAAC;oBAClC,KAAI,CAAC,MAAM,GAAG,KAAI,CAAC,UAAU,EAAE,CAAC;oBAChC,KAAI,CAAC,YAAY,EAAE,CAAC;iBACrB,EAAE,gBAAgB,CAAC,CAAC;aACtB;;;;;QAYD,wCAAW;;;;YAAX,UAAY,OAAsB;gBAChC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;gBAEhC,IAAI,OAAO,YAAS;oBAClB,IAAI,CAAC,YAAY,EAAE,CAAC;iBACrB;gBAED,IAAI,IAAI,CAAC,eAAe,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;oBACnE,IAAI,CAAC,YAAY,EAAE,CAAC;iBACrB;aACF;;;;QAEO,yCAAY;;;;gBAClB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;gBAC1C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;;;;;QAGhC,wCAAW;;;;gBACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAClD,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;;;;;QAG7C,sCAAS;;;;gBACf,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;;;;;QAG7B,yCAAY;;;;;;gBAClB,IAAM,aAAa,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;;gBACpF,IAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBAErF,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;;gBAEzB,IAAM,SAAS,GAAG;oBAChB;wBACE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO;wBACjC,KAAK,EAAE,aAAa,CAAC,IAAI,EAAE,CAAC,KAAK;wBACjC,GAAG,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK;qBAS9B;oBACD;wBACE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS;wBACnC,KAAK,EAAE,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK;wBAC/B,GAAG,EAAE,aAAa,CAAC,IAAI,EAAE,CAAC,KAAK;qBAShC;iBACF,CAAC;gBAEF,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,UAAA,KAAK;oBAC/B,oBACK,KAAI,CAAC,WAAW,CAAC,KAAK,CAAC,IAC1B,MAAM,EAAE,KAAI,CAAC,MAAM,CAAC,MAAM,EAC1B,QAAQ,EAAE,KAAI,CAAC,MAAM,CAAC,QAAQ,IAC9B;iBACH,CAAC,CAAC;gBACH,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAClD,IAAI,CAAC,WAAW,EAAE,CAAC;gBACnB,IAAI,CAAC,SAAS,EAAE,CAAC;;;;;;QAGX,wCAAW;;;;sBAAC,KAAK;gBACvB,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE;oBAC1B,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;oBAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE;wBAChC,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC;qBACtE,CAAC;oBACF,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE;wBAC5B,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC;qBAClE,CAAC;oBACF,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;iBAC/C,CAAC,CAAC;;;;;;QAGG,4CAAe;;;;sBAAC,GAAW;;gBACjC,IAAM,eAAe,GAAG,EAAE,CAAC;gBAE3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;oBAC1C,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;iBAC/E;gBAED,OAAO,eAAe,CAAC;;;;;;QAGjB,qCAAQ;;;;sBAAC,CAAS;gBACxB,OAAO,CAAC,CAAC,KAAK,OAAO,IAAI,KAAK,GAAG,OAAO,CAAC;;;;;QAGnC,yCAAY;;;;gBAClB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBACpC,IAAI,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC;gBAEpC,OAAO,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC;;;;;QAGlC,uCAAU;;;;;gBAChB,IAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC,KAAK,CAAC;;gBAC9D,IAAM,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,qBAAqB,EAAE,CAAC,MAAM,CAAC;;gBAEhE,IAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;gBAEtE,OAAO;oBACL,KAAK,EAAE;wBACL,CAAC,EAAE,CAAC;wBACJ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;qBACrE;oBACD,GAAG,EAAE;wBACH,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;wBACnE,CAAC,EAAE,CAAC;qBACL;oBACD,KAAK,EAAE,WAAW;oBAClB,MAAM,EAAE,YAAY;oBACpB,MAAM,EAAE,WAAW;iBACpB,CAAC;;;;;;;QAGI,2CAAc;;;;;sBAAC,KAAY,EAAE,MAAc;;gBACjD,IAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;gBAE1F,OAAO;oBACL,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC;oBAC/C,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC;iBAChD,CAAC;;;;;;;;QAGK,uCAAU;;;;;;sBAAC,KAAY,EAAE,MAAc,EAAE,aAA6B;gBAA7B,8BAAA;oBAAA,oBAA6B;;;;;;4BACvE,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;4BACjF,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;;;4BAGrF,qBAAM;oCACJ,KAAK,EAAE;wCACL,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;wCAChE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,KAAK,CAAC,CAAC;qCACjE;oCACD,MAAM,EAAE,MAAM;iCACf,EAAA;;4BAND,SAMC,CAAC;;;;;;;;;;;;QAIG,wCAAW;;;;;;sBAAC,KAAa,EAAE,MAAc,EAAE,aAA6B;gBAA7B,8BAAA;oBAAA,oBAA6B;;;;;;4BAC3E,OAAO,GAAG,CAAC,CAAC;4BACZ,KAAK,GAAG,CAAC,CAAC;4BACR,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;;;4BAG7C,qBAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,EAAA;;4BAA3D,SAA2D,CAAC;4BAC5D,KAAK,EAAE,CAAC;;;;;;;;;;QAIL,mDAAsB;;;;sBAAC,gBAAgB;gBAC5C,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE;oBACxC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;iBACzC;;;;;QAGM,8CAAiB;;;;;;;;4BACpB,MAAM,GAAG,CAAC,CAAC;;;kCAGT,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAA;gCAA3B,wBAA2B;4BAC7B,qBAAM,KAAK,EAAA;;4BAAX,SAAW,CAAC;4BACZ,MAAM,EAAE,CAAC;;gCAET,qBAAM,IAAI,EAAA;;4BAAV,SAAU,CAAC;4BACX,MAAM,GAAG,CAAC,CAAC;;;;;;;;oBArOlBC,cAAS,SAAC;wBACT,QAAQ,EAAE,YAAY;wBACtB,QAAQ,EAAE,qPAIX;wBACC,MAAM,EAAE,CAAC,8EAA8E,CAAC;qBACzF;;;;;wBAhBQ,gBAAgB;wBAChB,iBAAiB;wBACjB,cAAc;wBAEd,eAAe;;;;6BA0BrBC,UAAK;sCACLA,UAAK;gCACLA,UAAK;gCACLC,WAAM;kCACNA,WAAM;oCACNC,cAAS,SAAC,KAAK;+BAEfC,iBAAY,SAAC,eAAe,EAAE,CAAC,QAAQ,CAAC;;iCA/D3C;;;;;;;;QCiDE,+BACU,eACA,IACA,MACA;YAHA,kBAAa,GAAb,aAAa;YACb,OAAE,GAAF,EAAE;YACF,SAAI,GAAJ,IAAI;YACJ,iBAAY,GAAZ,YAAY;SAErB;;;;QAED,2CAAW;;;YAAX;gBACE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC;aACpC;;;;;QAED,2CAAW;;;;YAAX,UAAY,OAAsB;gBAAlC,iBAiDC;gBAhDC,IAAI,CAAC,KAAK,GAAGC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;gBACrD,IAAI,CAAC,MAAM,GAAGA,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;;gBAEvD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;gBAC7C,IAAI,CAAC,YAAY;oBACf,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK;oBACtB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS;mBACvB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE;oBAC3B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS;oBACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK;kBACrB,CAAC;gBACF,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAC9D,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBAE5D,IAAI,IAAI,CAAC,SAAS,EAAE;oBAClB,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,UAAC,IAAI,EAAE,CAAC;wBACtD,OAAO;4BACL,CAAC,EAAE,IAAI,CAAC,CAAC;4BACT,CAAC,EAAE,IAAI,CAAC,CAAC;;4BAET,MAAM,EAAE,KAAI,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,GAAG,GAAG;yBAC1C,CAAC;qBACH,CAAC,CAAC;oBACH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,UAAA,IAAI;;wBACvC,IAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;wBACxD,OAAO,KAAI,CAAC,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;qBAC7C,CAAC,CAAC;;oBACH,IAAI,GAAC,GAAG,CAAC,CAAC;oBACV,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC;wBACnC,KAAI,CAAC,YAAY,CAAC,GAAC,EAAE,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC;qBACvC,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;iBACzB;qBAAM;oBACL,IAAI,IAAI,CAAC,iBAAiB,EAAE;wBAC1B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;wBACnB,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;qBACvC;iBACF;gBAED,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC;gBACnC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;;gBAEvB,IAAM,MAAM,GAAG,IAAI,CAAC,WAAW;oBAC7B,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK;oBACtB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS;mBACvB,IAAI,CAAC,KAAK,CAAC,KAAK;oBACnB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS;oBACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK;mBACpB,CAAC,OAAO,CAAC,UAAC,MAAM,EAAE,KAAK,IAAK,OAAA,KAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAA,CAAC,CAAC;aACvD;;;;;QAEO,4CAAY;;;;sBAAC,CAAC;;;gBACpB,IAAM,MAAM,GAAG,IAAI,CAAC,WAAW;oBAC7B,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK;oBACtB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS;mBACvB,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,UAAC,KAAK,EAAE,CAAC;;oBAC/B,IAAM,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;oBACpD,OAAO,KAAI,CAAC,YAAY,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;iBAClF,CAAC;oBACF,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS;oBACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK;mBACpB,CAAC;gBAEH,MAAM,CAAC,OAAO,CAAC,UAAC,MAAM,EAAE,CAAC,IAAK,OAAA,KAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC,GAAA,CAAC,CAAC;;;;;;QAGrD,2CAAW;;;;sBAAC,MAAe;;;gBACjC,IAAM,cAAc,GAAG,EAAE,CAAC;;gBAC1B,IAAM,iBAAiB,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBAE1G,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACjD,cAAc,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;iBACrD;gBAED,OAAO,cAAc,CAAC,GAAG,CAAC,UAAA,MAAM;;oBAC9B,IAAM,aAAa,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;oBACrC,aAAa,CAAC,MAAM,CAAC,KAAI,CAAC,WAAW,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC;oBAClD,OAAO,aAAa,CAAC;iBACtB,CAAC,CAAC;;;;;;;QAGG,2CAAW;;;;;sBAAC,MAAe,EAAE,KAAa;gBAChD,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;qBACrB,IAAI,CAAC,GAAG,EAAEC,UAAU,EAAE;qBACpB,CAAC,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,GAAA,CAAC;qBACX,CAAC,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,GAAA,CAAC;qBACX,KAAK,CAACC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;;;;;;QAGhC,yCAAS;;;;sBAAC,MAAe;gBAC/B,IAAI,CAAC,KAAK;qBACP,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;qBAChC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;qBACvC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAExB,IAAI,CAAC,YAAY,CAAC,IAAI,CACpB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;qBACtB,IAAI,CAAC,GAAG,EAAED,UAAU,EAAE;qBACpB,CAAC,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,GAAA,CAAC;qBACX,CAAC,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,CAAC,GAAA,CAAC;qBACX,KAAK,CAACC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;;;;;;QAGnC,0CAAU;;;;sBAAC,MAAe;;gBAChC,MAAM,CAAC,OAAO,CAAC,UAAC,KAAK,EAAE,KAAK;;oBAC1B,IAAM,MAAM,GAAG,KAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oBAEtC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC;yBACpB,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;yBACnB,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;yBACnB,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;yBACZ,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC;yBACzB,IAAI,CAAC,MAAM,EAAE,KAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;oBAElC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;yBAClB,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;yBAClB,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;yBAClB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;yBACb,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;yBACd,IAAI,CAAC,MAAM,EAAE,KAAI,CAAC,KAAK,CAAC,KAAK,CAAC;yBAC9B,IAAI,CAAC,KAAK,CAAC,CAAC;iBAChB,CAAC,CAAC;;;oBAxJNC,cAAS,SAAC;wBACT,QAAQ,EAAE,gBAAgB;qBAC3B;;;;;wBANQ,gBAAgB;wBAVhBC,eAAU;wBAWV,cAAc;wBACd,eAAe;;;;4BAkBrBR,UAAK;gCACLA,UAAK;;oCA/CR;;;;;;;;;;;QCkCE,6BACU,MACA;YADA,SAAI,GAAJ,IAAI;YACJ,mBAAc,GAAd,cAAc;SAEvB;;;;;QAGM,qCAAO;;;;sBAAC,YAAmB;;gBAK9B,IAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;;gBACjD,IAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;;gBAC5D,IAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;gBAEhD,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,EAAE;oBACpC,CAAC,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC;oBACpB,CAAC,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC;iBACrB,CAAC,CAAC;gBAEH,OAAO,QAAQ,CAAC;;;;oBA/BrBL,eAAU;;;;;wBAHF,cAAc;wBACd,iBAAiB;;;kCAtB1B;;;;;;;ACAA;;;;oBAUCc,aAAQ,SAAC;wBACR,OAAO,EAAE;4BACPC,6BAAa;yBACd;wBACD,YAAY,EAAE;4BACZ,kBAAkB;4BAClB,qBAAqB;yBACtB;wBACD,SAAS,EAAE;4BACT,iBAAiB;4BACjB,gBAAgB;4BAChB,cAAc;4BACd,eAAe;yBAChB;wBACD,OAAO,EAAE;4BACP,kBAAkB;4BAClB,qBAAqB;yBACtB;qBACF;;iCA5BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
|