@mlightcad/data-model 1.3.0 → 1.3.3

package/lib/entity/AcDbCircle.js

@@ -1,249 +0,0 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { AcGeCircArc3d, AcGeVector3d, TAU } from '@mlightcad/geometry-engine';
-import { AcDbCurve } from './AcDbCurve';
-/**
- * Represents a circle entity in AutoCAD.
- *
- * A circle is a 2D geometric object defined by its center point and radius.
- * Circles are closed curves that can be used to create circular shapes
- * in drawings. The circle is always drawn in the plane defined by its normal vector.
- *
- * @example
- * ```typescript
- * // Create a circle with center at (0,0,0) and radius 5
- * const circle = new AcDbCircle(
- *   new AcGePoint3d(0, 0, 0),
- *   5
- * );
- *
- * // Access circle properties
- * console.log(`Center: ${circle.center}`);
- * console.log(`Radius: ${circle.radius}`);
- * console.log(`Normal: ${circle.normal}`);
- * ```
- */
-var AcDbCircle = /** @class */ (function (_super) {
-    __extends(AcDbCircle, _super);
-    /**
-     * Creates a new circle entity.
-     *
-     * This constructor creates a circle using the specified center point and radius.
-     * The center point must be in World Coordinate System (WCS) coordinates.
-     * The circle is created as a full circle (0 to 2π radians).
-     *
-     * @param center - The center point of the circle in WCS coordinates
-     * @param radius - The radius of the circle (must be positive)
-     * @param normal - The normal vector defining the plane of the circle (defaults to Z-axis)
-     *
-     * @example
-     * ```typescript
-     * // Create a circle in the XY plane
-     * const circle = new AcDbCircle(
-     *   new AcGePoint3d(10, 20, 0),
-     *   15
-     * );
-     *
-     * // Create a circle in a different plane
-     * const circleInYZ = new AcDbCircle(
-     *   new AcGePoint3d(0, 0, 0),
-     *   10,
-     *   AcGeVector3d.X_AXIS
-     * );
-     * ```
-     */
-    function AcDbCircle(center, radius, normal) {
-        if (normal === void 0) { normal = AcGeVector3d.Z_AXIS; }
-        var _this = _super.call(this) || this;
-        _this._geo = new AcGeCircArc3d(center, radius, 0, TAU, normal, AcGeVector3d.X_AXIS);
-        return _this;
-    }
-    Object.defineProperty(AcDbCircle.prototype, "center", {
-        /**
-         * Gets the center point of this circle.
-         *
-         * @returns The center point as a 3D point
-         *
-         * @example
-         * ```typescript
-         * const centerPoint = circle.center;
-         * console.log(`Circle center: ${centerPoint.x}, ${centerPoint.y}, ${centerPoint.z}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.center;
-        },
-        /**
-         * Sets the center point of this circle.
-         *
-         * @param value - The new center point
-         *
-         * @example
-         * ```typescript
-         * circle.center = new AcGePoint3d(5, 5, 0);
-         * ```
-         */
-        set: function (value) {
-            this._geo.center = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbCircle.prototype, "radius", {
-        /**
-         * Gets the radius of this circle.
-         *
-         * @returns The radius value
-         *
-         * @example
-         * ```typescript
-         * const radius = circle.radius;
-         * console.log(`Circle radius: ${radius}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.radius;
-        },
-        /**
-         * Sets the radius of this circle.
-         *
-         * @param value - The new radius value (must be positive)
-         *
-         * @example
-         * ```typescript
-         * circle.radius = 25;
-         * ```
-         */
-        set: function (value) {
-            this._geo.radius = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbCircle.prototype, "normal", {
-        /**
-         * Gets the normal vector of this circle.
-         *
-         * The normal vector defines the plane in which the circle lies.
-         *
-         * @returns The unit normal vector in WCS coordinates
-         *
-         * @example
-         * ```typescript
-         * const normal = circle.normal;
-         * console.log(`Circle normal: ${normal.x}, ${normal.y}, ${normal.z}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.normal;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbCircle.prototype, "geometricExtents", {
-        /**
-         * Gets the geometric extents (bounding box) of this circle.
-         *
-         * @returns The bounding box that encompasses the entire circle
-         *
-         * @example
-         * ```typescript
-         * const extents = circle.geometricExtents;
-         * console.log(`Circle bounds: ${extents.minPoint} to ${extents.maxPoint}`);
-         * ```
-         */
-        get: function () {
-            return this._geo.box;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(AcDbCircle.prototype, "closed", {
-        /**
-         * Gets whether this circle is closed.
-         *
-         * Circles are always closed entities, so this always returns true.
-         *
-         * @returns Always true for circles
-         */
-        get: function () {
-            return this._geo.closed;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Gets the grip points for this circle.
-     *
-     * Grip points are control points that can be used to modify the circle.
-     * For a circle, the grip point is the center point.
-     *
-     * @returns Array of grip points (center point)
-     *
-     * @example
-     * ```typescript
-     * const gripPoints = circle.subGetGripPoints();
-     * // gripPoints contains: [center]
-     * ```
-     */
-    AcDbCircle.prototype.subGetGripPoints = function () {
-        var gripPoints = new Array();
-        gripPoints.push(this.center);
-        return gripPoints;
-    };
-    /**
-     * Transforms this circle by the specified matrix.
-     *
-     * This method applies a geometric transformation to the circle, updating
-     * the center point, radius, and normal vector according to the transformation matrix.
-     *
-     * @param matrix - The transformation matrix to apply
-     * @returns This circle after transformation
-     *
-     * @example
-     * ```typescript
-     * const translationMatrix = AcGeMatrix3d.translation(10, 0, 0);
-     * circle.transformBy(translationMatrix);
-     * // Circle is now translated 10 units in the X direction
-     * ```
-     */
-    AcDbCircle.prototype.transformBy = function (matrix) {
-        this._geo.transform(matrix);
-        return this;
-    };
-    /**
-     * Draws this circle using the specified renderer.
-     *
-     * This method renders the circle as a circular arc using the circle's
-     * current style properties.
-     *
-     * @param renderer - The renderer to use for drawing
-     * @returns The rendered circle entity, or undefined if drawing failed
-     *
-     * @example
-     * ```typescript
-     * const renderedCircle = circle.draw(renderer);
-     * ```
-     */
-    AcDbCircle.prototype.draw = function (renderer) {
-        return renderer.circularArc(this._geo, this.lineStyle);
-    };
-    /** The entity type name */
-    AcDbCircle.typeName = 'Circle';
-    return AcDbCircle;
-}(AcDbCurve));
-export { AcDbCircle };
-//# sourceMappingURL=AcDbCircle.js.map

package/lib/entity/AcDbCircle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcDbCircle.js","sourceRoot":"","sources":["../../src/entity/AcDbCircle.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EACL,aAAa,EAKb,YAAY,EACZ,GAAG,EACJ,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAAgC,8BAAS;IAOvC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,oBACE,MAAqB,EACrB,MAAc,EACd,MAA0C;QAA1C,uBAAA,EAAA,SAAuB,YAAY,CAAC,MAAM;QAE1C,YAAA,MAAK,WAAE,SAAA;QACP,KAAI,CAAC,IAAI,GAAG,IAAI,aAAa,CAC3B,MAAM,EACN,MAAM,EACN,CAAC,EACD,GAAG,EACH,MAAM,EACN,YAAY,CAAC,MAAM,CACpB,CAAA;;IACH,CAAC;IAaD,sBAAI,8BAAM;QAXV;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;QACzB,CAAC;QAED;;;;;;;;;WASG;aACH,UAAW,KAAsB;YAC/B,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QAC1B,CAAC;;;OAdA;IA2BD,sBAAI,8BAAM;QAXV;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;QACzB,CAAC;QAED;;;;;;;;;WASG;aACH,UAAW,KAAa;YACtB,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QAC1B,CAAC;;;OAdA;IA6BD,sBAAI,8BAAM;QAbV;;;;;;;;;;;;WAYG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;QACzB,CAAC;;;OAAA;IAaD,sBAAI,wCAAgB;QAXpB;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;QACtB,CAAC;;;OAAA;IASD,sBAAI,8BAAM;QAPV;;;;;;WAMG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;QACzB,CAAC;;;OAAA;IAED;;;;;;;;;;;;;OAaG;IACH,qCAAgB,GAAhB;QACE,IAAM,UAAU,GAAG,IAAI,KAAK,EAAe,CAAA;QAC3C,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QAC5B,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gCAAW,GAAX,UAAY,MAAoB;QAC9B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAA;QAC3B,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,yBAAI,GAAJ,UAAK,QAAsB;QACzB,OAAO,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IACxD,CAAC;IA/MD,2BAA2B;IACX,mBAAQ,GAAW,QAAQ,CAAA;IA+M7C,iBAAC;CAAA,AAjND,CAAgC,SAAS,GAiNxC;SAjNY,UAAU"}

package/lib/entity/AcDbCurve.d.ts

@@ -1,42 +0,0 @@
-import { AcDbEntity } from './AcDbEntity';
-/**
- * Abstract base class for all curve entities.
- *
- * This class provides the fundamental functionality for all curve entities,
- * including the ability to determine if a curve is closed. A curve is
- * considered closed if its start point is identical to its end point.
- *
- * @example
- * ```typescript
- * class MyCurve extends AcDbCurve {
- *   get closed(): boolean {
- *     // Implementation to determine if curve is closed
- *     return this.startPoint.equals(this.endPoint);
- *   }
- * }
- * ```
- */
-export declare abstract class AcDbCurve extends AcDbEntity {
-    /** The entity type name */
-    static typeName: string;
-    /**
-     * Returns true if the curve is closed.
-     *
-     * A curve is considered closed if its start point is identical to its end point.
-     * This property is used by various operations that need to know if a curve
-     * forms a complete loop.
-     *
-     * @returns True if the curve is closed, false otherwise
-     *
-     * @example
-     * ```typescript
-     * const curve = new AcDbCircle();
-     * console.log('Is circle closed?', curve.closed); // true
-     *
-     * const line = new AcDbLine();
-     * console.log('Is line closed?', line.closed); // false
-     * ```
-     */
-    abstract get closed(): boolean;
-}
-//# sourceMappingURL=AcDbCurve.d.ts.map

package/lib/entity/AcDbCurve.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcDbCurve.d.ts","sourceRoot":"","sources":["../../src/entity/AcDbCurve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;;;;;;;;;;;;;;GAgBG;AACH,8BAAsB,SAAU,SAAQ,UAAU;IAChD,2BAA2B;IAC3B,OAAgB,QAAQ,EAAE,MAAM,CAAU;IAE1C;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,KAAK,MAAM,IAAI,OAAO,CAAA;CAC/B"}

package/lib/entity/AcDbCurve.js

@@ -1,44 +0,0 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { AcDbEntity } from './AcDbEntity';
-/**
- * Abstract base class for all curve entities.
- *
- * This class provides the fundamental functionality for all curve entities,
- * including the ability to determine if a curve is closed. A curve is
- * considered closed if its start point is identical to its end point.
- *
- * @example
- * ```typescript
- * class MyCurve extends AcDbCurve {
- *   get closed(): boolean {
- *     // Implementation to determine if curve is closed
- *     return this.startPoint.equals(this.endPoint);
- *   }
- * }
- * ```
- */
-var AcDbCurve = /** @class */ (function (_super) {
-    __extends(AcDbCurve, _super);
-    function AcDbCurve() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    /** The entity type name */
-    AcDbCurve.typeName = 'Curve';
-    return AcDbCurve;
-}(AcDbEntity));
-export { AcDbCurve };
-//# sourceMappingURL=AcDbCurve.js.map

package/lib/entity/AcDbCurve.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcDbCurve.js","sourceRoot":"","sources":["../../src/entity/AcDbCurve.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;;;;;;;;;;;;;;GAgBG;AACH;IAAwC,6BAAU;IAAlD;;IAuBA,CAAC;IAtBC,2BAA2B;IACX,kBAAQ,GAAW,OAAO,CAAA;IAqB5C,gBAAC;CAAA,AAvBD,CAAwC,UAAU,GAuBjD;SAvBqB,SAAS"}

package/lib/entity/AcDbEllipse.d.ts

@@ -1,207 +0,0 @@
-import { AcGePoint3d, AcGePoint3dLike, AcGePointLike, AcGeVector3dLike } from '@mlightcad/geometry-engine';
-import { AcGiRenderer } from '@mlightcad/graphic-interface';
-import { AcDbCurve } from './AcDbCurve';
-/**
- * Represents an ellipse entity in AutoCAD.
- *
- * An ellipse is a 2D geometric object defined by its center point, major and minor axes,
- * and optional start and end angles. Ellipses are curved shapes that can be used to
- * create elliptical shapes in drawings. The ellipse is always drawn in the plane
- * defined by its normal vector.
- *
- * @example
- * ```typescript
- * // Create a full ellipse
- * const ellipse = new AcDbEllipse(
- *   new AcGePoint3d(0, 0, 0),
- *   AcGeVector3d.Z_AXIS,
- *   AcGeVector3d.X_AXIS,
- *   10, // major axis radius
- *   5,  // minor axis radius
- *   0,  // start angle
- *   2 * Math.PI // end angle (full ellipse)
- * );
- *
- * // Access ellipse properties
- * console.log(`Center: ${ellipse.center}`);
- * console.log(`Major radius: ${ellipse.majorAxisRadius}`);
- * console.log(`Minor radius: ${ellipse.minorAxisRadius}`);
- * ```
- */
-export declare class AcDbEllipse extends AcDbCurve {
-    /** The entity type name */
-    static typeName: string;
-    /** The underlying geometric ellipse arc object */
-    private _geo;
-    /**
-     * Creates a new ellipse entity.
-     *
-     * This constructor creates an ellipse using the specified center point, normal vector,
-     * major axis, and radii. The center point must be in World Coordinate System (WCS) coordinates.
-     *
-     * @param center - The center point of the ellipse in WCS coordinates
-     * @param normal - The normal vector defining the plane of the ellipse
-     * @param majorAxis - The major axis vector in WCS coordinates
-     * @param majorAxisRadius - The radius of the major axis (must be positive)
-     * @param minorAxisRadius - The radius of the minor axis (must be positive)
-     * @param startAngle - The starting angle in radians (0 to 2π)
-     * @param endAngle - The ending angle in radians (0 to 2π)
-     *
-     * @example
-     * ```typescript
-     * // Create a full ellipse in the XY plane
-     * const fullEllipse = new AcDbEllipse(
-     *   new AcGePoint3d(0, 0, 0),
-     *   AcGeVector3d.Z_AXIS,
-     *   AcGeVector3d.X_AXIS,
-     *   20, // major radius
-     *   10, // minor radius
-     *   0,
-     *   2 * Math.PI
-     * );
-     *
-     * // Create a quarter ellipse
-     * const quarterEllipse = new AcDbEllipse(
-     *   new AcGePoint3d(10, 20, 0),
-     *   AcGeVector3d.Z_AXIS,
-     *   AcGeVector3d.X_AXIS,
-     *   15,
-     *   8,
-     *   0,
-     *   Math.PI / 2
-     * );
-     * ```
-     */
-    constructor(center: AcGePointLike, normal: AcGeVector3dLike, majorAxis: AcGeVector3dLike, majorAxisRadius: number, minorAxisRadius: number, startAngle: number, endAngle: number);
-    /**
-     * Gets the center point of this ellipse.
-     *
-     * @returns The center point as a 3D point
-     *
-     * @example
-     * ```typescript
-     * const centerPoint = ellipse.center;
-     * console.log(`Ellipse center: ${centerPoint.x}, ${centerPoint.y}, ${centerPoint.z}`);
-     * ```
-     */
-    get center(): AcGePoint3d;
-    /**
-     * Sets the center point of this ellipse.
-     *
-     * @param value - The new center point
-     *
-     * @example
-     * ```typescript
-     * ellipse.center = new AcGePoint3d(5, 5, 0);
-     * ```
-     */
-    set center(value: AcGePoint3dLike);
-    /**
-     * Gets the major axis radius of this ellipse.
-     *
-     * @returns The major axis radius value
-     *
-     * @example
-     * ```typescript
-     * const majorRadius = ellipse.majorAxisRadius;
-     * console.log(`Major radius: ${majorRadius}`);
-     * ```
-     */
-    get majorAxisRadius(): number;
-    /**
-     * Sets the major axis radius of this ellipse.
-     *
-     * @param value - The new major axis radius value (must be positive)
-     *
-     * @example
-     * ```typescript
-     * ellipse.majorAxisRadius = 25;
-     * ```
-     */
-    set majorAxisRadius(value: number);
-    /**
-     * Gets the minor axis radius of this ellipse.
-     *
-     * @returns The minor axis radius value
-     *
-     * @example
-     * ```typescript
-     * const minorRadius = ellipse.minorAxisRadius;
-     * console.log(`Minor radius: ${minorRadius}`);
-     * ```
-     */
-    get minorAxisRadius(): number;
-    /**
-     * Sets the minor axis radius of this ellipse.
-     *
-     * @param value - The new minor axis radius value (must be positive)
-     *
-     * @example
-     * ```typescript
-     * ellipse.minorAxisRadius = 12;
-     * ```
-     */
-    set minorAxisRadius(value: number);
-    /**
-     * Gets the normal vector of this ellipse.
-     *
-     * The normal vector defines the plane in which the ellipse lies.
-     *
-     * @returns The unit normal vector in WCS coordinates
-     *
-     * @example
-     * ```typescript
-     * const normal = ellipse.normal;
-     * console.log(`Ellipse normal: ${normal.x}, ${normal.y}, ${normal.z}`);
-     * ```
-     */
-    get normal(): AcGeVector3dLike;
-    /**
-     * Sets the normal vector of this ellipse.
-     *
-     * @param value - The new normal vector
-     *
-     * @example
-     * ```typescript
-     * ellipse.normal = AcGeVector3d.Y_AXIS;
-     * ```
-     */
-    set normal(value: AcGeVector3dLike);
-    /**
-     * Gets the geometric extents (bounding box) of this ellipse.
-     *
-     * @returns The bounding box that encompasses the entire ellipse
-     *
-     * @example
-     * ```typescript
-     * const extents = ellipse.geometricExtents;
-     * console.log(`Ellipse bounds: ${extents.minPoint} to ${extents.maxPoint}`);
-     * ```
-     */
-    get geometricExtents(): import("@mlightcad/geometry-engine").AcGeBox3d;
-    /**
-     * Gets whether this ellipse is closed.
-     *
-     * An ellipse is considered closed if the start and end angles are the same
-     * (forming a complete ellipse).
-     *
-     * @returns True if the ellipse is closed (forms a complete ellipse), false otherwise
-     */
-    get closed(): boolean;
-    /**
-     * Draws this ellipse using the specified renderer.
-     *
-     * This method renders the ellipse as an elliptical arc using the ellipse's
-     * current style properties.
-     *
-     * @param renderer - The renderer to use for drawing
-     * @returns The rendered ellipse entity, or undefined if drawing failed
-     *
-     * @example
-     * ```typescript
-     * const renderedEllipse = ellipse.draw(renderer);
-     * ```
-     */
-    draw(renderer: AcGiRenderer): import("@mlightcad/graphic-interface").AcGiEntity;
-}
-//# sourceMappingURL=AcDbEllipse.d.ts.map

package/lib/entity/AcDbEllipse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcDbEllipse.d.ts","sourceRoot":"","sources":["../../src/entity/AcDbEllipse.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EACX,eAAe,EACf,aAAa,EACb,gBAAgB,EACjB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAE3D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC,2BAA2B;IAC3B,OAAgB,QAAQ,EAAE,MAAM,CAAY;IAE5C,kDAAkD;IAClD,OAAO,CAAC,IAAI,CAAkB;IAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;gBAED,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,gBAAgB,EAC3B,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM;IAclB;;;;;;;;;;OAUG;IACH,IAAI,MAAM,IAAI,WAAW,CAExB;IAED;;;;;;;;;OASG;IACH,IAAI,MAAM,CAAC,KAAK,EAAE,eAAe,EAEhC;IAED;;;;;;;;;;OAUG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;;;;;;;;OASG;IACH,IAAI,eAAe,CAAC,KAAK,EAAE,MAAM,EAEhC;IAED;;;;;;;;;;OAUG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;;;;;;;;OASG;IACH,IAAI,eAAe,CAAC,KAAK,EAAE,MAAM,EAEhC;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,MAAM,IAcQ,gBAAgB,CAZjC;IAED;;;;;;;;;OASG;IACH,IAAI,MAAM,CAAC,KAAK,EAAE,gBAAgB,EAEjC;IAED;;;;;;;;;;OAUG;IACH,IAAI,gBAAgB,mDAEnB;IAED;;;;;;;OAOG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,QAAQ,EAAE,YAAY;CAG5B"}