@colijnit/homedecorator 255.1.1

package/esm2015/app/plugins/core3d/core/utils.js

@@ -0,0 +1,606 @@
+import * as PolygonTools from 'polygon-tools';
+import { Material, Mesh, Object3D, Scene, Vector2, Vector3 } from 'three';
+/** Collection of utility functions. */
+// @dynamic
+export class Utils {
+    /** Determines the distance of a point from a line.
+     * @param x Point's x coordinate.
+     * @param y Point's y coordinate.
+     * @param x1 Line-Point 1's x coordinate.
+     * @param y1 Line-Point 1's y coordinate.
+     * @param x2 Line-Point 2's x coordinate.
+     * @param y2 Line-Point 2's y coordinate.
+     * @returns The distance.
+     */
+    static pointDistanceFromLine(x, y, x1, y1, x2, y2) {
+        const tPoint = Utils.closestPointOnLine(x, y, x1, y1, x2, y2);
+        const tDx = x - tPoint.x;
+        const tDy = y - tPoint.y;
+        return Math.sqrt(tDx * tDx + tDy * tDy);
+    }
+    /** Gets the projection of a point onto a line.
+     * @param x Point's x coordinate.
+     * @param y Point's y coordinate.
+     * @param x1 Line-Point 1's x coordinate.
+     * @param y1 Line-Point 1's y coordinate.
+     * @param x2 Line-Point 2's x coordinate.
+     * @param y2 Line-Point 2's y coordinate.
+     * @returns The point.
+     */
+    static closestPointOnLine(x, y, x1, y1, x2, y2) {
+        // Inspired by: http://stackoverflow.com/a/6853926
+        const tA = x - x1;
+        const tB = y - y1;
+        const tC = x2 - x1;
+        const tD = y2 - y1;
+        const tDot = tA * tC + tB * tD;
+        const tLenSq = tC * tC + tD * tD;
+        const tParam = tDot / tLenSq;
+        let tXx, tYy;
+        if (tParam < 0 || (x1 === x2 && y1 === y2)) {
+            tXx = x1;
+            tYy = y1;
+        }
+        else if (tParam > 1) {
+            tXx = x2;
+            tYy = y2;
+        }
+        else {
+            tXx = x1 + tParam * tC;
+            tYy = y1 + tParam * tD;
+        }
+        return {
+            x: tXx,
+            y: tYy
+        };
+    }
+    /** Gets the distance of two points.
+     * @param x1 X part of first point.
+     * @param y1 Y part of first point.
+     * @param x2 X part of second point.
+     * @param y2 Y part of second point.
+     * @returns The distance.
+     */
+    static distance(x1, y1, x2, y2) {
+        return Math.sqrt(Math.pow(x2 - x1, 2) +
+            Math.pow(y2 - y1, 2));
+    }
+    /**  Gets the angle between 0,0 -> x1,y1 and 0,0 -> x2,y2 (-pi to pi)
+     * @returns The angle.
+     */
+    static angle(x1, y1, x2, y2) {
+        const tDot = x1 * x2 + y1 * y2;
+        const tDet = x1 * y2 - y1 * x2;
+        const tAngle = -Math.atan2(tDet, tDot);
+        return tAngle;
+    }
+    /** shifts angle to be 0 to 2pi */
+    static angle2pi(x1, y1, x2, y2) {
+        let tTheta = Utils.angle(x1, y1, x2, y2);
+        if (tTheta < 0) {
+            tTheta += 2 * Math.PI;
+        }
+        return tTheta;
+    }
+    static lineToXAxisAngle(x1, y1, x2, y2) {
+        return -(Utils.angle(1, 0, x2 - x1, y2 - y1) + (Math.PI / 2));
+    }
+    /** Gets end point of line through two points of a certain length
+     */
+    static ProlongStraightLine(startX, startY, endX, endY, length) {
+        const angle = -Utils.angle(1, 0, endX - startX, endY - startY);
+        const start = new Vector2(startX, startY);
+        const line = new Vector2(length, 0);
+        line.rotateAround(new Vector2(), angle);
+        const result = start.add(line);
+        return {
+            x: result.x,
+            y: result.y
+        };
+    }
+    /** Checks if Polygon is clockwise.
+     * @param polygon Is array of points with x,y attributes
+     * @returns True if clockwise.
+     * based on http://stackoverflow.com/questions/1165647
+     */
+    static isClockwise(polygon) {
+        const zeroX = Math.min(0, ...polygon.map(p => p.x));
+        const zeroY = Math.min(0, ...polygon.map(p => p.y));
+        const v = polygon.map(p => ({ x: p.x - zeroX, y: p.y - zeroY }));
+        let sum = 0;
+        for (let i = 0; i < v.length; i++) {
+            const v1 = v[i];
+            const v2 = v[(i + 1) % v.length];
+            sum += (v2.x - v1.x) * (v2.y + v1.y);
+        }
+        return sum >= 0;
+    }
+    /** Creates a Guid.
+     * @returns A new Guid.
+     */
+    static guid() {
+        const tS4 = function () {
+            return Math.floor((1 + Math.random()) * 0x10000)
+                .toString(16)
+                .substring(1);
+        };
+        return tS4() + tS4() + '-' + tS4() + '-' + tS4() + '-' +
+            tS4() + '-' + tS4() + tS4() + tS4();
+    }
+    /** both arguments are Polygon (arrays with x,y attributes) */
+    static polygonPolygonIntersect(first, second) {
+        for (let tI = 0; tI < first.length; tI++) {
+            const tFirstCorner = first[tI];
+            let tSecondCorner;
+            if (tI === first.length - 1) {
+                tSecondCorner = first[0];
+            }
+            else {
+                tSecondCorner = first[tI + 1];
+            }
+            if (Utils.linePolygonIntersect(tFirstCorner.x, tFirstCorner.y, tSecondCorner.x, tSecondCorner.y, second)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Polygon is an array of points with x,y attributes */
+    static linePolygonIntersect(x1, y1, x2, y2, polygon) {
+        for (let tI = 0; tI < polygon.length; tI++) {
+            const tFirstCorner = polygon[tI];
+            let tSecondCorner;
+            if (tI === polygon.length - 1) {
+                tSecondCorner = polygon[0];
+            }
+            else {
+                tSecondCorner = polygon[tI + 1];
+            }
+            if (Utils.lineLineIntersect(x1, y1, x2, y2, tFirstCorner.x, tFirstCorner.y, tSecondCorner.x, tSecondCorner.y)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** */
+    static lineLineIntersect(x1, y1, x2, y2, x3, y3, x4, y4) {
+        function tCCW(p1, p2, p3) {
+            const tA = p1.x;
+            const tB = p1.y;
+            const tC = p2.x;
+            const tD = p2.y;
+            const tE = p3.x;
+            const tF = p3.y;
+            return (tF - tB) * (tC - tA) > (tD - tB) * (tE - tA);
+        }
+        const tP1 = { x: x1, y: y1 };
+        const tP2 = { x: x2, y: y2 };
+        const tP3 = { x: x3, y: y3 };
+        const tP4 = { x: x4, y: y4 };
+        return (tCCW(tP1, tP3, tP4) !== tCCW(tP2, tP3, tP4)) && (tCCW(tP1, tP2, tP3) !== tCCW(tP1, tP2, tP4));
+    }
+    /* based on https://stackoverflow.com/questions/13937782/calculating-the-point-of-intersection-of-two-lines/#answer-38977789 */
+    static linesIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {
+        const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+        if (denom === 0) {
+            return null;
+        }
+        const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom;
+        return [
+            x1 + ua * (x2 - x1),
+            y1 + ua * (y2 - y1)
+        ];
+    }
+    /**
+     @param polygon Is an array of points with x,y attributes
+      @param startX X start coord for raycast
+      @param startY Y start coord for raycast
+    */
+    static pointInPolygon(x, y, polygon, startX, startY) {
+        // ensure that point(startX, startY) is outside the polygon
+        let tMinX = 0;
+        let tMinY = 0;
+        if (startX === undefined || startY === undefined) {
+            for (let tI = 0; tI < polygon.length; tI++) {
+                tMinX = Math.min(tMinX, polygon[tI].x);
+                tMinY = Math.min(tMinX, polygon[tI].y);
+            }
+            startX = tMinX - 10;
+            startY = tMinY - 10;
+        }
+        let tIntersects = 0;
+        for (let tI = 0; tI < polygon.length; tI++) {
+            const tFirstCorner = polygon[tI];
+            let tSecondCorner;
+            if (tI === polygon.length - 1) {
+                tSecondCorner = polygon[0];
+            }
+            else {
+                tSecondCorner = polygon[tI + 1];
+            }
+            if (Utils.lineLineIntersect(startX, startY, x, y, tFirstCorner.x, tFirstCorner.y, tSecondCorner.x, tSecondCorner.y)) {
+                tIntersects++;
+            }
+        }
+        // odd intersections means the point is in the polygon
+        return ((tIntersects % 2) === 1);
+    }
+    /** Checks if all corners of inside polygon are inside the outside polygon */
+    static polygonInsidePolygon(inside, outside, startX, startY) {
+        for (let tI = 0; tI < inside.length; tI++) {
+            if (!Utils.pointInPolygon(inside[tI].x, inside[tI].y, outside, startX, startY)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /** Checks if any corners of inside polygon are inside the second outside polygon */
+    static polygonOutsidePolygon(inside, outside, startX, startY) {
+        startX = startX || 0;
+        startY = startY || 0;
+        for (let tI = 0; tI < inside.length; tI++) {
+            if (Utils.pointInPolygon(inside[tI].x, inside[tI].y, outside, startX, startY)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static cloneMaterial(material) {
+        if (material instanceof Material) {
+            return material.clone();
+        }
+        return material.map((m) => m.clone());
+    }
+    static cloneObject3D(source) {
+        const newObject = new Object3D();
+        source.children.forEach((child) => {
+            if (!child.visible) {
+                return;
+            }
+            if (child instanceof Mesh) {
+                newObject.add(child.clone());
+            }
+            else if (child instanceof Object3D) {
+                const clone = this.cloneObject3D(child);
+                clone.position.copy(child.position);
+                clone.rotation.copy(child.rotation);
+                newObject.add(clone);
+            }
+        });
+        return newObject;
+    }
+    static cloneGroup(source, meshMaterial) {
+        const newGroup = this.cloneObject3D(source);
+        if (meshMaterial) {
+            newGroup.traverse((child) => {
+                if (child instanceof Mesh) {
+                    child.material = meshMaterial;
+                }
+            });
+        }
+        return newGroup;
+    }
+    // arrays
+    static forEach(array, action) {
+        for (let tI = 0; tI < array.length; tI++) {
+            action(array[tI]);
+        }
+    }
+    static forEachIndexed(array, action) {
+        for (let tI = 0; tI < array.length; tI++) {
+            action(tI, array[tI]);
+        }
+    }
+    static map(array, func) {
+        const tResult = [];
+        array.forEach((element) => {
+            tResult.push(func(element));
+        });
+        return tResult;
+    }
+    /** Remove elements in array if func(element) returns true */
+    static removeIf(array, func) {
+        const tResult = [];
+        array.forEach((element) => {
+            if (!func(element)) {
+                tResult.push(element);
+            }
+        });
+        return tResult;
+    }
+    /** Shift the items in an array by shift (positive integer) */
+    static cycle(arr, shift) {
+        const tReturn = arr.slice(0);
+        for (let tI = 0; tI < shift; tI++) {
+            const tmp = tReturn.shift();
+            tReturn.push(tmp);
+        }
+        return tReturn;
+    }
+    /** Returns in the unique elemnts in arr */
+    static unique(arr, hashFunc) {
+        const tResults = [];
+        const tMap = {};
+        for (let tI = 0; tI < arr.length; tI++) {
+            if (!tMap.hasOwnProperty(arr[tI])) {
+                tResults.push(arr[tI]);
+                tMap[hashFunc(arr[tI])] = true;
+            }
+        }
+        return tResults;
+    }
+    /** Remove value from array, if it is present */
+    static removeValue(array, value) {
+        for (let tI = array.length - 1; tI >= 0; tI--) {
+            if (array[tI] === value) {
+                array.splice(tI, 1);
+            }
+        }
+    }
+    /** Subtracts the elements in subArray from array */
+    static subtract(array, subArray) {
+        return Utils.removeIf(array, function (el) {
+            return Utils.hasValue(subArray, el);
+        });
+    }
+    /** based on https://stackoverflow.com/questions/16285134/calculating-polygon-area#answer-33670691 */
+    static polygonArea(vertices) {
+        let total = 0;
+        for (let i = 0, l = vertices.length; i < l; i++) {
+            const addX = vertices[i].x;
+            const addY = vertices[i === vertices.length - 1 ? 0 : i + 1].y;
+            const subX = vertices[i === vertices.length - 1 ? 0 : i + 1].x;
+            const subY = vertices[i].y;
+            total += (addX * addY * 0.5);
+            total -= (subX * subY * 0.5);
+        }
+        return Math.abs(total);
+    }
+    static polygonCenter(vertices) {
+        const sm = vertices.reduce((a, v) => {
+            a.x += v.x;
+            a.y += v.y;
+            return a;
+        }, { x: 0, y: 0 });
+        return {
+            x: sm.x / vertices.length,
+            y: sm.y / vertices.length
+        };
+    }
+    static getTranslatedLine(start, end, angle, distance) {
+        return {
+            start: new Vector2(start.x + Math.cos(angle) * distance, start.y + Math.sin(angle) * distance),
+            end: new Vector2(end.x + Math.cos(angle) * distance, end.y + Math.sin(angle) * distance)
+        };
+    }
+    static pointOnAngleAxis(distance, angle, dx, dy) {
+        const xd = distance * Math.cos(angle / 2 + Math.atan(dy / dx));
+        const yd = distance * Math.sin(angle / 2 + Math.atan(dy / dx));
+        return { x: xd, y: yd };
+    }
+    static selectPointInsidePolygon(origCorner, delta, origCorners) {
+        const zeroX = Math.min(0, ...origCorners.map(c => c.x));
+        const zeroY = Math.min(0, ...origCorners.map(c => c.y));
+        const corner = { x: origCorner.x - zeroX, y: origCorner.y - zeroY };
+        const corners = origCorners.map(c => new Vector2(c.x - zeroX, c.y - zeroY));
+        const { x, y } = corner;
+        const { x: xd, y: yd } = delta;
+        if (Utils.pointInPolygon(x + xd, y + yd, corners)) {
+            return { x: x + xd + zeroX, y: y + yd + zeroY };
+        }
+        else if (Utils.pointInPolygon(x - xd, y - yd, corners)) {
+            return { x: x - xd + zeroX, y: y - yd + zeroY };
+        }
+        if (Utils.pointInPolygon(x - yd, y + xd, corners)) {
+            return { x: x - yd + zeroX, y: y + xd + zeroY };
+        }
+        else if (Utils.pointInPolygon(x + yd, y - xd, corners)) {
+            return { x: x + yd + zeroX, y: y - xd + zeroY };
+        }
+        else { // this should never happen
+            return { x: x + zeroX, y: y + zeroY };
+        }
+    }
+    static setPlaneVisibility(plane, isVisible) {
+        if (plane.material.length) {
+            plane.material.forEach((m) => {
+                m.opacity = isVisible ? 1 : 0;
+                m.transparent = !isVisible;
+                m.depthWrite = isVisible;
+                m.depthTest = isVisible;
+            });
+        }
+        else {
+            plane.material.opacity = isVisible ? 1 : 0;
+            plane.material.transparent = !isVisible;
+            plane.material.depthWrite = isVisible;
+            plane.material.depthTest = isVisible;
+        }
+    }
+    static snapAngle(angle, snap = Math.PI / 12) {
+        return Math.round(angle / snap) * snap;
+    }
+    static moveAtAxis(position, rotation, axis, axisValue) {
+        const positionCopy = position.clone();
+        positionCopy[axis] = axisValue;
+        return positionCopy;
+    }
+    static DisposeNode(node) {
+        node.traverse((obj) => {
+            if (obj instanceof Mesh) {
+                if (obj.geometry) {
+                    obj.geometry.dispose();
+                }
+                Utils.DisposeMaterial(obj.material);
+            }
+            if (typeof obj.dispose === 'function') {
+                // @ts-ignore
+                obj.dispose();
+            }
+        });
+    }
+    static DisposeMaterial(material) {
+        if (!material) {
+            return;
+        }
+        if (Array.isArray(material)) {
+            material.forEach(mtrl => {
+                this.materialProps
+                    .filter(mapType => mtrl[mapType])
+                    .forEach(mapType => mtrl[mapType].dispose());
+                mtrl.dispose(); // disposes any programs associated with the material
+            });
+        }
+        else {
+            this.materialProps
+                .filter(mapType => material[mapType] && material[mapType].dispose)
+                .forEach(mapType => material[mapType].dispose());
+            if (material.dispose) {
+                material.dispose(); // disposes any programs associated with the material
+            }
+        }
+    }
+    static DisposeObject(object) {
+        if (!object) {
+            return;
+        }
+        if (object.children.length) {
+            object.children.forEach(child => this.DisposeObject(child));
+        }
+        this.DisposeNode(object);
+    }
+    static polygonUnion(p1, p2) {
+        const a1 = p1.map(p => [p.x, p.y]);
+        const a2 = p2.map(p => [p.x, p.y]);
+        const a = PolygonTools.polygon.union(a1, a2);
+        if (a && a.length) {
+            const polygon = a[0].map(coords => new Vector2(coords[0], coords[1]));
+            return polygon;
+        }
+        else {
+            return null;
+        }
+    }
+    static polygonsUnion(polygons) {
+        if (!polygons || !polygons.length) {
+            return [];
+        }
+        if (polygons.length < 2) {
+            return polygons;
+        }
+        const first = polygons[0].map(point => point.clone());
+        const others = polygons.slice(1);
+        return this.oneToRest(first, others);
+    }
+    static oneToRest(first, others) {
+        const overlapping = others.find((second) => this.polygonPolygonIntersect(first, second));
+        if (overlapping) {
+            // remove overlapping
+            const combinedPolygons = others.filter(p => p !== overlapping);
+            // combine first with overlapping
+            const union = this.polygonUnion(first, overlapping);
+            const combined = combinedPolygons.concat([union]);
+            return this.polygonsUnion(combined);
+        }
+        else if (others.length > 1) {
+            return [first, ...this.polygonsUnion(others)];
+        }
+        else {
+            return [first, ...others];
+        }
+    }
+    static uniqFn(v, i, a) {
+        return a.indexOf(v) === i;
+    }
+    static sampleSize(input, targetCount = 1) {
+        const eachNo = Math.trunc(input.length / targetCount) || 1;
+        return input.filter((v, i) => 0 === i % eachNo);
+    }
+    static toString(v) {
+        const dec = 100;
+        return `[${Math.round(v.x * dec) / dec},${Math.round(v.y * dec) / dec},${Math.round(v.z * dec) / dec}]`;
+    }
+    // TODO: Needs to be made compatible with BufferGeometry when method becomes used
+    static geometryMeshToWorldVertices(mesh, sampleSize) {
+        // const geo = mesh.geometry as BufferGeometry;
+        // const worldProps = Utils.worldProps(mesh);
+        // let sampled = geo.vertices;
+        // if (sampleSize) {
+        //   sampled = Utils.sampleSize(geo.vertices, sampleSize);
+        // }
+        // return sampled.map((v: Vector3)  => {
+        //   const vertex = v.clone();
+        //   worldProps.forEach((p: WorldProp) => vertex.applyMatrix4(p.matrix));
+        //   return vertex;
+        // });
+        return [];
+    }
+    static bufferGeometryMeshToWorldVertices(mesh, sampleSize) {
+        const geo = mesh.geometry;
+        const worldProps = Utils.worldProps(mesh);
+        const vertices = [];
+        const positions = geo.getAttribute('position');
+        let increment = 1;
+        if (sampleSize) {
+            increment = Math.trunc(positions.count / sampleSize) || 1;
+        }
+        for (let i = 0, len = positions.count; i < len; i += increment) {
+            const vertex = new Vector3().fromBufferAttribute(positions, i);
+            worldProps.forEach((p) => vertex
+                .sub(p.position)
+                .applyAxisAngle(Utils.axisY, -p.rotation.y)
+                .applyMatrix4(p.matrix));
+            vertices.push(vertex);
+        }
+        return vertices;
+    }
+    static worldProps(mesh) {
+        const worldProps = [];
+        let object = mesh;
+        while (object && !(object instanceof Scene)) {
+            worldProps.push({
+                matrix: object.matrixWorld.clone(),
+                position: object.position.clone(),
+                rotation: object.rotation.clone()
+            });
+            object = object.parent;
+        }
+        return worldProps;
+    }
+    static isCamera(object) {
+        return object.name === 'Camera';
+    }
+    static GetVector3ArrayFromBufferAttribute(bufferAttribute) {
+        const vector3Array = [];
+        for (let i = 0; i < bufferAttribute.count; i++) {
+            vector3Array.push(new Vector3(bufferAttribute.getX(i), bufferAttribute.getY(i), bufferAttribute.getZ(i)));
+        }
+        return vector3Array;
+    }
+    static ApplyBufferAttributeMatrixTransform(bufferAttribute, transform) {
+        const tempVector = new Vector3();
+        for (let i = 0; i < bufferAttribute.count; i++) {
+            tempVector.set(bufferAttribute.getX(i), bufferAttribute.getY(i), bufferAttribute.getZ(i));
+            tempVector.applyMatrix4(transform);
+            bufferAttribute.setXYZ(i, tempVector.x, tempVector.y, tempVector.z);
+        }
+        bufferAttribute.needsUpdate = true;
+    }
+    static GetFaceNormalFromBufferGeometry(bufferGeometry, faceIndex, vertexIndex) {
+        bufferGeometry.computeVertexNormals();
+        const index = 3 * faceIndex + vertexIndex;
+        const normalAttribute = bufferGeometry.getAttribute('normal');
+        return new Vector3(normalAttribute.getX(index), normalAttribute.getY(index), normalAttribute.getZ(index));
+    }
+}
+Utils.axisY = new Vector3(0, 1, 0);
+Utils.materialProps = ['map', 'lightMap', 'bumpMap', 'normalMap', 'specularMap', 'envMap', 'aoMap', 'roughnessMap', 'metalnessMap'];
+/** Checks if value is in array */
+Utils.hasValue = function (array, value) {
+    for (let tI = 0; tI < array.length; tI++) {
+        if (array[tI] === value) {
+            return true;
+        }
+    }
+    return false;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../src/client/app/plugins/core3d/core/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAC9C,OAAO,EAKL,QAAQ,EAER,IAAI,EAEJ,QAAQ,EACR,KAAK,EACL,OAAO,EACP,OAAO,EACR,MAAM,OAAO,CAAC;AASf,uCAAuC;AACvC,WAAW;AACX,MAAM,OAAO,KAAK;IAMhB;;;;;;;;OAQG;IACI,MAAM,CAAC,qBAAqB,CAAC,CAAS,EAAE,CAAS,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QACtG,MAAM,MAAM,GAAG,KAAK,CAAC,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC9D,MAAM,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;QACzB,MAAM,GAAG,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;QACzB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,kBAAkB,CAAC,CAAS,EAAE,CAAS,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QAC5F,kDAAkD;QAClD,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;QAClB,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC;QAClB,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QACnB,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QAEnB,MAAM,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;QAE7B,IAAI,GAAG,EAAE,GAAG,CAAC;QAEb,IAAI,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE;YAC1C,GAAG,GAAG,EAAE,CAAC;YACT,GAAG,GAAG,EAAE,CAAC;SACV;aAAM,IAAI,MAAM,GAAG,CAAC,EAAE;YACrB,GAAG,GAAG,EAAE,CAAC;YACT,GAAG,GAAG,EAAE,CAAC;SACV;aAAM;YACL,GAAG,GAAG,EAAE,GAAG,MAAM,GAAG,EAAE,CAAC;YACvB,GAAG,GAAG,EAAE,GAAG,MAAM,GAAG,EAAE,CAAC;SACxB;QAED,OAAO;YACL,CAAC,EAAE,GAAG;YACN,CAAC,EAAE,GAAG;SACP,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QAC5D,OAAO,IAAI,CAAC,IAAI,CACd,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;YACpB,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,KAAK,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QACzD,MAAM,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QAC/B,MAAM,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACvC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,kCAAkC;IAClC,MAAM,CAAC,QAAQ,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QAC5D,IAAI,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACzC,IAAI,MAAM,GAAG,CAAC,EAAE;YACd,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;SACvB;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,gBAAgB,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QACpE,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAChE,CAAC;IAED;OACG;IACH,MAAM,CAAC,mBAAmB,CAAC,MAAc,EAAE,MAAc,EAAE,IAAY,EAAE,IAAY,EAAE,MAAc;QACnG,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC,CAAC;QAC/D,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAE1C,MAAM,IAAI,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QACpC,IAAI,CAAC,YAAY,CAAC,IAAI,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC;QACxC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/B,OAAO;YACL,CAAC,EAAE,MAAM,CAAC,CAAC;YACX,CAAC,EAAE,MAAM,CAAC,CAAC;SACZ,CAAA;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,WAAW,CAAC,OAAgB;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,EAAC,CAAC,CAAC,CAAC;QAChE,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACjC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;YACjC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;SACtC;QACD,OAAO,GAAG,IAAI,CAAC,CAAC;IAClB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAI;QACT,MAAM,GAAG,GAAG;YACV,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC;iBAC7C,QAAQ,CAAC,EAAE,CAAC;iBACZ,SAAS,CAAC,CAAC,CAAC,CAAC;QAClB,CAAC,CAAC;QAEF,OAAO,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG;YACpD,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,GAAG,GAAG,EAAE,CAAC;IACxC,CAAC;IAED,8DAA8D;IAC9D,MAAM,CAAC,uBAAuB,CAAC,KAAc,EAAE,MAAe;QAC5D,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YACxC,MAAM,YAAY,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC;YAC/B,IAAI,aAAa,CAAC;YAElB,IAAI,EAAE,KAAK,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC3B,aAAa,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;aAC1B;iBAAM;gBACL,aAAa,GAAG,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;aAC/B;YAED,IAAI,KAAK,CAAC,oBAAoB,CAC5B,YAAY,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,EAC9B,aAAa,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,EAChC,MAAM,CAAC,EAAE;gBACT,OAAO,IAAI,CAAC;aACb;SACF;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,wDAAwD;IACxD,MAAM,CAAC,oBAAoB,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,OAAgB;QAC1F,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YAC1C,MAAM,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;YACjC,IAAI,aAAa,CAAC;YAElB,IAAI,EAAE,KAAK,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC7B,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;aAC5B;iBAAM;gBACL,aAAa,GAAG,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;aACjC;YAED,IAAI,KAAK,CAAC,iBAAiB,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EACxC,YAAY,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,EAC9B,aAAa,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE;gBACnC,OAAO,IAAI,CAAC;aACb;SACF;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM;IACN,MAAM,CAAC,iBAAiB,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QACrH,SAAS,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;YACtB,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YAChB,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;YAChB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;QACvD,CAAC;QAED,MAAM,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;QAC7B,MAAM,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;QAC7B,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IACxG,CAAC;IAED,+HAA+H;IAC/H,MAAM,CAAC,iBAAiB,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;QACrH,MAAM,KAAK,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;QAC5D,IAAI,KAAK,KAAK,CAAC,EAAE;YACb,OAAO,IAAI,CAAC;SACf;QACD,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;QACnE,OAAO;YACH,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC;YACnB,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC;SACtB,CAAC;IACJ,CAAC;IAED;;;;MAIE;IACF,MAAM,CAAC,cAAc,CAAC,CAAS,EAAE,CAAS,EAAE,OAAgB,EAAE,MAAe,EAAE,MAAe;QAE5F,2DAA2D;QAC3D,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,SAAS,EAAE;YAChD,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;gBAC1C,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;gBACvC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aACxC;YACD,MAAM,GAAG,KAAK,GAAG,EAAE,CAAC;YACpB,MAAM,GAAG,KAAK,GAAG,EAAE,CAAC;SACrB;QAED,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YAC1C,MAAM,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC;YACjC,IAAI,aAAa,CAAC;YAClB,IAAI,EAAE,KAAK,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC7B,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;aAC5B;iBAAM;gBACL,aAAa,GAAG,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;aACjC;YAED,IAAI,KAAK,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,EAC9C,YAAY,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,EAC9B,aAAa,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE;gBACnC,WAAW,EAAE,CAAC;aACf;SACF;QACD,sDAAsD;QACtD,OAAO,CAAC,CAAC,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IACnC,CAAC;IAED,6EAA6E;IAC7E,MAAM,CAAC,oBAAoB,CAAC,MAAe,EAAE,OAAgB,EAAE,MAAe,EAAE,MAAe;QAE7F,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YACzC,IAAI,CAAC,KAAK,CAAC,cAAc,CACvB,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAC1B,OAAO,EACP,MAAM,EAAE,MAAM,CAAC,EAAE;gBACjB,OAAO,KAAK,CAAC;aACd;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,oFAAoF;IACpF,MAAM,CAAC,qBAAqB,CAAC,MAAe,EAAE,OAAgB,EAAE,MAAe,EAAE,MAAe;QAC9F,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC;QACrB,MAAM,GAAG,MAAM,IAAI,CAAC,CAAC;QAErB,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YACzC,IAAI,KAAK,CAAC,cAAc,CACtB,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAC1B,OAAO,EACP,MAAM,EAAE,MAAM,CAAC,EAAE;gBACjB,OAAO,KAAK,CAAC;aACd;SACF;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,QAA+B;QAClD,IAAI,QAAQ,YAAY,QAAQ,EAAE;YAChC,OAAO,QAAQ,CAAC,KAAK,EAAE,CAAC;SACzB;QACD,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAW,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;IAClD,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,MAAgB;QACnC,MAAM,SAAS,GAAG,IAAI,QAAQ,EAAE,CAAC;QACjC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAU,EAAE,EAAE;YACrC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE;gBAAE,OAAO;aAAE;YAC/B,IAAI,KAAK,YAAY,IAAI,EAAE;gBACzB,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;aAC9B;iBAAM,IAAI,KAAK,YAAY,QAAQ,EAAE;gBACpC,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBACxC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;gBACpC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;gBACpC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;aACtB;QACH,CAAC,CAAC,CAAC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,MAAa,EAAE,YAAgC;QAC/D,MAAM,QAAQ,GAAU,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACnD,IAAI,YAAY,EAAE;YAChB,QAAQ,CAAC,QAAQ,CAAC,CAAC,KAAU,EAAE,EAAE;gBAC/B,IAAI,KAAK,YAAY,IAAI,EAAE;oBACzB,KAAK,CAAC,QAAQ,GAAG,YAAY,CAAC;iBAC/B;YACH,CAAC,CAAC,CAAC;SACJ;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,SAAS;IAET,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM;QAC1B,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YACxC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;SACnB;IACH,CAAC;IAED,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM;QACjC,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YACxC,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;SACvB;IACH,CAAC;IAED,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI;QACpB,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YACxB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,6DAA6D;IAC7D,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI;QACzB,MAAM,OAAO,GAAG,EAAE,CAAC;QACnB,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YACxB,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE;gBAClB,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;aACvB;QACH,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,8DAA8D;IAC9D,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK;QACrB,MAAM,OAAO,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7B,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE;YACjC,MAAM,GAAG,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;YAC5B,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACnB;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,2CAA2C;IAC3C,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ;QACzB,MAAM,QAAQ,GAAG,EAAE,CAAC;QACpB,MAAM,IAAI,GAAG,EAAE,CAAC;QAChB,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;YACtC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE;gBACjC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;gBACvB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;aAChC;SACF;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,gDAAgD;IAChD,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK;QAC7B,KAAK,IAAI,EAAE,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE;YAC7C,IAAI,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,EAAE;gBACvB,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;aACrB;SACF;IACH,CAAC;IAYD,oDAAoD;IACpD,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,QAAQ;QAC7B,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE;YACvC,OAAO,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,qGAAqG;IACrG,MAAM,CAAC,WAAW,CAAC,QAAiB;QAClC,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YAC/C,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3B,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/D,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,KAAK,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/D,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAE3B,KAAK,IAAI,CAAC,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC;YAC7B,KAAK,IAAI,CAAC,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC,CAAC;SAC9B;QAED,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,QAAiB;QACpC,MAAM,EAAE,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAyB,EAAE,CAAC,EAAE,EAAE;YAC1D,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACX,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACX,OAAO,CAAC,CAAC;QACX,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;QACnB,OAAO;YACL,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM;YACzB,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM;SAC1B,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,iBAAiB,CACtB,KAAc,EAAE,GAAY,EAC5B,KAAa,EAAE,QAAgB;QAE/B,OAAO;YACL,KAAK,EAAE,IAAI,OAAO,CAChB,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,QAAQ,EACpC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,QAAQ,CACrC;YACD,GAAG,EAAE,IAAI,OAAO,CACd,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,QAAQ,EAClC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,QAAQ,CACnC;SACF,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,gBAAgB,CAAC,QAAgB,EAAE,KAAa,EAAE,EAAU,EAAE,EAAU;QAC7E,MAAM,EAAE,GAAW,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;QACvE,MAAM,EAAE,GAAW,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC;QACvE,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,wBAAwB,CAC7B,UAAkC,EAClC,KAA6B,EAC7B,WAAoB;QAEpB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,MAAM,GAAG,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC;QACpE,MAAM,OAAO,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,OAAO,CAC9C,CAAC,CAAC,CAAC,GAAG,KAAK,EACX,CAAC,CAAC,CAAC,GAAG,KAAK,CACZ,CAAC,CAAC;QACH,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC;QACxB,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,GAAG,KAAK,CAAC;QAC/B,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE;YACjD,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAC,CAAC;SAChD;aAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE;YACxD,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAC,CAAC;SAChD;QAAC,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE;YACnD,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAC,CAAC;SAChD;aAAM,IAAI,KAAK,CAAC,cAAc,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE;YACxD,OAAO,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,EAAC,CAAC;SAChD;aAAM,EAAE,2BAA2B;YAClC,OAAO,EAAE,CAAC,EAAG,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC;SACxC;IACH,CAAC;IAED,MAAM,CAAC,kBAAkB,CAAC,KAAW,EAAE,SAAkB;QACvD,IAAK,KAAK,CAAC,QAAgB,CAAC,MAAM,EAAE;YACjC,KAAK,CAAC,QAAuB,CAAC,OAAO,CAAC,CAAC,CAAW,EAAE,EAAE;gBACrD,CAAC,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC9B,CAAC,CAAC,WAAW,GAAG,CAAC,SAAS,CAAC;gBAC3B,CAAC,CAAC,UAAU,GAAG,SAAS,CAAC;gBACzB,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC;YAC1B,CAAC,CAAC,CAAC;SACJ;aAAM;YACJ,KAAK,CAAC,QAAqB,CAAC,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACxD,KAAK,CAAC,QAAqB,CAAC,WAAW,GAAG,CAAC,SAAS,CAAC;YACrD,KAAK,CAAC,QAAqB,CAAC,UAAU,GAAG,SAAS,CAAC;YACnD,KAAK,CAAC,QAAqB,CAAC,SAAS,GAAG,SAAS,CAAC;SACpD;IACH,CAAC;IAED,MAAM,CAAC,SAAS,CAAC,KAAa,EAAE,OAAe,IAAI,CAAC,EAAE,GAAG,EAAE;QACzD,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;IACzC,CAAC;IAED,MAAM,CAAC,UAAU,CACf,QAAiB,EACjB,QAAe,EACf,IAAqB,EACrB,SAAiB;QAEjB,MAAM,YAAY,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtC,YAAY,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;QAC/B,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,MAAM,CAAC,WAAW,CAAC,IAAqB;QAC9C,IAAI,CAAC,QAAQ,CAAC,CAAC,GAAa,EAAE,EAAE;YAC9B,IAAI,GAAG,YAAY,IAAI,EAAE;gBACvB,IAAI,GAAG,CAAC,QAAQ,EAAE;oBAChB,GAAG,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;iBACxB;gBACD,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;aACrC;YACD,IAAI,OAAQ,GAAW,CAAC,OAAO,KAAK,UAAU,EAAE;gBAC9C,aAAa;gBACb,GAAG,CAAC,OAAO,EAAE,CAAC;aACf;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,eAAe,CAAC,QAA+B;QAC3D,IAAI,CAAC,QAAQ,EAAE;YACb,OAAO;SACR;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YAC3B,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACtB,IAAI,CAAC,aAAa;qBACf,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;qBAChC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;gBAC/C,IAAI,CAAC,OAAO,EAAE,CAAC,CAAI,qDAAqD;YAC1E,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,IAAI,CAAC,aAAa;iBACf,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;iBACjE,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;YACnD,IAAI,QAAQ,CAAC,OAAO,EAAE;gBACpB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAG,qDAAqD;aAC5E;SACF;IACH,CAAC;IAEM,MAAM,CAAC,aAAa,CAAC,MAAuB;QACjD,IAAI,CAAC,MAAM,EAAE;YACX,OAAO;SACR;QACD,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE;YAC1B,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;SAC7D;QACD,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B,CAAC;IAED,MAAM,CAAC,YAAY,CAAC,EAAW,EAAE,EAAW;QAC1C,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACnC,MAAM,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE;YACjB,MAAM,OAAO,GAAY,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/E,OAAO,OAAO,CAAC;SAChB;aAAM;YACL,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED,MAAM,CAAC,aAAa,CAAC,QAAmB;QACtC,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YACjC,OAAO,EAAE,CAAC;SACX;QACD,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YACvB,OAAO,QAAQ,CAAC;SACjB;QACD,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC;QACtD,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACjC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACvC,CAAC;IAEO,MAAM,CAAC,SAAS,CAAC,KAAc,EAAE,MAAiB;QACxD,MAAM,WAAW,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,MAAe,EAAE,EAAE,CAClD,IAAI,CAAC,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;QAC/C,IAAI,WAAW,EAAE;YACf,qBAAqB;YACrB,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC;YAC/D,iCAAiC;YACjC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;YACpD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YAClD,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;SACrC;aAAM,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5B,OAAO,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;SAC/C;aAAM;YACL,OAAO,CAAC,KAAK,EAAE,GAAG,MAAM,CAAC,CAAC;SAC3B;IACH,CAAC;IAEM,MAAM,CAAC,MAAM,CAAI,CAAI,EAAE,CAAS,EAAE,CAAM;QAC7C,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAEM,MAAM,CAAC,UAAU,CAAI,KAAU,EAAE,cAAsB,CAAC;QAC7D,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,WAAW,CAAC,IAAK,CAAC,CAAC;QAC5D,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC;IAClD,CAAC;IAEM,MAAM,CAAC,QAAQ,CAAC,CAAkB;QACvC,MAAM,GAAG,GAAG,GAAG,CAAC;QAChB,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC;IAC1G,CAAC;IAED,iFAAiF;IAC1E,MAAM,CAAC,2BAA2B,CAAC,IAAU,EAAE,UAAmB;QACvE,+CAA+C;QAC/C,6CAA6C;QAC7C,8BAA8B;QAC9B,oBAAoB;QACpB,0DAA0D;QAC1D,IAAI;QACJ,wCAAwC;QACxC,8BAA8B;QAC9B,yEAAyE;QACzE,mBAAmB;QACnB,MAAM;QACN,OAAO,EAAE,CAAC;IACZ,CAAC;IAEM,MAAM,CAAC,iCAAiC,CAAC,IAAU,EAAE,UAAmB;QAC7E,MAAM,GAAG,GAAG,IAAI,CAAC,QAA0B,CAAC;QAC5C,MAAM,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1C,MAAM,QAAQ,GAAc,EAAE,CAAC;QAC/B,MAAM,SAAS,GAAG,GAAG,CAAC,YAAY,CAAC,UAAU,CAAoB,CAAC;QAClE,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,UAAU,EAAE;YACd,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,GAAG,UAAU,CAAC,IAAK,CAAC,CAAC;SAC5D;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,IAAI,SAAS,EAAE;YAC9D,MAAM,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC,mBAAmB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;YAC/D,UAAU,CAAC,OAAO,CAAC,CAAC,CAAY,EAAE,EAAE,CAAC,MAAM;iBACxC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC;iBACf,cAAc,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;iBAC1C,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CACxB,CAAC;YACF,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SACvB;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,MAAM,CAAC,UAAU,CAAC,IAAU;QACjC,MAAM,UAAU,GAAgB,EAAE,CAAC;QACnC,IAAI,MAAM,GAAoB,IAAI,CAAC;QACnC,OAAO,MAAM,IAAI,CAAC,CAAC,MAAM,YAAY,KAAK,CAAC,EAAE;YAC3C,UAAU,CAAC,IAAI,CAAC;gBACd,MAAM,EAAE,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE;gBAClC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE;gBACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE;aAClC,CAAC,CAAC;YACH,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;SACxB;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAEM,MAAM,CAAC,QAAQ,CAAC,MAAsB;QAC3C,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC;IAClC,CAAC;IAEM,MAAM,CAAC,kCAAkC,CAAC,eAAgC;QAC/E,MAAM,YAAY,GAAc,EAAE,CAAC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YAC9C,YAAY,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;SAC3G;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAEM,MAAM,CAAC,mCAAmC,CAAC,eAAgC,EAAE,SAAkB;QACpG,MAAM,UAAU,GAAY,IAAI,OAAO,EAAE,CAAC;QAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YAC9C,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1F,UAAU,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YACnC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;SACrE;QACD,eAAe,CAAC,WAAW,GAAG,IAAI,CAAC;IACrC,CAAC;IAEM,MAAM,CAAC,+BAA+B,CAAC,cAA8B,EAAE,SAAiB,EAAE,WAAmB;QAClH,cAAc,CAAC,oBAAoB,EAAE,CAAC;QACtC,MAAM,KAAK,GAAW,CAAC,GAAG,SAAS,GAAG,WAAW,CAAC;QAClD,MAAM,eAAe,GAAqC,cAAc,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAChG,OAAO,IAAI,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5G,CAAC;;AAprBM,WAAK,GAAG,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAE7B,mBAAa,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC;AAiYrI,kCAAkC;AAC3B,cAAQ,GAAG,UAAU,KAAK,EAAE,KAAK;IACtC,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;QACxC,IAAI,KAAK,CAAC,EAAE,CAAC,KAAK,KAAK,EAAE;YACvB,OAAO,IAAI,CAAC;SACb;KACF;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC","sourcesContent":["import * as PolygonTools from 'polygon-tools';\r\nimport {\r\n  BufferAttribute,\r\n  BufferGeometry,\r\n  Euler,\r\n  Group,\r\n  Material,\r\n  Matrix4,\r\n  Mesh,\r\n  MeshBasicMaterial,\r\n  Object3D,\r\n  Scene,\r\n  Vector2,\r\n  Vector3\r\n} from 'three';\r\n\r\ntype Polygon = Vector2[];\r\ninterface WorldProp {\r\n  matrix: Matrix4;\r\n  position: Vector3;\r\n  rotation: Euler;\r\n}\r\n\r\n/** Collection of utility functions. */\r\n// @dynamic\r\nexport class Utils {\r\n\r\n  static axisY = new Vector3(0, 1, 0);\r\n\r\n  static materialProps = ['map', 'lightMap', 'bumpMap', 'normalMap', 'specularMap', 'envMap', 'aoMap', 'roughnessMap', 'metalnessMap'];\r\n\r\n  /** Determines the distance of a point from a line.\r\n   * @param x Point's x coordinate.\r\n   * @param y Point's y coordinate.\r\n   * @param x1 Line-Point 1's x coordinate.\r\n   * @param y1 Line-Point 1's y coordinate.\r\n   * @param x2 Line-Point 2's x coordinate.\r\n   * @param y2 Line-Point 2's y coordinate.\r\n   * @returns The distance.\r\n   */\r\n  public static pointDistanceFromLine(x: number, y: number, x1: number, y1: number, x2: number, y2: number): number {\r\n    const tPoint = Utils.closestPointOnLine(x, y, x1, y1, x2, y2);\r\n    const tDx = x - tPoint.x;\r\n    const tDy = y - tPoint.y;\r\n    return Math.sqrt(tDx * tDx + tDy * tDy);\r\n  }\r\n\r\n  /** Gets the projection of a point onto a line.\r\n   * @param x Point's x coordinate.\r\n   * @param y Point's y coordinate.\r\n   * @param x1 Line-Point 1's x coordinate.\r\n   * @param y1 Line-Point 1's y coordinate.\r\n   * @param x2 Line-Point 2's x coordinate.\r\n   * @param y2 Line-Point 2's y coordinate.\r\n   * @returns The point.\r\n   */\r\n  static closestPointOnLine(x: number, y: number, x1: number, y1: number, x2: number, y2: number): { x: number, y: number } {\r\n    // Inspired by: http://stackoverflow.com/a/6853926\r\n    const tA = x - x1;\r\n    const tB = y - y1;\r\n    const tC = x2 - x1;\r\n    const tD = y2 - y1;\r\n\r\n    const tDot = tA * tC + tB * tD;\r\n    const tLenSq = tC * tC + tD * tD;\r\n    const tParam = tDot / tLenSq;\r\n\r\n    let tXx, tYy;\r\n\r\n    if (tParam < 0 || (x1 === x2 && y1 === y2)) {\r\n      tXx = x1;\r\n      tYy = y1;\r\n    } else if (tParam > 1) {\r\n      tXx = x2;\r\n      tYy = y2;\r\n    } else {\r\n      tXx = x1 + tParam * tC;\r\n      tYy = y1 + tParam * tD;\r\n    }\r\n\r\n    return {\r\n      x: tXx,\r\n      y: tYy\r\n    };\r\n  }\r\n\r\n  /** Gets the distance of two points.\r\n   * @param x1 X part of first point.\r\n   * @param y1 Y part of first point.\r\n   * @param x2 X part of second point.\r\n   * @param y2 Y part of second point.\r\n   * @returns The distance.\r\n   */\r\n  static distance(x1: number, y1: number, x2: number, y2: number): number {\r\n    return Math.sqrt(\r\n      Math.pow(x2 - x1, 2) +\r\n      Math.pow(y2 - y1, 2));\r\n  }\r\n\r\n  /**  Gets the angle between 0,0 -> x1,y1 and 0,0 -> x2,y2 (-pi to pi)\r\n   * @returns The angle.\r\n   */\r\n  static angle(x1: number, y1: number, x2: number, y2: number): number {\r\n    const tDot = x1 * x2 + y1 * y2;\r\n    const tDet = x1 * y2 - y1 * x2;\r\n    const tAngle = -Math.atan2(tDet, tDot);\r\n    return tAngle;\r\n  }\r\n\r\n  /** shifts angle to be 0 to 2pi */\r\n  static angle2pi(x1: number, y1: number, x2: number, y2: number) {\r\n    let tTheta = Utils.angle(x1, y1, x2, y2);\r\n    if (tTheta < 0) {\r\n      tTheta += 2 * Math.PI;\r\n    }\r\n    return tTheta;\r\n  }\r\n\r\n  static lineToXAxisAngle(x1: number, y1: number, x2: number, y2: number): number {\r\n    return -(Utils.angle(1, 0, x2 - x1, y2 - y1) + (Math.PI / 2));\r\n  }\r\n\r\n  /** Gets end point of line through two points of a certain length\r\n   */\r\n  static ProlongStraightLine(startX: number, startY: number, endX: number, endY: number, length: number): { x: number, y: number } {\r\n    const angle = -Utils.angle(1, 0, endX - startX, endY - startY);\r\n    const start = new Vector2(startX, startY);\r\n\r\n    const line = new Vector2(length, 0);\r\n    line.rotateAround(new Vector2(), angle);\r\n    const result = start.add(line);\r\n    return {\r\n      x: result.x,\r\n      y: result.y\r\n    }\r\n  }\r\n\r\n  /** Checks if Polygon is clockwise.\r\n   * @param polygon Is array of points with x,y attributes\r\n   * @returns True if clockwise.\r\n   * based on http://stackoverflow.com/questions/1165647\r\n   */\r\n  static isClockwise(polygon: Polygon): boolean {\r\n    const zeroX = Math.min(0, ...polygon.map(p => p.x));\r\n    const zeroY = Math.min(0, ...polygon.map(p => p.y));\r\n    const v = polygon.map(p => ({ x: p.x - zeroX, y: p.y - zeroY}));\r\n    let sum = 0;\r\n    for (let i = 0; i < v.length; i++) {\r\n      const v1 = v[i];\r\n      const v2 = v[(i + 1) % v.length];\r\n      sum += (v2.x - v1.x) * (v2.y + v1.y);\r\n    }\r\n    return sum >= 0;\r\n  }\r\n\r\n  /** Creates a Guid.\r\n   * @returns A new Guid.\r\n   */\r\n  static guid(): /* () => */ string {\r\n    const tS4 = function () {\r\n      return Math.floor((1 + Math.random()) * 0x10000)\r\n        .toString(16)\r\n        .substring(1);\r\n    };\r\n\r\n    return tS4() + tS4() + '-' + tS4() + '-' + tS4() + '-' +\r\n      tS4() + '-' + tS4() + tS4() + tS4();\r\n  }\r\n\r\n  /** both arguments are Polygon (arrays with x,y attributes) */\r\n  static polygonPolygonIntersect(first: Polygon, second: Polygon): boolean {\r\n    for (let tI = 0; tI < first.length; tI++) {\r\n      const tFirstCorner = first[tI];\r\n      let tSecondCorner;\r\n\r\n      if (tI === first.length - 1) {\r\n        tSecondCorner = first[0];\r\n      } else {\r\n        tSecondCorner = first[tI + 1];\r\n      }\r\n\r\n      if (Utils.linePolygonIntersect(\r\n        tFirstCorner.x, tFirstCorner.y,\r\n        tSecondCorner.x, tSecondCorner.y,\r\n        second)) {\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /** Polygon is an array of points with x,y attributes */\r\n  static linePolygonIntersect(x1: number, y1: number, x2: number, y2: number, polygon: Polygon): boolean {\r\n    for (let tI = 0; tI < polygon.length; tI++) {\r\n      const tFirstCorner = polygon[tI];\r\n      let tSecondCorner;\r\n\r\n      if (tI === polygon.length - 1) {\r\n        tSecondCorner = polygon[0];\r\n      } else {\r\n        tSecondCorner = polygon[tI + 1];\r\n      }\r\n\r\n      if (Utils.lineLineIntersect(x1, y1, x2, y2,\r\n        tFirstCorner.x, tFirstCorner.y,\r\n        tSecondCorner.x, tSecondCorner.y)) {\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /** */\r\n  static lineLineIntersect(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): boolean {\r\n    function tCCW(p1, p2, p3) {\r\n      const tA = p1.x;\r\n      const tB = p1.y;\r\n      const tC = p2.x;\r\n      const tD = p2.y;\r\n      const tE = p3.x;\r\n      const tF = p3.y;\r\n      return (tF - tB) * (tC - tA) > (tD - tB) * (tE - tA);\r\n    }\r\n\r\n    const tP1 = { x: x1, y: y1 };\r\n    const tP2 = { x: x2, y: y2 };\r\n    const tP3 = { x: x3, y: y3 };\r\n    const tP4 = { x: x4, y: y4 };\r\n    return (tCCW(tP1, tP3, tP4) !== tCCW(tP2, tP3, tP4)) && (tCCW(tP1, tP2, tP3) !== tCCW(tP1, tP2, tP4));\r\n  }\r\n\r\n  /* based on https://stackoverflow.com/questions/13937782/calculating-the-point-of-intersection-of-two-lines/#answer-38977789 */\r\n  static linesIntersection(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number): number[] {\r\n    const denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);\r\n    if (denom === 0) {\r\n        return null;\r\n    }\r\n    const ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom;\r\n    return [\r\n        x1 + ua * (x2 - x1),\r\n        y1 + ua * (y2 - y1)\r\n    ];\r\n  }\r\n\r\n  /**\r\n   @param polygon Is an array of points with x,y attributes\r\n    @param startX X start coord for raycast\r\n    @param startY Y start coord for raycast\r\n  */\r\n  static pointInPolygon(x: number, y: number, polygon: Polygon, startX?: number, startY?: number): boolean {\r\n\r\n    // ensure that point(startX, startY) is outside the polygon\r\n    let tMinX = 0;\r\n    let tMinY = 0;\r\n\r\n    if (startX === undefined || startY === undefined) {\r\n      for (let tI = 0; tI < polygon.length; tI++) {\r\n        tMinX = Math.min(tMinX, polygon[tI].x);\r\n        tMinY = Math.min(tMinX, polygon[tI].y);\r\n      }\r\n      startX = tMinX - 10;\r\n      startY = tMinY - 10;\r\n    }\r\n\r\n    let tIntersects = 0;\r\n    for (let tI = 0; tI < polygon.length; tI++) {\r\n      const tFirstCorner = polygon[tI];\r\n      let tSecondCorner;\r\n      if (tI === polygon.length - 1) {\r\n        tSecondCorner = polygon[0];\r\n      } else {\r\n        tSecondCorner = polygon[tI + 1];\r\n      }\r\n\r\n      if (Utils.lineLineIntersect(startX, startY, x, y,\r\n        tFirstCorner.x, tFirstCorner.y,\r\n        tSecondCorner.x, tSecondCorner.y)) {\r\n        tIntersects++;\r\n      }\r\n    }\r\n    // odd intersections means the point is in the polygon\r\n    return ((tIntersects % 2) === 1);\r\n  }\r\n\r\n  /** Checks if all corners of inside polygon are inside the outside polygon */\r\n  static polygonInsidePolygon(inside: Polygon, outside: Polygon, startX?: number, startY?: number): boolean {\r\n\r\n    for (let tI = 0; tI < inside.length; tI++) {\r\n      if (!Utils.pointInPolygon(\r\n        inside[tI].x, inside[tI].y,\r\n        outside,\r\n        startX, startY)) {\r\n        return false;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /** Checks if any corners of inside polygon are inside the second outside polygon */\r\n  static polygonOutsidePolygon(inside: Polygon, outside: Polygon, startX?: number, startY?: number): boolean {\r\n    startX = startX || 0;\r\n    startY = startY || 0;\r\n\r\n    for (let tI = 0; tI < inside.length; tI++) {\r\n      if (Utils.pointInPolygon(\r\n        inside[tI].x, inside[tI].y,\r\n        outside,\r\n        startX, startY)) {\r\n        return false;\r\n      }\r\n    }\r\n    return true;\r\n  }\r\n\r\n  static cloneMaterial(material: Material | Material[]): Material | Material[] {\r\n    if (material instanceof Material) {\r\n      return material.clone();\r\n    }\r\n    return material.map((m: Material) => m.clone());\r\n  }\r\n\r\n  static cloneObject3D(source: Object3D): Object3D {\r\n    const newObject = new Object3D();\r\n    source.children.forEach((child: any) => {\r\n      if (!child.visible) { return; }\r\n      if (child instanceof Mesh) {\r\n        newObject.add(child.clone());\r\n      } else if (child instanceof Object3D) {\r\n        const clone = this.cloneObject3D(child);\r\n        clone.position.copy(child.position);\r\n        clone.rotation.copy(child.rotation);\r\n        newObject.add(clone);\r\n      }\r\n    });\r\n    return newObject;\r\n  }\r\n\r\n  static cloneGroup(source: Group, meshMaterial?: MeshBasicMaterial): Group {\r\n    const newGroup = <Group>this.cloneObject3D(source);\r\n    if (meshMaterial) {\r\n      newGroup.traverse((child: any) => {\r\n        if (child instanceof Mesh) {\r\n          child.material = meshMaterial;\r\n        }\r\n      });\r\n    }\r\n    return newGroup;\r\n  }\r\n\r\n  // arrays\r\n\r\n  static forEach(array, action) {\r\n    for (let tI = 0; tI < array.length; tI++) {\r\n      action(array[tI]);\r\n    }\r\n  }\r\n\r\n  static forEachIndexed(array, action) {\r\n    for (let tI = 0; tI < array.length; tI++) {\r\n      action(tI, array[tI]);\r\n    }\r\n  }\r\n\r\n  static map(array, func) {\r\n    const tResult = [];\r\n    array.forEach((element) => {\r\n      tResult.push(func(element));\r\n    });\r\n    return tResult;\r\n  }\r\n\r\n  /** Remove elements in array if func(element) returns true */\r\n  static removeIf(array, func) {\r\n    const tResult = [];\r\n    array.forEach((element) => {\r\n      if (!func(element)) {\r\n        tResult.push(element);\r\n      }\r\n    });\r\n    return tResult;\r\n  }\r\n\r\n  /** Shift the items in an array by shift (positive integer) */\r\n  static cycle(arr, shift) {\r\n    const tReturn = arr.slice(0);\r\n    for (let tI = 0; tI < shift; tI++) {\r\n      const tmp = tReturn.shift();\r\n      tReturn.push(tmp);\r\n    }\r\n    return tReturn;\r\n  }\r\n\r\n  /** Returns in the unique elemnts in arr */\r\n  static unique(arr, hashFunc) {\r\n    const tResults = [];\r\n    const tMap = {};\r\n    for (let tI = 0; tI < arr.length; tI++) {\r\n      if (!tMap.hasOwnProperty(arr[tI])) {\r\n        tResults.push(arr[tI]);\r\n        tMap[hashFunc(arr[tI])] = true;\r\n      }\r\n    }\r\n    return tResults;\r\n  }\r\n\r\n  /** Remove value from array, if it is present */\r\n  static removeValue(array, value) {\r\n    for (let tI = array.length - 1; tI >= 0; tI--) {\r\n      if (array[tI] === value) {\r\n        array.splice(tI, 1);\r\n      }\r\n    }\r\n  }\r\n\r\n  /** Checks if value is in array */\r\n  static hasValue = function (array, value): boolean {\r\n    for (let tI = 0; tI < array.length; tI++) {\r\n      if (array[tI] === value) {\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  };\r\n\r\n  /** Subtracts the elements in subArray from array */\r\n  static subtract(array, subArray) {\r\n    return Utils.removeIf(array, function (el) {\r\n      return Utils.hasValue(subArray, el);\r\n    });\r\n  }\r\n\r\n  /** based on https://stackoverflow.com/questions/16285134/calculating-polygon-area#answer-33670691 */\r\n  static polygonArea(vertices: Polygon): number {\r\n    let total = 0;\r\n\r\n    for (let i = 0, l = vertices.length; i < l; i++) {\r\n      const addX = vertices[i].x;\r\n      const addY = vertices[i === vertices.length - 1 ? 0 : i + 1].y;\r\n      const subX = vertices[i === vertices.length - 1 ? 0 : i + 1].x;\r\n      const subY = vertices[i].y;\r\n\r\n      total += (addX * addY * 0.5);\r\n      total -= (subX * subY * 0.5);\r\n    }\r\n\r\n    return Math.abs(total);\r\n  }\r\n\r\n  static polygonCenter(vertices: Polygon): { x: number, y: number } {\r\n    const sm = vertices.reduce((a: {x: number, y: number}, v) => {\r\n      a.x += v.x;\r\n      a.y += v.y;\r\n      return a;\r\n    }, { x: 0, y: 0 });\r\n    return {\r\n      x: sm.x / vertices.length,\r\n      y: sm.y / vertices.length\r\n    };\r\n  }\r\n\r\n  static getTranslatedLine(\r\n    start: Vector2, end: Vector2,\r\n    angle: number, distance: number\r\n  ): { start: Vector2, end: Vector2 } {\r\n    return {\r\n      start: new Vector2(\r\n        start.x + Math.cos(angle) * distance,\r\n        start.y + Math.sin(angle) * distance\r\n      ),\r\n      end: new Vector2(\r\n        end.x + Math.cos(angle) * distance,\r\n        end.y + Math.sin(angle) * distance\r\n      )\r\n    };\r\n  }\r\n\r\n  static pointOnAngleAxis(distance: number, angle: number, dx: number, dy: number): { x: number, y: number } {\r\n    const xd: number = distance * Math.cos(angle / 2 + Math.atan(dy / dx));\r\n    const yd: number = distance * Math.sin(angle / 2 + Math.atan(dy / dx));\r\n    return { x: xd, y: yd };\r\n  }\r\n\r\n  static selectPointInsidePolygon(\r\n    origCorner: {x: number, y: number},\r\n    delta: {x: number, y: number},\r\n    origCorners: Polygon\r\n  ): {x: number, y: number} {\r\n    const zeroX = Math.min(0, ...origCorners.map(c => c.x));\r\n    const zeroY = Math.min(0, ...origCorners.map(c => c.y));\r\n    const corner = { x: origCorner.x - zeroX, y: origCorner.y - zeroY };\r\n    const corners = origCorners.map(c => new Vector2(\r\n      c.x - zeroX,\r\n      c.y - zeroY\r\n    ));\r\n    const { x, y } = corner;\r\n    const { x: xd, y: yd } = delta;\r\n    if (Utils.pointInPolygon(x + xd, y + yd, corners)) {\r\n      return { x: x + xd + zeroX, y: y + yd + zeroY};\r\n    } else if (Utils.pointInPolygon(x - xd, y - yd, corners)) {\r\n      return { x: x - xd + zeroX, y: y - yd + zeroY};\r\n    } if (Utils.pointInPolygon(x - yd, y + xd, corners)) {\r\n      return { x: x - yd + zeroX, y: y + xd + zeroY};\r\n    } else if (Utils.pointInPolygon(x + yd, y - xd, corners)) {\r\n      return { x: x + yd + zeroX, y: y - xd + zeroY};\r\n    } else { // this should never happen\r\n      return { x : x + zeroX, y: y + zeroY };\r\n    }\r\n  }\r\n\r\n  static setPlaneVisibility(plane: Mesh, isVisible: boolean) {\r\n    if ((plane.material as any).length) {\r\n      (plane.material as Material[]).forEach((m: Material) => {\r\n        m.opacity = isVisible ? 1 : 0;\r\n        m.transparent = !isVisible;\r\n        m.depthWrite = isVisible;\r\n        m.depthTest = isVisible;\r\n      });\r\n    } else {\r\n      (plane.material as Material).opacity = isVisible ? 1 : 0;\r\n      (plane.material as Material).transparent = !isVisible;\r\n      (plane.material as Material).depthWrite = isVisible;\r\n      (plane.material as Material).depthTest = isVisible;\r\n    }\r\n  }\r\n\r\n  static snapAngle(angle: number, snap: number = Math.PI / 12): number {\r\n    return Math.round(angle / snap) * snap;\r\n  }\r\n\r\n  static moveAtAxis(\r\n    position: Vector3,\r\n    rotation: Euler,\r\n    axis: 'x' | 'y' | 'z',\r\n    axisValue: number\r\n  ): Vector3 {\r\n    const positionCopy = position.clone();\r\n    positionCopy[axis] = axisValue;\r\n    return positionCopy;\r\n  }\r\n\r\n  private static DisposeNode(node: Object3D | Mesh): void {\r\n    node.traverse((obj: Object3D) => {\r\n      if (obj instanceof Mesh) {\r\n        if (obj.geometry) {\r\n          obj.geometry.dispose();\r\n        }\r\n        Utils.DisposeMaterial(obj.material);\r\n      }\r\n      if (typeof (obj as any).dispose === 'function') {\r\n        // @ts-ignore\r\n        obj.dispose();\r\n      }\r\n    });\r\n  }\r\n\r\n  public static DisposeMaterial(material: Material | Material[]): void {\r\n    if (!material) {\r\n      return;\r\n    }\r\n    if (Array.isArray(material)) {\r\n      material.forEach(mtrl => {\r\n        this.materialProps\r\n          .filter(mapType => mtrl[mapType])\r\n          .forEach(mapType => mtrl[mapType].dispose());\r\n        mtrl.dispose();    // disposes any programs associated with the material\r\n      });\r\n    } else {\r\n      this.materialProps\r\n        .filter(mapType => material[mapType] && material[mapType].dispose)\r\n        .forEach(mapType => material[mapType].dispose());\r\n      if (material.dispose) {\r\n        material.dispose();   // disposes any programs associated with the material\r\n      }\r\n    }\r\n  }\r\n\r\n  public static DisposeObject(object: Object3D | Mesh): void {\r\n    if (!object) {\r\n      return;\r\n    }\r\n    if (object.children.length) {\r\n      object.children.forEach(child => this.DisposeObject(child));\r\n    }\r\n    this.DisposeNode(object);\r\n  }\r\n\r\n  static polygonUnion(p1: Polygon, p2: Polygon): Polygon {\r\n    const a1 = p1.map(p => [p.x, p.y]);\r\n    const a2 = p2.map(p => [p.x, p.y]);\r\n    const a = PolygonTools.polygon.union(a1, a2);\r\n    if (a && a.length) {\r\n      const polygon: Polygon = a[0].map(coords => new Vector2(coords[0], coords[1]));\r\n      return polygon;\r\n    } else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  static polygonsUnion(polygons: Polygon[]): Polygon[] {\r\n    if (!polygons || !polygons.length) {\r\n      return [];\r\n    }\r\n    if (polygons.length < 2) {\r\n      return polygons;\r\n    }\r\n    const first = polygons[0].map(point => point.clone());\r\n    const others = polygons.slice(1);\r\n    return this.oneToRest(first, others);\r\n  }\r\n\r\n  private static oneToRest(first: Polygon, others: Polygon[]): Polygon[] {\r\n    const overlapping = others.find((second: Polygon) =>\r\n      this.polygonPolygonIntersect(first, second));\r\n    if (overlapping) {\r\n      // remove overlapping\r\n      const combinedPolygons = others.filter(p => p !== overlapping);\r\n      // combine first with overlapping\r\n      const union = this.polygonUnion(first, overlapping);\r\n      const combined = combinedPolygons.concat([union]);\r\n      return this.polygonsUnion(combined);\r\n    } else if (others.length > 1) {\r\n      return [first, ...this.polygonsUnion(others)];\r\n    } else {\r\n      return [first, ...others];\r\n    }\r\n  }\r\n\r\n  public static uniqFn<T>(v: T, i: number, a: T[]): boolean {\r\n    return a.indexOf(v) === i;\r\n  }\r\n\r\n  public static sampleSize<T>(input: T[], targetCount: number = 1): T[] {\r\n    const eachNo = Math.trunc(input.length / targetCount) ||  1;\r\n    return input.filter((v, i) => 0 === i % eachNo);\r\n  }\r\n\r\n  public static toString(v: Vector3 | Euler): string {\r\n    const dec = 100;\r\n    return `[${Math.round(v.x * dec) / dec},${Math.round(v.y * dec) / dec},${Math.round(v.z * dec) / dec}]`;\r\n  }\r\n\r\n  // TODO: Needs to be made compatible with BufferGeometry when method becomes used\r\n  public static geometryMeshToWorldVertices(mesh: Mesh, sampleSize?: number): Vector3[] {\r\n    // const geo = mesh.geometry as BufferGeometry;\r\n    // const worldProps = Utils.worldProps(mesh);\r\n    // let sampled = geo.vertices;\r\n    // if (sampleSize) {\r\n    //   sampled = Utils.sampleSize(geo.vertices, sampleSize);\r\n    // }\r\n    // return sampled.map((v: Vector3)  => {\r\n    //   const vertex = v.clone();\r\n    //   worldProps.forEach((p: WorldProp) => vertex.applyMatrix4(p.matrix));\r\n    //   return vertex;\r\n    // });\r\n    return [];\r\n  }\r\n\r\n  public static bufferGeometryMeshToWorldVertices(mesh: Mesh, sampleSize?: number): Vector3[] {\r\n    const geo = mesh.geometry as BufferGeometry;\r\n    const worldProps = Utils.worldProps(mesh);\r\n    const vertices: Vector3[] = [];\r\n    const positions = geo.getAttribute('position') as BufferAttribute;\r\n    let increment = 1;\r\n    if (sampleSize) {\r\n      increment = Math.trunc(positions.count / sampleSize) ||  1;\r\n    }\r\n    for (let i = 0, len = positions.count; i < len; i += increment) {\r\n      const vertex = new Vector3().fromBufferAttribute(positions, i);\r\n      worldProps.forEach((p: WorldProp) => vertex\r\n        .sub(p.position)\r\n        .applyAxisAngle(Utils.axisY, -p.rotation.y)\r\n        .applyMatrix4(p.matrix)\r\n      );\r\n      vertices.push(vertex);\r\n    }\r\n    return vertices;\r\n  }\r\n\r\n  public static worldProps(mesh: Mesh): WorldProp[] {\r\n    const worldProps: WorldProp[] = [];\r\n    let object: Mesh | Object3D = mesh;\r\n    while (object && !(object instanceof Scene)) {\r\n      worldProps.push({\r\n        matrix: object.matrixWorld.clone(),\r\n        position: object.position.clone(),\r\n        rotation: object.rotation.clone()\r\n      });\r\n      object = object.parent;\r\n    }\r\n    return worldProps;\r\n  }\r\n\r\n  public static isCamera(object: {name: string}): boolean {\r\n    return object.name === 'Camera';\r\n  }\r\n\r\n  public static GetVector3ArrayFromBufferAttribute(bufferAttribute: BufferAttribute): Vector3[] {\r\n    const vector3Array: Vector3[] = [];\r\n    for (let i = 0; i < bufferAttribute.count; i++) {\r\n      vector3Array.push(new Vector3(bufferAttribute.getX(i), bufferAttribute.getY(i), bufferAttribute.getZ(i)));\r\n    }\r\n    return vector3Array;\r\n  }\r\n\r\n  public static ApplyBufferAttributeMatrixTransform(bufferAttribute: BufferAttribute, transform: Matrix4): void {\r\n    const tempVector: Vector3 = new Vector3();\r\n    for (let i = 0; i < bufferAttribute.count; i++) {\r\n      tempVector.set(bufferAttribute.getX(i), bufferAttribute.getY(i), bufferAttribute.getZ(i));\r\n      tempVector.applyMatrix4(transform);\r\n      bufferAttribute.setXYZ(i, tempVector.x, tempVector.y, tempVector.z);\r\n    }\r\n    bufferAttribute.needsUpdate = true;\r\n  }\r\n\r\n  public static GetFaceNormalFromBufferGeometry(bufferGeometry: BufferGeometry, faceIndex: number, vertexIndex: number): Vector3 {\r\n    bufferGeometry.computeVertexNormals();\r\n    const index: number = 3 * faceIndex + vertexIndex;\r\n    const normalAttribute: BufferAttribute = <BufferAttribute>bufferGeometry.getAttribute('normal');\r\n    return new Vector3(normalAttribute.getX(index), normalAttribute.getY(index), normalAttribute.getZ(index));\r\n  }\r\n}\r\n"]}