@mlightcad/data-model 1.3.3 → 1.3.4

package/lib/entity/AcDbEllipse.js

@@ -0,0 +1,272 @@
+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 { AcGeEllipseArc3d } from '@mlightcad/geometry-engine';
+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}`);
+ * ```
+ */
+var AcDbEllipse = /** @class */ (function (_super) {
+    __extends(AcDbEllipse, _super);
+    /**
+     * 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
+     * );
+     * ```
+     */
+    function AcDbEllipse(center, normal, majorAxis, majorAxisRadius, minorAxisRadius, startAngle, endAngle) {
+        var _this = _super.call(this) || this;
+        _this._geo = new AcGeEllipseArc3d(center, normal, majorAxis, majorAxisRadius, minorAxisRadius, startAngle, endAngle);
+        return _this;
+    }
+    Object.defineProperty(AcDbEllipse.prototype, "center", {
+        /**
+         * 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: function () {
+            return this._geo.center;
+        },
+        /**
+         * Sets the center point of this ellipse.
+         *
+         * @param value - The new center point
+         *
+         * @example
+         * ```typescript
+         * ellipse.center = new AcGePoint3d(5, 5, 0);
+         * ```
+         */
+        set: function (value) {
+            this._geo.center = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbEllipse.prototype, "majorAxisRadius", {
+        /**
+         * 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: function () {
+            return this._geo.majorAxisRadius;
+        },
+        /**
+         * 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: function (value) {
+            this._geo.majorAxisRadius = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbEllipse.prototype, "minorAxisRadius", {
+        /**
+         * 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: function () {
+            return this._geo.minorAxisRadius;
+        },
+        /**
+         * 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: function (value) {
+            this._geo.minorAxisRadius = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbEllipse.prototype, "normal", {
+        /**
+         * 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: function () {
+            return this._geo.normal;
+        },
+        /**
+         * Sets the normal vector of this ellipse.
+         *
+         * @param value - The new normal vector
+         *
+         * @example
+         * ```typescript
+         * ellipse.normal = AcGeVector3d.Y_AXIS;
+         * ```
+         */
+        set: function (value) {
+            this._geo.normal = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbEllipse.prototype, "geometricExtents", {
+        /**
+         * 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: function () {
+            return this._geo.box;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbEllipse.prototype, "closed", {
+        /**
+         * 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: function () {
+            return this._geo.closed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * 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);
+     * ```
+     */
+    AcDbEllipse.prototype.draw = function (renderer) {
+        return renderer.ellipticalArc(this._geo, this.lineStyle);
+    };
+    /** The entity type name */
+    AcDbEllipse.typeName = 'Ellipse';
+    return AcDbEllipse;
+}(AcDbCurve));
+export { AcDbEllipse };
+//# sourceMappingURL=AcDbEllipse.js.map

package/lib/entity/AcDbEllipse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbEllipse.js","sourceRoot":"","sources":["../../src/entity/AcDbEllipse.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EACL,gBAAgB,EAKjB,MAAM,4BAA4B,CAAA;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAAiC,+BAAS;IAOxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,qBACE,MAAqB,EACrB,MAAwB,EACxB,SAA2B,EAC3B,eAAuB,EACvB,eAAuB,EACvB,UAAkB,EAClB,QAAgB;QAEhB,YAAA,MAAK,WAAE,SAAA;QACP,KAAI,CAAC,IAAI,GAAG,IAAI,gBAAgB,CAC9B,MAAM,EACN,MAAM,EACN,SAAS,EACT,eAAe,EACf,eAAe,EACf,UAAU,EACV,QAAQ,CACT,CAAA;;IACH,CAAC;IAaD,sBAAI,+BAAM;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,wCAAe;QAXnB;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe,CAAA;QAClC,CAAC;QAED;;;;;;;;;WASG;aACH,UAAoB,KAAa;YAC/B,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAA;QACnC,CAAC;;;OAdA;IA2BD,sBAAI,wCAAe;QAXnB;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,eAAe,CAAA;QAClC,CAAC;QAED;;;;;;;;;WASG;aACH,UAAoB,KAAa;YAC/B,IAAI,CAAC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAA;QACnC,CAAC;;;OAdA;IA6BD,sBAAI,+BAAM;QAbV;;;;;;;;;;;;WAYG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;QACzB,CAAC;QAED;;;;;;;;;WASG;aACH,UAAW,KAAuB;YAChC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QAC1B,CAAC;;;OAdA;IA2BD,sBAAI,yCAAgB;QAXpB;;;;;;;;;;WAUG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;QACtB,CAAC;;;OAAA;IAUD,sBAAI,+BAAM;QARV;;;;;;;WAOG;aACH;YACE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAA;QACzB,CAAC;;;OAAA;IAED;;;;;;;;;;;;;OAaG;IACH,0BAAI,GAAJ,UAAK,QAAsB;QACzB,OAAO,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC1D,CAAC;IAnOD,2BAA2B;IACX,oBAAQ,GAAW,SAAS,CAAA;IAmO9C,kBAAC;CAAA,AArOD,CAAiC,SAAS,GAqOzC;SArOY,WAAW"}

package/lib/entity/AcDbEntity.d.ts

@@ -0,0 +1,385 @@
+import { AcCmColor } from '@mlightcad/common';
+import { AcGeBox3d, AcGeMatrix3d, AcGePoint3d } from '@mlightcad/geometry-engine';
+import { AcGiEntity, AcGiLineStyle, AcGiRenderer } from '@mlightcad/graphic-interface';
+import { AcDbObject } from '../base/AcDbObject';
+import { AcDbOsnapMode } from '../misc';
+/**
+ * Abstract base class for all drawing entities.
+ *
+ * This class provides the fundamental functionality for all drawing entities,
+ * including layer management, color handling, linetype support, visibility,
+ * and geometric operations. All specific entity types (lines, circles, text, etc.)
+ * inherit from this class.
+ *
+ * @example
+ * ```typescript
+ * class MyEntity extends AcDbEntity {
+ *   get geometricExtents(): AcGeBox3d {
+ *     // Implementation for geometric extents
+ *   }
+ *
+ *   draw(renderer: AcGiRenderer): AcGiEntity | undefined {
+ *     // Implementation for drawing
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class AcDbEntity extends AcDbObject {
+    /** The entity type name */
+    static typeName: string;
+    /** The layer name this entity belongs to */
+    private _layer;
+    /** The color of this entity */
+    private _color;
+    /** The linetype name for this entity */
+    private _lineType;
+    /** The line weight for this entity */
+    private _lineWeight;
+    /** The linetype scale factor for this entity */
+    private _linetypeScale;
+    /** Whether this entity is visible */
+    private _visibility;
+    /** The transparency level of this entity (0-1) */
+    private _transparency;
+    /**
+     * Gets the type name of this entity.
+     *
+     * This method returns the entity type by removing the "AcDb" prefix
+     * from the constructor name.
+     *
+     * @returns The entity type name
+     *
+     * @example
+     * ```typescript
+     * const entity = new AcDbLine();
+     * console.log(entity.type); // "Line"
+     * ```
+     */
+    get type(): string;
+    /**
+     * Gets the name of the layer referenced by this entity.
+     *
+     * @returns The layer name
+     *
+     * @example
+     * ```typescript
+     * const layerName = entity.layer;
+     * ```
+     */
+    get layer(): string;
+    /**
+     * Sets the name of the layer for this entity.
+     *
+     * @param value - The new layer name
+     *
+     * @example
+     * ```typescript
+     * entity.layer = 'MyLayer';
+     * ```
+     */
+    set layer(value: string);
+    /**
+     * Gets the color information of this entity.
+     *
+     * @returns The color object for this entity
+     *
+     * @example
+     * ```typescript
+     * const color = entity.color;
+     * ```
+     */
+    get color(): AcCmColor;
+    /**
+     * Sets the color information for this entity.
+     *
+     * @param value - The new color object
+     *
+     * @example
+     * ```typescript
+     * entity.color = new AcCmColor(0xFF0000);
+     * ```
+     */
+    set color(value: AcCmColor);
+    /**
+     * Gets the RGB color of this entity after converting color index.
+     *
+     * This method handles the conversion of color indices (including ByLayer and ByBlock)
+     * to actual RGB colors. It resolves layer colors and block colors as needed.
+     *
+     * @returns The RGB color value as a number
+     *
+     * @example
+     * ```typescript
+     * const rgbColor = entity.rgbColor;
+     * console.log(`RGB: ${rgbColor.toString(16)}`);
+     * ```
+     */
+    get rgbColor(): number;
+    /**
+     * Gets the name of the line type referenced by this entity.
+     *
+     * @returns The linetype name
+     *
+     * @example
+     * ```typescript
+     * const lineType = entity.lineType;
+     * ```
+     */
+    get lineType(): string;
+    /**
+     * Sets the name of the line type for this entity.
+     *
+     * @param value - The new linetype name
+     *
+     * @example
+     * ```typescript
+     * entity.lineType = 'DASHED';
+     * ```
+     */
+    set lineType(value: string);
+    /**
+     * Gets the line weight used by this entity.
+     *
+     * @returns The line weight value
+     *
+     * @example
+     * ```typescript
+     * const weight = entity.lineWeight;
+     * ```
+     */
+    get lineWeight(): number;
+    /**
+     * Sets the line weight for this entity.
+     *
+     * @param value - The new line weight value
+     *
+     * @example
+     * ```typescript
+     * entity.lineWeight = 2;
+     * ```
+     */
+    set lineWeight(value: number);
+    /**
+     * Gets the line type scale factor of this entity.
+     *
+     * When an entity is first instantiated, its line type scale is initialized
+     * to an invalid value. When the entity is added to the database, if a
+     * linetype scale has not been specified for the entity, it is set to the
+     * database's current line type scale value.
+     *
+     * @returns The linetype scale factor
+     *
+     * @example
+     * ```typescript
+     * const scale = entity.linetypeScale;
+     * ```
+     */
+    get linetypeScale(): number;
+    /**
+     * Sets the line type scale factor for this entity.
+     *
+     * @param value - The new linetype scale factor
+     *
+     * @example
+     * ```typescript
+     * entity.linetypeScale = 2.0;
+     * ```
+     */
+    set linetypeScale(value: number);
+    /**
+     * Gets whether this entity is visible.
+     *
+     * @returns True if the entity is visible, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isVisible = entity.visibility;
+     * ```
+     */
+    get visibility(): boolean;
+    /**
+     * Sets whether this entity is visible.
+     *
+     * @param value - True to make the entity visible, false to hide it
+     *
+     * @example
+     * ```typescript
+     * entity.visibility = false; // Hide the entity
+     * ```
+     */
+    set visibility(value: boolean);
+    /**
+     * Gets the transparency level of this entity.
+     *
+     * @returns The transparency value (0-1, where 0 is opaque and 1 is fully transparent)
+     *
+     * @example
+     * ```typescript
+     * const transparency = entity.transparency;
+     * ```
+     */
+    get transparency(): number;
+    /**
+     * Sets the transparency level of this entity.
+     *
+     * @param value - The transparency value (0-1, where 0 is opaque and 1 is fully transparent)
+     *
+     * @example
+     * ```typescript
+     * entity.transparency = 0.5; // 50% transparent
+     * ```
+     */
+    set transparency(value: number);
+    /**
+     * Gets the grip points for this entity.
+     *
+     * Grip points are the control points that can be used to modify the entity.
+     * This method should be overridden by subclasses to provide entity-specific
+     * grip points.
+     *
+     * @returns Array of grip points as 3D points
+     *
+     * @example
+     * ```typescript
+     * const gripPoints = entity.subGetGripPoints();
+     * ```
+     */
+    subGetGripPoints(): AcGePoint3d[];
+    /**
+     * Gets the object snap points for this entity.
+     *
+     * Object snap points are the points that can be used for precise positioning
+     * when drawing or editing. This method should be overridden by subclasses
+     * to provide entity-specific snap points.
+     *
+     * @param osnapMode - The object snap mode
+     * @param gsSelectionMark - The selection mark
+     * @param pickPoint - The pick point
+     * @param lastPoint - The last point
+     * @param snapPoints - Array to populate with snap points
+     *
+     * @example
+     * ```typescript
+     * const snapPoints: AcGePoint3d[] = [];
+     * entity.subGetOsnapPoints(AcDbOsnapMode.Endpoint, 0, pickPoint, lastPoint, snapPoints);
+     * ```
+     */
+    subGetOsnapPoints(osnapMode: AcDbOsnapMode, gsSelectionMark: number, pickPoint: AcGePoint3d, lastPoint: AcGePoint3d, snapPoints: AcGePoint3d[]): void;
+    /**
+     * Transforms this entity by the specified matrix.
+     *
+     * This method applies a geometric transformation to the entity.
+     * Subclasses should override this method to provide entity-specific
+     * transformation behavior.
+     *
+     * @param matrix - The transformation matrix to apply
+     * @returns This entity after transformation
+     *
+     * @example
+     * ```typescript
+     * const matrix = AcGeMatrix3d.translation(10, 0, 0);
+     * entity.transformBy(matrix);
+     * ```
+     */
+    transformBy(matrix: AcGeMatrix3d): this;
+    /**
+     * Gets the geometric extents of this entity.
+     *
+     * This method should be implemented by subclasses to return the
+     * bounding box that encompasses the entire entity.
+     *
+     * @returns The geometric extents as a 3D bounding box
+     *
+     * @example
+     * ```typescript
+     * const extents = entity.geometricExtents;
+     * console.log(`Min: ${extents.minPoint}, Max: ${extents.maxPoint}`);
+     * ```
+     */
+    abstract get geometricExtents(): AcGeBox3d;
+    /**
+     * Draws this entity using the specified renderer.
+     *
+     * This method should be implemented by subclasses to provide
+     * entity-specific drawing behavior.
+     *
+     * @param renderer - The renderer to use for drawing
+     * @param delay - The flag to delay creating one rendered entity and just create one dummy
+     * entity. Renderer can delay heavy calculation operation to avoid blocking UI when this flag
+     * is true. For now, text and mtext entity supports this flag only. Other types of entities
+     * just ignore this flag.
+     * @returns The rendered entity, or undefined if drawing failed
+     *
+     * @example
+     * ```typescript
+     * const renderedEntity = entity.draw(renderer);
+     * ```
+     */
+    abstract draw(renderer: AcGiRenderer, delay?: boolean): AcGiEntity | undefined;
+    /**
+     * Triggers a modified event for this entity.
+     *
+     * This method notifies listeners that the entity has been modified.
+     *
+     * @example
+     * ```typescript
+     * entity.triggerModifiedEvent();
+     * ```
+     */
+    triggerModifiedEvent(): void;
+    /**
+     * Gets the line style for this entity.
+     *
+     * This method returns the line style based on the entity's linetype
+     * and other properties.
+     *
+     * @returns The line style object
+     *
+     * @example
+     * ```typescript
+     * const lineStyle = entity.lineStyle;
+     * ```
+     */
+    protected get lineStyle(): AcGiLineStyle;
+    /**
+     * Gets the line type for this entity.
+     *
+     * This method resolves the line type, handling ByLayer and ByBlock
+     * references as needed.
+     *
+     * @returns The resolved line type name
+     *
+     * @example
+     * ```typescript
+     * const lineType = entity.getLineType();
+     * ```
+     */
+    private getLineType;
+    /**
+     * Gets the color of the layer this entity belongs to.
+     *
+     * This method retrieves the color from the layer table for the
+     * layer this entity belongs to.
+     *
+     * @returns The layer color, or undefined if the layer doesn't exist
+     *
+     * @example
+     * ```typescript
+     * const layerColor = entity.getLayerColor();
+     * ```
+     */
+    protected getLayerColor(): AcCmColor | null;
+    /**
+     * Attaches entity information to a graphic interface entity.
+     *
+     * This method transfers essential entity properties (object ID, owner ID,
+     * layer name, and visibility) from this entity to the target graphic
+     * interface entity. This is typically used during the rendering process
+     * to ensure the graphic entity has the correct metadata.
+     *
+     * @param target - The graphic interface entity to attach information to
+     *
+     */
+    protected attachEntityInfo(target: AcGiEntity | null | undefined): void;
+}
+//# sourceMappingURL=AcDbEntity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AcDbEntity.d.ts","sourceRoot":"","sources":["../../src/entity/AcDbEntity.ts"],"names":[],"mappings":"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"}