@itwin/core-geometry 3.0.0-dev.76 → 3.0.0-dev.80

package/lib/esm/geometry3d/PolygonOps.d.ts

@@ -0,0 +1,306 @@
+/** @packageDocumentation
+ * @module CartesianGeometry
+ */
+import { PlaneAltitudeEvaluator } from "../Geometry";
+import { Matrix4d } from "../geometry4d/Matrix4d";
+import { GrowableXYZArray } from "./GrowableXYZArray";
+import { IndexedReadWriteXYZCollection, IndexedXYZCollection } from "./IndexedXYZCollection";
+import { Point2d } from "./Point2dVector2d";
+import { Point3d, Vector3d } from "./Point3dVector3d";
+import { Range1d, Range3d } from "./Range";
+import { Ray3d } from "./Ray3d";
+import { XAndY } from "./XYZProps";
+/**
+ * Carrier for a loop extracted from clip operation, annotated for sorting
+ * @internal
+ */
+export declare class CutLoop {
+    xyz: GrowableXYZArray;
+    edge?: Ray3d;
+    sortCoordinate0: number;
+    sortCoordinate1: number;
+    sortDelta: number;
+    isNotch: boolean;
+    constructor(xyz: GrowableXYZArray);
+    /**
+     * Create a `CutLoop` structure annotated with the vector from last point to first.
+     * @param xyz coordinates to capture
+     */
+    static createCaptureWithReturnEdge(xyz: GrowableXYZArray): CutLoop;
+    /**
+     * Set up coordinates for sort steps:
+     * * Make `sortCoordinate0` and `sortCoordinate` the (algebraically sorted) start and end fractions along the ray
+     * * Make `sortDelta` the oriented difference of those two
+     * * Hence sorting on the coordinates puts loops in left-to-right order by the their edge vector leftmost point.
+     */
+    setSortCoordinates(ray: Ray3d): void;
+    /** Return
+     * * 0 if other sort limits are not strictly contained in this.
+     * * 1 if other sort limits are strictly contained with same direction
+     * * -1 if other sort limits are strictly contained in opposite direction.
+     */
+    containsSortLimits(other: CutLoop): number;
+    /**
+     * * push coordinates from other onto this
+     * * reset this.sortCoordinate0 to other.sortCoordinate1
+     * @param other new coordinates
+     */
+    absorb(other: CutLoop): void;
+    /** Comparison function for system sort function applied to an array of CutLoop .... */
+    static sortFunction(loopA: CutLoop, loopB: CutLoop): number;
+    /** Return first point coordinates.
+     * * For type checking, assume array is not empty.
+     */
+    front(result?: Point3d): Point3d;
+    /** Return last point coordinates.
+     * * For type checking, assume array is not empty.
+     */
+    back(result?: Point3d): Point3d;
+}
+/**
+ * Context to hold an array of input loops and apply sort logic.
+ * * This is used when a non-convex face is clipped by a plane
+ * *  Simple convex clip logic in this case generates double-back edges that need to be eliminated.
+ * * This class manages the elimination.
+ * * Usage pattern is:
+ * @internal
+ */
+export declare class CutLoopMergeContext {
+    /** Array (filled by user code) of loops being sorted. Contents are subject to being changed during sort. */
+    inputLoops: CutLoop[];
+    /** Array (filled by sortAndMergeLoops) of reorganized loops. */
+    outputLoops: CutLoop[];
+    constructor();
+    /**
+     *  * Search all start and end points for the one most distant from point0.
+     */
+    private mostDistantPoint;
+    /**
+     * * Find a long (probably longest) edge through start and end points of inputs.
+     * * Setup sortCoordinate0 and sortCoordinate1 along that edge for each loop
+     * * sort all inputLoop members by sortCoordinate0.
+     */
+    private sortInputs;
+    /**
+     * * sort all input loops by coordinate along the cut edge
+     * * sweep left to right, using start and end coordinates to decide if loops are outer or hole, and combine holes into their containing outer loops.
+     */
+    sortAndMergeLoops(): void;
+}
+/** Static class for operations that treat an array of points as a polygon (with area!) */
+/**
+ * Various (static method) computations for arrays of points interpreted as a polygon.
+ * @public
+ */
+export declare class PolygonOps {
+    /** Sum areas of triangles from points[0] to each far edge.
+     * * Consider triangles from points[0] to each edge.
+     * * Sum the areas(absolute, without regard to orientation) all these triangles.
+     * @returns sum of absolute triangle areas.
+     */
+    static sumTriangleAreas(points: Point3d[] | GrowableXYZArray): number;
+    /** Sum areas of triangles from points[0] to each far edge.
+     * * Consider triangles from points[0] to each edge.
+     * * Sum the areas(absolute, without regard to orientation) all these triangles.
+     * @returns sum of absolute triangle areas.
+     */
+    static sumTriangleAreasXY(points: Point3d[]): number;
+    /** These values are the integrated area moment products [xx,xy,xz, x]
+     * for a right triangle in the first quadrant at the origin -- (0,0),(1,0),(0,1)
+     */
+    private static readonly _triangleMomentWeights;
+    /** These values are the integrated volume moment products [xx,xy,xz, x, yx,yy,yz,y, zx,zy,zz,z,x,y,z,1]
+     * for a tetrahedron in the first quadrant at the origin -- (0,00),(1,0,0),(0,1,0),(0,0,1)
+     */
+    private static readonly _tetrahedralMomentWeights;
+    private static _vector0;
+    private static _vector1;
+    private static _vector2;
+    private static _vectorOrigin;
+    private static _normal;
+    private static _matrixA;
+    private static _matrixB;
+    private static _matrixC;
+    /** return a vector which is perpendicular to the polygon and has magnitude equal to the polygon area. */
+    static areaNormalGo(points: IndexedXYZCollection, result?: Vector3d): Vector3d | undefined;
+    /** return a vector which is perpendicular to the polygon and has magnitude equal to the polygon area. */
+    static areaNormal(points: Point3d[], result?: Vector3d): Vector3d;
+    /** return the area of the polygon.
+     * * This assumes the polygon is planar
+     * * This does NOT assume the polygon is on the xy plane.
+     */
+    static area(points: Point3d[]): number;
+    /** return the projected XY area of the polygon. */
+    static areaXY(points: Point3d[] | IndexedXYZCollection): number;
+    /**
+     * Return a Ray3d with (assuming the polygon is planar and not self-intersecting)
+     * * origin at the centroid of the (3D) polygon
+     * * normal is a unit vector perpendicular to the plane
+     * * 'a' member is the area.
+     * @param points
+     */
+    static centroidAreaNormal(points: IndexedXYZCollection | Point3d[]): Ray3d | undefined;
+    /**
+     * * Return (in caller-allocated centroid) the centroid of the xy polygon.
+     * * Return (as function value)  the area
+     */
+    static centroidAndAreaXY(points: Point2d[], centroid: Point2d): number | undefined;
+    /**
+     * Return a unit normal to the plane of the polygon.
+     * @param points array of points around the polygon.  This is assumed to NOT have closure edge.
+     * @param result caller-allocated result vector.
+     */
+    static unitNormal(points: IndexedXYZCollection, result: Vector3d): boolean;
+    /** Accumulate to the matrix of area products of a polygon with respect to an origin.
+     * The polygon is assumed to be planar and non-self-intersecting.
+     */
+    /** Accumulate to the matrix of area products of a polygon with respect to an origin.
+     * * The polygon is assumed to be planar and non-self-intersecting.
+     * * Accumulated values are integrals over triangles from point 0 of the polygon to other edges of the polygon.
+     * * Integral over each triangle is transformed to integrals from the given origin.
+     * @param points array of points around the polygon.   Final closure point is not needed.
+     * @param origin origin for global accumulation.
+     * @param moments 4x4 matrix where products are accumulated.
+     */
+    static addSecondMomentAreaProducts(points: IndexedXYZCollection, origin: Point3d, moments: Matrix4d): void;
+    /** Accumulate to the matrix of volume products of a polygon with respect to an origin.
+     * * The polygon is assumed to be planar and non-self-intersecting.
+     * * Accumulated values are integrals over tetrahedra from the origin to triangles on the polygon.
+     * @param points array of points around the polygon.   Final closure point is not needed.
+     * @param origin origin for tetrahedra
+     * @param moments 4x4 matrix where products are accumulated.
+     */
+    static addSecondMomentVolumeProducts(points: IndexedXYZCollection, origin: Point3d, moments: Matrix4d): void;
+    /** Return the matrix of area products of a polygon with respect to an origin.
+     * The polygon is assumed to be planar and non-self-intersecting.
+     * * `frameType===2` has xy vectors in the plane of the polygon, plus a unit normal z. (Used for area integrals)
+     * * `frameType===3` has vectors from origin to 3 points in the triangle. (Used for volume integrals)
+     */
+    private static addSecondMomentTransformedProducts;
+    /** Test the direction of turn at the vertices of the polygon, ignoring z-coordinates.
+     *
+     * *  For a polygon without self intersections, this is a convexity and orientation test: all positive is convex and counterclockwise,
+     * all negative is convex and clockwise
+     * *  Beware that a polygon which turns through more than a full turn can cross itself and close, but is not convex
+     * *  Returns 1 if all turns are to the left, -1 if all to the right, and 0 if there are any zero or reverse turns
+     */
+    static testXYPolygonTurningDirections(pPointArray: Point2d[] | Point3d[]): number;
+    /**
+     * Test if point (x,y) is IN, OUT or ON a polygon.
+     * @return (1) for in, (-1) for OUT, (0) for ON
+     * @param x x coordinate
+     * @param y y coordinate
+     * @param points array of xy coordinates.
+     */
+    static classifyPointInPolygon(x: number, y: number, points: XAndY[]): number | undefined;
+    /**
+     * Test if point (x,y) is IN, OUT or ON a polygon.
+     * @return (1) for in, (-1) for OUT, (0) for ON
+     * @param x x coordinate
+     * @param y y coordinate
+     * @param points array of xy coordinates.
+     */
+    static classifyPointInPolygonXY(x: number, y: number, points: IndexedXYZCollection): number | undefined;
+    /**
+     * Reverse loops as necessary to make them all have CCW orientation for given outward normal.
+     * @param loops
+     * @param outwardNormal
+     * @return the number of loops reversed.
+     */
+    static orientLoopsCCWForOutwardNormalInPlace(loops: IndexedReadWriteXYZCollection | IndexedReadWriteXYZCollection[], outwardNormal: Vector3d): number;
+    /**
+     * If reverse loops as necessary to make them all have CCW orientation for given outward normal.
+     * * Return an array of arrays which capture the input pointers.
+     * * In each first level array:
+     *    * The first loop is an outer loop.
+     *    * all subsequent loops are holes
+     *    * The outer loop is CCW
+     *    * The holes are CW.
+     * * Call RegionOps.sortOuterAndHoleLoopsXY to have the result returned as a UnionRegion
+     * @param loops multiple loops to sort and reverse.
+     */
+    static sortOuterAndHoleLoopsXY(loops: IndexedReadWriteXYZCollection[]): IndexedReadWriteXYZCollection[][];
+}
+/**
+ *  `IndexedXYZCollectionPolygonOps` class contains _static_ methods for typical operations on polygons carried as `IndexedXyZCollection`
+ * @public
+ */
+export declare class IndexedXYZCollectionPolygonOps {
+    private static _xyz0Work;
+    private static _xyz1Work;
+    private static _xyz2Work;
+    /**
+     * Split a (convex) polygon into 2 parts based on altitude evaluations.
+     * * POSITIVE ALTITUDE IS IN
+     * @param plane any `PlaneAltitudeEvaluator` object that can evaluate `plane.altitude(xyz)` for distance from the plane.
+     * @param xyz original polygon
+     * @param xyzPositive array to receive inside part (altitude > 0)
+     * @param xyzNegative array to receive outside part
+     * @param altitudeRange min and max altitudes encountered.
+     */
+    static splitConvexPolygonInsideOutsidePlane(plane: PlaneAltitudeEvaluator, xyz: IndexedReadWriteXYZCollection, xyzPositive: IndexedReadWriteXYZCollection, xyzNegative: IndexedReadWriteXYZCollection, altitudeRange: Range1d): void;
+    /**
+     * Clip a polygon to one side of a plane.
+     * * Results with 2 or fewer points are ignored.
+     * * Other than ensuring capacity in the arrays, there are no object allocations during execution of this function.
+     * * plane is passed as unrolled Point4d (ax,ay,az,aw) point (x,y,z) acts as homogeneous (x,y,z,1)
+     *   * `keepPositive === true` selects positive altitudes.
+     * @param plane any type that has `plane.altitude`
+     * @param xyz input points.
+     * @param work work buffer
+     * @param tolerance tolerance for "on plane" decision.
+     * @return the number of crossings.   If this is larger than 2, the result is "correct" in a parity sense but may have overlapping (hence cancelling) parts.
+     */
+    static clipConvexPolygonInPlace(plane: PlaneAltitudeEvaluator, xyz: GrowableXYZArray, work: GrowableXYZArray, keepPositive?: boolean, tolerance?: number): number;
+    /**
+     * * Input a "clipped" polygon (from clipConvexPolygonInPlace) with more than 2 crossings, i.e. is from a non-convex polygon with configurations like:
+     *   * multiple distinct polygons
+     *   * single polygon, but cut lines overlap and cancel by parity rules.
+     * * return 1 or more polygons, each having first and last points "on" the plane and intermediate points "off"
+     * * `minChainLength` indicates the shortest chain to be returned.
+     * @internal
+     */
+    static gatherCutLoopsFromPlaneClip(plane: PlaneAltitudeEvaluator, xyz: GrowableXYZArray, minChainLength?: number, tolerance?: number): CutLoopMergeContext;
+    /**
+     * * Input the loops from `gatherCutLoopsFromClipPlane`
+     * * Consolidate loops for reentrant configurations.
+     * * WARNING: The output reuses and modifies input loops whenever possible.
+     * @internal
+     */
+    static reorderCutLoops(loops: CutLoopMergeContext): void;
+    /**
+     * Return the intersection of the plane with a range cube.
+     * @param range
+     * @param xyzOut intersection polygon.  This is convex.
+     * @return reference to xyz if the polygon still has points; undefined if all points are clipped away.
+     */
+    static intersectRangeConvexPolygonInPlace(range: Range3d, xyz: GrowableXYZArray): GrowableXYZArray | undefined;
+}
+/**
+ * `Point3dArrayPolygonOps` class contains _static_ methods for typical operations on polygons carried as `Point3d[]`
+ * @public
+ */
+export declare class Point3dArrayPolygonOps {
+    private static _xyz0Work;
+    /**
+     * Split a (convex) polygon into 2 parts.
+     * @param xyz original polygon
+     * @param xyzIn array to receive inside part
+     * @param xyzOut array to receive outside part
+     * @param altitudeRange min and max altitudes encountered.
+     */
+    static convexPolygonSplitInsideOutsidePlane(plane: PlaneAltitudeEvaluator, xyz: Point3d[], xyzIn: Point3d[], xyzOut: Point3d[], altitudeRange: Range1d): void;
+    /** Return an array containing
+     * * All points that are exactly on the plane.
+     * * Crossing points between adjacent points that are (strictly) on opposite sides.
+     */
+    static polygonPlaneCrossings(plane: PlaneAltitudeEvaluator, xyz: Point3d[], crossings: Point3d[]): void;
+    /**
+     * Clip a polygon, returning the clip result in the same object.
+     * @param xyz input/output polygon
+     * @param work scratch object
+     * @param tolerance tolerance for on-plane decision.
+     */
+    static convexPolygonClipInPlace(plane: PlaneAltitudeEvaluator, xyz: Point3d[], work: Point3d[] | undefined, tolerance?: number): void;
+}
+//# sourceMappingURL=PolygonOps.d.ts.map

package/lib/esm/geometry3d/PolygonOps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PolygonOps.d.ts","sourceRoot":"","sources":["../../../src/geometry3d/PolygonOps.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,OAAO,EAAY,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAGlD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,6BAA6B,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC7F,OAAO,EAAE,OAAO,EAAY,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC;;;GAGG;AACH,qBAAa,OAAO;IAEX,GAAG,EAAE,gBAAgB,CAAC;IAEtB,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;gBACL,GAAG,EAAE,gBAAgB;IAOxC;;;OAGG;WACW,2BAA2B,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO;IAMzE;;;;;OAKG;IACI,kBAAkB,CAAC,GAAG,EAAE,KAAK;IAYpC;;;;OAIG;IACI,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAQjD;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,OAAO;IAI5B,uFAAuF;WACzE,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM;IAKlE;;OAEG;IACI,KAAK,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;IACvC;;OAEG;IACI,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,OAAO;CAEvC;AACD;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAC9B,4GAA4G;IACrG,UAAU,EAAE,OAAO,EAAE,CAAC;IAC7B,gEAAgE;IACzD,WAAW,EAAE,OAAO,EAAE,CAAC;;IAM9B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmBxB;;;;OAIG;IACH,OAAO,CAAC,UAAU;IAiBlB;;;OAGG;IACI,iBAAiB;CAoCzB;AACD,0FAA0F;AAC1F;;;GAGG;AACH,qBAAa,UAAU;IACrB;;;;OAIG;WACW,gBAAgB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,gBAAgB,GAAG,MAAM;IAwB5E;;;;OAIG;WACW,kBAAkB,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM;IAkB3D;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAA8J;IAC5M;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,yBAAyB,CAIA;IAIjD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAqB;IAC5C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAqB;IAC5C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAqB;IAC5C,OAAO,CAAC,MAAM,CAAC,aAAa,CAAqB;IACjD,OAAO,CAAC,MAAM,CAAC,OAAO,CAAqB;IAC3C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA6B;IACpD,yGAAyG;WAC3F,YAAY,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS;IAiBjG,yGAAyG;WAC3F,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAMxE;;;OAGG;WACW,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM;IAG7C,mDAAmD;WACrC,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,oBAAoB,GAAG,MAAM;IAqBtE;;;;;;OAMG;WACW,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,EAAE,GAAG,KAAK,GAAG,SAAS;IAyD7F;;;OAGG;WACW,iBAAiB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS;IAwBzF;;;;OAIG;WACW,UAAU,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,QAAQ,GAAG,OAAO;IAiBjF;;OAEG;IACH;;;;;;;OAOG;WACW,2BAA2B,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ;IAI1G;;;;;;OAMG;WACW,6BAA6B,CAAC,MAAM,EAAE,oBAAoB,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ;IAG5G;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,kCAAkC;IAuCjD;;;;;;OAMG;WACW,8BAA8B,CAAC,WAAW,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,MAAM;IA0BxF;;;;;;OAMG;WACW,sBAAsB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,GAAG,SAAS;IA2B/F;;;;;;OAMG;WACW,wBAAwB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,GAAG,MAAM,GAAG,SAAS;IA4B9G;;;;;OAKG;WACW,qCAAqC,CAAC,KAAK,EAAE,6BAA6B,GAAG,6BAA6B,EAAE,EAAE,aAAa,EAAE,QAAQ,GAAG,MAAM;IAoB5J;;;;;;;;;;OAUG;WACW,uBAAuB,CAAC,KAAK,EAAE,6BAA6B,EAAE,GAAG,6BAA6B,EAAE,EAAE;CAOjH;AACD;;;GAGG;AACH,qBAAa,8BAA8B;IACzC,OAAO,CAAC,MAAM,CAAC,SAAS,CAA6B;IACrD,OAAO,CAAC,MAAM,CAAC,SAAS,CAA6B;IACrD,OAAO,CAAC,MAAM,CAAC,SAAS,CAA6B;IACrD;;;;;;;;OAQG;WACW,oCAAoC,CAAC,KAAK,EAAE,sBAAsB,EAC9E,GAAG,EAAE,6BAA6B,EAClC,WAAW,EAAE,6BAA6B,EAC1C,WAAW,EAAE,6BAA6B,EAAE,aAAa,EAAE,OAAO;IA2CpE;;;;;;;;;;;OAWG;WACW,wBAAwB,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,gBAAgB,EAAE,IAAI,EAAE,gBAAgB,EAAE,YAAY,GAAE,OAAc,EAAE,SAAS,GAAE,MAAqC,GAAG,MAAM;IAsD5M;;;;;;;OAOG;WACW,2BAA2B,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,gBAAgB,EAAE,cAAc,GAAE,MAAU,EAAE,SAAS,GAAE,MAAqC,GAAG,mBAAmB;IAmClM;;;;;OAKG;WACW,eAAe,CAAC,KAAK,EAAE,mBAAmB;IAuBxD;;;;;OAKG;WACW,kCAAkC,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,SAAS;CAqCtH;AACD;;;GAGG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,MAAM,CAAC,SAAS,CAA6B;IAGrD;;;;;;OAMG;WACW,oCAAoC,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,EAAE,aAAa,EAAE,OAAO;IAQ7J;;;OAGG;WACW,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE;IAqBvG;;;;;OAKG;WACW,wBAAwB,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,SAAS,EAAE,SAAS,GAAE,MAAqC;CA0CpK"}