angular-three-soba 2.0.0-beta.4 → 2.0.0-beta.41

package/esm2022/controls/orbit-controls/orbit-controls.mjs

@@ -1,114 +1,122 @@
-import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, EventEmitter, inject, Input, Output, } from '@angular/core';
-import { injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, NgtStore } from 'angular-three';
+import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, EventEmitter, Input, Output } from '@angular/core';
+import { injectBeforeRender, injectNgtRef, injectNgtStore, NgtArgs, signalStore, } from 'angular-three';
 import { OrbitControls } from 'three-stdlib';
 import * as i0 from "@angular/core";
-class NgtsOrbitControls extends NgtSignalStore {
-    set camera(camera) {
-        this.set({ camera });
+export class NgtsOrbitControls {
+    set _camera(camera) {
+        this.inputs.set({ camera });
     }
-    set domElement(domElement) {
-        this.set({ domElement });
+    set _domElement(domElement) {
+        this.inputs.set({ domElement });
     }
-    set makeDefault(makeDefault) {
-        this.set({ makeDefault });
+    set _makeDefault(makeDefault) {
+        this.inputs.set({ makeDefault });
     }
-    set regress(regress) {
-        this.set({ regress });
+    set _regress(regress) {
+        this.inputs.set({ regress });
     }
-    set target(target) {
-        this.set({ target });
+    set _target(target) {
+        this.inputs.set({ target });
     }
-    set enableDamping(enableDamping) {
-        this.set({ enableDamping });
+    set _enableDamping(enableDamping) {
+        this.inputs.set({ enableDamping });
+    }
+    set _keyEvents(keyEvents) {
+        this.inputs.set({ keyEvents });
     }
-    #store;
     constructor() {
-        super({ enableDamping: true, regress: false, makeDefault: false });
+        this.inputs = signalStore({
+            enableDamping: true,
+            regress: false,
+            makeDefault: false,
+            keyEvents: false,
+        });
         this.controlsRef = injectNgtRef();
         this.change = new EventEmitter();
         this.start = new EventEmitter();
         this.end = new EventEmitter();
-        this.#store = inject(NgtStore);
+        this.store = injectNgtStore();
+        this.invalidate = this.store.select('invalidate');
+        this.performanceRegress = this.store.select('performance', 'regress');
+        this.defaultCamera = this.store.select('camera');
+        this.glDomElement = this.store.select('gl', 'domElement');
+        this.regress = this.inputs.select('regress');
+        this.camera = this.inputs.select('camera');
+        this.domElement = this.inputs.select('domElement');
+        this.keyEvents = this.inputs.select('keyEvents');
+        this.makeDefault = this.inputs.select('makeDefault');
         this.args = computed(() => [this.controlsRef.nativeElement]);
-        this.damping = this.select('enableDamping');
+        this.enableDamping = this.inputs.select('enableDamping');
         injectBeforeRender(() => {
-            const controls = this.controlsRef.untracked;
+            const controls = this.controlsRef.nativeElement;
             if (controls && controls.enabled) {
                 controls.update();
             }
         }, { priority: -1 });
-        this.#setControls();
-        this.#connectElement();
-        this.#makeControlsDefault();
-        this.#setEvents();
+        this.setControls();
+        this.connectElement();
+        this.makeControlsDefault();
+        this.setEvents();
     }
-    #setControls() {
-        const camera = this.select('camera');
-        const defaultCamera = this.#store.select('camera');
-        const trigger = computed(() => ({ camera: camera(), defaultCamera: defaultCamera() }));
+    setControls() {
         effect(() => {
-            const { camera, defaultCamera } = trigger();
+            const [camera, defaultCamera, controls] = [
+                this.camera(),
+                this.defaultCamera(),
+                this.controlsRef.nativeElement,
+            ];
             const controlsCamera = camera || defaultCamera;
-            const controls = this.controlsRef.nativeElement;
             if (!controls || controls.object !== controlsCamera) {
                 this.controlsRef.nativeElement = new OrbitControls(controlsCamera);
             }
-        }, { allowSignalWrites: true });
-    }
-    #connectElement() {
-        const glDomElement = this.#store.select('gl', 'domElement');
-        const domElement = this.select('domElement');
-        const regress = this.select('regress');
-        const invalidate = this.#store.select('invalidate');
-        const trigger = computed(() => {
-            const eventsSource = this.#store.get('events', 'connected');
-            return {
-                controls: this.controlsRef.nativeElement,
-                domElement: domElement() || eventsSource || glDomElement(),
-                regress: regress(),
-                invalidate: invalidate(),
-            };
         });
+    }
+    connectElement() {
         effect((onCleanup) => {
-            const { domElement, controls } = trigger();
+            const [keyEvents, domElement, controls] = [
+                this.keyEvents(),
+                this.domElement() || this.store.get('events', 'connected') || this.glDomElement(),
+                this.controlsRef.nativeElement,
+                this.invalidate(),
+                this.regress(),
+            ];
             if (!controls)
                 return;
-            controls.connect(domElement);
+            if (keyEvents) {
+                controls.connect(keyEvents === true ? domElement : keyEvents);
+            }
+            else {
+                controls.connect(domElement);
+            }
             onCleanup(() => void controls.dispose());
         });
     }
-    #makeControlsDefault() {
-        const makeDefault = this.select('makeDefault');
-        const trigger = computed(() => ({ controls: this.controlsRef.nativeElement, makeDefault: makeDefault() }));
+    makeControlsDefault() {
         effect((onCleanup) => {
-            const { controls, makeDefault } = trigger();
+            const [controls, makeDefault] = [this.controlsRef.nativeElement, this.makeDefault()];
             if (!controls)
                 return;
             if (makeDefault) {
-                const oldControls = this.#store.get('controls');
-                this.#store.set({ controls });
-                onCleanup(() => void this.#store.set({ controls: oldControls }));
+                const oldControls = this.store.get('controls');
+                this.store.set({ controls });
+                onCleanup(() => void this.store.set({ controls: oldControls }));
             }
-        }, { allowSignalWrites: true });
+        });
     }
-    #setEvents() {
-        const invalidate = this.#store.select('invalidate');
-        const performance = this.#store.select('performance');
-        const regress = this.select('regress');
-        const trigger = computed(() => ({
-            invalidate: invalidate(),
-            performance: performance(),
-            regress: regress(),
-            controls: this.controlsRef.nativeElement,
-        }));
+    setEvents() {
         effect((onCleanup) => {
-            const { controls, invalidate, performance, regress } = trigger();
+            const [controls, invalidate, performanceRegress, regress] = [
+                this.controlsRef.nativeElement,
+                this.invalidate(),
+                this.performanceRegress(),
+                this.regress(),
+            ];
             if (!controls)
                 return;
             const changeCallback = (e) => {
                 invalidate();
                 if (regress)
-                    performance.regress();
+                    performanceRegress();
                 if (this.change.observed)
                     this.change.emit(e);
             };
@@ -128,33 +136,49 @@ class NgtsOrbitControls extends NgtSignalStore {
             });
         });
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsOrbitControls, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: NgtsOrbitControls, isStandalone: true, selector: "ngts-orbit-controls", inputs: { controlsRef: "controlsRef", camera: "camera", domElement: "domElement", makeDefault: "makeDefault", regress: "regress", target: "target", enableDamping: "enableDamping" }, outputs: { change: "change", start: "start", end: "end" }, usesInheritance: true, ngImport: i0, template: ` <ngt-primitive *args="args()" ngtCompound [enableDamping]="damping()" /> `, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "[args]", inputs: ["args"] }] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsOrbitControls, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.3", type: NgtsOrbitControls, isStandalone: true, selector: "ngts-orbit-controls", inputs: { controlsRef: "controlsRef", _camera: ["camera", "_camera"], _domElement: ["domElement", "_domElement"], _makeDefault: ["makeDefault", "_makeDefault"], _regress: ["regress", "_regress"], _target: ["target", "_target"], _enableDamping: ["enableDamping", "_enableDamping"], _keyEvents: ["keyEvents", "_keyEvents"] }, outputs: { change: "change", start: "start", end: "end" }, ngImport: i0, template: `
+		<ngt-primitive *args="args()" ngtCompound [enableDamping]="enableDamping()">
+			<ng-content />
+		</ngt-primitive>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }] }); }
 }
-export { NgtsOrbitControls };
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgtsOrbitControls, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsOrbitControls, decorators: [{
             type: Component,
             args: [{
                     selector: 'ngts-orbit-controls',
                     standalone: true,
-                    template: ` <ngt-primitive *args="args()" ngtCompound [enableDamping]="damping()" /> `,
+                    template: `
+		<ngt-primitive *args="args()" ngtCompound [enableDamping]="enableDamping()">
+			<ng-content />
+		</ngt-primitive>
+	`,
                     imports: [NgtArgs],
                     schemas: [CUSTOM_ELEMENTS_SCHEMA],
                 }]
         }], ctorParameters: function () { return []; }, propDecorators: { controlsRef: [{
                 type: Input
-            }], camera: [{
-                type: Input
-            }], domElement: [{
-                type: Input
-            }], makeDefault: [{
-                type: Input
-            }], regress: [{
-                type: Input
-            }], target: [{
-                type: Input
-            }], enableDamping: [{
-                type: Input
+            }], _camera: [{
+                type: Input,
+                args: [{ alias: 'camera' }]
+            }], _domElement: [{
+                type: Input,
+                args: [{ alias: 'domElement' }]
+            }], _makeDefault: [{
+                type: Input,
+                args: [{ alias: 'makeDefault' }]
+            }], _regress: [{
+                type: Input,
+                args: [{ alias: 'regress' }]
+            }], _target: [{
+                type: Input,
+                args: [{ alias: 'target' }]
+            }], _enableDamping: [{
+                type: Input,
+                args: [{ alias: 'enableDamping' }]
+            }], _keyEvents: [{
+                type: Input,
+                args: [{ alias: 'keyEvents' }]
             }], change: [{
                 type: Output
             }], start: [{
@@ -162,4 +186,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImpor
             }], end: [{
                 type: Output
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orbit-controls.js","sourceRoot":"","sources":["../../../../../../libs/soba/controls/src/orbit-controls/orbit-controls.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    computed,\n    CUSTOM_ELEMENTS_SCHEMA,\n    effect,\n    EventEmitter,\n    inject,\n    Input,\n    Output,\n} from '@angular/core';\nimport { injectBeforeRender, injectNgtRef, NgtArgs, NgtSignalStore, NgtStore, NgtVector3 } from 'angular-three';\nimport { OrbitControls } from 'three-stdlib';\n\nexport type NgtsOrbitControlsState = {\n    camera?: THREE.Camera;\n    domElement?: HTMLElement;\n    target?: NgtVector3;\n    makeDefault: boolean;\n    regress: boolean;\n    enableDamping: boolean;\n};\n\ndeclare global {\n    interface HTMLElementTagNameMap {\n        'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsState;\n    }\n}\n\n@Component({\n    selector: 'ngts-orbit-controls',\n    standalone: true,\n    template: ` <ngt-primitive *args=\"args()\" ngtCompound [enableDamping]=\"damping()\" /> `,\n    imports: [NgtArgs],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsOrbitControls extends NgtSignalStore<NgtsOrbitControlsState> {\n    @Input() controlsRef = injectNgtRef<OrbitControls>();\n\n    @Input() set camera(camera: THREE.Camera) {\n        this.set({ camera });\n    }\n\n    @Input() set domElement(domElement: HTMLElement) {\n        this.set({ domElement });\n    }\n\n    @Input() set makeDefault(makeDefault: boolean) {\n        this.set({ makeDefault });\n    }\n\n    @Input() set regress(regress: boolean) {\n        this.set({ regress });\n    }\n\n    @Input() set target(target: THREE.Vector3 | Parameters<THREE.Vector3['set']>) {\n        this.set({ target });\n    }\n\n    @Input() set enableDamping(enableDamping: boolean) {\n        this.set({ enableDamping });\n    }\n\n    @Output() change = new EventEmitter<THREE.Event>();\n    @Output() start = new EventEmitter<THREE.Event>();\n    @Output() end = new EventEmitter<THREE.Event>();\n\n    readonly #store = inject(NgtStore);\n\n    readonly args = computed(() => [this.controlsRef.nativeElement]);\n    readonly damping = this.select('enableDamping');\n\n    constructor() {\n        super({ enableDamping: true, regress: false, makeDefault: false });\n        injectBeforeRender(\n            () => {\n                const controls = this.controlsRef.untracked;\n                if (controls && controls.enabled) {\n                    controls.update();\n                }\n            },\n            { priority: -1 }\n        );\n\n        this.#setControls();\n        this.#connectElement();\n        this.#makeControlsDefault();\n        this.#setEvents();\n    }\n\n    #setControls() {\n        const camera = this.select('camera');\n        const defaultCamera = this.#store.select('camera');\n        const trigger = computed(() => ({ camera: camera(), defaultCamera: defaultCamera() }));\n\n        effect(\n            () => {\n                const { camera, defaultCamera } = trigger();\n                const controlsCamera = camera || defaultCamera;\n                const controls = this.controlsRef.nativeElement;\n                if (!controls || controls.object !== controlsCamera) {\n                    this.controlsRef.nativeElement = new OrbitControls(controlsCamera);\n                }\n            },\n            { allowSignalWrites: true }\n        );\n    }\n\n    #connectElement() {\n        const glDomElement = this.#store.select('gl', 'domElement');\n        const domElement = this.select('domElement');\n        const regress = this.select('regress');\n        const invalidate = this.#store.select('invalidate');\n\n        const trigger = computed(() => {\n            const eventsSource = this.#store.get('events', 'connected');\n            return {\n                controls: this.controlsRef.nativeElement,\n                domElement: domElement() || eventsSource || glDomElement(),\n                regress: regress(),\n                invalidate: invalidate(),\n            };\n        });\n\n        effect((onCleanup) => {\n            const { domElement, controls } = trigger();\n            if (!controls) return;\n            controls.connect(domElement);\n            onCleanup(() => void controls.dispose());\n        });\n    }\n\n    #makeControlsDefault() {\n        const makeDefault = this.select('makeDefault');\n        const trigger = computed(() => ({ controls: this.controlsRef.nativeElement, makeDefault: makeDefault() }));\n\n        effect(\n            (onCleanup) => {\n                const { controls, makeDefault } = trigger();\n                if (!controls) return;\n                if (makeDefault) {\n                    const oldControls = this.#store.get('controls');\n                    this.#store.set({ controls });\n                    onCleanup(() => void this.#store.set({ controls: oldControls }));\n                }\n            },\n            { allowSignalWrites: true }\n        );\n    }\n\n    #setEvents() {\n        const invalidate = this.#store.select('invalidate');\n        const performance = this.#store.select('performance');\n        const regress = this.select('regress');\n\n        const trigger = computed(() => ({\n            invalidate: invalidate(),\n            performance: performance(),\n            regress: regress(),\n            controls: this.controlsRef.nativeElement,\n        }));\n        effect((onCleanup) => {\n            const { controls, invalidate, performance, regress } = trigger();\n            if (!controls) return;\n            const changeCallback: (e: THREE.Event) => void = (e) => {\n                invalidate();\n                if (regress) performance.regress();\n                if (this.change.observed) this.change.emit(e);\n            };\n\n            const startCallback = this.start.observed ? this.start.emit.bind(this.start) : null;\n            const endCallback = this.end.observed ? this.end.emit.bind(this.end) : null;\n\n            controls.addEventListener('change', changeCallback);\n            if (startCallback) controls.addEventListener('start', startCallback);\n            if (endCallback) controls.addEventListener('end', endCallback);\n\n            onCleanup(() => {\n                controls.removeEventListener('change', changeCallback);\n                if (startCallback) controls.removeEventListener('start', startCallback);\n                if (endCallback) controls.removeEventListener('end', endCallback);\n            });\n        });\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"orbit-controls.js","sourceRoot":"","sources":["../../../../../../libs/soba/controls/src/orbit-controls/orbit-controls.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, CUSTOM_ELEMENTS_SCHEMA, effect, EventEmitter, Input, Output } from '@angular/core';\nimport {\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tNgtArgs,\n\tsignalStore,\n\ttype NgtCamera,\n\ttype NgtVector3,\n} from 'angular-three';\nimport { OrbitControls } from 'three-stdlib';\n\nexport type NgtsOrbitControlsState = {\n\tcamera?: THREE.Camera;\n\tdomElement?: HTMLElement;\n\ttarget?: NgtVector3;\n\tmakeDefault: boolean;\n\tregress: boolean;\n\tenableDamping: boolean;\n\tkeyEvents: boolean | HTMLElement;\n};\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t/**\n\t\t * @extends three-stdlib|OrbitControls\n\t\t */\n\t\t'ngts-orbit-controls': OrbitControls & NgtsOrbitControlsState;\n\t}\n}\n\n@Component({\n\tselector: 'ngts-orbit-controls',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-primitive *args=\"args()\" ngtCompound [enableDamping]=\"enableDamping()\">\n\t\t\t<ng-content />\n\t\t</ngt-primitive>\n\t`,\n\timports: [NgtArgs],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsOrbitControls {\n\tprivate inputs = signalStore<NgtsOrbitControlsState>({\n\t\tenableDamping: true,\n\t\tregress: false,\n\t\tmakeDefault: false,\n\t\tkeyEvents: false,\n\t});\n\n\t@Input() controlsRef = injectNgtRef<OrbitControls>();\n\n\t@Input({ alias: 'camera' }) set _camera(camera: THREE.Camera) {\n\t\tthis.inputs.set({ camera });\n\t}\n\n\t@Input({ alias: 'domElement' }) set _domElement(domElement: HTMLElement) {\n\t\tthis.inputs.set({ domElement });\n\t}\n\n\t@Input({ alias: 'makeDefault' }) set _makeDefault(makeDefault: boolean) {\n\t\tthis.inputs.set({ makeDefault });\n\t}\n\n\t@Input({ alias: 'regress' }) set _regress(regress: boolean) {\n\t\tthis.inputs.set({ regress });\n\t}\n\n\t@Input({ alias: 'target' }) set _target(target: THREE.Vector3 | Parameters<THREE.Vector3['set']>) {\n\t\tthis.inputs.set({ target });\n\t}\n\n\t@Input({ alias: 'enableDamping' }) set _enableDamping(enableDamping: boolean) {\n\t\tthis.inputs.set({ enableDamping });\n\t}\n\n\t@Input({ alias: 'keyEvents' }) set _keyEvents(keyEvents: boolean) {\n\t\tthis.inputs.set({ keyEvents });\n\t}\n\n\t@Output() change = new EventEmitter<THREE.Event>();\n\t@Output() start = new EventEmitter<THREE.Event>();\n\t@Output() end = new EventEmitter<THREE.Event>();\n\n\tprivate store = injectNgtStore();\n\tprivate invalidate = this.store.select('invalidate');\n\tprivate performanceRegress = this.store.select('performance', 'regress');\n\tprivate defaultCamera = this.store.select('camera');\n\tprivate glDomElement = this.store.select('gl', 'domElement');\n\tprivate regress = this.inputs.select('regress');\n\tprivate camera = this.inputs.select('camera');\n\tprivate domElement = this.inputs.select('domElement');\n\tprivate keyEvents = this.inputs.select('keyEvents');\n\tprivate makeDefault = this.inputs.select('makeDefault');\n\n\targs = computed(() => [this.controlsRef.nativeElement]);\n\tenableDamping = this.inputs.select('enableDamping');\n\n\tconstructor() {\n\t\tinjectBeforeRender(\n\t\t\t() => {\n\t\t\t\tconst controls = this.controlsRef.nativeElement;\n\t\t\t\tif (controls && controls.enabled) {\n\t\t\t\t\tcontrols.update();\n\t\t\t\t}\n\t\t\t},\n\t\t\t{ priority: -1 },\n\t\t);\n\n\t\tthis.setControls();\n\t\tthis.connectElement();\n\t\tthis.makeControlsDefault();\n\t\tthis.setEvents();\n\t}\n\n\tprivate setControls() {\n\t\teffect(() => {\n\t\t\tconst [camera, defaultCamera, controls] = [\n\t\t\t\tthis.camera(),\n\t\t\t\tthis.defaultCamera(),\n\t\t\t\tthis.controlsRef.nativeElement,\n\t\t\t];\n\t\t\tconst controlsCamera = camera || defaultCamera;\n\t\t\tif (!controls || controls.object !== controlsCamera) {\n\t\t\t\tthis.controlsRef.nativeElement = new OrbitControls(controlsCamera as NgtCamera);\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate connectElement() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [keyEvents, domElement, controls] = [\n\t\t\t\tthis.keyEvents(),\n\t\t\t\tthis.domElement() || this.store.get('events', 'connected') || this.glDomElement(),\n\t\t\t\tthis.controlsRef.nativeElement,\n\t\t\t\tthis.invalidate(),\n\t\t\t\tthis.regress(),\n\t\t\t];\n\t\t\tif (!controls) return;\n\t\t\tif (keyEvents) {\n\t\t\t\tcontrols.connect(keyEvents === true ? domElement : keyEvents);\n\t\t\t} else {\n\t\t\t\tcontrols.connect(domElement);\n\t\t\t}\n\t\t\tonCleanup(() => void controls.dispose());\n\t\t});\n\t}\n\n\tprivate makeControlsDefault() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [controls, makeDefault] = [this.controlsRef.nativeElement, this.makeDefault()];\n\t\t\tif (!controls) return;\n\t\t\tif (makeDefault) {\n\t\t\t\tconst oldControls = this.store.get('controls');\n\t\t\t\tthis.store.set({ controls });\n\t\t\t\tonCleanup(() => void this.store.set({ controls: oldControls }));\n\t\t\t}\n\t\t});\n\t}\n\n\tprivate setEvents() {\n\t\teffect((onCleanup) => {\n\t\t\tconst [controls, invalidate, performanceRegress, regress] = [\n\t\t\t\tthis.controlsRef.nativeElement,\n\t\t\t\tthis.invalidate(),\n\t\t\t\tthis.performanceRegress(),\n\t\t\t\tthis.regress(),\n\t\t\t];\n\t\t\tif (!controls) return;\n\t\t\tconst changeCallback: (e: THREE.Event) => void = (e) => {\n\t\t\t\tinvalidate();\n\t\t\t\tif (regress) performanceRegress();\n\t\t\t\tif (this.change.observed) this.change.emit(e);\n\t\t\t};\n\n\t\t\tconst startCallback = this.start.observed ? this.start.emit.bind(this.start) : null;\n\t\t\tconst endCallback = this.end.observed ? this.end.emit.bind(this.end) : null;\n\n\t\t\tcontrols.addEventListener('change', changeCallback);\n\t\t\tif (startCallback) controls.addEventListener('start', startCallback);\n\t\t\tif (endCallback) controls.addEventListener('end', endCallback);\n\n\t\t\tonCleanup(() => {\n\t\t\t\tcontrols.removeEventListener('change', changeCallback);\n\t\t\t\tif (startCallback) controls.removeEventListener('start', startCallback);\n\t\t\t\tif (endCallback) controls.removeEventListener('end', endCallback);\n\t\t\t});\n\t\t});\n\t}\n}\n"]}

package/esm2022/gizmos/angular-three-soba-gizmos.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhci10aHJlZS1zb2JhLWdpem1vcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9naXptb3Mvc3JjL2FuZ3VsYXItdGhyZWUtc29iYS1naXptb3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2022/gizmos/gizmo-helper/gizmo-helper.mjs

@@ -0,0 +1,198 @@
+import { NgTemplateOutlet } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, Component, ContentChild, EventEmitter, Input, Output, TemplateRef, computed, effect, forwardRef, } from '@angular/core';
+import { NgtPortal, NgtPortalContent, extend, injectBeforeRender, injectNgtRef, injectNgtStore, signalStore, } from 'angular-three';
+import { NgtsOrthographicCamera } from 'angular-three-soba/cameras';
+import { NgtsSobaContent } from 'angular-three-soba/utils';
+import { createInjectionToken } from 'ngxtension/create-injection-token';
+import { Group, Matrix4, Object3D, OrthographicCamera, Quaternion, Vector3 } from 'three';
+import { OrbitControls } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const isOrbitControls = (controls) => {
+    return 'minPolarAngle' in controls;
+};
+extend({ Group });
+export const [injectNgtsGizmoHelperApi, provideNgtsGizmoHelperApi] = createInjectionToken((gizmoHelper) => gizmoHelper.api, { isRoot: false, deps: [forwardRef(() => NgtsGizmoHelper)] });
+export class NgtsGizmoHelper {
+    set _alignment(alignment) {
+        this.inputs.set({ alignment });
+    }
+    set _margin(margin) {
+        this.inputs.set({ margin });
+    }
+    set _renderPriority(renderPriority) {
+        this.inputs.set({ renderPriority });
+    }
+    set _autoClear(autoClear) {
+        this.inputs.set({ autoClear });
+    }
+    constructor() {
+        this.inputs = signalStore({
+            alignment: 'bottom-right',
+            margin: [80, 80],
+            renderPriority: 1,
+        });
+        this.gizmoRef = injectNgtRef();
+        this.update = new EventEmitter();
+        this.store = injectNgtStore();
+        this.mainCamera = this.store.select('camera');
+        // @ts-expect-error
+        this.defaultControls = this.store.select('controls');
+        this.invalidate = this.store.select('invalidate');
+        this.size = this.store.select('size');
+        this.animating = false;
+        this.q1 = new Quaternion();
+        this.q2 = new Quaternion();
+        this.turnRate = 2 * Math.PI; // turn rate in angles per second
+        this.matrix = new Matrix4();
+        this.radius = 0;
+        this.focusPoint = new Vector3(0, 0, 0);
+        this.defaultUp = new Vector3(0, 0, 0);
+        this.target = new Vector3();
+        this.targetPosition = new Vector3();
+        this.dummy = new Object3D();
+        this.margin = this.inputs.select('margin');
+        this.alignment = this.inputs.select('alignment');
+        this.virtualCamRef = injectNgtRef();
+        this.renderPriority = this.inputs.select('renderPriority');
+        this.gizmoPosition = computed(() => {
+            const [{ width, height }, [marginX, marginY], alignment] = [this.size(), this.margin(), this.alignment()];
+            const x = alignment.endsWith('-center')
+                ? 0
+                : alignment.endsWith('-left')
+                    ? -width / 2 + marginX
+                    : width / 2 - marginX;
+            const y = alignment.startsWith('center-')
+                ? 0
+                : alignment.startsWith('top-')
+                    ? height / 2 - marginY
+                    : -height / 2 + marginY;
+            return [x, y, 0];
+        });
+        this.api = {
+            tweenCamera: (direction) => {
+                const [defaultControls, mainCamera, invalidate] = [
+                    this.defaultControls(),
+                    this.mainCamera(),
+                    this.invalidate(),
+                ];
+                this.animating = true;
+                if (defaultControls)
+                    this.focusPoint = defaultControls?.target;
+                this.radius = mainCamera.position.distanceTo(this.target);
+                // Rotate from current camera orientation
+                this.q1.copy(mainCamera.quaternion);
+                // To new current camera orientation
+                this.targetPosition.copy(direction).multiplyScalar(this.radius).add(this.target);
+                this.dummy.lookAt(this.targetPosition);
+                this.dummy.up.copy(mainCamera.up);
+                this.q2.copy(this.dummy.quaternion);
+                invalidate();
+            },
+        };
+        this.trackMainCameraUp();
+        this.beforeRender();
+    }
+    trackMainCameraUp() {
+        effect(() => {
+            const mainCamera = this.mainCamera();
+            this.defaultUp.copy(mainCamera.up);
+        });
+    }
+    beforeRender() {
+        injectBeforeRender(({ delta }) => {
+            const [gizmo, virtualCam, defaultControls, mainCamera, invalidate] = [
+                this.gizmoRef.nativeElement,
+                this.virtualCamRef.nativeElement,
+                this.defaultControls(),
+                this.mainCamera(),
+                this.invalidate(),
+            ];
+            if (gizmo && virtualCam) {
+                // Animate step
+                if (this.animating) {
+                    if (this.q1.angleTo(this.q2) < 0.01) {
+                        this.animating = false;
+                        // Orbit controls uses UP vector as the orbit axes,
+                        // so we need to reset it after the animation is done
+                        // moving it around for the controls to work correctly
+                        if (isOrbitControls(defaultControls)) {
+                            mainCamera.up.copy(this.defaultUp);
+                        }
+                    }
+                    else {
+                        const step = delta * this.turnRate;
+                        // animate position by doing a slerp and then scaling the position on the unit sphere
+                        this.q1.rotateTowards(this.q2, step);
+                        // animate orientation
+                        mainCamera.position
+                            .set(0, 0, 1)
+                            .applyQuaternion(this.q1)
+                            .multiplyScalar(this.radius)
+                            .add(this.focusPoint);
+                        mainCamera.up.set(0, 1, 0).applyQuaternion(this.q1).normalize();
+                        mainCamera.quaternion.copy(this.q1);
+                        if (this.update.observed)
+                            this.update.emit();
+                        else if (defaultControls)
+                            defaultControls.update();
+                        invalidate();
+                    }
+                }
+                // Sync Gizmo with main camera orientation
+                this.matrix.copy(mainCamera.matrix).invert();
+                gizmo.quaternion.setFromRotationMatrix(this.matrix);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsGizmoHelper, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.3", type: NgtsGizmoHelper, isStandalone: true, selector: "ngts-gizmo-helper", inputs: { gizmoRef: "gizmoRef", _alignment: ["alignment", "_alignment"], _margin: ["margin", "_margin"], _renderPriority: ["renderPriority", "_renderPriority"], _autoClear: ["autoClear", "_autoClear"] }, outputs: { update: "update" }, providers: [provideNgtsGizmoHelperApi()], queries: [{ propertyName: "content", first: true, predicate: NgtsSobaContent, descendants: true, read: TemplateRef, static: true }], ngImport: i0, template: `
+		<ngt-portal [renderPriority]="renderPriority()">
+			<ng-template ngtPortalContent>
+				<ngts-orthographic-camera [makeDefault]="true" [position]="[0, 0, 200]" [cameraRef]="virtualCamRef" />
+				<ngt-group [ref]="gizmoRef" [position]="gizmoPosition()">
+					<ng-container *ngTemplateOutlet="content" />
+				</ngt-group>
+			</ng-template>
+		</ngt-portal>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtPortal, selector: "ngt-portal", inputs: ["container", "state", "autoRender", "autoRenderPriority"], outputs: ["beforeRender"] }, { kind: "directive", type: NgtPortalContent, selector: "ng-template[ngtPortalContent]" }, { kind: "component", type: NgtsOrthographicCamera, selector: "ngts-orthographic-camera", inputs: ["left", "right", "top", "bottom"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.3", ngImport: i0, type: NgtsGizmoHelper, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-gizmo-helper',
+                    standalone: true,
+                    template: `
+		<ngt-portal [renderPriority]="renderPriority()">
+			<ng-template ngtPortalContent>
+				<ngts-orthographic-camera [makeDefault]="true" [position]="[0, 0, 200]" [cameraRef]="virtualCamRef" />
+				<ngt-group [ref]="gizmoRef" [position]="gizmoPosition()">
+					<ng-container *ngTemplateOutlet="content" />
+				</ngt-group>
+			</ng-template>
+		</ngt-portal>
+	`,
+                    imports: [NgtPortal, NgtPortalContent, NgtsOrthographicCamera, NgTemplateOutlet],
+                    providers: [provideNgtsGizmoHelperApi()],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { gizmoRef: [{
+                type: Input
+            }], _alignment: [{
+                type: Input,
+                args: [{ alias: 'alignment' }]
+            }], _margin: [{
+                type: Input,
+                args: [{ alias: 'margin' }]
+            }], _renderPriority: [{
+                type: Input,
+                args: [{ alias: 'renderPriority' }]
+            }], _autoClear: [{
+                type: Input,
+                args: [{ alias: 'autoClear' }]
+            }], update: [{
+                type: Output
+            }], content: [{
+                type: ContentChild,
+                args: [NgtsSobaContent, { static: true, read: TemplateRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gizmo-helper.js","sourceRoot":"","sources":["../../../../../../libs/soba/gizmos/src/gizmo-helper/gizmo-helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgTemplateOutlet } from '@angular/common';\nimport {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tComponent,\n\tContentChild,\n\tEventEmitter,\n\tInput,\n\tOutput,\n\tTemplateRef,\n\tcomputed,\n\teffect,\n\tforwardRef,\n\ttype Signal,\n} from '@angular/core';\nimport {\n\tNgtPortal,\n\tNgtPortalContent,\n\textend,\n\tinjectBeforeRender,\n\tinjectNgtRef,\n\tinjectNgtStore,\n\tsignalStore,\n\ttype NgtGroup,\n} from 'angular-three';\nimport { NgtsOrthographicCamera } from 'angular-three-soba/cameras';\nimport { NgtsSobaContent } from 'angular-three-soba/utils';\nimport { createInjectionToken } from 'ngxtension/create-injection-token';\nimport { Group, Matrix4, Object3D, OrthographicCamera, Quaternion, Vector3 } from 'three';\nimport { OrbitControls } from 'three-stdlib';\n\nexport type NgtsGizmoHelperState = {\n\talignment:\n\t\t| 'top-left'\n\t\t| 'top-right'\n\t\t| 'bottom-right'\n\t\t| 'bottom-left'\n\t\t| 'bottom-center'\n\t\t| 'center-right'\n\t\t| 'center-left'\n\t\t| 'center-center'\n\t\t| 'top-center';\n\tmargin: [number, number];\n\trenderPriority: number;\n\tautoClear?: boolean;\n};\n\ntype ControlsProto = { update(): void; target: THREE.Vector3 };\n\nconst isOrbitControls = (controls: ControlsProto): controls is OrbitControls => {\n\treturn 'minPolarAngle' in (controls as OrbitControls);\n};\n\nextend({ Group });\n\ndeclare global {\n\tinterface HTMLElementTagNameMap {\n\t\t'ngts-gizmo-helper': NgtsGizmoHelperState & NgtGroup;\n\t}\n}\n\nexport const [injectNgtsGizmoHelperApi, provideNgtsGizmoHelperApi] = createInjectionToken(\n\t(gizmoHelper: NgtsGizmoHelper) => gizmoHelper.api,\n\t{ isRoot: false, deps: [forwardRef(() => NgtsGizmoHelper)] },\n);\n\n@Component({\n\tselector: 'ngts-gizmo-helper',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-portal [renderPriority]=\"renderPriority()\">\n\t\t\t<ng-template ngtPortalContent>\n\t\t\t\t<ngts-orthographic-camera [makeDefault]=\"true\" [position]=\"[0, 0, 200]\" [cameraRef]=\"virtualCamRef\" />\n\t\t\t\t<ngt-group [ref]=\"gizmoRef\" [position]=\"gizmoPosition()\">\n\t\t\t\t\t<ng-container *ngTemplateOutlet=\"content\" />\n\t\t\t\t</ngt-group>\n\t\t\t</ng-template>\n\t\t</ngt-portal>\n\t`,\n\timports: [NgtPortal, NgtPortalContent, NgtsOrthographicCamera, NgTemplateOutlet],\n\tproviders: [provideNgtsGizmoHelperApi()],\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n})\nexport class NgtsGizmoHelper {\n\tprivate inputs = signalStore<NgtsGizmoHelperState>({\n\t\talignment: 'bottom-right',\n\t\tmargin: [80, 80],\n\t\trenderPriority: 1,\n\t});\n\n\t@Input() gizmoRef = injectNgtRef<Group>();\n\n\t@Input({ alias: 'alignment' }) set _alignment(\n\t\talignment:\n\t\t\t| 'top-left'\n\t\t\t| 'top-right'\n\t\t\t| 'bottom-right'\n\t\t\t| 'bottom-left'\n\t\t\t| 'bottom-center'\n\t\t\t| 'center-right'\n\t\t\t| 'center-left'\n\t\t\t| 'center-center'\n\t\t\t| 'top-center',\n\t) {\n\t\tthis.inputs.set({ alignment });\n\t}\n\n\t@Input({ alias: 'margin' }) set _margin(margin: [number, number]) {\n\t\tthis.inputs.set({ margin });\n\t}\n\n\t@Input({ alias: 'renderPriority' }) set _renderPriority(renderPriority: number) {\n\t\tthis.inputs.set({ renderPriority });\n\t}\n\n\t@Input({ alias: 'autoClear' }) set _autoClear(autoClear: boolean) {\n\t\tthis.inputs.set({ autoClear });\n\t}\n\n\t@Output() update = new EventEmitter();\n\n\t@ContentChild(NgtsSobaContent, { static: true, read: TemplateRef }) content!: TemplateRef<unknown>;\n\n\tprivate store = injectNgtStore();\n\tprivate mainCamera = this.store.select('camera');\n\t// @ts-expect-error\n\tprivate defaultControls = this.store.select('controls') as Signal<ControlsProto>;\n\tprivate invalidate = this.store.select('invalidate');\n\tprivate size = this.store.select('size');\n\n\tprivate animating = false;\n\tprivate q1 = new Quaternion();\n\tprivate q2 = new Quaternion();\n\tprivate turnRate = 2 * Math.PI; // turn rate in angles per second\n\tprivate matrix = new Matrix4();\n\n\tprivate radius = 0;\n\tprivate focusPoint = new Vector3(0, 0, 0);\n\tprivate defaultUp = new Vector3(0, 0, 0);\n\tprivate target = new Vector3();\n\tprivate targetPosition = new Vector3();\n\tprivate dummy = new Object3D();\n\n\tprivate margin = this.inputs.select('margin');\n\tprivate alignment = this.inputs.select('alignment');\n\n\tvirtualCamRef = injectNgtRef<OrthographicCamera>();\n\trenderPriority = this.inputs.select('renderPriority');\n\n\tgizmoPosition = computed(() => {\n\t\tconst [{ width, height }, [marginX, marginY], alignment] = [this.size(), this.margin(), this.alignment()];\n\t\tconst x = alignment.endsWith('-center')\n\t\t\t? 0\n\t\t\t: alignment.endsWith('-left')\n\t\t\t? -width / 2 + marginX\n\t\t\t: width / 2 - marginX;\n\t\tconst y = alignment.startsWith('center-')\n\t\t\t? 0\n\t\t\t: alignment.startsWith('top-')\n\t\t\t? height / 2 - marginY\n\t\t\t: -height / 2 + marginY;\n\t\treturn [x, y, 0];\n\t});\n\n\tapi = {\n\t\ttweenCamera: (direction: Vector3) => {\n\t\t\tconst [defaultControls, mainCamera, invalidate] = [\n\t\t\t\tthis.defaultControls(),\n\t\t\t\tthis.mainCamera(),\n\t\t\t\tthis.invalidate(),\n\t\t\t];\n\t\t\tthis.animating = true;\n\t\t\tif (defaultControls) this.focusPoint = defaultControls?.target;\n\t\t\tthis.radius = mainCamera.position.distanceTo(this.target);\n\n\t\t\t// Rotate from current camera orientation\n\t\t\tthis.q1.copy(mainCamera.quaternion);\n\n\t\t\t// To new current camera orientation\n\t\t\tthis.targetPosition.copy(direction).multiplyScalar(this.radius).add(this.target);\n\n\t\t\tthis.dummy.lookAt(this.targetPosition);\n\t\t\tthis.dummy.up.copy(mainCamera.up);\n\n\t\t\tthis.q2.copy(this.dummy.quaternion);\n\n\t\t\tinvalidate();\n\t\t},\n\t};\n\n\tconstructor() {\n\t\tthis.trackMainCameraUp();\n\t\tthis.beforeRender();\n\t}\n\n\tprivate trackMainCameraUp() {\n\t\teffect(() => {\n\t\t\tconst mainCamera = this.mainCamera();\n\t\t\tthis.defaultUp.copy(mainCamera.up);\n\t\t});\n\t}\n\n\tprivate beforeRender() {\n\t\tinjectBeforeRender(({ delta }) => {\n\t\t\tconst [gizmo, virtualCam, defaultControls, mainCamera, invalidate] = [\n\t\t\t\tthis.gizmoRef.nativeElement,\n\t\t\t\tthis.virtualCamRef.nativeElement,\n\t\t\t\tthis.defaultControls(),\n\t\t\t\tthis.mainCamera(),\n\t\t\t\tthis.invalidate(),\n\t\t\t];\n\n\t\t\tif (gizmo && virtualCam) {\n\t\t\t\t// Animate step\n\t\t\t\tif (this.animating) {\n\t\t\t\t\tif (this.q1.angleTo(this.q2) < 0.01) {\n\t\t\t\t\t\tthis.animating = false;\n\t\t\t\t\t\t// Orbit controls uses UP vector as the orbit axes,\n\t\t\t\t\t\t// so we need to reset it after the animation is done\n\t\t\t\t\t\t// moving it around for the controls to work correctly\n\t\t\t\t\t\tif (isOrbitControls(defaultControls)) {\n\t\t\t\t\t\t\tmainCamera.up.copy(this.defaultUp);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconst step = delta * this.turnRate;\n\t\t\t\t\t\t// animate position by doing a slerp and then scaling the position on the unit sphere\n\t\t\t\t\t\tthis.q1.rotateTowards(this.q2, step);\n\t\t\t\t\t\t// animate orientation\n\t\t\t\t\t\tmainCamera.position\n\t\t\t\t\t\t\t.set(0, 0, 1)\n\t\t\t\t\t\t\t.applyQuaternion(this.q1)\n\t\t\t\t\t\t\t.multiplyScalar(this.radius)\n\t\t\t\t\t\t\t.add(this.focusPoint);\n\t\t\t\t\t\tmainCamera.up.set(0, 1, 0).applyQuaternion(this.q1).normalize();\n\t\t\t\t\t\tmainCamera.quaternion.copy(this.q1);\n\t\t\t\t\t\tif (this.update.observed) this.update.emit();\n\t\t\t\t\t\telse if (defaultControls) defaultControls.update();\n\t\t\t\t\t\tinvalidate();\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Sync Gizmo with main camera orientation\n\t\t\t\tthis.matrix.copy(mainCamera.matrix).invert();\n\t\t\t\tgizmo.quaternion.setFromRotationMatrix(this.matrix);\n\t\t\t}\n\t\t});\n\t}\n}\n"]}

package/esm2022/gizmos/gizmo-helper/gizmo-viewcube/constants.mjs

@@ -0,0 +1,31 @@
+import * as THREE from 'three';
+export const colors = { bg: '#f0f0f0', hover: '#999', text: 'black', stroke: 'black' };
+export const defaultFaces = ['Right', 'Left', 'Top', 'Bottom', 'Front', 'Back'];
+const makePositionVector = (xyz) => new THREE.Vector3(...xyz).multiplyScalar(0.38);
+export const corners = [
+    [1, 1, 1],
+    [1, 1, -1],
+    [1, -1, 1],
+    [1, -1, -1],
+    [-1, 1, 1],
+    [-1, 1, -1],
+    [-1, -1, 1],
+    [-1, -1, -1],
+].map(makePositionVector);
+export const cornerDimensions = [0.25, 0.25, 0.25];
+export const edges = [
+    [1, 1, 0],
+    [1, 0, 1],
+    [1, 0, -1],
+    [1, -1, 0],
+    [0, 1, 1],
+    [0, 1, -1],
+    [0, -1, 1],
+    [0, -1, -1],
+    [-1, 1, 0],
+    [-1, 0, 1],
+    [-1, 0, -1],
+    [-1, -1, 0],
+].map(makePositionVector);
+export const edgeDimensions = edges.map((edge) => edge.toArray().map((axis) => (axis == 0 ? 0.5 : 0.25)));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zb2JhL2dpem1vcy9zcmMvZ2l6bW8taGVscGVyL2dpem1vLXZpZXdjdWJlL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUUvQixNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsRUFBRSxFQUFFLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFDdkYsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFHLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNoRixNQUFNLGtCQUFrQixHQUFHLENBQUMsR0FBYSxFQUFFLEVBQUUsQ0FBQyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUM7QUFFN0YsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFvQjtJQUN2QyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1QsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ1YsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1YsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDWCxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDVixDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNYLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1gsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztDQUNaLENBQUMsR0FBRyxDQUFDLGtCQUFrQixDQUFDLENBQUM7QUFFMUIsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBNkIsQ0FBQztBQUUvRSxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQW9CO0lBQ3JDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDVCxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1QsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ1YsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1YsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNULENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUNWLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUNWLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ1gsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1YsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1YsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7SUFDWCxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQztDQUNYLENBQUMsR0FBRyxDQUFDLGtCQUFrQixDQUFDLENBQUM7QUFFMUIsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLEtBQUssQ0FBQyxHQUFHLENBQ3RDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBWSxFQUFVLEVBQUUsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQTZCLENBQzVHLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBUSFJFRSBmcm9tICd0aHJlZSc7XG5cbmV4cG9ydCBjb25zdCBjb2xvcnMgPSB7IGJnOiAnI2YwZjBmMCcsIGhvdmVyOiAnIzk5OScsIHRleHQ6ICdibGFjaycsIHN0cm9rZTogJ2JsYWNrJyB9O1xuZXhwb3J0IGNvbnN0IGRlZmF1bHRGYWNlcyA9IFsnUmlnaHQnLCAnTGVmdCcsICdUb3AnLCAnQm90dG9tJywgJ0Zyb250JywgJ0JhY2snXTtcbmNvbnN0IG1ha2VQb3NpdGlvblZlY3RvciA9ICh4eXo6IG51bWJlcltdKSA9PiBuZXcgVEhSRUUuVmVjdG9yMyguLi54eXopLm11bHRpcGx5U2NhbGFyKDAuMzgpO1xuXG5leHBvcnQgY29uc3QgY29ybmVyczogVEhSRUUuVmVjdG9yM1tdID0gW1xuXHRbMSwgMSwgMV0sXG5cdFsxLCAxLCAtMV0sXG5cdFsxLCAtMSwgMV0sXG5cdFsxLCAtMSwgLTFdLFxuXHRbLTEsIDEsIDFdLFxuXHRbLTEsIDEsIC0xXSxcblx0Wy0xLCAtMSwgMV0sXG5cdFstMSwgLTEsIC0xXSxcbl0ubWFwKG1ha2VQb3NpdGlvblZlY3Rvcik7XG5cbmV4cG9ydCBjb25zdCBjb3JuZXJEaW1lbnNpb25zID0gWzAuMjUsIDAuMjUsIDAuMjVdIGFzIFtudW1iZXIsIG51bWJlciwgbnVtYmVyXTtcblxuZXhwb3J0IGNvbnN0IGVkZ2VzOiBUSFJFRS5WZWN0b3IzW10gPSBbXG5cdFsxLCAxLCAwXSxcblx0WzEsIDAsIDFdLFxuXHRbMSwgMCwgLTFdLFxuXHRbMSwgLTEsIDBdLFxuXHRbMCwgMSwgMV0sXG5cdFswLCAxLCAtMV0sXG5cdFswLCAtMSwgMV0sXG5cdFswLCAtMSwgLTFdLFxuXHRbLTEsIDEsIDBdLFxuXHRbLTEsIDAsIDFdLFxuXHRbLTEsIDAsIC0xXSxcblx0Wy0xLCAtMSwgMF0sXG5dLm1hcChtYWtlUG9zaXRpb25WZWN0b3IpO1xuXG5leHBvcnQgY29uc3QgZWRnZURpbWVuc2lvbnMgPSBlZGdlcy5tYXAoXG5cdChlZGdlKSA9PiBlZGdlLnRvQXJyYXkoKS5tYXAoKGF4aXM6IG51bWJlcik6IG51bWJlciA9PiAoYXhpcyA9PSAwID8gMC41IDogMC4yNSkpIGFzIFtudW1iZXIsIG51bWJlciwgbnVtYmVyXSxcbik7XG4iXX0=