angular-three-soba 2.0.0-beta.9 → 2.0.0

package/esm2022/staging/lib/accumulative-shadows.mjs

@@ -0,0 +1,182 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, DestroyRef, afterNextRender, computed, inject, input, untracked, viewChild, } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, injectStore, omit, pick } from 'angular-three';
+import { ProgressiveLightMap, SoftShadowMaterial } from 'angular-three-soba/vanilla-exports';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, Mesh, PlaneGeometry } from 'three';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    temporal: false,
+    frames: 40,
+    limit: Infinity,
+    blend: 20,
+    scale: 10,
+    opacity: 1,
+    alphaTest: 0.75,
+    color: 'black',
+    colorBlend: 2,
+    resolution: 1024,
+    toneMapped: true,
+};
+export class NgtsAccumulativeShadows {
+    constructor() {
+        this.nullTraversal = () => null;
+        this.Math = Math;
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'temporal',
+            'frames',
+            'limit',
+            'blend',
+            'scale',
+            'opacity',
+            'alphaTest',
+            'color',
+            'colorBlend',
+            'resolution',
+            'toneMapped',
+        ]);
+        this.lightsRef = viewChild.required('lights');
+        this.planeRef = viewChild.required('plane');
+        this.store = injectStore();
+        this.gl = this.store.select('gl');
+        this.camera = this.store.select('camera');
+        this.scene = this.store.select('scene');
+        this.invalidate = this.store.select('invalidate');
+        this.opacity = pick(this.options, 'opacity');
+        this.alphaTest = pick(this.options, 'alphaTest');
+        this.limit = pick(this.options, 'limit');
+        this.resolution = pick(this.options, 'resolution');
+        this.pLM = computed(() => {
+            if (this.previousPLM) {
+                this.previousPLM.clear();
+            }
+            return (this.previousPLM = new ProgressiveLightMap(this.gl(), this.scene(), this.resolution()));
+        });
+        this.scale = pick(this.options, 'scale');
+        this.toneMapped = pick(this.options, 'toneMapped');
+        this.color = pick(this.options, 'color');
+        this.colorBlend = pick(this.options, 'colorBlend');
+        this.map = computed(() => this.pLM().progressiveLightMap2.texture);
+        this.lightsMap = new Map();
+        this.temporal = computed(() => !!this.options().temporal);
+        this.frames = computed(() => Math.max(2, this.options().frames));
+        this.blend = computed(() => Math.max(2, this.options().frames === Infinity ? this.options().blend : this.options().frames));
+        this.count = 0;
+        extend({ Group, SoftShadowMaterial, Mesh, PlaneGeometry });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            this.pLM().configure(this.planeRef().nativeElement);
+            autoEffect(() => {
+                const sceneLS = getLocalState(this.scene());
+                if (!sceneLS)
+                    return;
+                // track deps
+                this.planeRef();
+                this.options();
+                sceneLS.objects();
+                // Reset internals, buffers, ...
+                this.reset();
+                // Update lightmap
+                if (!this.temporal() && this.frames() !== Infinity)
+                    this.update(this.blend());
+            });
+        });
+        injectBeforeRender(() => {
+            const [frames, temporal, invalidate, limit] = [this.frames(), !!this.temporal(), this.invalidate(), this.limit()];
+            if ((temporal || frames === Infinity) && this.count < frames && this.count < limit) {
+                invalidate();
+                this.update();
+                this.count++;
+            }
+        });
+        inject(DestroyRef).onDestroy(() => {
+            this.previousPLM?.clear();
+        });
+    }
+    getMesh() {
+        return this.planeRef().nativeElement;
+    }
+    reset() {
+        // Clear buffers, reset opacities, set frame count to 0
+        untracked(this.pLM).clear();
+        const material = untracked(this.planeRef).nativeElement.material;
+        material.opacity = 0;
+        material.alphaTest = 0;
+        this.count = 0;
+    }
+    update(frames = 1) {
+        // Adapt the opacity-blend ratio to the number of frames
+        const material = this.planeRef().nativeElement.material;
+        if (!this.temporal()) {
+            material.opacity = this.opacity();
+            material.alphaTest = this.alphaTest();
+        }
+        else {
+            material.opacity = Math.min(this.opacity(), material.opacity + this.opacity() / this.blend());
+            material.alphaTest = Math.min(this.alphaTest(), material.alphaTest + this.alphaTest() / this.blend());
+        }
+        // Switch accumulative lights on
+        this.lightsRef().nativeElement.visible = true;
+        // Collect scene lights and meshes
+        this.pLM().prepare();
+        // Update the lightmap and the accumulative lights
+        for (let i = 0; i < frames; i++) {
+            this.lightsMap.forEach((lightUpdate) => lightUpdate());
+            this.pLM().update(this.camera(), this.blend());
+        }
+        // Switch lights off
+        this.lightsRef().nativeElement.visible = false;
+        // Restore lights and meshes
+        this.pLM().finish();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsAccumulativeShadows, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsAccumulativeShadows, isStandalone: true, selector: "ngts-accumulative-shadows", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "lightsRef", first: true, predicate: ["lights"], descendants: true, isSignal: true }, { propertyName: "planeRef", first: true, predicate: ["plane"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group [parameters]="parameters()">
+			<ngt-group #lights [traverse]="nullTraversal">
+				<ng-content />
+			</ngt-group>
+
+			<ngt-mesh #plane [scale]="scale()" [rotation]="[-Math.PI / 2, 0, 0]" [receiveShadow]="true">
+				<ngt-plane-geometry />
+				<ngt-soft-shadow-material
+					[depthWrite]="false"
+					[toneMapped]="toneMapped()"
+					[color]="color()"
+					[blend]="colorBlend()"
+					[map]="map()"
+					[transparent]="true"
+				/>
+			</ngt-mesh>
+		</ngt-group>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsAccumulativeShadows, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-accumulative-shadows',
+                    standalone: true,
+                    template: `
+		<ngt-group [parameters]="parameters()">
+			<ngt-group #lights [traverse]="nullTraversal">
+				<ng-content />
+			</ngt-group>
+
+			<ngt-mesh #plane [scale]="scale()" [rotation]="[-Math.PI / 2, 0, 0]" [receiveShadow]="true">
+				<ngt-plane-geometry />
+				<ngt-soft-shadow-material
+					[depthWrite]="false"
+					[toneMapped]="toneMapped()"
+					[color]="color()"
+					[blend]="colorBlend()"
+					[map]="map()"
+					[transparent]="true"
+				/>
+			</ngt-mesh>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"accumulative-shadows.js","sourceRoot":"","sources":["../../../../../../libs/soba/staging/src/lib/accumulative-shadows.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tChangeDetectionStrategy,\n\tComponent,\n\tDestroyRef,\n\tElementRef,\n\tafterNextRender,\n\tcomputed,\n\tinject,\n\tinput,\n\tuntracked,\n\tviewChild,\n} from '@angular/core';\nimport { NgtGroup, extend, getLocalState, injectBeforeRender, injectStore, omit, pick } from 'angular-three';\nimport { ProgressiveLightMap, SoftShadowMaterial } from 'angular-three-soba/vanilla-exports';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Group, Mesh, PlaneGeometry } from 'three';\n\nexport interface NgtsAccumulativeShadowsOptions extends Partial<NgtGroup> {\n\t/** How many frames it can render, more yields cleaner results but takes more time, 40 */\n\tframes: number;\n\t/** If frames === Infinity blend controls the refresh ratio, 100 */\n\tblend: number;\n\t/** Can limit the amount of frames rendered if frames === Infinity, usually to get some performance back once a movable scene has settled, Infinity */\n\tlimit: number;\n\t/** Scale of the plane,  */\n\tscale: number;\n\t/** Temporal accumulates shadows over time which is more performant but has a visual regression over instant results, false  */\n\ttemporal?: boolean;\n\t/** Opacity of the plane, 1 */\n\topacity: number;\n\t/** Discards alpha pixels, 0.65 */\n\talphaTest: number;\n\t/** Shadow color, black */\n\tcolor: string;\n\t/** Colorblend, how much colors turn to black, 0 is black, 2 */\n\tcolorBlend: number;\n\t/** Buffer resolution, 1024 */\n\tresolution: number;\n\t/** Texture tonemapping */\n\ttoneMapped: boolean;\n}\n\nconst defaultOptions: NgtsAccumulativeShadowsOptions = {\n\ttemporal: false,\n\tframes: 40,\n\tlimit: Infinity,\n\tblend: 20,\n\tscale: 10,\n\topacity: 1,\n\talphaTest: 0.75,\n\tcolor: 'black',\n\tcolorBlend: 2,\n\tresolution: 1024,\n\ttoneMapped: true,\n};\n\n@Component({\n\tselector: 'ngts-accumulative-shadows',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-group [parameters]=\"parameters()\">\n\t\t\t<ngt-group #lights [traverse]=\"nullTraversal\">\n\t\t\t\t<ng-content />\n\t\t\t</ngt-group>\n\n\t\t\t<ngt-mesh #plane [scale]=\"scale()\" [rotation]=\"[-Math.PI / 2, 0, 0]\" [receiveShadow]=\"true\">\n\t\t\t\t<ngt-plane-geometry />\n\t\t\t\t<ngt-soft-shadow-material\n\t\t\t\t\t[depthWrite]=\"false\"\n\t\t\t\t\t[toneMapped]=\"toneMapped()\"\n\t\t\t\t\t[color]=\"color()\"\n\t\t\t\t\t[blend]=\"colorBlend()\"\n\t\t\t\t\t[map]=\"map()\"\n\t\t\t\t\t[transparent]=\"true\"\n\t\t\t\t/>\n\t\t\t</ngt-mesh>\n\t\t</ngt-group>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class NgtsAccumulativeShadows {\n\tnullTraversal = () => null;\n\tMath = Math;\n\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'temporal',\n\t\t'frames',\n\t\t'limit',\n\t\t'blend',\n\t\t'scale',\n\t\t'opacity',\n\t\t'alphaTest',\n\t\t'color',\n\t\t'colorBlend',\n\t\t'resolution',\n\t\t'toneMapped',\n\t]);\n\n\tlightsRef = viewChild.required<ElementRef<Group>>('lights');\n\tplaneRef = viewChild.required<ElementRef<Mesh<PlaneGeometry, InstanceType<typeof SoftShadowMaterial>>>>('plane');\n\n\tprivate store = injectStore();\n\tprivate gl = this.store.select('gl');\n\tprivate camera = this.store.select('camera');\n\tprivate scene = this.store.select('scene');\n\tprivate invalidate = this.store.select('invalidate');\n\n\tprivate opacity = pick(this.options, 'opacity');\n\tprivate alphaTest = pick(this.options, 'alphaTest');\n\tprivate limit = pick(this.options, 'limit');\n\tprivate resolution = pick(this.options, 'resolution');\n\n\tprivate previousPLM: ProgressiveLightMap | undefined;\n\tprivate pLM = computed(() => {\n\t\tif (this.previousPLM) {\n\t\t\tthis.previousPLM.clear();\n\t\t}\n\t\treturn (this.previousPLM = new ProgressiveLightMap(this.gl(), this.scene(), this.resolution()));\n\t});\n\n\tscale = pick(this.options, 'scale');\n\ttoneMapped = pick(this.options, 'toneMapped');\n\tcolor = pick(this.options, 'color');\n\tcolorBlend = pick(this.options, 'colorBlend');\n\tmap = computed(() => this.pLM().progressiveLightMap2.texture);\n\n\tlightsMap = new Map<string, () => void>();\n\ttemporal = computed(() => !!this.options().temporal);\n\tframes = computed(() => Math.max(2, this.options().frames));\n\tblend = computed(() =>\n\t\tMath.max(2, this.options().frames === Infinity ? this.options().blend : this.options().frames),\n\t);\n\tcount = 0;\n\n\tconstructor() {\n\t\textend({ Group, SoftShadowMaterial, Mesh, PlaneGeometry });\n\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tthis.pLM().configure(this.planeRef().nativeElement);\n\n\t\t\tautoEffect(() => {\n\t\t\t\tconst sceneLS = getLocalState(this.scene());\n\t\t\t\tif (!sceneLS) return;\n\t\t\t\t// track deps\n\t\t\t\tthis.planeRef();\n\t\t\t\tthis.options();\n\t\t\t\tsceneLS.objects();\n\n\t\t\t\t// Reset internals, buffers, ...\n\t\t\t\tthis.reset();\n\t\t\t\t// Update lightmap\n\t\t\t\tif (!this.temporal() && this.frames() !== Infinity) this.update(this.blend());\n\t\t\t});\n\t\t});\n\n\t\tinjectBeforeRender(() => {\n\t\t\tconst [frames, temporal, invalidate, limit] = [this.frames(), !!this.temporal(), this.invalidate(), this.limit()];\n\t\t\tif ((temporal || frames === Infinity) && this.count < frames && this.count < limit) {\n\t\t\t\tinvalidate();\n\t\t\t\tthis.update();\n\t\t\t\tthis.count++;\n\t\t\t}\n\t\t});\n\n\t\tinject(DestroyRef).onDestroy(() => {\n\t\t\tthis.previousPLM?.clear();\n\t\t});\n\t}\n\n\tgetMesh() {\n\t\treturn this.planeRef().nativeElement;\n\t}\n\n\treset() {\n\t\t// Clear buffers, reset opacities, set frame count to 0\n\t\tuntracked(this.pLM).clear();\n\t\tconst material = untracked(this.planeRef).nativeElement.material;\n\t\tmaterial.opacity = 0;\n\t\tmaterial.alphaTest = 0;\n\t\tthis.count = 0;\n\t}\n\n\tupdate(frames = 1) {\n\t\t// Adapt the opacity-blend ratio to the number of frames\n\t\tconst material = this.planeRef().nativeElement.material;\n\t\tif (!this.temporal()) {\n\t\t\tmaterial.opacity = this.opacity();\n\t\t\tmaterial.alphaTest = this.alphaTest();\n\t\t} else {\n\t\t\tmaterial.opacity = Math.min(this.opacity(), material.opacity + this.opacity() / this.blend());\n\t\t\tmaterial.alphaTest = Math.min(this.alphaTest(), material.alphaTest + this.alphaTest() / this.blend());\n\t\t}\n\n\t\t// Switch accumulative lights on\n\t\tthis.lightsRef().nativeElement.visible = true;\n\t\t// Collect scene lights and meshes\n\t\tthis.pLM().prepare();\n\n\t\t// Update the lightmap and the accumulative lights\n\t\tfor (let i = 0; i < frames; i++) {\n\t\t\tthis.lightsMap.forEach((lightUpdate) => lightUpdate());\n\t\t\tthis.pLM().update(this.camera(), this.blend());\n\t\t}\n\t\t// Switch lights off\n\t\tthis.lightsRef().nativeElement.visible = false;\n\t\t// Restore lights and meshes\n\t\tthis.pLM().finish();\n\t}\n}\n"]}

package/esm2022/staging/lib/backdrop.mjs

@@ -0,0 +1,73 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { checkUpdate, extend, NgtArgs, omit, pick } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Group, Mesh, PlaneGeometry } from 'three';
+import * as i0 from "@angular/core";
+function easeInExpo(x) {
+    return x === 0 ? 0 : Math.pow(2, 10 * x - 10);
+}
+const defaultOptions = {
+    floor: 0.25,
+    segments: 20,
+};
+export class NgtsBackdrop {
+    constructor() {
+        this.Math = Math;
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['floor', 'segments', 'receiveShadow']);
+        this.groupRef = viewChild.required('group');
+        this.planeRef = viewChild('plane');
+        this.receiveShadow = pick(this.options, 'receiveShadow');
+        this.segments = pick(this.options, 'segments');
+        this.floor = pick(this.options, 'floor');
+        extend({ Group, Mesh, PlaneGeometry });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const plane = this.planeRef()?.nativeElement;
+                if (!plane)
+                    return;
+                const [segments, floor] = [this.segments(), this.floor()];
+                let i = 0;
+                const offset = segments / segments / 2;
+                const position = plane.attributes['position'];
+                for (let x = 0; x < segments + 1; x++) {
+                    for (let y = 0; y < segments + 1; y++) {
+                        position.setXYZ(i++, x / segments - offset + (x === 0 ? -floor : 0), y / segments - offset, easeInExpo(x / segments));
+                    }
+                }
+                checkUpdate(position);
+                plane.computeVertexNormals();
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBackdrop, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsBackdrop, isStandalone: true, selector: "ngts-backdrop", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "groupRef", first: true, predicate: ["group"], descendants: true, isSignal: true }, { propertyName: "planeRef", first: true, predicate: ["plane"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-mesh [receiveShadow]="receiveShadow()" [rotation]="[-Math.PI / 2, 0, Math.PI / 2]">
+				<ngt-plane-geometry #plane *args="[1, 1, segments(), segments()]" />
+				<ng-content />
+			</ngt-mesh>
+		</ngt-group>
+	`, isInline: true, dependencies: [{ kind: "directive", type: NgtArgs, selector: "ng-template[args]", inputs: ["args"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBackdrop, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-backdrop',
+                    standalone: true,
+                    template: `
+		<ngt-group #group [parameters]="parameters()">
+			<ngt-mesh [receiveShadow]="receiveShadow()" [rotation]="[-Math.PI / 2, 0, Math.PI / 2]">
+				<ngt-plane-geometry #plane *args="[1, 1, segments(), segments()]" />
+				<ng-content />
+			</ngt-mesh>
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFja2Ryb3AuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3NvYmEvc3RhZ2luZy9zcmMvbGliL2JhY2tkcm9wLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTixlQUFlLEVBQ2YsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFDVCxzQkFBc0IsRUFFdEIsS0FBSyxFQUNMLFNBQVMsR0FDVCxNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQVksSUFBSSxFQUFFLElBQUksRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMxRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdkQsT0FBTyxFQUFtQixLQUFLLEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSxNQUFNLE9BQU8sQ0FBQzs7QUFFcEUsU0FBUyxVQUFVLENBQUMsQ0FBUztJQUM1QixPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsRUFBRSxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQztBQUMvQyxDQUFDO0FBUUQsTUFBTSxjQUFjLEdBQXdCO0lBQzNDLEtBQUssRUFBRSxJQUFJO0lBQ1gsUUFBUSxFQUFFLEVBQUU7Q0FDWixDQUFDO0FBaUJGLE1BQU0sT0FBTyxZQUFZO0lBYXhCO1FBWm1CLFNBQUksR0FBRyxJQUFJLENBQUM7UUFFL0IsWUFBTyxHQUFHLEtBQUssQ0FBQyxjQUFjLEVBQUUsRUFBRSxTQUFTLEVBQUUsV0FBVyxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM1RSxlQUFVLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxPQUFPLEVBQUUsVUFBVSxFQUFFLGVBQWUsQ0FBQyxDQUFDLENBQUM7UUFFeEUsYUFBUSxHQUFHLFNBQVMsQ0FBQyxRQUFRLENBQW9CLE9BQU8sQ0FBQyxDQUFDO1FBQzFELGFBQVEsR0FBRyxTQUFTLENBQTRCLE9BQU8sQ0FBQyxDQUFDO1FBRXpELGtCQUFhLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsZUFBZSxDQUFDLENBQUM7UUFDcEQsYUFBUSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ2xDLFVBQUssR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsQ0FBQztRQUczQyxNQUFNLENBQUMsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSxDQUFDLENBQUM7UUFFdkMsTUFBTSxVQUFVLEdBQUcsZ0JBQWdCLEVBQUUsQ0FBQztRQUN0QyxlQUFlLENBQUMsR0FBRyxFQUFFO1lBQ3BCLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQ2YsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLFFBQVEsRUFBRSxFQUFFLGFBQWEsQ0FBQztnQkFDN0MsSUFBSSxDQUFDLEtBQUs7b0JBQUUsT0FBTztnQkFFbkIsTUFBTSxDQUFDLFFBQVEsRUFBRSxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQztnQkFFMUQsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDO2dCQUNWLE1BQU0sTUFBTSxHQUFHLFFBQVEsR0FBRyxRQUFRLEdBQUcsQ0FBQyxDQUFDO2dCQUN2QyxNQUFNLFFBQVEsR0FBRyxLQUFLLENBQUMsVUFBVSxDQUFDLFVBQVUsQ0FBb0IsQ0FBQztnQkFDakUsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFFBQVEsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztvQkFDdkMsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFFBQVEsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQzt3QkFDdkMsUUFBUSxDQUFDLE1BQU0sQ0FDZCxDQUFDLEVBQUUsRUFDSCxDQUFDLEdBQUcsUUFBUSxHQUFHLE1BQU0sR0FBRyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFDOUMsQ0FBQyxHQUFHLFFBQVEsR0FBRyxNQUFNLEVBQ3JCLFVBQVUsQ0FBQyxDQUFDLEdBQUcsUUFBUSxDQUFDLENBQ3hCLENBQUM7b0JBQ0gsQ0FBQztnQkFDRixDQUFDO2dCQUVELFdBQVcsQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDdEIsS0FBSyxDQUFDLG9CQUFvQixFQUFFLENBQUM7WUFDOUIsQ0FBQyxDQUFDLENBQUM7UUFDSixDQUFDLENBQUMsQ0FBQztJQUNKLENBQUM7OEdBMUNXLFlBQVk7a0dBQVosWUFBWSwwYUFaZDs7Ozs7OztFQU9ULDREQUdTLE9BQU87OzJGQUVMLFlBQVk7a0JBZnhCLFNBQVM7bUJBQUM7b0JBQ1YsUUFBUSxFQUFFLGVBQWU7b0JBQ3pCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixRQUFRLEVBQUU7Ozs7Ozs7RUFPVDtvQkFDRCxPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDakMsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07b0JBQy9DLE9BQU8sRUFBRSxDQUFDLE9BQU8sQ0FBQztpQkFDbEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuXHRhZnRlck5leHRSZW5kZXIsXG5cdENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuXHRDb21wb25lbnQsXG5cdENVU1RPTV9FTEVNRU5UU19TQ0hFTUEsXG5cdEVsZW1lbnRSZWYsXG5cdGlucHV0LFxuXHR2aWV3Q2hpbGQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgY2hlY2tVcGRhdGUsIGV4dGVuZCwgTmd0QXJncywgTmd0R3JvdXAsIG9taXQsIHBpY2sgfSBmcm9tICdhbmd1bGFyLXRocmVlJztcbmltcG9ydCB7IGluamVjdEF1dG9FZmZlY3QgfSBmcm9tICduZ3h0ZW5zaW9uL2F1dG8tZWZmZWN0JztcbmltcG9ydCB7IG1lcmdlSW5wdXRzIH0gZnJvbSAnbmd4dGVuc2lvbi9pbmplY3QtaW5wdXRzJztcbmltcG9ydCB7IEJ1ZmZlckF0dHJpYnV0ZSwgR3JvdXAsIE1lc2gsIFBsYW5lR2VvbWV0cnkgfSBmcm9tICd0aHJlZSc7XG5cbmZ1bmN0aW9uIGVhc2VJbkV4cG8oeDogbnVtYmVyKSB7XG5cdHJldHVybiB4ID09PSAwID8gMCA6IE1hdGgucG93KDIsIDEwICogeCAtIDEwKTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBOZ3RzQmFja2Ryb3BPcHRpb25zIGV4dGVuZHMgUGFydGlhbDxOZ3RHcm91cD4ge1xuXHRmbG9vcjogbnVtYmVyO1xuXHRzZWdtZW50czogbnVtYmVyO1xuXHRyZWNlaXZlU2hhZG93PzogYm9vbGVhbjtcbn1cblxuY29uc3QgZGVmYXVsdE9wdGlvbnM6IE5ndHNCYWNrZHJvcE9wdGlvbnMgPSB7XG5cdGZsb29yOiAwLjI1LFxuXHRzZWdtZW50czogMjAsXG59O1xuXG5AQ29tcG9uZW50KHtcblx0c2VsZWN0b3I6ICduZ3RzLWJhY2tkcm9wJyxcblx0c3RhbmRhbG9uZTogdHJ1ZSxcblx0dGVtcGxhdGU6IGBcblx0XHQ8bmd0LWdyb3VwICNncm91cCBbcGFyYW1ldGVyc109XCJwYXJhbWV0ZXJzKClcIj5cblx0XHRcdDxuZ3QtbWVzaCBbcmVjZWl2ZVNoYWRvd109XCJyZWNlaXZlU2hhZG93KClcIiBbcm90YXRpb25dPVwiWy1NYXRoLlBJIC8gMiwgMCwgTWF0aC5QSSAvIDJdXCI+XG5cdFx0XHRcdDxuZ3QtcGxhbmUtZ2VvbWV0cnkgI3BsYW5lICphcmdzPVwiWzEsIDEsIHNlZ21lbnRzKCksIHNlZ21lbnRzKCldXCIgLz5cblx0XHRcdFx0PG5nLWNvbnRlbnQgLz5cblx0XHRcdDwvbmd0LW1lc2g+XG5cdFx0PC9uZ3QtZ3JvdXA+XG5cdGAsXG5cdHNjaGVtYXM6IFtDVVNUT01fRUxFTUVOVFNfU0NIRU1BXSxcblx0Y2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG5cdGltcG9ydHM6IFtOZ3RBcmdzXSxcbn0pXG5leHBvcnQgY2xhc3MgTmd0c0JhY2tkcm9wIHtcblx0cHJvdGVjdGVkIHJlYWRvbmx5IE1hdGggPSBNYXRoO1xuXG5cdG9wdGlvbnMgPSBpbnB1dChkZWZhdWx0T3B0aW9ucywgeyB0cmFuc2Zvcm06IG1lcmdlSW5wdXRzKGRlZmF1bHRPcHRpb25zKSB9KTtcblx0cGFyYW1ldGVycyA9IG9taXQodGhpcy5vcHRpb25zLCBbJ2Zsb29yJywgJ3NlZ21lbnRzJywgJ3JlY2VpdmVTaGFkb3cnXSk7XG5cblx0Z3JvdXBSZWYgPSB2aWV3Q2hpbGQucmVxdWlyZWQ8RWxlbWVudFJlZjxHcm91cD4+KCdncm91cCcpO1xuXHRwbGFuZVJlZiA9IHZpZXdDaGlsZDxFbGVtZW50UmVmPFBsYW5lR2VvbWV0cnk+PigncGxhbmUnKTtcblxuXHRyZWNlaXZlU2hhZG93ID0gcGljayh0aGlzLm9wdGlvbnMsICdyZWNlaXZlU2hhZG93Jyk7XG5cdHNlZ21lbnRzID0gcGljayh0aGlzLm9wdGlvbnMsICdzZWdtZW50cycpO1xuXHRwcml2YXRlIGZsb29yID0gcGljayh0aGlzLm9wdGlvbnMsICdmbG9vcicpO1xuXG5cdGNvbnN0cnVjdG9yKCkge1xuXHRcdGV4dGVuZCh7IEdyb3VwLCBNZXNoLCBQbGFuZUdlb21ldHJ5IH0pO1xuXG5cdFx0Y29uc3QgYXV0b0VmZmVjdCA9IGluamVjdEF1dG9FZmZlY3QoKTtcblx0XHRhZnRlck5leHRSZW5kZXIoKCkgPT4ge1xuXHRcdFx0YXV0b0VmZmVjdCgoKSA9PiB7XG5cdFx0XHRcdGNvbnN0IHBsYW5lID0gdGhpcy5wbGFuZVJlZigpPy5uYXRpdmVFbGVtZW50O1xuXHRcdFx0XHRpZiAoIXBsYW5lKSByZXR1cm47XG5cblx0XHRcdFx0Y29uc3QgW3NlZ21lbnRzLCBmbG9vcl0gPSBbdGhpcy5zZWdtZW50cygpLCB0aGlzLmZsb29yKCldO1xuXG5cdFx0XHRcdGxldCBpID0gMDtcblx0XHRcdFx0Y29uc3Qgb2Zmc2V0ID0gc2VnbWVudHMgLyBzZWdtZW50cyAvIDI7XG5cdFx0XHRcdGNvbnN0IHBvc2l0aW9uID0gcGxhbmUuYXR0cmlidXRlc1sncG9zaXRpb24nXSBhcyBCdWZmZXJBdHRyaWJ1dGU7XG5cdFx0XHRcdGZvciAobGV0IHggPSAwOyB4IDwgc2VnbWVudHMgKyAxOyB4KyspIHtcblx0XHRcdFx0XHRmb3IgKGxldCB5ID0gMDsgeSA8IHNlZ21lbnRzICsgMTsgeSsrKSB7XG5cdFx0XHRcdFx0XHRwb3NpdGlvbi5zZXRYWVooXG5cdFx0XHRcdFx0XHRcdGkrKyxcblx0XHRcdFx0XHRcdFx0eCAvIHNlZ21lbnRzIC0gb2Zmc2V0ICsgKHggPT09IDAgPyAtZmxvb3IgOiAwKSxcblx0XHRcdFx0XHRcdFx0eSAvIHNlZ21lbnRzIC0gb2Zmc2V0LFxuXHRcdFx0XHRcdFx0XHRlYXNlSW5FeHBvKHggLyBzZWdtZW50cyksXG5cdFx0XHRcdFx0XHQpO1xuXHRcdFx0XHRcdH1cblx0XHRcdFx0fVxuXG5cdFx0XHRcdGNoZWNrVXBkYXRlKHBvc2l0aW9uKTtcblx0XHRcdFx0cGxhbmUuY29tcHV0ZVZlcnRleE5vcm1hbHMoKTtcblx0XHRcdH0pO1xuXHRcdH0pO1xuXHR9XG59XG4iXX0=

package/esm2022/staging/lib/bb-anchor.mjs

@@ -0,0 +1,58 @@
+import { CUSTOM_ELEMENTS_SCHEMA, ChangeDetectionStrategy, Component, afterNextRender, input, signal, viewChild, } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, omit, vector3 } from 'angular-three';
+import { Box3, Group, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+const boundingBox = new Box3();
+const boundingBoxSize = new Vector3();
+export class NgtsBBAnchor {
+    constructor() {
+        this.options = input.required();
+        this.parameters = omit(this.options, ['anchor']);
+        this.bbAnchorRef = viewChild.required('bbAnchor');
+        this.parent = signal(null);
+        this.anchor = vector3(this.options, 'anchor');
+        extend({ Group });
+        // Reattach group created by this component to the parent's parent,
+        // so it becomes a sibling of its initial parent.
+        // We do that so the children have no impact on a bounding box of a parent.
+        afterNextRender(() => {
+            const bbAnchorLS = getLocalState(this.bbAnchorRef().nativeElement);
+            const bbAnchorParent = bbAnchorLS?.parent();
+            if (bbAnchorParent?.parent) {
+                this.parent.set(bbAnchorParent);
+                bbAnchorParent.parent.add(this.bbAnchorRef().nativeElement);
+            }
+        });
+        injectBeforeRender(() => {
+            const parent = this.parent();
+            if (parent) {
+                boundingBox.setFromObject(parent);
+                boundingBox.getSize(boundingBoxSize);
+                const anchor = this.anchor();
+                const bbAnchor = this.bbAnchorRef().nativeElement;
+                bbAnchor.position.set(parent.position.x + (boundingBoxSize.x * anchor.x) / 2, parent.position.y + (boundingBoxSize.y * anchor.y) / 2, parent.position.z + (boundingBoxSize.z * anchor.z) / 2);
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBBAnchor, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.0", type: NgtsBBAnchor, isStandalone: true, selector: "ngts-bb-anchor", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "bbAnchorRef", first: true, predicate: ["bbAnchor"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-group #bbAnchor [parameters]="parameters()">
+			<ng-content />
+		</ngt-group>
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.0", ngImport: i0, type: NgtsBBAnchor, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-bb-anchor',
+                    standalone: true,
+                    template: `
+		<ngt-group #bbAnchor [parameters]="parameters()">
+			<ng-content />
+		</ngt-group>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmItYW5jaG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zb2JhL3N0YWdpbmcvc3JjL2xpYi9iYi1hbmNob3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNOLHNCQUFzQixFQUN0Qix1QkFBdUIsRUFDdkIsU0FBUyxFQUVULGVBQWUsRUFDZixLQUFLLEVBQ0wsTUFBTSxFQUNOLFNBQVMsR0FDVCxNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQXdCLE1BQU0sRUFBRSxhQUFhLEVBQUUsa0JBQWtCLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMvRyxPQUFPLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBWSxPQUFPLEVBQUUsTUFBTSxPQUFPLENBQUM7O0FBRXZELE1BQU0sV0FBVyxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7QUFDL0IsTUFBTSxlQUFlLEdBQUcsSUFBSSxPQUFPLEVBQUUsQ0FBQztBQWlCdEMsTUFBTSxPQUFPLFlBQVk7SUFTeEI7UUFSQSxZQUFPLEdBQUcsS0FBSyxDQUFDLFFBQVEsRUFBdUIsQ0FBQztRQUNoRCxlQUFVLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO1FBRTVDLGdCQUFXLEdBQUcsU0FBUyxDQUFDLFFBQVEsQ0FBb0IsVUFBVSxDQUFDLENBQUM7UUFFaEUsV0FBTSxHQUFHLE1BQU0sQ0FBa0IsSUFBSSxDQUFDLENBQUM7UUFDL0IsV0FBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBR2hELE1BQU0sQ0FBQyxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7UUFFbEIsbUVBQW1FO1FBQ25FLGlEQUFpRDtRQUNqRCwyRUFBMkU7UUFDM0UsZUFBZSxDQUFDLEdBQUcsRUFBRTtZQUNwQixNQUFNLFVBQVUsR0FBRyxhQUFhLENBQUMsSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBQ25FLE1BQU0sY0FBYyxHQUFHLFVBQVUsRUFBRSxNQUFNLEVBQUUsQ0FBQztZQUM1QyxJQUFJLGNBQWMsRUFBRSxNQUFNLEVBQUUsQ0FBQztnQkFDNUIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7Z0JBQ2hDLGNBQWMsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQyxhQUFhLENBQUMsQ0FBQztZQUM3RCxDQUFDO1FBQ0YsQ0FBQyxDQUFDLENBQUM7UUFFSCxrQkFBa0IsQ0FBQyxHQUFHLEVBQUU7WUFDdkIsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQzdCLElBQUksTUFBTSxFQUFFLENBQUM7Z0JBQ1osV0FBVyxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztnQkFDbEMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxlQUFlLENBQUMsQ0FBQztnQkFFckMsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO2dCQUM3QixNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUMsYUFBYSxDQUFDO2dCQUVsRCxRQUFRLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FDcEIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFDLEVBQ3RELE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxHQUFHLENBQUMsZUFBZSxDQUFDLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxFQUN0RCxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsR0FBRyxDQUFDLGVBQWUsQ0FBQyxDQUFDLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FDdEQsQ0FBQztZQUNILENBQUM7UUFDRixDQUFDLENBQUMsQ0FBQztJQUNKLENBQUM7OEdBeENXLFlBQVk7a0dBQVosWUFBWSw0VUFSZDs7OztFQUlUOzsyRkFJVyxZQUFZO2tCQVh4QixTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxnQkFBZ0I7b0JBQzFCLFVBQVUsRUFBRSxJQUFJO29CQUNoQixRQUFRLEVBQUU7Ozs7RUFJVDtvQkFDRCxPQUFPLEVBQUUsQ0FBQyxzQkFBc0IsQ0FBQztvQkFDakMsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07aUJBQy9DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcblx0Q1VTVE9NX0VMRU1FTlRTX1NDSEVNQSxcblx0Q2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG5cdENvbXBvbmVudCxcblx0RWxlbWVudFJlZixcblx0YWZ0ZXJOZXh0UmVuZGVyLFxuXHRpbnB1dCxcblx0c2lnbmFsLFxuXHR2aWV3Q2hpbGQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTmd0R3JvdXAsIE5ndFZlY3RvcjMsIGV4dGVuZCwgZ2V0TG9jYWxTdGF0ZSwgaW5qZWN0QmVmb3JlUmVuZGVyLCBvbWl0LCB2ZWN0b3IzIH0gZnJvbSAnYW5ndWxhci10aHJlZSc7XG5pbXBvcnQgeyBCb3gzLCBHcm91cCwgT2JqZWN0M0QsIFZlY3RvcjMgfSBmcm9tICd0aHJlZSc7XG5cbmNvbnN0IGJvdW5kaW5nQm94ID0gbmV3IEJveDMoKTtcbmNvbnN0IGJvdW5kaW5nQm94U2l6ZSA9IG5ldyBWZWN0b3IzKCk7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmd0c0JCQW5jaG9yT3B0aW9ucyBleHRlbmRzIFBhcnRpYWw8Tmd0R3JvdXA+IHtcblx0YW5jaG9yOiBOZ3RWZWN0b3IzO1xufVxuXG5AQ29tcG9uZW50KHtcblx0c2VsZWN0b3I6ICduZ3RzLWJiLWFuY2hvcicsXG5cdHN0YW5kYWxvbmU6IHRydWUsXG5cdHRlbXBsYXRlOiBgXG5cdFx0PG5ndC1ncm91cCAjYmJBbmNob3IgW3BhcmFtZXRlcnNdPVwicGFyYW1ldGVycygpXCI+XG5cdFx0XHQ8bmctY29udGVudCAvPlxuXHRcdDwvbmd0LWdyb3VwPlxuXHRgLFxuXHRzY2hlbWFzOiBbQ1VTVE9NX0VMRU1FTlRTX1NDSEVNQV0sXG5cdGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxufSlcbmV4cG9ydCBjbGFzcyBOZ3RzQkJBbmNob3Ige1xuXHRvcHRpb25zID0gaW5wdXQucmVxdWlyZWQ8Tmd0c0JCQW5jaG9yT3B0aW9ucz4oKTtcblx0cGFyYW1ldGVycyA9IG9taXQodGhpcy5vcHRpb25zLCBbJ2FuY2hvciddKTtcblxuXHRiYkFuY2hvclJlZiA9IHZpZXdDaGlsZC5yZXF1aXJlZDxFbGVtZW50UmVmPEdyb3VwPj4oJ2JiQW5jaG9yJyk7XG5cblx0cGFyZW50ID0gc2lnbmFsPE9iamVjdDNEIHwgbnVsbD4obnVsbCk7XG5cdHByaXZhdGUgYW5jaG9yID0gdmVjdG9yMyh0aGlzLm9wdGlvbnMsICdhbmNob3InKTtcblxuXHRjb25zdHJ1Y3RvcigpIHtcblx0XHRleHRlbmQoeyBHcm91cCB9KTtcblxuXHRcdC8vIFJlYXR0YWNoIGdyb3VwIGNyZWF0ZWQgYnkgdGhpcyBjb21wb25lbnQgdG8gdGhlIHBhcmVudCdzIHBhcmVudCxcblx0XHQvLyBzbyBpdCBiZWNvbWVzIGEgc2libGluZyBvZiBpdHMgaW5pdGlhbCBwYXJlbnQuXG5cdFx0Ly8gV2UgZG8gdGhhdCBzbyB0aGUgY2hpbGRyZW4gaGF2ZSBubyBpbXBhY3Qgb24gYSBib3VuZGluZyBib3ggb2YgYSBwYXJlbnQuXG5cdFx0YWZ0ZXJOZXh0UmVuZGVyKCgpID0+IHtcblx0XHRcdGNvbnN0IGJiQW5jaG9yTFMgPSBnZXRMb2NhbFN0YXRlKHRoaXMuYmJBbmNob3JSZWYoKS5uYXRpdmVFbGVtZW50KTtcblx0XHRcdGNvbnN0IGJiQW5jaG9yUGFyZW50ID0gYmJBbmNob3JMUz8ucGFyZW50KCk7XG5cdFx0XHRpZiAoYmJBbmNob3JQYXJlbnQ/LnBhcmVudCkge1xuXHRcdFx0XHR0aGlzLnBhcmVudC5zZXQoYmJBbmNob3JQYXJlbnQpO1xuXHRcdFx0XHRiYkFuY2hvclBhcmVudC5wYXJlbnQuYWRkKHRoaXMuYmJBbmNob3JSZWYoKS5uYXRpdmVFbGVtZW50KTtcblx0XHRcdH1cblx0XHR9KTtcblxuXHRcdGluamVjdEJlZm9yZVJlbmRlcigoKSA9PiB7XG5cdFx0XHRjb25zdCBwYXJlbnQgPSB0aGlzLnBhcmVudCgpO1xuXHRcdFx0aWYgKHBhcmVudCkge1xuXHRcdFx0XHRib3VuZGluZ0JveC5zZXRGcm9tT2JqZWN0KHBhcmVudCk7XG5cdFx0XHRcdGJvdW5kaW5nQm94LmdldFNpemUoYm91bmRpbmdCb3hTaXplKTtcblxuXHRcdFx0XHRjb25zdCBhbmNob3IgPSB0aGlzLmFuY2hvcigpO1xuXHRcdFx0XHRjb25zdCBiYkFuY2hvciA9IHRoaXMuYmJBbmNob3JSZWYoKS5uYXRpdmVFbGVtZW50O1xuXG5cdFx0XHRcdGJiQW5jaG9yLnBvc2l0aW9uLnNldChcblx0XHRcdFx0XHRwYXJlbnQucG9zaXRpb24ueCArIChib3VuZGluZ0JveFNpemUueCAqIGFuY2hvci54KSAvIDIsXG5cdFx0XHRcdFx0cGFyZW50LnBvc2l0aW9uLnkgKyAoYm91bmRpbmdCb3hTaXplLnkgKiBhbmNob3IueSkgLyAyLFxuXHRcdFx0XHRcdHBhcmVudC5wb3NpdGlvbi56ICsgKGJvdW5kaW5nQm94U2l6ZS56ICogYW5jaG9yLnopIC8gMixcblx0XHRcdFx0KTtcblx0XHRcdH1cblx0XHR9KTtcblx0fVxufVxuIl19