restore backup and add opencode support

2025-09-23 12:02:03 +02:00
1 parent b99d2ff835
commit c295660631
@@ -0,0 +1,422 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+import * as tslib_1 from "tslib";
+import { ViewChild, Component, Input, Output, EventEmitter, HostListener } from '@angular/core';
+import { NlsCanvasService } from './../services/canvas.service';
+import { NlsHistoryService } from './../services/history.service';
+import { NlsMathService } from './../services/math.service';
+import { NlsGraphService } from './../services/graph.service';
+/** @type {?} */
+var RESIZING_TIMEOUT = 800;
+var NlsGraphsComponent = /** @class */ (function () {
+    function NlsGraphsComponent(canvasService, historyService, math, graphService) {
+        this.canvasService = canvasService;
+        this.historyService = historyService;
+        this.math = math;
+        this.graphService = graphService;
+        this.svgChange = new EventEmitter();
+        this.graphChange = new 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 tslib_1.__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 totalArea = Math.abs(canvasWidth * canvasHeight);
+        /** @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 tslib_1.__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:
+                    if (!true) return [3 /*break*/, 3];
+                    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 tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    current = 0;
+                    index = 0;
+                    sign = this.math.flipSign(startPositive);
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    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 tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    cycles = 1;
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 6];
+                    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: 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: Input }],
+        restoredHistory: [{ type: Input }],
+        animation: [{ type: Input }],
+        svgChange: [{ type: Output }],
+        graphChange: [{ type: Output }],
+        svgElementRef: [{ type: ViewChild, args: ['svg',] }],
+        onResize: [{ type: HostListener, args: ['window:resize', ['$event'],] }]
+    };
+    return NlsGraphsComponent;
+}());
+export { NlsGraphsComponent };
+function NlsGraphsComponent_tsickle_Closure_declarations() {
+    /** @type {?} */
+    NlsGraphsComponent.prototype.canvas;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.matrix;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.graphs;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.windowHeight;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.windowWidth;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.genShiftPoint;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.genLoadedAllGraphs;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.hash;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.resizingWindow;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.config;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.restoredHistory;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.animation;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.svgChange;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.graphChange;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.svgElementRef;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.canvasService;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.historyService;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.math;
+    /** @type {?} */
+    NlsGraphsComponent.prototype.graphService;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhcGhzLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25scy1ndWlsbG9jaGUvIiwic291cmNlcyI6WyJubHMvY29tcG9uZW50cy9ncmFwaHMuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBZ0JBLE9BQU8sRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQTRCLFlBQVksRUFBRSxZQUFZLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFVMUgsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDaEUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDbEUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRTVELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7QUFFOUQsSUFBTSxnQkFBZ0IsR0FBRyxHQUFHLENBQUM7O0lBMEMzQiw0QkFDVSxlQUNBLGdCQUNBLE1BQ0E7UUFIQSxrQkFBYSxHQUFiLGFBQWE7UUFDYixtQkFBYyxHQUFkLGNBQWM7UUFDZCxTQUFJLEdBQUosSUFBSTtRQUNKLGlCQUFZLEdBQVosWUFBWTt5QkFuQkEsSUFBSSxZQUFZLEVBQUU7MkJBQ2hCLElBQUksWUFBWSxFQUFFO1FBb0J4QyxJQUFJLENBQUMsa0JBQWtCLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixFQUFFLENBQUM7UUFDbkQsSUFBSSxDQUFDLGNBQWMsR0FBRyxLQUFLLENBQUM7S0FDN0I7Ozs7O0lBbEJELHFDQUFROzs7O0lBRFIsVUFDUyxLQUFLO1FBRGQsaUJBU0M7UUFQQyxZQUFZLENBQUMsSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBRWxDLElBQUksQ0FBQyxjQUFjLEdBQUcsVUFBVSxDQUFDO1lBQy9CLEtBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1lBQ2xDLEtBQUksQ0FBQyxNQUFNLEdBQUcsS0FBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ2hDLEtBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztTQUNyQixFQUFFLGdCQUFnQixDQUFDLENBQUM7S0FDdEI7Ozs7O0lBWUQsd0NBQVc7Ozs7SUFBWCxVQUFZLE9BQXNCO1FBQ2hDLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ2xDLElBQUksQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1FBRWhDLEVBQUUsQ0FBQyxDQUFDLE9BQU8sWUFBUyxDQUFDO1lBQ25CLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztTQUNyQjtRQUVELEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxlQUFlLElBQUksSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDcEUsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1NBQ3JCO0tBQ0Y7Ozs7SUFFTyx5Q0FBWTs7OztRQUNsQixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUMsTUFBTSxDQUFDO1FBQzFDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUM7Ozs7O0lBR2hDLHdDQUFXOzs7O1FBQ2pCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO1FBQ2xELElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDOzs7OztJQUc3QyxzQ0FBUzs7OztRQUNmLElBQUksQ0FBQyxZQUFZLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQzs7Ozs7SUFHN0IseUNBQVk7Ozs7OztRQUNsQixJQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDOztRQUNwRixJQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsQ0FBQztRQUVyRixPQUFPLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQzs7UUFFekIsSUFBTSxTQUFTLEdBQUc7WUFDaEI7Z0JBQ0UsS0FBSyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLE9BQU87Z0JBQ2pDLEtBQUssRUFBRSxhQUFhLENBQUMsSUFBSSxFQUFFLENBQUMsS0FBSztnQkFDakMsR0FBRyxFQUFFLFdBQVcsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLO2FBUzlCO1lBQ0Q7Z0JBQ0UsS0FBSyxFQUFFLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLFNBQVM7Z0JBQ25DLEtBQUssRUFBRSxXQUFXLENBQUMsSUFBSSxFQUFFLENBQUMsS0FBSztnQkFDL0IsR0FBRyxFQUFFLGFBQWEsQ0FBQyxJQUFJLEVBQUUsQ0FBQyxLQUFLO2FBU2hDO1NBQ0YsQ0FBQztRQUVGLElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLEdBQUcsQ0FBQyxVQUFBLEtBQUs7WUFDL0IsTUFBTSxzQkFDRCxLQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxJQUMxQixNQUFNLEVBQUUsS0FBSSxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQzFCLFFBQVEsRUFBRSxLQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsSUFDOUI7U0FDSCxDQUFDLENBQUM7UUFDSCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNsRCxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDbkIsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDOzs7Ozs7SUFHWCx3Q0FBVzs7OztjQUFDLEtBQUs7UUFDdkIsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFO1lBQzFCLE1BQU0sRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU07WUFDMUIsS0FBSyxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssRUFBRTtnQkFDaEMsU0FBUyxFQUFFLElBQUksQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUM7YUFDdEUsQ0FBQztZQUNGLEdBQUcsRUFBRSxNQUFNLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUU7Z0JBQzVCLFNBQVMsRUFBRSxJQUFJLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFFLEtBQUssQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDO2FBQ2xFLENBQUM7WUFDRixLQUFLLEVBQUUsSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQztTQUMvQyxDQUFDLENBQUM7Ozs7OztJQUdHLDRDQUFlOzs7O2NBQUMsR0FBVzs7UUFDakMsSUFBTSxlQUFlLEdBQUcsRUFBRSxDQUFDO1FBRTNCLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztZQUMzQyxlQUFlLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1NBQy9FO1FBRUQsTUFBTSxDQUFDLGVBQWUsQ0FBQzs7Ozs7O0lBR2pCLHFDQUFROzs7O2NBQUMsQ0FBUztRQUN4QixNQUFNLENBQUMsQ0FBQyxDQUFDLEtBQUssT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsT0FBTyxDQ
Line truncated
@@ -0,0 +1,269 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+import * as tslib_1 from "tslib";
+import { ElementRef, Input, Directive } from '@angular/core';
+import * as Selection from 'd3-selection';
+import * as Shape from 'd3-shape';
+import { NlsCanvasService } from './../services/canvas.service';
+import { NlsMathService } from './../services/math.service';
+import { NlsGraphService } from '../services/graph.service';
+var NlsGuillocheDirective = /** @class */ (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 = tslib_1.__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(tslib_1.__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(tslib_1.__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: Directive, args: [{
+                    selector: '[nlsGuilloche]'
+                },] },
+    ];
+    /** @nocollapse */
+    NlsGuillocheDirective.ctorParameters = function () { return [
+        { type: NlsCanvasService },
+        { type: ElementRef },
+        { type: NlsMathService },
+        { type: NlsGraphService }
+    ]; };
+    NlsGuillocheDirective.propDecorators = {
+        graph: [{ type: Input }],
+        animation: [{ type: Input }]
+    };
+    return NlsGuillocheDirective;
+}());
+export { NlsGuillocheDirective };
+function NlsGuillocheDirective_tsickle_Closure_declarations() {
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.canvas;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.group;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.bounce;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.bounces;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.initialNodes;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.initialCurve;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.animationInterval;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.medianPoint;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.medianIndex;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.pathElements;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.graph;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.animation;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.canvasService;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.el;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.math;
+    /** @type {?} */
+    NlsGuillocheDirective.prototype.graphService;
+}
+
+//# sourceMappingURL=data:application/json;base64,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
Line truncated
@@ -0,0 +1,51 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+/**
+ * @record
+ */
+export function Config() { }
+function Config_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Config.prototype.margin;
+    /** @type {?} */
+    Config.prototype.start;
+    /** @type {?} */
+    Config.prototype.end;
+    /** @type {?} */
+    Config.prototype.vectors;
+    /** @type {?} */
+    Config.prototype.colors;
+    /** @type {?} */
+    Config.prototype.spread;
+    /** @type {?} */
+    Config.prototype.nodes;
+    /** @type {?} */
+    Config.prototype.stroke;
+    /** @type {?} */
+    Config.prototype.overlap;
+    /** @type {?} */
+    Config.prototype.scale;
+    /** @type {?} */
+    Config.prototype.interval;
+    /** @type {?|undefined} */
+    Config.prototype.date;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmxzLWd1aWxsb2NoZS8iLCJzb3VyY2VzIjpbIm5scy9tb2RlbHMvY29uZmlnLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoQykgMjAxOCBNaWNoYWVsIEN6ZWNob3dza2kgPG1haWxAZGFpbHlzaC5pdD5cbiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0XG4gKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZVxuICogU29mdHdhcmUgRm91bmRhdGlvbjsgdmVyc2lvbiAyLlxuICpcbiAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVFxuICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yXG4gKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3JcbiAqIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZyB3aXRoXG4gKiB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTFcbiAqIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLlxuICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29uZmlnIHtcbiAgbWFyZ2luOiB7XG4gICAgeDogbnVtYmVyO1xuICAgIHk6IG51bWJlcjtcbiAgfTtcbiAgc3RhcnQ6IHtcbiAgICB4OiBudW1iZXI7XG4gICAgeTogbnVtYmVyO1xuICB9O1xuICBlbmQ6IHtcbiAgICB4OiBudW1iZXI7XG4gICAgeTogbnVtYmVyO1xuICB9O1xuICB2ZWN0b3JzOiB7XG4gICAgc3BhY2luZzogbnVtYmVyO1xuICAgIHN0YXJ0OiBhbnk7XG4gICAgZW5kOiBhbnk7XG4gICAgcmFuZ2U6IGFueTtcbiAgfTtcbiAgY29sb3JzOiB7XG4gICAgcHJpbWFyeTogc3RyaW5nO1xuICAgIHNlY29uZGFyeTogc3RyaW5nO1xuICB9O1xuICBzcHJlYWQ6IHtcbiAgICBhbW91bnQ6IG51bWJlcjtcbiAgICBzcGFjaW5nOiBudW1iZXJcbiAgfTtcbiAgbm9kZXM6IGFueTtcbiAgc3Ryb2tlOiBhbnk7XG4gIG92ZXJsYXA6IGFueTtcbiAgc2NhbGU6IGFueTtcbiAgaW50ZXJ2YWw6IG51bWJlcjtcbiAgZGF0ZT86IERhdGU7XG59XG4iXX0=
@@ -0,0 +1,28 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @record
+ */
+export function Graph() { }
+function Graph_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Graph.prototype.id;
+    /** @type {?} */
+    Graph.prototype.color;
+    /** @type {?} */
+    Graph.prototype.start;
+    /** @type {?} */
+    Graph.prototype.end;
+    /** @type {?} */
+    Graph.prototype.spread;
+    /** @type {?} */
+    Graph.prototype.interval;
+    /** @type {?} */
+    Graph.prototype.stroke;
+    /** @type {?|undefined} */
+    Graph.prototype.nodes;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3JhcGgubW9kZWwuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9ubHMtZ3VpbGxvY2hlLyIsInNvdXJjZXMiOlsibmxzL21vZGVscy9ncmFwaC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW50ZXJ2YWwgfSBmcm9tICdyeGpzJztcbi8qKlxuICogQ29weXJpZ2h0IChDKSAyMDE4IE1pY2hhZWwgQ3plY2hvd3NraSA8bWFpbEBkYWlseXNoLml0PlxuICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXRcbiAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlXG4gKiBTb2Z0d2FyZSBGb3VuZGF0aW9uOyB2ZXJzaW9uIDIuXG4gKlxuICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUXG4gKiBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3JcbiAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvclxuICogbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nIHdpdGhcbiAqIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLCA1MVxuICogRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EuXG4gKi9cblxuaW1wb3J0IHsgUG9pbnQgfSBmcm9tICcuL3BvaW50Lm1vZGVsJztcbmltcG9ydCB7IENvbmZpZyB9IGZyb20gJy4vY29uZmlnLm1vZGVsJztcblxuZXhwb3J0IGludGVyZmFjZSBHcmFwaCB7XG4gIGlkOiBzdHJpbmc7XG4gIGNvbG9yOiBzdHJpbmc7IC8vIGNhbiBiZSBzZXQgaW4gZW52aXJvbWVudFxuICBzdGFydDoge1xuICAgIHBvaW50OiBQb2ludDtcbiAgICBkaXJlY3Rpb24/OiBQb2ludDtcbiAgICB2ZWN0b3I6IG51bWJlcjsgLy8gZGVncmVlIGJldHdlZW4gMCBhbmQgMzYwXG4gIH07XG4gIGVuZDoge1xuICAgIHBvaW50OiBQb2ludDtcbiAgICBkaXJlY3Rpb24/OiBQb2ludDtcbiAgICB2ZWN0b3I6IG51bWJlcjsgLy8gZGVncmVlIGJldHdlZW4gMCBhbmQgMzYwXG4gIH07XG4gIHNwcmVhZDoge1xuICAgIGFtb3VudDogbnVtYmVyO1xuICAgIHNwYWNpbmc6IG51bWJlclxuICB9O1xuICBpbnRlcnZhbDogbnVtYmVyO1xuICBzdHJva2U6IG51bWJlcjsgLy8gc3Ryb2tlIHdpZHRoXG4gIG5vZGVzPzogUG9pbnRbXTsgLy8gb3JpZW50YXRpb24gcG9pbnRzXG59XG4iXX0=
@@ -0,0 +1,39 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+/**
+ * @record
+ */
+export function Matrix() { }
+function Matrix_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Matrix.prototype.start;
+    /** @type {?} */
+    Matrix.prototype.end;
+    /** @type {?} */
+    Matrix.prototype.center;
+    /** @type {?} */
+    Matrix.prototype.width;
+    /** @type {?} */
+    Matrix.prototype.height;
+    /** @type {?|undefined} */
+    Matrix.prototype.unit;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0cml4Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6Im5nOi8vbmxzLWd1aWxsb2NoZS8iLCJzb3VyY2VzIjpbIm5scy9tb2RlbHMvbWF0cml4Lm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENvcHlyaWdodCAoQykgMjAxOCBNaWNoYWVsIEN6ZWNob3dza2kgPG1haWxAZGFpbHlzaC5pdD5cbiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0XG4gKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZVxuICogU29mdHdhcmUgRm91bmRhdGlvbjsgdmVyc2lvbiAyLlxuICpcbiAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVFxuICogQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yXG4gKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3JcbiAqIG1vcmUgZGV0YWlscy5cbiAqXG4gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZyB3aXRoXG4gKiB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgNTFcbiAqIEZyYW5rbGluIFN0cmVldCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSwgVVNBLlxuICovXG5cbmltcG9ydCB7IFBvaW50IH0gZnJvbSAnLi9wb2ludC5tb2RlbCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTWF0cml4IHtcbiAgc3RhcnQ6IFBvaW50O1xuICBlbmQ6IFBvaW50O1xuICBjZW50ZXI6IFBvaW50O1xuICB3aWR0aDogbnVtYmVyO1xuICBoZWlnaHQ6IG51bWJlcjtcbiAgdW5pdD86IG51bWJlcjtcbn1cbiJdfQ==
@@ -0,0 +1,41 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+/**
+ * @record
+ */
+export function Param() { }
+function Param_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Param.prototype.colors;
+    /** @type {?} */
+    Param.prototype.points;
+    /** @type {?} */
+    Param.prototype.margin;
+    /** @type {?} */
+    Param.prototype.spread;
+    /** @type {?} */
+    Param.prototype.space;
+    /** @type {?|undefined} */
+    Param.prototype.stroke;
+    /** @type {?|undefined} */
+    Param.prototype.showGrid;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYW0ubW9kZWwuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9ubHMtZ3VpbGxvY2hlLyIsInNvdXJjZXMiOlsibmxzL21vZGVscy9wYXJhbS5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTggTWljaGFlbCBDemVjaG93c2tpIDxtYWlsQGRhaWx5c2guaXQ+XG4gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdFxuICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWVcbiAqIFNvZnR3YXJlIEZvdW5kYXRpb247IHZlcnNpb24gMi5cbiAqXG4gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVRcbiAqIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvclxuICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yXG4gKiBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxvbmcgd2l0aFxuICogdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxXG4gKiBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS5cbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFBhcmFtIHtcbiAgY29sb3JzOiB7XG4gICAgc3RhcnQ6IHN0cmluZyxcbiAgICBlbmQ6IHN0cmluZ1xuICB9O1xuICBwb2ludHM6IG51bWJlcjtcbiAgbWFyZ2luOiB7XG4gICAgeDogbnVtYmVyLFxuICAgIHk6IG51bWJlclxuICB9O1xuICBzcHJlYWQ6IG51bWJlcjtcbiAgc3BhY2U6IG51bWJlcjtcbiAgc3Ryb2tlPzoge1xuICAgIHdpZHRoOiBudW1iZXI7XG4gIH07XG4gIHNob3dHcmlkPzogYm9vbGVhbjtcbn1cbiJdfQ==
@@ -0,0 +1,35 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+/**
+ * @record
+ */
+export function Point() { }
+function Point_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Point.prototype.x;
+    /** @type {?} */
+    Point.prototype.y;
+    /** @type {?|undefined} */
+    Point.prototype.color;
+    /** @type {?|undefined} */
+    Point.prototype.ascent;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9pbnQubW9kZWwuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9ubHMtZ3VpbGxvY2hlLyIsInNvdXJjZXMiOlsibmxzL21vZGVscy9wb2ludC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTggTWljaGFlbCBDemVjaG93c2tpIDxtYWlsQGRhaWx5c2guaXQ+XG4gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdFxuICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWVcbiAqIFNvZnR3YXJlIEZvdW5kYXRpb247IHZlcnNpb24gMi5cbiAqXG4gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVRcbiAqIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvclxuICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yXG4gKiBtb3JlIGRldGFpbHMuXG4gKlxuICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxvbmcgd2l0aFxuICogdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sIDUxXG4gKiBGcmFua2xpbiBTdHJlZXQsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQS5cbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIFBvaW50IHtcbiAgeDogbnVtYmVyO1xuICB5OiBudW1iZXI7XG4gIGNvbG9yPzogc3RyaW5nO1xuICBhc2NlbnQ/OiBudW1iZXI7XG59XG4iXX0=
@@ -0,0 +1,41 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { BrowserModule } from '@angular/platform-browser';
+import { NgModule } from '@angular/core';
+import { NlsGraphsComponent } from './components/graphs.component';
+import { NlsGuillocheDirective } from './directives/guilloche.directive';
+import { NlsHistoryService } from './services/history.service';
+import { NlsCanvasService } from './services/canvas.service';
+import { NlsMathService } from './services/math.service';
+import { NlsGraphService } from './services/graph.service';
+var NlsGuillocheModule = /** @class */ (function () {
+    function NlsGuillocheModule() {
+    }
+    NlsGuillocheModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [
+                        BrowserModule
+                    ],
+                    declarations: [
+                        NlsGraphsComponent,
+                        NlsGuillocheDirective
+                    ],
+                    providers: [
+                        NlsHistoryService,
+                        NlsCanvasService,
+                        NlsMathService,
+                        NlsGraphService,
+                    ],
+                    exports: [
+                        NlsGraphsComponent,
+                        NlsGuillocheDirective
+                    ]
+                },] },
+    ];
+    return NlsGuillocheModule;
+}());
+export { NlsGuillocheModule };
+
+//# sourceMappingURL=data:application/json;base64,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
@@ -0,0 +1,77 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+import { Injectable } from '@angular/core';
+import { NlsMathService } from './math.service';
+import { NlsHistoryService } from './history.service';
+var NlsAnimationService = /** @class */ (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: Injectable },
+    ];
+    /** @nocollapse */
+    NlsAnimationService.ctorParameters = function () { return [
+        { type: NlsMathService },
+        { type: NlsHistoryService }
+    ]; };
+    return NlsAnimationService;
+}());
+export { NlsAnimationService };
+function NlsAnimationService_tsickle_Closure_declarations() {
+    /** @type {?} */
+    NlsAnimationService.prototype.graphs;
+    /** @type {?} */
+    NlsAnimationService.prototype.speed;
+    /** @type {?} */
+    NlsAnimationService.prototype.range;
+    /** @type {?} */
+    NlsAnimationService.prototype.math;
+    /** @type {?} */
+    NlsAnimationService.prototype.historyService;
+}
+
+//# sourceMappingURL=data:application/json;base64,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
@@ -0,0 +1,78 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+import { Injectable, RendererFactory2 } from '@angular/core';
+var NlsCanvasService = /** @class */ (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: Injectable },
+    ];
+    /** @nocollapse */
+    NlsCanvasService.ctorParameters = function () { return [
+        { type: RendererFactory2 }
+    ]; };
+    return NlsCanvasService;
+}());
+export { NlsCanvasService };
+function NlsCanvasService_tsickle_Closure_declarations() {
+    /** @type {?} */
+    NlsCanvasService.prototype.renderer;
+    /** @type {?} */
+    NlsCanvasService.prototype.canvas;
+    /** @type {?} */
+    NlsCanvasService.prototype.rendererFactory;
+}
+
+//# sourceMappingURL=data:application/json;base64,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
@@ -0,0 +1,129 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { NlsMathService } from './math.service';
+var NlsGraphService = /** @class */ (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 tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sign = this.math.flipSign();
+                    currentPoint = start;
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    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: Injectable },
+    ];
+    /** @nocollapse */
+    NlsGraphService.ctorParameters = function () { return [
+        { type: NlsMathService }
+    ]; };
+    return NlsGraphService;
+}());
+export { NlsGraphService };
+function NlsGraphService_tsickle_Closure_declarations() {
+    /** @type {?} */
+    NlsGraphService.prototype.graphs;
+    /** @type {?} */
+    NlsGraphService.prototype.animation;
+    /** @type {?} */
+    NlsGraphService.prototype.math;
+}
+
+//# sourceMappingURL=data:application/json;base64,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
@@ -0,0 +1,76 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+import { Injectable } from '@angular/core';
+var NlsHistoryService = /** @class */ (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: Injectable },
+    ];
+    /** @nocollapse */
+    NlsHistoryService.ctorParameters = function () { return []; };
+    return NlsHistoryService;
+}());
+export { NlsHistoryService };
+function NlsHistoryService_tsickle_Closure_declarations() {
+    /** @type {?} */
+    NlsHistoryService.prototype.history;
+}
+
+//# sourceMappingURL=data:application/json;base64,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
@@ -0,0 +1,318 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; version 2.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 51
+ * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import * as Random from 'd3-random';
+var NlsMathService = /** @class */ (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 tslib_1.__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 tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    power = Math.pow(10, decimals);
+                    step = 2 / (power);
+                    index = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    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 tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    sign = startPositive ? 1 : -1;
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    return [4 /*yield*/, sign = sign * (-1)];
+                case 2:
+                    _a.sent();
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/];
+            }
+        });
+    };
+    NlsMathService.decorators = [
+        { type: Injectable },
+    ];
+    return NlsMathService;
+}());
+export { NlsMathService };
+
+//# sourceMappingURL=data:application/json;base64,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
Line truncated