angular-three-soba 2.0.0-beta.26 → 2.0.0-beta.261

package/esm2022/abstractions/lib/grid.mjs

@@ -0,0 +1,103 @@
+import { ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { extend, injectBeforeRender, NgtArgs, omit, pick } from 'angular-three';
+import { GridMaterial } from 'angular-three-soba/shaders';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { BackSide, Mesh, Plane, PlaneGeometry, Vector3 } from 'three';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    planeArgs: [],
+    cellSize: 0.5,
+    cellThickness: 0.5,
+    cellColor: 'black',
+    sectionSize: 1,
+    sectionThickness: 1,
+    sectionColor: '#2080ff',
+    infiniteGrid: false,
+    followCamera: false,
+    fadeDistance: 100,
+    fadeStrength: 1,
+    fadeFrom: 1,
+    side: BackSide,
+};
+export class NgtsGrid {
+    constructor() {
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'planeArgs',
+            'cellSize',
+            'cellThickness',
+            'cellColor',
+            'sectionSize',
+            'sectionThickness',
+            'sectionColor',
+            'infiniteGrid',
+            'followCamera',
+            'fadeDistance',
+            'fadeStrength',
+            'fadeFrom',
+            'side',
+        ]);
+        this.mesh = viewChild.required('mesh');
+        this.plane = new Plane();
+        this.upVector = new Vector3(0, 1, 0);
+        this.zeroVector = new Vector3(0, 0, 0);
+        this.planeArgs = pick(this.options, 'planeArgs');
+        this.side = pick(this.options, 'side');
+        this.uniforms = computed(() => {
+            const { cellSize, sectionSize, cellColor, sectionColor, cellThickness, sectionThickness, fadeDistance, fadeStrength, fadeFrom, infiniteGrid, followCamera, } = this.options();
+            return {
+                cellSize,
+                sectionSize,
+                cellColor,
+                sectionColor,
+                cellThickness,
+                sectionThickness,
+                fadeDistance,
+                fadeStrength,
+                fadeFrom,
+                infiniteGrid,
+                followCamera,
+            };
+        });
+        extend({ Mesh, PlaneGeometry, GridMaterial });
+        injectBeforeRender(({ camera }) => {
+            const mesh = this.mesh().nativeElement;
+            this.plane.setFromNormalAndCoplanarPoint(this.upVector, this.zeroVector).applyMatrix4(mesh.matrixWorld);
+            const gridMaterial = mesh.material;
+            const worldCamProjPosition = gridMaterial.uniforms['worldCamProjPosition'];
+            const worldPlanePosition = gridMaterial.uniforms['worldPlanePosition'];
+            this.plane.projectPoint(camera.position, worldCamProjPosition.value);
+            worldPlanePosition.value.set(0, 0, 0).applyMatrix4(mesh.matrixWorld);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsGrid, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsGrid, isStandalone: true, selector: "ngts-grid", inputs: { options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "mesh", first: true, predicate: ["mesh"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-mesh #mesh [frustumCulled]="false" [parameters]="parameters()">
+			<ngt-plane-geometry *args="planeArgs()" />
+			<ngt-grid-material [transparent]="true" [side]="side()" [parameters]="uniforms()">
+				<ngt-value attach="extensions.derivatives" [rawValue]="true" />
+			</ngt-grid-material>
+			<ng-content />
+		</ngt-mesh>
+	`, 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.1.0", ngImport: i0, type: NgtsGrid, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-grid',
+                    standalone: true,
+                    template: `
+		<ngt-mesh #mesh [frustumCulled]="false" [parameters]="parameters()">
+			<ngt-plane-geometry *args="planeArgs()" />
+			<ngt-grid-material [transparent]="true" [side]="side()" [parameters]="uniforms()">
+				<ngt-value attach="extensions.derivatives" [rawValue]="true" />
+			</ngt-grid-material>
+			<ng-content />
+		</ngt-mesh>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/lib/grid.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinput,\n\tviewChild,\n} from '@angular/core';\nimport { extend, injectBeforeRender, NgtArgs, NgtMesh, omit, pick } from 'angular-three';\nimport { GridMaterial, GridMaterialOptions } from 'angular-three-soba/shaders';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { BackSide, Mesh, Plane, PlaneGeometry, ShaderMaterial, Uniform, Vector3 } from 'three';\n\nconst defaultOptions: Partial<NgtMesh> &\n\tGridMaterialOptions & { planeArgs: ConstructorParameters<typeof PlaneGeometry> } = {\n\tplaneArgs: [],\n\tcellSize: 0.5,\n\tcellThickness: 0.5,\n\tcellColor: 'black',\n\tsectionSize: 1,\n\tsectionThickness: 1,\n\tsectionColor: '#2080ff',\n\tinfiniteGrid: false,\n\tfollowCamera: false,\n\tfadeDistance: 100,\n\tfadeStrength: 1,\n\tfadeFrom: 1,\n\tside: BackSide,\n};\n\n@Component({\n\tselector: 'ngts-grid',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-mesh #mesh [frustumCulled]=\"false\" [parameters]=\"parameters()\">\n\t\t\t<ngt-plane-geometry *args=\"planeArgs()\" />\n\t\t\t<ngt-grid-material [transparent]=\"true\" [side]=\"side()\" [parameters]=\"uniforms()\">\n\t\t\t\t<ngt-value attach=\"extensions.derivatives\" [rawValue]=\"true\" />\n\t\t\t</ngt-grid-material>\n\t\t\t<ng-content />\n\t\t</ngt-mesh>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtArgs],\n})\nexport class NgtsGrid {\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, [\n\t\t'planeArgs',\n\t\t'cellSize',\n\t\t'cellThickness',\n\t\t'cellColor',\n\t\t'sectionSize',\n\t\t'sectionThickness',\n\t\t'sectionColor',\n\t\t'infiniteGrid',\n\t\t'followCamera',\n\t\t'fadeDistance',\n\t\t'fadeStrength',\n\t\t'fadeFrom',\n\t\t'side',\n\t]);\n\n\tmesh = viewChild.required<ElementRef<Mesh>>('mesh');\n\n\tprivate plane = new Plane();\n\tprivate upVector = new Vector3(0, 1, 0);\n\tprivate zeroVector = new Vector3(0, 0, 0);\n\n\tplaneArgs = pick(this.options, 'planeArgs');\n\tside = pick(this.options, 'side');\n\tuniforms = computed(() => {\n\t\tconst {\n\t\t\tcellSize,\n\t\t\tsectionSize,\n\t\t\tcellColor,\n\t\t\tsectionColor,\n\t\t\tcellThickness,\n\t\t\tsectionThickness,\n\t\t\tfadeDistance,\n\t\t\tfadeStrength,\n\t\t\tfadeFrom,\n\t\t\tinfiniteGrid,\n\t\t\tfollowCamera,\n\t\t} = this.options();\n\t\treturn {\n\t\t\tcellSize,\n\t\t\tsectionSize,\n\t\t\tcellColor,\n\t\t\tsectionColor,\n\t\t\tcellThickness,\n\t\t\tsectionThickness,\n\t\t\tfadeDistance,\n\t\t\tfadeStrength,\n\t\t\tfadeFrom,\n\t\t\tinfiniteGrid,\n\t\t\tfollowCamera,\n\t\t};\n\t});\n\n\tconstructor() {\n\t\textend({ Mesh, PlaneGeometry, GridMaterial });\n\n\t\tinjectBeforeRender(({ camera }) => {\n\t\t\tconst mesh = this.mesh().nativeElement;\n\n\t\t\tthis.plane.setFromNormalAndCoplanarPoint(this.upVector, this.zeroVector).applyMatrix4(mesh.matrixWorld);\n\n\t\t\tconst gridMaterial = mesh.material as ShaderMaterial;\n\t\t\tconst worldCamProjPosition = gridMaterial.uniforms['worldCamProjPosition'] as Uniform<Vector3>;\n\t\t\tconst worldPlanePosition = gridMaterial.uniforms['worldPlanePosition'] as Uniform<Vector3>;\n\n\t\t\tthis.plane.projectPoint(camera.position, worldCamProjPosition.value);\n\t\t\tworldPlanePosition.value.set(0, 0, 0).applyMatrix4(mesh.matrixWorld);\n\t\t});\n\t}\n}\n"]}

package/esm2022/abstractions/lib/helper.mjs

@@ -0,0 +1,80 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, signal, untracked, viewChild, } from '@angular/core';
+import { extend, getLocalState, injectBeforeRender, injectStore, resolveRef } from 'angular-three';
+import { assertInjector } from 'ngxtension/assert-injector';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { Object3D } from 'three';
+import * as i0 from "@angular/core";
+export function injectHelper(object, helperConstructor, { injector, args = () => [], } = {}) {
+    return assertInjector(injectHelper, injector, () => {
+        const autoEffect = injectAutoEffect();
+        const store = injectStore();
+        const scene = store.select('scene');
+        const helper = signal(null);
+        afterNextRender(() => {
+            autoEffect(() => {
+                let currentHelper = undefined;
+                const maybeObject3D = object();
+                if (!maybeObject3D)
+                    return;
+                const object3D = resolveRef(maybeObject3D);
+                if (!object3D)
+                    return;
+                currentHelper = new (helperConstructor())(object3D, ...args());
+                if (!currentHelper)
+                    return;
+                untracked(() => {
+                    helper.set(currentHelper);
+                });
+                // Prevent the helpers from blocking rays
+                currentHelper.traverse((child) => (child.raycast = () => null));
+                scene().add(currentHelper);
+                return () => {
+                    helper.set(null);
+                    scene().remove(currentHelper);
+                    currentHelper.dispose?.();
+                };
+            });
+        });
+        injectBeforeRender(() => {
+            const currentHelper = helper();
+            if (currentHelper)
+                currentHelper.update();
+        });
+        return helper.asReadonly();
+    });
+}
+export class NgtsHelper {
+    constructor() {
+        this.type = input.required();
+        this.options = input([]);
+        this.helperRef = viewChild.required('helper');
+        this.parent = computed(() => {
+            const helper = this.helperRef().nativeElement;
+            if (!helper)
+                return;
+            const localState = getLocalState(helper);
+            if (!localState)
+                return;
+            return localState.parent();
+        });
+        this.helper = injectHelper(this.parent, this.type, { args: this.options });
+        extend({ Object3D });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsHelper, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsHelper, isStandalone: true, selector: "ngts-helper", inputs: { type: { classPropertyName: "type", publicName: "type", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "helperRef", first: true, predicate: ["helper"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-object-3D #helper />
+	`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsHelper, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'ngts-helper',
+                    template: `
+		<ngt-object-3D #helper />
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9zb2JhL2Fic3RyYWN0aW9ucy9zcmMvbGliL2hlbHBlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ04sZUFBZSxFQUNmLHVCQUF1QixFQUN2QixTQUFTLEVBQ1QsUUFBUSxFQUNSLHNCQUFzQixFQUd0QixLQUFLLEVBQ0wsTUFBTSxFQUNOLFNBQVMsRUFDVCxTQUFTLEdBQ1QsTUFBTSxlQUFlLENBQUM7QUFDdkIsT0FBTyxFQUFFLE1BQU0sRUFBRSxhQUFhLEVBQUUsa0JBQWtCLEVBQUUsV0FBVyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNuRyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDNUQsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDMUQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLE9BQU8sQ0FBQzs7QUFJakMsTUFBTSxVQUFVLFlBQVksQ0FJM0IsTUFBZ0UsRUFDaEUsaUJBQXFDLEVBQ3JDLEVBQ0MsUUFBUSxFQUNSLElBQUksR0FBRyxHQUFHLEVBQUUsQ0FBQyxFQUF5QyxNQUNhLEVBQUU7SUFFdEUsT0FBTyxjQUFjLENBQUMsWUFBWSxFQUFFLFFBQVEsRUFBRSxHQUFHLEVBQUU7UUFDbEQsTUFBTSxVQUFVLEdBQUcsZ0JBQWdCLEVBQUUsQ0FBQztRQUN0QyxNQUFNLEtBQUssR0FBRyxXQUFXLEVBQUUsQ0FBQztRQUM1QixNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBRXBDLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBeUIsSUFBSSxDQUFDLENBQUM7UUFFcEQsZUFBZSxDQUFDLEdBQUcsRUFBRTtZQUNwQixVQUFVLENBQUMsR0FBRyxFQUFFO2dCQUNmLElBQUksYUFBYSxHQUFnQyxTQUFTLENBQUM7Z0JBQzNELE1BQU0sYUFBYSxHQUFHLE1BQU0sRUFBRSxDQUFDO2dCQUMvQixJQUFJLENBQUMsYUFBYTtvQkFBRSxPQUFPO2dCQUUzQixNQUFNLFFBQVEsR0FBRyxVQUFVLENBQUMsYUFBYSxDQUFDLENBQUM7Z0JBQzNDLElBQUksQ0FBQyxRQUFRO29CQUFFLE9BQU87Z0JBRXRCLGFBQWEsR0FBRyxLQUFLLGlCQUFpQixFQUFVLEVBQUMsUUFBUSxFQUFFLEdBQUcsSUFBSSxFQUFFLENBQUMsQ0FBQztnQkFDdEUsSUFBSSxDQUFDLGFBQWE7b0JBQUUsT0FBTztnQkFFM0IsU0FBUyxDQUFDLEdBQUcsRUFBRTtvQkFDZCxNQUFNLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDO2dCQUMzQixDQUFDLENBQUMsQ0FBQztnQkFFSCx5Q0FBeUM7Z0JBQ3pDLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUMsS0FBSyxDQUFDLE9BQU8sR0FBRyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO2dCQUNoRSxLQUFLLEVBQUUsQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLENBQUM7Z0JBRTNCLE9BQU8sR0FBRyxFQUFFO29CQUNYLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUM7b0JBQ2pCLEtBQUssRUFBRSxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztvQkFDOUIsYUFBYSxDQUFDLE9BQU8sRUFBRSxFQUFFLENBQUM7Z0JBQzNCLENBQUMsQ0FBQztZQUNILENBQUMsQ0FBQyxDQUFDO1FBQ0osQ0FBQyxDQUFDLENBQUM7UUFFSCxrQkFBa0IsQ0FBQyxHQUFHLEVBQUU7WUFDdkIsTUFBTSxhQUFhLEdBQUcsTUFBTSxFQUFFLENBQUM7WUFDL0IsSUFBSSxhQUFhO2dCQUFFLGFBQWEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUMzQyxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sTUFBTSxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQzVCLENBQUMsQ0FBQyxDQUFDO0FBQ0osQ0FBQztBQVdELE1BQU0sT0FBTyxVQUFVO0lBZ0J0QjtRQWZBLFNBQUksR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFnQixDQUFDO1FBQ3RDLFlBQU8sR0FBRyxLQUFLLENBQTJCLEVBQXlDLENBQUMsQ0FBQztRQUVyRixjQUFTLEdBQUcsU0FBUyxDQUFDLFFBQVEsQ0FBdUIsUUFBUSxDQUFDLENBQUM7UUFFdkQsV0FBTSxHQUFHLFFBQVEsQ0FBQyxHQUFHLEVBQUU7WUFDOUIsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLFNBQVMsRUFBRSxDQUFDLGFBQWEsQ0FBQztZQUM5QyxJQUFJLENBQUMsTUFBTTtnQkFBRSxPQUFPO1lBQ3BCLE1BQU0sVUFBVSxHQUFHLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztZQUN6QyxJQUFJLENBQUMsVUFBVTtnQkFBRSxPQUFPO1lBQ3hCLE9BQU8sVUFBVSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQzVCLENBQUMsQ0FBQyxDQUFDO1FBRUgsV0FBTSxHQUFHLFlBQVksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7UUFHckUsTUFBTSxDQUFDLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztJQUN0QixDQUFDOzhHQWxCVyxVQUFVO2tHQUFWLFVBQVUsMGJBTlo7O0VBRVQ7OzJGQUlXLFVBQVU7a0JBVHRCLFNBQVM7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLElBQUk7b0JBQ2hCLFFBQVEsRUFBRSxhQUFhO29CQUN2QixRQUFRLEVBQUU7O0VBRVQ7b0JBQ0QsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ2pDLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUMvQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG5cdGFmdGVyTmV4dFJlbmRlcixcblx0Q2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG5cdENvbXBvbmVudCxcblx0Y29tcHV0ZWQsXG5cdENVU1RPTV9FTEVNRU5UU19TQ0hFTUEsXG5cdEVsZW1lbnRSZWYsXG5cdEluamVjdG9yLFxuXHRpbnB1dCxcblx0c2lnbmFsLFxuXHR1bnRyYWNrZWQsXG5cdHZpZXdDaGlsZCxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBleHRlbmQsIGdldExvY2FsU3RhdGUsIGluamVjdEJlZm9yZVJlbmRlciwgaW5qZWN0U3RvcmUsIHJlc29sdmVSZWYgfSBmcm9tICdhbmd1bGFyLXRocmVlJztcbmltcG9ydCB7IGFzc2VydEluamVjdG9yIH0gZnJvbSAnbmd4dGVuc2lvbi9hc3NlcnQtaW5qZWN0b3InO1xuaW1wb3J0IHsgaW5qZWN0QXV0b0VmZmVjdCB9IGZyb20gJ25neHRlbnNpb24vYXV0by1lZmZlY3QnO1xuaW1wb3J0IHsgT2JqZWN0M0QgfSBmcm9tICd0aHJlZSc7XG5cbnR5cGUgSGVscGVyQXJnczxUPiA9IFQgZXh0ZW5kcyBbaW5mZXIgXywgLi4uaW5mZXIgUl0gPyBSIDogbmV2ZXI7XG5cbmV4cG9ydCBmdW5jdGlvbiBpbmplY3RIZWxwZXI8XG5cdFRDb25zdHJ1Y3RvciBleHRlbmRzIG5ldyAoLi4uYXJnczogYW55W10pID0+IE9iamVjdDNELFxuXHRUSGVscGVySW5zdGFuY2UgZXh0ZW5kcyBJbnN0YW5jZVR5cGU8VENvbnN0cnVjdG9yPiAmIHsgdXBkYXRlOiAoKSA9PiB2b2lkOyBkaXNwb3NlOiAoKSA9PiB2b2lkIH0sXG4+KFxuXHRvYmplY3Q6ICgpID0+IEVsZW1lbnRSZWY8T2JqZWN0M0Q+IHwgT2JqZWN0M0QgfCB1bmRlZmluZWQgfCBudWxsLFxuXHRoZWxwZXJDb25zdHJ1Y3RvcjogKCkgPT4gVENvbnN0cnVjdG9yLFxuXHR7XG5cdFx0aW5qZWN0b3IsXG5cdFx0YXJncyA9ICgpID0+IFtdIGFzIHVua25vd24gYXMgSGVscGVyQXJnczxUQ29uc3RydWN0b3I+LFxuXHR9OiB7IGluamVjdG9yPzogSW5qZWN0b3I7IGFyZ3M/OiAoKSA9PiBIZWxwZXJBcmdzPFRDb25zdHJ1Y3Rvcj4gfSA9IHt9LFxuKSB7XG5cdHJldHVybiBhc3NlcnRJbmplY3RvcihpbmplY3RIZWxwZXIsIGluamVjdG9yLCAoKSA9PiB7XG5cdFx0Y29uc3QgYXV0b0VmZmVjdCA9IGluamVjdEF1dG9FZmZlY3QoKTtcblx0XHRjb25zdCBzdG9yZSA9IGluamVjdFN0b3JlKCk7XG5cdFx0Y29uc3Qgc2NlbmUgPSBzdG9yZS5zZWxlY3QoJ3NjZW5lJyk7XG5cblx0XHRjb25zdCBoZWxwZXIgPSBzaWduYWw8VEhlbHBlckluc3RhbmNlIHwgbnVsbD4obnVsbCk7XG5cblx0XHRhZnRlck5leHRSZW5kZXIoKCkgPT4ge1xuXHRcdFx0YXV0b0VmZmVjdCgoKSA9PiB7XG5cdFx0XHRcdGxldCBjdXJyZW50SGVscGVyOiBUSGVscGVySW5zdGFuY2UgfCB1bmRlZmluZWQgPSB1bmRlZmluZWQ7XG5cdFx0XHRcdGNvbnN0IG1heWJlT2JqZWN0M0QgPSBvYmplY3QoKTtcblx0XHRcdFx0aWYgKCFtYXliZU9iamVjdDNEKSByZXR1cm47XG5cblx0XHRcdFx0Y29uc3Qgb2JqZWN0M0QgPSByZXNvbHZlUmVmKG1heWJlT2JqZWN0M0QpO1xuXHRcdFx0XHRpZiAoIW9iamVjdDNEKSByZXR1cm47XG5cblx0XHRcdFx0Y3VycmVudEhlbHBlciA9IG5ldyAoaGVscGVyQ29uc3RydWN0b3IoKSBhcyBhbnkpKG9iamVjdDNELCAuLi5hcmdzKCkpO1xuXHRcdFx0XHRpZiAoIWN1cnJlbnRIZWxwZXIpIHJldHVybjtcblxuXHRcdFx0XHR1bnRyYWNrZWQoKCkgPT4ge1xuXHRcdFx0XHRcdGhlbHBlci5zZXQoY3VycmVudEhlbHBlcik7XG5cdFx0XHRcdH0pO1xuXG5cdFx0XHRcdC8vIFByZXZlbnQgdGhlIGhlbHBlcnMgZnJvbSBibG9ja2luZyByYXlzXG5cdFx0XHRcdGN1cnJlbnRIZWxwZXIudHJhdmVyc2UoKGNoaWxkKSA9PiAoY2hpbGQucmF5Y2FzdCA9ICgpID0+IG51bGwpKTtcblx0XHRcdFx0c2NlbmUoKS5hZGQoY3VycmVudEhlbHBlcik7XG5cblx0XHRcdFx0cmV0dXJuICgpID0+IHtcblx0XHRcdFx0XHRoZWxwZXIuc2V0KG51bGwpO1xuXHRcdFx0XHRcdHNjZW5lKCkucmVtb3ZlKGN1cnJlbnRIZWxwZXIpO1xuXHRcdFx0XHRcdGN1cnJlbnRIZWxwZXIuZGlzcG9zZT8uKCk7XG5cdFx0XHRcdH07XG5cdFx0XHR9KTtcblx0XHR9KTtcblxuXHRcdGluamVjdEJlZm9yZVJlbmRlcigoKSA9PiB7XG5cdFx0XHRjb25zdCBjdXJyZW50SGVscGVyID0gaGVscGVyKCk7XG5cdFx0XHRpZiAoY3VycmVudEhlbHBlcikgY3VycmVudEhlbHBlci51cGRhdGUoKTtcblx0XHR9KTtcblxuXHRcdHJldHVybiBoZWxwZXIuYXNSZWFkb25seSgpO1xuXHR9KTtcbn1cblxuQENvbXBvbmVudCh7XG5cdHN0YW5kYWxvbmU6IHRydWUsXG5cdHNlbGVjdG9yOiAnbmd0cy1oZWxwZXInLFxuXHR0ZW1wbGF0ZTogYFxuXHRcdDxuZ3Qtb2JqZWN0LTNEICNoZWxwZXIgLz5cblx0YCxcblx0c2NoZW1hczogW0NVU1RPTV9FTEVNRU5UU19TQ0hFTUFdLFxuXHRjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbn0pXG5leHBvcnQgY2xhc3MgTmd0c0hlbHBlcjxUQ29uc3RydWN0b3IgZXh0ZW5kcyBuZXcgKC4uLmFyZ3M6IGFueVtdKSA9PiBPYmplY3QzRD4ge1xuXHR0eXBlID0gaW5wdXQucmVxdWlyZWQ8VENvbnN0cnVjdG9yPigpO1xuXHRvcHRpb25zID0gaW5wdXQ8SGVscGVyQXJnczxUQ29uc3RydWN0b3I+PihbXSBhcyB1bmtub3duIGFzIEhlbHBlckFyZ3M8VENvbnN0cnVjdG9yPik7XG5cblx0aGVscGVyUmVmID0gdmlld0NoaWxkLnJlcXVpcmVkPEVsZW1lbnRSZWY8T2JqZWN0M0Q+PignaGVscGVyJyk7XG5cblx0cHJpdmF0ZSBwYXJlbnQgPSBjb21wdXRlZCgoKSA9PiB7XG5cdFx0Y29uc3QgaGVscGVyID0gdGhpcy5oZWxwZXJSZWYoKS5uYXRpdmVFbGVtZW50O1xuXHRcdGlmICghaGVscGVyKSByZXR1cm47XG5cdFx0Y29uc3QgbG9jYWxTdGF0ZSA9IGdldExvY2FsU3RhdGUoaGVscGVyKTtcblx0XHRpZiAoIWxvY2FsU3RhdGUpIHJldHVybjtcblx0XHRyZXR1cm4gbG9jYWxTdGF0ZS5wYXJlbnQoKTtcblx0fSk7XG5cblx0aGVscGVyID0gaW5qZWN0SGVscGVyKHRoaXMucGFyZW50LCB0aGlzLnR5cGUsIHsgYXJnczogdGhpcy5vcHRpb25zIH0pO1xuXG5cdGNvbnN0cnVjdG9yKCkge1xuXHRcdGV4dGVuZCh7IE9iamVjdDNEIH0pO1xuXHR9XG59XG4iXX0=

package/esm2022/abstractions/lib/line.mjs

@@ -0,0 +1,123 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { checkNeedsUpdate, injectStore, NgtArgs, omit, pick } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Color, Vector2, Vector3, Vector4 } from 'three';
+import { Line2, LineGeometry, LineMaterial, LineSegments2, LineSegmentsGeometry, } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    lineWidth: 1,
+    segments: false,
+    color: 0xffffff,
+};
+export class NgtsLine {
+    // NOTE: use attached event to call computeLineDistances to ensure the geometry has been attached
+    onGeometryAttached({ parent }) {
+        parent.computeLineDistances();
+    }
+    constructor() {
+        this.points = input.required();
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['color', 'vertexColors', 'lineWidth', 'segments', 'linewidth', 'dashed']);
+        this.line = viewChild('line');
+        this.store = injectStore();
+        this.size = this.store.select('size');
+        this.segments = pick(this.options, 'segments');
+        this.vertexColors = pick(this.options, 'vertexColors');
+        this.dashed = pick(this.options, 'dashed');
+        this.color = pick(this.options, 'color');
+        this.lineWidth = pick(this.options, 'lineWidth');
+        this.linewidth = pick(this.options, 'linewidth');
+        this.vertex = computed(() => Boolean(this.vertexColors()));
+        this.resolution = computed(() => [this.size().width, this.size().height]);
+        this.line2 = computed(() => (this.segments() ? new LineSegments2() : new Line2()));
+        this.lineMaterial = computed(() => new LineMaterial());
+        this.itemSize = computed(() => (this.vertexColors()?.[0]?.length === 4 ? 4 : 3));
+        this.lineGeometry = computed(() => {
+            const geom = this.segments() ? new LineSegmentsGeometry() : new LineGeometry();
+            const pValues = this.points().map((p) => {
+                const isArray = Array.isArray(p);
+                return p instanceof Vector3 || p instanceof Vector4
+                    ? [p.x, p.y, p.z]
+                    : p instanceof Vector2
+                        ? [p.x, p.y, 0]
+                        : isArray && p.length === 3
+                            ? [p[0], p[1], p[2]]
+                            : isArray && p.length === 2
+                                ? [p[0], p[1], 0]
+                                : p;
+            });
+            geom.setPositions(pValues.flat());
+            const vertexColors = this.vertexColors();
+            if (vertexColors) {
+                const cValues = vertexColors.map((c) => (c instanceof Color ? c.toArray() : c));
+                // @ts-expect-error - flat() isn't defined
+                geom.setColors(cValues.flat(), this.itemSize());
+            }
+            return geom;
+        });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const [lineMaterial, dashed] = [this.lineMaterial(), this.dashed()];
+                if (dashed) {
+                    lineMaterial.defines['USE_DASH'] = '';
+                }
+                else {
+                    delete lineMaterial.defines['USE_DASH'];
+                }
+                checkNeedsUpdate(lineMaterial);
+            });
+            autoEffect(() => {
+                const lineGeometry = this.lineGeometry();
+                return () => lineGeometry.dispose();
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsLine, isStandalone: true, selector: "ngts-line", inputs: { points: { classPropertyName: "points", publicName: "points", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "line", first: true, predicate: ["line"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-primitive *args="[line2()]" #line [parameters]="parameters()">
+			<ngt-primitive *args="[lineGeometry()]" attach="geometry" (attached)="onGeometryAttached($any($event))" />
+			<ngt-primitive
+				*args="[lineMaterial()]"
+				attach="material"
+				[color]="color()"
+				[vertexColors]="vertex()"
+				[resolution]="resolution()"
+				[linewidth]="linewidth() ?? lineWidth() ?? 1"
+				[dashed]="dashed()"
+				[transparent]="itemSize() === 4"
+				[parameters]="parameters()"
+			/>
+			<ng-content />
+		</ngt-primitive>
+	`, 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.1.0", ngImport: i0, type: NgtsLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-line',
+                    standalone: true,
+                    template: `
+		<ngt-primitive *args="[line2()]" #line [parameters]="parameters()">
+			<ngt-primitive *args="[lineGeometry()]" attach="geometry" (attached)="onGeometryAttached($any($event))" />
+			<ngt-primitive
+				*args="[lineMaterial()]"
+				attach="material"
+				[color]="color()"
+				[vertexColors]="vertex()"
+				[resolution]="resolution()"
+				[linewidth]="linewidth() ?? lineWidth() ?? 1"
+				[dashed]="dashed()"
+				[transparent]="itemSize() === 4"
+				[parameters]="parameters()"
+			/>
+			<ng-content />
+		</ngt-primitive>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"line.js","sourceRoot":"","sources":["../../../../../../libs/soba/abstractions/src/lib/line.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n\tafterNextRender,\n\tChangeDetectionStrategy,\n\tComponent,\n\tcomputed,\n\tCUSTOM_ELEMENTS_SCHEMA,\n\tElementRef,\n\tinput,\n\tviewChild,\n} from '@angular/core';\nimport { checkNeedsUpdate, injectStore, NgtAfterAttach, NgtArgs, NgtObject3DNode, omit, pick } from 'angular-three';\nimport { injectAutoEffect } from 'ngxtension/auto-effect';\nimport { mergeInputs } from 'ngxtension/inject-inputs';\nimport { Color, ColorRepresentation, Vector2, Vector3, Vector4 } from 'three';\nimport {\n\tLine2,\n\tLineGeometry,\n\tLineMaterial,\n\tLineMaterialParameters,\n\tLineSegments2,\n\tLineSegmentsGeometry,\n} from 'three-stdlib';\n\nexport type NgtLine2 = NgtObject3DNode<Line2, typeof Line2>;\nexport type NgtLineMaterial = NgtObject3DNode<LineMaterial, [LineMaterialParameters]>;\n\nexport type NgtsLineOptions = Omit<LineMaterialParameters, 'vertexColors' | 'color'> &\n\tOmit<Partial<NgtLine2>, '__ngt_args__'> &\n\tOmit<Partial<NgtLineMaterial>, 'color' | 'vertexColors' | '__ngt_args__'> & {\n\t\t/** Array of colors, [0, 0, 0] */\n\t\tvertexColors?: Array<ColorRepresentation | [number, number, number] | [number, number, number, number]>;\n\t\t/** Line width, 1 */\n\t\tlineWidth: number;\n\t\t/** Segments, false */\n\t\tsegments: boolean;\n\t\t/** Color */\n\t\tcolor?: ColorRepresentation;\n\t};\n\nconst defaultOptions: NgtsLineOptions = {\n\tlineWidth: 1,\n\tsegments: false,\n\tcolor: 0xffffff,\n};\n\n@Component({\n\tselector: 'ngts-line',\n\tstandalone: true,\n\ttemplate: `\n\t\t<ngt-primitive *args=\"[line2()]\" #line [parameters]=\"parameters()\">\n\t\t\t<ngt-primitive *args=\"[lineGeometry()]\" attach=\"geometry\" (attached)=\"onGeometryAttached($any($event))\" />\n\t\t\t<ngt-primitive\n\t\t\t\t*args=\"[lineMaterial()]\"\n\t\t\t\tattach=\"material\"\n\t\t\t\t[color]=\"color()\"\n\t\t\t\t[vertexColors]=\"vertex()\"\n\t\t\t\t[resolution]=\"resolution()\"\n\t\t\t\t[linewidth]=\"linewidth() ?? lineWidth() ?? 1\"\n\t\t\t\t[dashed]=\"dashed()\"\n\t\t\t\t[transparent]=\"itemSize() === 4\"\n\t\t\t\t[parameters]=\"parameters()\"\n\t\t\t/>\n\t\t\t<ng-content />\n\t\t</ngt-primitive>\n\t`,\n\tschemas: [CUSTOM_ELEMENTS_SCHEMA],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n\timports: [NgtArgs],\n})\nexport class NgtsLine {\n\tpoints = input.required<Array<Vector3 | Vector2 | [number, number, number] | [number, number] | number>>();\n\toptions = input(defaultOptions, { transform: mergeInputs(defaultOptions) });\n\tparameters = omit(this.options, ['color', 'vertexColors', 'lineWidth', 'segments', 'linewidth', 'dashed']);\n\n\tline = viewChild<ElementRef<Line2 | LineSegments2>>('line');\n\n\tprivate store = injectStore();\n\tprivate size = this.store.select('size');\n\n\tprivate segments = pick(this.options, 'segments');\n\tprivate vertexColors = pick(this.options, 'vertexColors');\n\n\tdashed = pick(this.options, 'dashed');\n\tcolor = pick(this.options, 'color');\n\tlineWidth = pick(this.options, 'lineWidth');\n\tlinewidth = pick(this.options, 'linewidth');\n\tvertex = computed(() => Boolean(this.vertexColors()));\n\tresolution = computed(() => [this.size().width, this.size().height]);\n\n\tline2 = computed(() => (this.segments() ? new LineSegments2() : new Line2()));\n\tlineMaterial = computed(() => new LineMaterial());\n\n\titemSize = computed(() => ((this.vertexColors()?.[0] as number[] | undefined)?.length === 4 ? 4 : 3));\n\n\tlineGeometry = computed(() => {\n\t\tconst geom = this.segments() ? new LineSegmentsGeometry() : new LineGeometry();\n\t\tconst pValues = this.points().map((p) => {\n\t\t\tconst isArray = Array.isArray(p);\n\t\t\treturn p instanceof Vector3 || p instanceof Vector4\n\t\t\t\t? [p.x, p.y, p.z]\n\t\t\t\t: p instanceof Vector2\n\t\t\t\t\t? [p.x, p.y, 0]\n\t\t\t\t\t: isArray && p.length === 3\n\t\t\t\t\t\t? [p[0], p[1], p[2]]\n\t\t\t\t\t\t: isArray && p.length === 2\n\t\t\t\t\t\t\t? [p[0], p[1], 0]\n\t\t\t\t\t\t\t: p;\n\t\t});\n\n\t\tgeom.setPositions(pValues.flat());\n\n\t\tconst vertexColors = this.vertexColors();\n\n\t\tif (vertexColors) {\n\t\t\tconst cValues = vertexColors.map((c) => (c instanceof Color ? c.toArray() : c));\n\t\t\t// @ts-expect-error - flat() isn't defined\n\t\t\tgeom.setColors(cValues.flat(), this.itemSize());\n\t\t}\n\n\t\treturn geom;\n\t});\n\n\t// NOTE: use attached event to call computeLineDistances to ensure the geometry has been attached\n\tonGeometryAttached({ parent }: NgtAfterAttach<LineGeometry, Line2 | LineSegments2>) {\n\t\tparent.computeLineDistances();\n\t}\n\n\tconstructor() {\n\t\tconst autoEffect = injectAutoEffect();\n\n\t\tafterNextRender(() => {\n\t\t\tautoEffect(() => {\n\t\t\t\tconst [lineMaterial, dashed] = [this.lineMaterial(), this.dashed()];\n\t\t\t\tif (dashed) {\n\t\t\t\t\tlineMaterial.defines['USE_DASH'] = '';\n\t\t\t\t} else {\n\t\t\t\t\tdelete lineMaterial.defines['USE_DASH'];\n\t\t\t\t}\n\t\t\t\tcheckNeedsUpdate(lineMaterial);\n\t\t\t});\n\n\t\t\tautoEffect(() => {\n\t\t\t\tconst lineGeometry = this.lineGeometry();\n\t\t\t\treturn () => lineGeometry.dispose();\n\t\t\t});\n\t\t});\n\t}\n}\n"]}

package/esm2022/abstractions/lib/prism-geometry.mjs

@@ -0,0 +1,55 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { extend, NgtArgs } from 'angular-three';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { ExtrudeGeometry, Shape, Vector2 } from 'three';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    height: 1,
+    bevelEnabled: false,
+};
+export class NgtsPrismGeometry {
+    constructor() {
+        this.vertices = input.required();
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = computed(() => ({ ...this.options(), depth: this.options().height }));
+        this.shape = computed(() => {
+            const vertices = this.vertices();
+            const interpolatedVertices = vertices.map((v) => (v instanceof Vector2 ? v : new Vector2(...v)));
+            return new Shape(interpolatedVertices);
+        });
+        this.geometry = viewChild('geometry');
+        extend({ ExtrudeGeometry });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            // autoEffect(() => {
+            // 	const geometry = this.geometry()?.nativeElement;
+            // 	if (!geometry) return;
+            //
+            // 	geometry.center();
+            // });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsPrismGeometry, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsPrismGeometry, isStandalone: true, selector: "ngts-prism-geometry", inputs: { vertices: { classPropertyName: "vertices", publicName: "vertices", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "geometry", first: true, predicate: ["geometry"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-extrude-geometry #geometry *args="[shape(), parameters()]">
+			<ng-content />
+		</ngt-extrude-geometry>
+	`, 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.1.0", ngImport: i0, type: NgtsPrismGeometry, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-prism-geometry',
+                    standalone: true,
+                    template: `
+		<ngt-extrude-geometry #geometry *args="[shape(), parameters()]">
+			<ng-content />
+		</ngt-extrude-geometry>
+	`,
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtArgs],
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abstractions/lib/quadratic-bezier-line.mjs

@@ -0,0 +1,73 @@
+import { ChangeDetectionStrategy, Component, computed, input, viewChild } from '@angular/core';
+import { omit, pick } from 'angular-three';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { QuadraticBezierCurve3, Vector3 } from 'three';
+import { NgtsLine } from './line';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    lineWidth: 1,
+    segments: 20,
+};
+export class NgtsQuadraticBezierLine {
+    constructor() {
+        this.start = input([0, 0, 0]);
+        this.end = input([0, 0, 0]);
+        this.mid = input();
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, ['segments']);
+        this.segments = pick(this.options, 'segments');
+        this.line = viewChild.required(NgtsLine);
+        this.points = computed(() => this.getPoints(this.start(), this.end(), this.mid(), this.segments()));
+        this.curve = new QuadraticBezierCurve3();
+    }
+    setPoints(start, end, mid) {
+        const points = this.getPoints(start, end, mid);
+        const geometry = this.line().lineGeometry();
+        if (geometry)
+            geometry.setPositions(points.map((p) => p.toArray()).flat());
+    }
+    getPoints(start, end, mid, segments = 20) {
+        if (start instanceof Vector3)
+            this.curve.v0.copy(start);
+        else
+            this.curve.v0.set(...start);
+        if (end instanceof Vector3)
+            this.curve.v2.copy(end);
+        else
+            this.curve.v2.set(...end);
+        if (mid instanceof Vector3) {
+            this.curve.v1.copy(mid);
+        }
+        else if (Array.isArray(mid)) {
+            this.curve.v1.set(...mid);
+        }
+        else {
+            this.curve.v1.copy(this.curve.v0
+                .clone()
+                .add(this.curve.v2.clone().sub(this.curve.v0))
+                .add(new Vector3(0, this.curve.v0.y - this.curve.v2.y, 0)));
+        }
+        return this.curve.getPoints(segments);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsQuadraticBezierLine, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsQuadraticBezierLine, isStandalone: true, selector: "ngts-quadratic-bezier-line", inputs: { start: { classPropertyName: "start", publicName: "start", isSignal: true, isRequired: false, transformFunction: null }, end: { classPropertyName: "end", publicName: "end", isSignal: true, isRequired: false, transformFunction: null }, mid: { classPropertyName: "mid", publicName: "mid", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "line", first: true, predicate: NgtsLine, descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngts-line [points]="points()" [options]="parameters()">
+			<ng-content />
+		</ngts-line>
+	`, isInline: true, dependencies: [{ kind: "component", type: NgtsLine, selector: "ngts-line", inputs: ["points", "options"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsQuadraticBezierLine, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-quadratic-bezier-line',
+                    standalone: true,
+                    template: `
+		<ngts-line [points]="points()" [options]="parameters()">
+			<ng-content />
+		</ngts-line>
+	`,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    imports: [NgtsLine],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/abstractions/lib/text-3d.mjs

@@ -0,0 +1,98 @@
+import { afterNextRender, ChangeDetectionStrategy, Component, computed, CUSTOM_ELEMENTS_SCHEMA, input, viewChild, } from '@angular/core';
+import { extend, NgtArgs, omit, pick } from 'angular-three';
+import { injectFont } from 'angular-three-soba/loaders';
+import { injectAutoEffect } from 'ngxtension/auto-effect';
+import { mergeInputs } from 'ngxtension/inject-inputs';
+import { Mesh } from 'three';
+import { mergeVertices, TextGeometry } from 'three-stdlib';
+import * as i0 from "@angular/core";
+const defaultOptions = {
+    letterSpacing: 0,
+    lineHeight: 1,
+    size: 1,
+    height: 0.2,
+    bevelThickness: 0.1,
+    bevelSize: 0.01,
+    bevelEnabled: false,
+    bevelOffset: 0,
+    bevelSegments: 4,
+    curveSegments: 8,
+};
+export class NgtsText3D {
+    constructor() {
+        this.font = input.required();
+        this.text = input.required();
+        this.options = input(defaultOptions, { transform: mergeInputs(defaultOptions) });
+        this.parameters = omit(this.options, [
+            'letterSpacing',
+            'lineHeight',
+            'size',
+            'height',
+            'bevelThickness',
+            'bevelSize',
+            'bevelEnabled',
+            'bevelOffset',
+            'bevelSegments',
+            'curveSegments',
+            'smooth',
+        ]);
+        this.mesh = viewChild('mesh');
+        this.loadedFont = injectFont(this.font);
+        this.smooth = pick(this.options, 'smooth');
+        this.textOptions = pick(this.options, [
+            'letterSpacing',
+            'lineHeight',
+            'size',
+            'height',
+            'bevelThickness',
+            'bevelSize',
+            'bevelEnabled',
+            'bevelOffset',
+            'bevelSegments',
+            'curveSegments',
+        ]);
+        this.textArgs = computed(() => {
+            const [text, font, textOptions] = [this.text(), this.loadedFont(), this.textOptions()];
+            if (!font)
+                return null;
+            return [text, { font, ...textOptions }];
+        });
+        extend({ Mesh, TextGeometry });
+        const autoEffect = injectAutoEffect();
+        afterNextRender(() => {
+            autoEffect(() => {
+                const [mesh, smooth, textArgs] = [this.mesh()?.nativeElement, this.smooth(), this.textArgs()];
+                if (!textArgs || !mesh)
+                    return;
+                if (smooth) {
+                    mesh.geometry = mergeVertices(mesh.geometry, smooth);
+                    mesh.geometry.computeVertexNormals();
+                }
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.0", ngImport: i0, type: NgtsText3D, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.1.0", type: NgtsText3D, isStandalone: true, selector: "ngts-text-3d", inputs: { font: { classPropertyName: "font", publicName: "font", isSignal: true, isRequired: true, transformFunction: null }, text: { classPropertyName: "text", publicName: "text", isSignal: true, isRequired: true, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, viewQueries: [{ propertyName: "mesh", first: true, predicate: ["mesh"], descendants: true, isSignal: true }], ngImport: i0, template: `
+		<ngt-mesh #mesh [parameters]="parameters()">
+			<ngt-text-geometry *args="textArgs()" />
+			<ng-content />
+		</ngt-mesh>
+	`, 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.1.0", ngImport: i0, type: NgtsText3D, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ngts-text-3d',
+                    standalone: true,
+                    template: `
+		<ngt-mesh #mesh [parameters]="parameters()">
+			<ngt-text-geometry *args="textArgs()" />
+			<ng-content />
+		</ngt-mesh>
+	`,
+                    imports: [NgtArgs],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGV4dC0zZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvc29iYS9hYnN0cmFjdGlvbnMvc3JjL2xpYi90ZXh0LTNkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTixlQUFlLEVBQ2YsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFDVCxRQUFRLEVBQ1Isc0JBQXNCLEVBRXRCLEtBQUssRUFDTCxTQUFTLEdBQ1QsTUFBTSxlQUFlLENBQUM7QUFDdkIsT0FBTyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQVcsSUFBSSxFQUFFLElBQUksRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUNyRSxPQUFPLEVBQUUsVUFBVSxFQUFpQixNQUFNLDRCQUE0QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzFELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sT0FBTyxDQUFDO0FBQzdCLE9BQU8sRUFBRSxhQUFhLEVBQUUsWUFBWSxFQUEwQixNQUFNLGNBQWMsQ0FBQzs7QUFPbkYsTUFBTSxjQUFjLEdBQXlDO0lBQzVELGFBQWEsRUFBRSxDQUFDO0lBQ2hCLFVBQVUsRUFBRSxDQUFDO0lBQ2IsSUFBSSxFQUFFLENBQUM7SUFDUCxNQUFNLEVBQUUsR0FBRztJQUNYLGNBQWMsRUFBRSxHQUFHO0lBQ25CLFNBQVMsRUFBRSxJQUFJO0lBQ2YsWUFBWSxFQUFFLEtBQUs7SUFDbkIsV0FBVyxFQUFFLENBQUM7SUFDZCxhQUFhLEVBQUUsQ0FBQztJQUNoQixhQUFhLEVBQUUsQ0FBQztDQUNoQixDQUFDO0FBZUYsTUFBTSxPQUFPLFVBQVU7SUF5Q3RCO1FBeENBLFNBQUksR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFpQixDQUFDO1FBQ3ZDLFNBQUksR0FBRyxLQUFLLENBQUMsUUFBUSxFQUFVLENBQUM7UUFDaEMsWUFBTyxHQUFHLEtBQUssQ0FBQyxjQUFjLEVBQUUsRUFBRSxTQUFTLEVBQUUsV0FBVyxDQUFDLGNBQWMsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM1RSxlQUFVLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUU7WUFDL0IsZUFBZTtZQUNmLFlBQVk7WUFDWixNQUFNO1lBQ04sUUFBUTtZQUNSLGdCQUFnQjtZQUNoQixXQUFXO1lBQ1gsY0FBYztZQUNkLGFBQWE7WUFDYixlQUFlO1lBQ2YsZUFBZTtZQUNmLFFBQVE7U0FDUixDQUFDLENBQUM7UUFFSCxTQUFJLEdBQUcsU0FBUyxDQUFtQixNQUFNLENBQUMsQ0FBQztRQUUzQyxlQUFVLEdBQUcsVUFBVSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMzQixXQUFNLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFDdEMsZ0JBQVcsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRTtZQUN4QyxlQUFlO1lBQ2YsWUFBWTtZQUNaLE1BQU07WUFDTixRQUFRO1lBQ1IsZ0JBQWdCO1lBQ2hCLFdBQVc7WUFDWCxjQUFjO1lBQ2QsYUFBYTtZQUNiLGVBQWU7WUFDZixlQUFlO1NBQ2YsQ0FBQyxDQUFDO1FBRUgsYUFBUSxHQUFHLFFBQVEsQ0FBQyxHQUFHLEVBQUU7WUFDeEIsTUFBTSxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEVBQUUsSUFBSSxDQUFDLFVBQVUsRUFBRSxFQUFFLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDO1lBQ3ZGLElBQUksQ0FBQyxJQUFJO2dCQUFFLE9BQU8sSUFBSSxDQUFDO1lBQ3ZCLE9BQU8sQ0FBQyxJQUFJLEVBQUUsRUFBRSxJQUFJLEVBQUUsR0FBRyxXQUFXLEVBQUUsQ0FBQyxDQUFDO1FBQ3pDLENBQUMsQ0FBQyxDQUFDO1FBR0YsTUFBTSxDQUFDLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSxDQUFDLENBQUM7UUFFL0IsTUFBTSxVQUFVLEdBQUcsZ0JBQWdCLEVBQUUsQ0FBQztRQUV0QyxlQUFlLENBQUMsR0FBRyxFQUFFO1lBQ3BCLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQ2YsTUFBTSxDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsUUFBUSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLEVBQUUsYUFBYSxFQUFFLElBQUksQ0FBQyxNQUFNLEVBQUUsRUFBRSxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQztnQkFDOUYsSUFBSSxDQUFDLFFBQVEsSUFBSSxDQUFDLElBQUk7b0JBQUUsT0FBTztnQkFDL0IsSUFBSSxNQUFNLEVBQUUsQ0FBQztvQkFDWixJQUFJLENBQUMsUUFBUSxHQUFHLGFBQWEsQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxDQUFDO29CQUNyRCxJQUFJLENBQUMsUUFBUSxDQUFDLG9CQUFvQixFQUFFLENBQUM7Z0JBQ3RDLENBQUM7WUFDRixDQUFDLENBQUMsQ0FBQztRQUNKLENBQUMsQ0FBQyxDQUFDO0lBQ0osQ0FBQzs4R0F4RFcsVUFBVTtrR0FBVixVQUFVLHdpQkFWWjs7Ozs7RUFLVCw0REFDUyxPQUFPOzsyRkFJTCxVQUFVO2tCQWJ0QixTQUFTO21CQUFDO29CQUNWLFFBQVEsRUFBRSxjQUFjO29CQUN4QixVQUFVLEVBQUUsSUFBSTtvQkFDaEIsUUFBUSxFQUFFOzs7OztFQUtUO29CQUNELE9BQU8sRUFBRSxDQUFDLE9BQU8sQ0FBQztvQkFDbEIsT0FBTyxFQUFFLENBQUMsc0JBQXNCLENBQUM7b0JBQ2pDLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2lCQUMvQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG5cdGFmdGVyTmV4dFJlbmRlcixcblx0Q2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG5cdENvbXBvbmVudCxcblx0Y29tcHV0ZWQsXG5cdENVU1RPTV9FTEVNRU5UU19TQ0hFTUEsXG5cdEVsZW1lbnRSZWYsXG5cdGlucHV0LFxuXHR2aWV3Q2hpbGQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgZXh0ZW5kLCBOZ3RBcmdzLCBOZ3RNZXNoLCBvbWl0LCBwaWNrIH0gZnJvbSAnYW5ndWxhci10aHJlZSc7XG5pbXBvcnQgeyBpbmplY3RGb250LCBOZ3RzRm9udElucHV0IH0gZnJvbSAnYW5ndWxhci10aHJlZS1zb2JhL2xvYWRlcnMnO1xuaW1wb3J0IHsgaW5qZWN0QXV0b0VmZmVjdCB9IGZyb20gJ25neHRlbnNpb24vYXV0by1lZmZlY3QnO1xuaW1wb3J0IHsgbWVyZ2VJbnB1dHMgfSBmcm9tICduZ3h0ZW5zaW9uL2luamVjdC1pbnB1dHMnO1xuaW1wb3J0IHsgTWVzaCB9IGZyb20gJ3RocmVlJztcbmltcG9ydCB7IG1lcmdlVmVydGljZXMsIFRleHRHZW9tZXRyeSwgVGV4dEdlb21ldHJ5UGFyYW1ldGVycyB9IGZyb20gJ3RocmVlLXN0ZGxpYic7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmd0c1RleHQzRE9wdGlvbnMgZXh0ZW5kcyBPbWl0PFRleHRHZW9tZXRyeVBhcmFtZXRlcnMsICdmb250Jz4ge1xuXHRiZXZlbFNlZ21lbnRzOiBudW1iZXI7XG5cdHNtb290aD86IG51bWJlcjtcbn1cblxuY29uc3QgZGVmYXVsdE9wdGlvbnM6IFBhcnRpYWw8Tmd0TWVzaD4gJiBOZ3RzVGV4dDNET3B0aW9ucyA9IHtcblx0bGV0dGVyU3BhY2luZzogMCxcblx0bGluZUhlaWdodDogMSxcblx0c2l6ZTogMSxcblx0aGVpZ2h0OiAwLjIsXG5cdGJldmVsVGhpY2tuZXNzOiAwLjEsXG5cdGJldmVsU2l6ZTogMC4wMSxcblx0YmV2ZWxFbmFibGVkOiBmYWxzZSxcblx0YmV2ZWxPZmZzZXQ6IDAsXG5cdGJldmVsU2VnbWVudHM6IDQsXG5cdGN1cnZlU2VnbWVudHM6IDgsXG59O1xuXG5AQ29tcG9uZW50KHtcblx0c2VsZWN0b3I6ICduZ3RzLXRleHQtM2QnLFxuXHRzdGFuZGFsb25lOiB0cnVlLFxuXHR0ZW1wbGF0ZTogYFxuXHRcdDxuZ3QtbWVzaCAjbWVzaCBbcGFyYW1ldGVyc109XCJwYXJhbWV0ZXJzKClcIj5cblx0XHRcdDxuZ3QtdGV4dC1nZW9tZXRyeSAqYXJncz1cInRleHRBcmdzKClcIiAvPlxuXHRcdFx0PG5nLWNvbnRlbnQgLz5cblx0XHQ8L25ndC1tZXNoPlxuXHRgLFxuXHRpbXBvcnRzOiBbTmd0QXJnc10sXG5cdHNjaGVtYXM6IFtDVVNUT01fRUxFTUVOVFNfU0NIRU1BXSxcblx0Y2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG59KVxuZXhwb3J0IGNsYXNzIE5ndHNUZXh0M0Qge1xuXHRmb250ID0gaW5wdXQucmVxdWlyZWQ8Tmd0c0ZvbnRJbnB1dD4oKTtcblx0dGV4dCA9IGlucHV0LnJlcXVpcmVkPHN0cmluZz4oKTtcblx0b3B0aW9ucyA9IGlucHV0KGRlZmF1bHRPcHRpb25zLCB7IHRyYW5zZm9ybTogbWVyZ2VJbnB1dHMoZGVmYXVsdE9wdGlvbnMpIH0pO1xuXHRwYXJhbWV0ZXJzID0gb21pdCh0aGlzLm9wdGlvbnMsIFtcblx0XHQnbGV0dGVyU3BhY2luZycsXG5cdFx0J2xpbmVIZWlnaHQnLFxuXHRcdCdzaXplJyxcblx0XHQnaGVpZ2h0Jyxcblx0XHQnYmV2ZWxUaGlja25lc3MnLFxuXHRcdCdiZXZlbFNpemUnLFxuXHRcdCdiZXZlbEVuYWJsZWQnLFxuXHRcdCdiZXZlbE9mZnNldCcsXG5cdFx0J2JldmVsU2VnbWVudHMnLFxuXHRcdCdjdXJ2ZVNlZ21lbnRzJyxcblx0XHQnc21vb3RoJyxcblx0XSk7XG5cblx0bWVzaCA9IHZpZXdDaGlsZDxFbGVtZW50UmVmPE1lc2g+PignbWVzaCcpO1xuXG5cdGxvYWRlZEZvbnQgPSBpbmplY3RGb250KHRoaXMuZm9udCk7XG5cdHByaXZhdGUgc21vb3RoID0gcGljayh0aGlzLm9wdGlvbnMsICdzbW9vdGgnKTtcblx0cHJpdmF0ZSB0ZXh0T3B0aW9ucyA9IHBpY2sodGhpcy5vcHRpb25zLCBbXG5cdFx0J2xldHRlclNwYWNpbmcnLFxuXHRcdCdsaW5lSGVpZ2h0Jyxcblx0XHQnc2l6ZScsXG5cdFx0J2hlaWdodCcsXG5cdFx0J2JldmVsVGhpY2tuZXNzJyxcblx0XHQnYmV2ZWxTaXplJyxcblx0XHQnYmV2ZWxFbmFibGVkJyxcblx0XHQnYmV2ZWxPZmZzZXQnLFxuXHRcdCdiZXZlbFNlZ21lbnRzJyxcblx0XHQnY3VydmVTZWdtZW50cycsXG5cdF0pO1xuXG5cdHRleHRBcmdzID0gY29tcHV0ZWQoKCkgPT4ge1xuXHRcdGNvbnN0IFt0ZXh0LCBmb250LCB0ZXh0T3B0aW9uc10gPSBbdGhpcy50ZXh0KCksIHRoaXMubG9hZGVkRm9udCgpLCB0aGlzLnRleHRPcHRpb25zKCldO1xuXHRcdGlmICghZm9udCkgcmV0dXJuIG51bGw7XG5cdFx0cmV0dXJuIFt0ZXh0LCB7IGZvbnQsIC4uLnRleHRPcHRpb25zIH1dO1xuXHR9KTtcblxuXHRjb25zdHJ1Y3RvcigpIHtcblx0XHRleHRlbmQoeyBNZXNoLCBUZXh0R2VvbWV0cnkgfSk7XG5cblx0XHRjb25zdCBhdXRvRWZmZWN0ID0gaW5qZWN0QXV0b0VmZmVjdCgpO1xuXG5cdFx0YWZ0ZXJOZXh0UmVuZGVyKCgpID0+IHtcblx0XHRcdGF1dG9FZmZlY3QoKCkgPT4ge1xuXHRcdFx0XHRjb25zdCBbbWVzaCwgc21vb3RoLCB0ZXh0QXJnc10gPSBbdGhpcy5tZXNoKCk/Lm5hdGl2ZUVsZW1lbnQsIHRoaXMuc21vb3RoKCksIHRoaXMudGV4dEFyZ3MoKV07XG5cdFx0XHRcdGlmICghdGV4dEFyZ3MgfHwgIW1lc2gpIHJldHVybjtcblx0XHRcdFx0aWYgKHNtb290aCkge1xuXHRcdFx0XHRcdG1lc2guZ2VvbWV0cnkgPSBtZXJnZVZlcnRpY2VzKG1lc2guZ2VvbWV0cnksIHNtb290aCk7XG5cdFx0XHRcdFx0bWVzaC5nZW9tZXRyeS5jb21wdXRlVmVydGV4Tm9ybWFscygpO1xuXHRcdFx0XHR9XG5cdFx0XHR9KTtcblx0XHR9KTtcblx0fVxufVxuIl19