@mlightcad/data-model 1.7.26 → 1.7.28

package/lib/entity/AcDbMLeader.js

@@ -0,0 +1,2122 @@
+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 __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { AcGeArea2d, AcGeBox3d, AcGeMatrix3d, AcGePoint3d, AcGePolyline2d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcGiMTextAttachmentPoint, AcGiMTextFlowDirection } from '@mlightcad/graphic-interface';
+import { AcDbRenderingCache, DEFAULT_TEXT_STYLE } from '../misc';
+import { AcDbEntity } from './AcDbEntity';
+/**
+ * Defines the type of leader line used by a multileader.
+ */
+export var AcDbMLeaderLineType;
+(function (AcDbMLeaderLineType) {
+    /** The leader line is not displayed. */
+    AcDbMLeaderLineType[AcDbMLeaderLineType["InvisibleLeader"] = 0] = "InvisibleLeader";
+    /** The leader line is drawn using straight segments. */
+    AcDbMLeaderLineType[AcDbMLeaderLineType["StraightLeader"] = 1] = "StraightLeader";
+    /** The leader line is drawn as a spline. */
+    AcDbMLeaderLineType[AcDbMLeaderLineType["SplineLeader"] = 2] = "SplineLeader";
+})(AcDbMLeaderLineType || (AcDbMLeaderLineType = {}));
+/**
+ * Defines the annotation content type used by a multileader.
+ */
+export var AcDbMLeaderContentType;
+(function (AcDbMLeaderContentType) {
+    /** No annotation content. */
+    AcDbMLeaderContentType[AcDbMLeaderContentType["NoneContent"] = 0] = "NoneContent";
+    /** Block annotation content. */
+    AcDbMLeaderContentType[AcDbMLeaderContentType["BlockContent"] = 1] = "BlockContent";
+    /** MText annotation content. */
+    AcDbMLeaderContentType[AcDbMLeaderContentType["MTextContent"] = 2] = "MTextContent";
+    /** Tolerance annotation content. */
+    AcDbMLeaderContentType[AcDbMLeaderContentType["ToleranceContent"] = 3] = "ToleranceContent";
+})(AcDbMLeaderContentType || (AcDbMLeaderContentType = {}));
+/**
+ * Defines the attachment direction of multileader text.
+ */
+export var AcDbMLeaderTextAttachmentDirection;
+(function (AcDbMLeaderTextAttachmentDirection) {
+    /** Text is attached horizontally. */
+    AcDbMLeaderTextAttachmentDirection[AcDbMLeaderTextAttachmentDirection["Horizontal"] = 0] = "Horizontal";
+    /** Text is attached vertically. */
+    AcDbMLeaderTextAttachmentDirection[AcDbMLeaderTextAttachmentDirection["Vertical"] = 1] = "Vertical";
+})(AcDbMLeaderTextAttachmentDirection || (AcDbMLeaderTextAttachmentDirection = {}));
+/**
+ * Defines the general direction of a leader branch.
+ */
+export var AcDbMLeaderDirectionType;
+(function (AcDbMLeaderDirectionType) {
+    /** Direction is not known or not applicable. */
+    AcDbMLeaderDirectionType[AcDbMLeaderDirectionType["Unknown"] = 0] = "Unknown";
+    /** Leader points to the left of the content. */
+    AcDbMLeaderDirectionType[AcDbMLeaderDirectionType["Left"] = 1] = "Left";
+    /** Leader points to the right of the content. */
+    AcDbMLeaderDirectionType[AcDbMLeaderDirectionType["Right"] = 2] = "Right";
+    /** Leader points above the content. */
+    AcDbMLeaderDirectionType[AcDbMLeaderDirectionType["Top"] = 3] = "Top";
+    /** Leader points below the content. */
+    AcDbMLeaderDirectionType[AcDbMLeaderDirectionType["Bottom"] = 4] = "Bottom";
+})(AcDbMLeaderDirectionType || (AcDbMLeaderDirectionType = {}));
+/**
+ * Represents a multileader entity.
+ *
+ * A multileader contains one or more leader branches, each of which can contain
+ * one or more leader lines, plus optional MText or block content.
+ */
+var AcDbMLeader = /** @class */ (function (_super) {
+    __extends(AcDbMLeader, _super);
+    /**
+     * Creates an empty multileader entity with default style-related state.
+     */
+    function AcDbMLeader() {
+        var _this = _super.call(this) || this;
+        _this._leaders = [];
+        _this._leaderLineType = AcDbMLeaderLineType.StraightLeader;
+        _this._contentType = AcDbMLeaderContentType.NoneContent;
+        _this._doglegEnabled = false;
+        _this._doglegLength = 0;
+        _this._doglegVector = new AcGeVector3d(1, 0, 0);
+        _this._normal = new AcGeVector3d(0, 0, 1);
+        _this._mleaderStyleId = '';
+        _this._textHeight = 2.5;
+        _this._textWidth = 0;
+        _this._textRotation = 0;
+        _this._textDirection = new AcGeVector3d(1, 0, 0);
+        _this._textStyleName = '';
+        _this._textAttachmentPoint = AcGiMTextAttachmentPoint.MiddleLeft;
+        _this._textDrawingDirection = AcGiMTextFlowDirection.LEFT_TO_RIGHT;
+        _this._textLineSpacingFactor = 1;
+        _this._textAttachmentDirection =
+            AcDbMLeaderTextAttachmentDirection.Horizontal;
+        _this._arrowheadOverrides = [];
+        _this._blockAttributes = [];
+        return _this;
+    }
+    Object.defineProperty(AcDbMLeader.prototype, "dxfTypeName", {
+        /**
+         * Gets the DXF type name used when exporting this entity.
+         */
+        get: function () {
+            return 'MULTILEADER';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "leaders", {
+        /**
+         * Gets a deep-cloned collection of all leader branches.
+         */
+        get: function () {
+            var _this = this;
+            return this._leaders.map(function (leader) { return _this.cloneLeader(leader); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "numberOfLeaders", {
+        /**
+         * Gets the current number of leader branches.
+         */
+        get: function () {
+            return this._leaders.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "leaderLineType", {
+        /**
+         * Gets the leader line type.
+         */
+        get: function () {
+            return this._leaderLineType;
+        },
+        set: function (value) {
+            this._leaderLineType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "contentType", {
+        /**
+         * Gets the content type.
+         */
+        get: function () {
+            return this._contentType;
+        },
+        set: function (value) {
+            this._contentType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "doglegEnabled", {
+        /**
+         * Gets the dogleg enabled.
+         */
+        get: function () {
+            return this._doglegEnabled;
+        },
+        set: function (value) {
+            this._doglegEnabled = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "doglegLength", {
+        /**
+         * Gets the dogleg length.
+         */
+        get: function () {
+            return this._doglegLength;
+        },
+        set: function (value) {
+            this._doglegLength = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "doglegVector", {
+        /**
+         * Gets the dogleg vector.
+         */
+        get: function () {
+            return this._doglegVector;
+        },
+        set: function (value) {
+            this._doglegVector.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "landingPoint", {
+        /**
+         * Gets the landing point.
+         */
+        get: function () {
+            return this._landingPoint;
+        },
+        set: function (value) {
+            this._landingPoint = value ? this.createPoint(value) : undefined;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "normal", {
+        /**
+         * Gets the normal.
+         */
+        get: function () {
+            return this._normal;
+        },
+        set: function (value) {
+            this._normal.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "mleaderStyleId", {
+        /**
+         * Gets the mleader style id.
+         */
+        get: function () {
+            return this._mleaderStyleId;
+        },
+        set: function (value) {
+            this._mleaderStyleId = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "version", {
+        /**
+         * Gets or sets the serialized MLeader version code.
+         *
+         * This value mirrors DXF/internal version metadata and is used to keep
+         * compatibility with files saved from different AutoCAD generations.
+         */
+        get: function () {
+            return this._version;
+        },
+        set: function (value) {
+            this._version = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "leaderStyleId", {
+        /**
+         * Gets or sets the MLeader style handle override stored on the entity.
+         *
+         * When provided, this value is typically used as a fallback in addition to
+         * `mleaderStyleId` during style resolution.
+         */
+        get: function () {
+            return this._leaderStyleId;
+        },
+        set: function (value) {
+            this._leaderStyleId = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "propertyOverrideFlag", {
+        /**
+         * Gets or sets the property-override bit flag.
+         *
+         * The flag indicates which visual/behavioral properties are overridden at the
+         * entity level instead of inherited from the referenced MLeader style.
+         */
+        get: function () {
+            return this._propertyOverrideFlag;
+        },
+        set: function (value) {
+            this._propertyOverrideFlag = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "leaderLineColor", {
+        /**
+         * Gets or sets the explicit leader line color override.
+         */
+        get: function () {
+            return this._leaderLineColor;
+        },
+        set: function (value) {
+            this._leaderLineColor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "leaderLineTypeId", {
+        /**
+         * Gets or sets the leader line type handle override.
+         */
+        get: function () {
+            return this._leaderLineTypeId;
+        },
+        set: function (value) {
+            this._leaderLineTypeId = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "leaderLineWeight", {
+        /**
+         * Gets or sets the lineweight override for leader segments.
+         */
+        get: function () {
+            return this._leaderLineWeight;
+        },
+        set: function (value) {
+            this._leaderLineWeight = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "landingEnabled", {
+        /**
+         * Gets or sets whether leader landings are enabled.
+         */
+        get: function () {
+            return this._landingEnabled;
+        },
+        set: function (value) {
+            this._landingEnabled = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "arrowheadId", {
+        /**
+         * Gets or sets the arrowhead block handle/name override.
+         */
+        get: function () {
+            return this._arrowheadId;
+        },
+        set: function (value) {
+            this._arrowheadId = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "arrowheadSize", {
+        /**
+         * Gets or sets the arrowhead size override in drawing units.
+         */
+        get: function () {
+            return this._arrowheadSize;
+        },
+        set: function (value) {
+            this._arrowheadSize = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textStyleId", {
+        /**
+         * Gets or sets the text style handle override for MText content.
+         */
+        get: function () {
+            return this._textStyleId;
+        },
+        set: function (value) {
+            this._textStyleId = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textLeftAttachmentType", {
+        /**
+         * Gets or sets left-side text attachment behavior code.
+         */
+        get: function () {
+            return this._textLeftAttachmentType;
+        },
+        set: function (value) {
+            this._textLeftAttachmentType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textRightAttachmentType", {
+        /**
+         * Gets or sets right-side text attachment behavior code.
+         */
+        get: function () {
+            return this._textRightAttachmentType;
+        },
+        set: function (value) {
+            this._textRightAttachmentType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textAngleType", {
+        /**
+         * Gets or sets the text angle type code controlling rotation strategy.
+         */
+        get: function () {
+            return this._textAngleType;
+        },
+        set: function (value) {
+            this._textAngleType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textAlignmentType", {
+        /**
+         * Gets or sets the text alignment type code.
+         */
+        get: function () {
+            return this._textAlignmentType;
+        },
+        set: function (value) {
+            this._textAlignmentType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textColor", {
+        /**
+         * Gets or sets the MText color override.
+         */
+        get: function () {
+            return this._textColor;
+        },
+        set: function (value) {
+            this._textColor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textFrameEnabled", {
+        /**
+         * Gets or sets whether a text frame (border) is enabled.
+         */
+        get: function () {
+            return this._textFrameEnabled;
+        },
+        set: function (value) {
+            this._textFrameEnabled = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "landingGap", {
+        /**
+         * Gets or sets the gap distance between landing and annotation content.
+         */
+        get: function () {
+            return this._landingGap;
+        },
+        set: function (value) {
+            this._landingGap = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textAttachment", {
+        /**
+         * Gets or sets the legacy text attachment value used in some DXF variants.
+         */
+        get: function () {
+            return this._textAttachment;
+        },
+        set: function (value) {
+            this._textAttachment = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textFlowDirection", {
+        /**
+         * Gets or sets the text flow direction override code.
+         */
+        get: function () {
+            return this._textFlowDirection;
+        },
+        set: function (value) {
+            this._textFlowDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockContentId", {
+        /**
+         * Gets or sets the referenced block content id/handle for block-based content.
+         */
+        get: function () {
+            return this._blockContentId;
+        },
+        set: function (value) {
+            this._blockContentId = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockContentColor", {
+        /**
+         * Gets or sets the block content color override.
+         */
+        get: function () {
+            return this._blockContentColor;
+        },
+        set: function (value) {
+            this._blockContentColor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockContentScale", {
+        /**
+         * Gets or sets the block content scale vector override.
+         */
+        get: function () {
+            return this._blockContentScale;
+        },
+        set: function (value) {
+            this._blockContentScale = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockContentRotation", {
+        /**
+         * Gets or sets the block content rotation override in radians.
+         */
+        get: function () {
+            return this._blockContentRotation;
+        },
+        set: function (value) {
+            this._blockContentRotation = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockContentConnectionType", {
+        /**
+         * Gets or sets the block content connection type code.
+         */
+        get: function () {
+            return this._blockContentConnectionType;
+        },
+        set: function (value) {
+            this._blockContentConnectionType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "annotativeScaleEnabled", {
+        /**
+         * Gets or sets whether annotative scaling is enabled for this entity.
+         */
+        get: function () {
+            return this._annotativeScaleEnabled;
+        },
+        set: function (value) {
+            this._annotativeScaleEnabled = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "arrowheadOverrides", {
+        /**
+         * Gets or sets per-index arrowhead overrides.
+         *
+         * Each entry maps a branch/line index to a specific arrowhead handle.
+         */
+        get: function () {
+            return this._arrowheadOverrides;
+        },
+        set: function (value) {
+            this._arrowheadOverrides = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockAttributes", {
+        /**
+         * Gets or sets block attribute override values used by block content.
+         */
+        get: function () {
+            return this._blockAttributes;
+        },
+        set: function (value) {
+            this._blockAttributes = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textDirectionNegative", {
+        /**
+         * Gets or sets whether text direction is treated as negative.
+         */
+        get: function () {
+            return this._textDirectionNegative;
+        },
+        set: function (value) {
+            this._textDirectionNegative = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textAlignInIPE", {
+        /**
+         * Gets or sets the in-place editor text alignment code.
+         */
+        get: function () {
+            return this._textAlignInIPE;
+        },
+        set: function (value) {
+            this._textAlignInIPE = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "bottomTextAttachmentDirection", {
+        /**
+         * Gets or sets bottom attachment direction code for vertical text behavior.
+         */
+        get: function () {
+            return this._bottomTextAttachmentDirection;
+        },
+        set: function (value) {
+            this._bottomTextAttachmentDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "topTextAttachmentDirection", {
+        /**
+         * Gets or sets top attachment direction code for vertical text behavior.
+         */
+        get: function () {
+            return this._topTextAttachmentDirection;
+        },
+        set: function (value) {
+            this._topTextAttachmentDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "contentScale", {
+        /**
+         * Gets or sets the overall content scale override.
+         */
+        get: function () {
+            return this._contentScale;
+        },
+        set: function (value) {
+            this._contentScale = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "contentBasePosition", {
+        /**
+         * Gets or sets the base insertion position of annotation content.
+         */
+        get: function () {
+            return this._contentBasePosition;
+        },
+        set: function (value) {
+            this._contentBasePosition = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textAnchor", {
+        /**
+         * Gets or sets the explicit text anchor position.
+         */
+        get: function () {
+            return this._textAnchor;
+        },
+        set: function (value) {
+            this._textAnchor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textLineSpacingStyle", {
+        /**
+         * Gets or sets the text line spacing style code for column/text layout.
+         */
+        get: function () {
+            return this._textLineSpacingStyle;
+        },
+        set: function (value) {
+            this._textLineSpacingStyle = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textBackgroundColor", {
+        /**
+         * Gets or sets text background color override.
+         */
+        get: function () {
+            return this._textBackgroundColor;
+        },
+        set: function (value) {
+            this._textBackgroundColor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textBackgroundScaleFactor", {
+        /**
+         * Gets or sets background-mask scale factor around text.
+         */
+        get: function () {
+            return this._textBackgroundScaleFactor;
+        },
+        set: function (value) {
+            this._textBackgroundScaleFactor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textBackgroundTransparency", {
+        /**
+         * Gets or sets text background transparency value.
+         */
+        get: function () {
+            return this._textBackgroundTransparency;
+        },
+        set: function (value) {
+            this._textBackgroundTransparency = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textBackgroundColorOn", {
+        /**
+         * Gets or sets whether explicit background color masking is enabled.
+         */
+        get: function () {
+            return this._textBackgroundColorOn;
+        },
+        set: function (value) {
+            this._textBackgroundColorOn = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textFillOn", {
+        /**
+         * Gets or sets whether text fill/mask is enabled.
+         */
+        get: function () {
+            return this._textFillOn;
+        },
+        set: function (value) {
+            this._textFillOn = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textColumnType", {
+        /**
+         * Gets or sets the text column layout type code.
+         */
+        get: function () {
+            return this._textColumnType;
+        },
+        set: function (value) {
+            this._textColumnType = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textUseAutoHeight", {
+        /**
+         * Gets or sets whether text column height is auto-managed.
+         */
+        get: function () {
+            return this._textUseAutoHeight;
+        },
+        set: function (value) {
+            this._textUseAutoHeight = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textColumnWidth", {
+        /**
+         * Gets or sets the fixed width for text columns.
+         */
+        get: function () {
+            return this._textColumnWidth;
+        },
+        set: function (value) {
+            this._textColumnWidth = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textColumnGutterWidth", {
+        /**
+         * Gets or sets the gutter width between text columns.
+         */
+        get: function () {
+            return this._textColumnGutterWidth;
+        },
+        set: function (value) {
+            this._textColumnGutterWidth = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textColumnFlowReversed", {
+        /**
+         * Gets or sets whether text columns flow in reverse order.
+         */
+        get: function () {
+            return this._textColumnFlowReversed;
+        },
+        set: function (value) {
+            this._textColumnFlowReversed = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textColumnHeight", {
+        /**
+         * Gets or sets the explicit text column height.
+         */
+        get: function () {
+            return this._textColumnHeight;
+        },
+        set: function (value) {
+            this._textColumnHeight = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textUseWordBreak", {
+        /**
+         * Gets or sets whether word breaking is enabled in column layout.
+         */
+        get: function () {
+            return this._textUseWordBreak;
+        },
+        set: function (value) {
+            this._textUseWordBreak = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "hasMText", {
+        /**
+         * Gets or sets whether MText content exists in the serialized payload.
+         */
+        get: function () {
+            return this._hasMText;
+        },
+        set: function (value) {
+            this._hasMText = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "hasBlock", {
+        /**
+         * Gets or sets whether block content exists in the serialized payload.
+         */
+        get: function () {
+            return this._hasBlock;
+        },
+        set: function (value) {
+            this._hasBlock = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "planeOrigin", {
+        /**
+         * Gets or sets the origin of the MLeader plane definition.
+         */
+        get: function () {
+            return this._planeOrigin;
+        },
+        set: function (value) {
+            this._planeOrigin = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "planeXAxisDirection", {
+        /**
+         * Gets or sets the X-axis direction vector of the MLeader plane.
+         */
+        get: function () {
+            return this._planeXAxisDirection;
+        },
+        set: function (value) {
+            this._planeXAxisDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "planeYAxisDirection", {
+        /**
+         * Gets or sets the Y-axis direction vector of the MLeader plane.
+         */
+        get: function () {
+            return this._planeYAxisDirection;
+        },
+        set: function (value) {
+            this._planeYAxisDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "planeNormalReversed", {
+        /**
+         * Gets or sets whether the MLeader plane normal is reversed.
+         */
+        get: function () {
+            return this._planeNormalReversed;
+        },
+        set: function (value) {
+            this._planeNormalReversed = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "leaderSections", {
+        /**
+         * Gets the alias of `leaders`.
+         */
+        get: function () {
+            return this.leaders;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockContentData", {
+        /**
+         * Gets the alias of `blockContent`.
+         */
+        get: function () {
+            return this.blockContent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "mtextContent", {
+        /**
+         * Gets the MText content payload if present.
+         */
+        get: function () {
+            return this._mtextContent
+                ? {
+                    text: this._mtextContent.text,
+                    anchorPoint: this._mtextContent.anchorPoint.clone()
+                }
+                : undefined;
+        },
+        set: function (value) {
+            if (!value) {
+                this._mtextContent = undefined;
+                if (this._contentType === AcDbMLeaderContentType.MTextContent) {
+                    this._contentType = AcDbMLeaderContentType.NoneContent;
+                }
+                return;
+            }
+            this._mtextContent = {
+                text: value.text,
+                anchorPoint: this.createPoint(value.anchorPoint)
+            };
+            this._contentType = AcDbMLeaderContentType.MTextContent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "contents", {
+        /**
+         * Gets the displayed MText string content.
+         */
+        get: function () {
+            var _a, _b;
+            return (_b = (_a = this._mtextContent) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
+        },
+        set: function (value) {
+            if (!this._mtextContent) {
+                this._mtextContent = {
+                    text: value,
+                    anchorPoint: new AcGePoint3d()
+                };
+            }
+            else {
+                this._mtextContent.text = value;
+            }
+            this._contentType = AcDbMLeaderContentType.MTextContent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textLocation", {
+        /**
+         * Gets the MText anchor point.
+         */
+        get: function () {
+            var _a;
+            return (_a = this._mtextContent) === null || _a === void 0 ? void 0 : _a.anchorPoint;
+        },
+        set: function (value) {
+            if (!value) {
+                this._mtextContent = undefined;
+                return;
+            }
+            if (!this._mtextContent) {
+                this._mtextContent = {
+                    text: '',
+                    anchorPoint: this.createPoint(value)
+                };
+            }
+            else {
+                this._mtextContent.anchorPoint.copy(value);
+            }
+            this._contentType = AcDbMLeaderContentType.MTextContent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textHeight", {
+        /**
+         * Gets the text height.
+         */
+        get: function () {
+            return this._textHeight;
+        },
+        set: function (value) {
+            this._textHeight = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textWidth", {
+        /**
+         * Gets the text width.
+         */
+        get: function () {
+            return this._textWidth;
+        },
+        set: function (value) {
+            this._textWidth = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textRotation", {
+        /**
+         * Gets the text rotation.
+         */
+        get: function () {
+            return this._textRotation;
+        },
+        set: function (value) {
+            this._textRotation = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textDirection", {
+        /**
+         * Gets the text direction.
+         */
+        get: function () {
+            return this._textDirection;
+        },
+        set: function (value) {
+            this._textDirection.copy(value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textStyleName", {
+        /**
+         * Gets the text style name.
+         */
+        get: function () {
+            return this._textStyleName;
+        },
+        set: function (value) {
+            this._textStyleName = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textAttachmentPoint", {
+        /**
+         * Gets the text attachment point.
+         */
+        get: function () {
+            return this._textAttachmentPoint;
+        },
+        set: function (value) {
+            this._textAttachmentPoint = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textDrawingDirection", {
+        /**
+         * Gets the text drawing direction.
+         */
+        get: function () {
+            return this._textDrawingDirection;
+        },
+        set: function (value) {
+            this._textDrawingDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textLineSpacingFactor", {
+        /**
+         * Gets the text line spacing factor.
+         */
+        get: function () {
+            return this._textLineSpacingFactor;
+        },
+        set: function (value) {
+            this._textLineSpacingFactor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "textAttachmentDirection", {
+        /**
+         * Gets the text attachment direction.
+         */
+        get: function () {
+            return this._textAttachmentDirection;
+        },
+        set: function (value) {
+            this._textAttachmentDirection = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLeader.prototype, "blockContent", {
+        /**
+         * Gets the block content.
+         */
+        get: function () {
+            var _a, _b;
+            return this._blockContent
+                ? {
+                    blockContentId: this._blockContent.blockContentId,
+                    blockHandle: this._blockContent.blockHandle,
+                    normal: (_a = this._blockContent.normal) === null || _a === void 0 ? void 0 : _a.clone(),
+                    position: (_b = this._blockContent.position) === null || _b === void 0 ? void 0 : _b.clone(),
+                    scale: this._blockContent.scale.clone(),
+                    rotation: this._blockContent.rotation,
+                    color: this._blockContent.color,
+                    transformationMatrix: __spreadArray([], __read(this._blockContent.transformationMatrix), false)
+                }
+                : undefined;
+        },
+        set: function (value) {
+            var _a, _b, _c;
+            if (!value) {
+                this._blockContent = undefined;
+                if (this._contentType === AcDbMLeaderContentType.BlockContent) {
+                    this._contentType = AcDbMLeaderContentType.NoneContent;
+                }
+                return;
+            }
+            this._blockContent = {
+                blockContentId: (_a = value.blockContentId) !== null && _a !== void 0 ? _a : value.blockHandle,
+                blockHandle: value.blockHandle,
+                normal: value.normal ? new AcGeVector3d(value.normal) : undefined,
+                position: value.position ? this.createPoint(value.position) : undefined,
+                scale: new AcGeVector3d((_b = value.scale) !== null && _b !== void 0 ? _b : { x: 1, y: 1, z: 1 }),
+                rotation: (_c = value.rotation) !== null && _c !== void 0 ? _c : 0,
+                color: value.color,
+                transformationMatrix: value.transformationMatrix
+                    ? __spreadArray([], __read(value.transformationMatrix), false) : []
+            };
+            this.blockContentId = this._blockContent.blockContentId;
+            this._contentType = AcDbMLeaderContentType.BlockContent;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Adds a leader branch and returns its index.
+     */
+    AcDbMLeader.prototype.addLeader = function (leader) {
+        var _this = this;
+        var _a, _b, _c;
+        if (leader === void 0) { leader = {}; }
+        var dbLeader = {
+            lastLeaderLinePoint: leader.lastLeaderLinePoint
+                ? this.createPoint(leader.lastLeaderLinePoint)
+                : undefined,
+            lastLeaderLinePointSet: leader.lastLeaderLinePointSet,
+            landingPoint: leader.landingPoint
+                ? this.createPoint(leader.landingPoint)
+                : undefined,
+            doglegVector: leader.doglegVector
+                ? new AcGeVector3d(leader.doglegVector)
+                : undefined,
+            doglegVectorSet: leader.doglegVectorSet,
+            doglegLength: leader.doglegLength,
+            breaks: (_b = (_a = leader.breaks) === null || _a === void 0 ? void 0 : _a.map(function (item) { return ({
+                index: item.index,
+                start: _this.createPoint(item.start),
+                end: _this.createPoint(item.end)
+            }); })) !== null && _b !== void 0 ? _b : [],
+            leaderBranchIndex: leader.leaderBranchIndex,
+            directionType: leader.directionType,
+            leaderLines: []
+        };
+        (_c = leader.leaderLines) === null || _c === void 0 ? void 0 : _c.forEach(function (line) {
+            dbLeader.leaderLines.push(_this.createLeaderLine(line));
+        });
+        this._leaders.push(dbLeader);
+        return this._leaders.length - 1;
+    };
+    /**
+     * Removes a leader branch.
+     */
+    AcDbMLeader.prototype.removeLeader = function (leaderIndex) {
+        this.checkLeaderIndex(leaderIndex);
+        this._leaders.splice(leaderIndex, 1);
+        return this;
+    };
+    /**
+     * Adds a leader line to a leader branch and returns the line index.
+     */
+    AcDbMLeader.prototype.addLeaderLine = function (leaderIndex, vertices) {
+        if (vertices === void 0) { vertices = []; }
+        this.checkLeaderIndex(leaderIndex);
+        this._leaders[leaderIndex].leaderLines.push(this.createLeaderLine({ vertices: vertices }));
+        return this._leaders[leaderIndex].leaderLines.length - 1;
+    };
+    /**
+     * Appends a vertex to one leader line.
+     */
+    AcDbMLeader.prototype.appendVertex = function (leaderIndex, leaderLineIndex, point) {
+        this.getMutableLeaderLine(leaderIndex, leaderLineIndex).vertices.push(this.createPoint(point));
+        return this;
+    };
+    /**
+     * Replaces the vertices of one leader line.
+     */
+    AcDbMLeader.prototype.setLeaderLineVertices = function (leaderIndex, leaderLineIndex, vertices) {
+        var _this = this;
+        this.getMutableLeaderLine(leaderIndex, leaderLineIndex).vertices =
+            vertices.map(function (point) { return _this.createPoint(point); });
+        return this;
+    };
+    /**
+     * Gets cloned vertices from the specified leader line.
+     *
+     * @param leaderIndex Index of the leader branch.
+     * @param leaderLineIndex Index of the leader line in the branch.
+     * @returns A cloned vertex list so callers cannot mutate internal state.
+     */
+    AcDbMLeader.prototype.getLeaderLineVertices = function (leaderIndex, leaderLineIndex) {
+        return this.getMutableLeaderLine(leaderIndex, leaderLineIndex).vertices.map(function (point) { return point.clone(); });
+    };
+    /**
+     * Adds a break segment to a specific leader line.
+     *
+     * @param leaderIndex Index of the leader branch.
+     * @param leaderLineIndex Index of the leader line.
+     * @param start Break start point.
+     * @param end Break end point.
+     * @returns The current entity instance for chaining.
+     */
+    AcDbMLeader.prototype.addBreak = function (leaderIndex, leaderLineIndex, start, end) {
+        this.getMutableLeaderLine(leaderIndex, leaderLineIndex).breaks.push({
+            start: this.createPoint(start),
+            end: this.createPoint(end)
+        });
+        return this;
+    };
+    /**
+     * Sets the landing point for one leader branch.
+     *
+     * @param leaderIndex Index of the leader branch.
+     * @param point New landing point, or `undefined` to clear it.
+     * @returns The current entity instance for chaining.
+     */
+    AcDbMLeader.prototype.setLandingPoint = function (leaderIndex, point) {
+        this.checkLeaderIndex(leaderIndex);
+        this._leaders[leaderIndex].landingPoint = point
+            ? this.createPoint(point)
+            : undefined;
+        return this;
+    };
+    /**
+     * Sets the dogleg direction for one leader branch.
+     *
+     * @param leaderIndex Index of the leader branch.
+     * @param vector New dogleg direction vector.
+     * @returns The current entity instance for chaining.
+     */
+    AcDbMLeader.prototype.setDoglegDirection = function (leaderIndex, vector) {
+        this.checkLeaderIndex(leaderIndex);
+        this._leaders[leaderIndex].doglegVector = new AcGeVector3d(vector);
+        return this;
+    };
+    /**
+     * Sets the dogleg length for one leader branch.
+     *
+     * @param leaderIndex Index of the leader branch.
+     * @param length New dogleg length, or `undefined` to clear the override.
+     * @returns The current entity instance for chaining.
+     */
+    AcDbMLeader.prototype.setDoglegLength = function (leaderIndex, length) {
+        this.checkLeaderIndex(leaderIndex);
+        this._leaders[leaderIndex].doglegLength = length;
+        return this;
+    };
+    Object.defineProperty(AcDbMLeader.prototype, "geometricExtents", {
+        /**
+         * Gets the axis-aligned extents computed from all geometry points.
+         */
+        get: function () {
+            var points = this.collectGeometryPoints();
+            return points.length > 0
+                ? new AcGeBox3d().setFromPoints(points)
+                : new AcGeBox3d();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Gets grip points used for interactive editing.
+     *
+     * @returns Cloned grip points derived from renderable geometry.
+     */
+    AcDbMLeader.prototype.subGetGripPoints = function () {
+        return this.collectGeometryPoints().map(function (point) { return point.clone(); });
+    };
+    /**
+     * Applies a transformation matrix to this entity.
+     *
+     * @param matrix Transformation matrix applied to all geometry and vectors.
+     * @returns The current entity instance for chaining.
+     */
+    AcDbMLeader.prototype.transformBy = function (matrix) {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        this._leaders.forEach(function (leader) {
+            var _a, _b;
+            (_a = leader.lastLeaderLinePoint) === null || _a === void 0 ? void 0 : _a.applyMatrix4(matrix);
+            (_b = leader.landingPoint) === null || _b === void 0 ? void 0 : _b.applyMatrix4(matrix);
+            if (leader.doglegVector) {
+                _this.transformVector(leader.doglegVector, matrix);
+            }
+            leader.breaks.forEach(function (item) {
+                item.start.applyMatrix4(matrix);
+                item.end.applyMatrix4(matrix);
+            });
+            leader.leaderLines.forEach(function (line) {
+                line.vertices.forEach(function (point) { return point.applyMatrix4(matrix); });
+                line.breaks.forEach(function (item) {
+                    item.start.applyMatrix4(matrix);
+                    item.end.applyMatrix4(matrix);
+                });
+            });
+        });
+        (_a = this._landingPoint) === null || _a === void 0 ? void 0 : _a.applyMatrix4(matrix);
+        (_b = this.contentBasePosition) === null || _b === void 0 ? void 0 : _b.applyMatrix4(matrix);
+        this.transformVector(this._doglegVector, matrix);
+        this.transformVector(this._normal, matrix);
+        (_c = this.textAnchor) === null || _c === void 0 ? void 0 : _c.applyMatrix4(matrix);
+        (_d = this._mtextContent) === null || _d === void 0 ? void 0 : _d.anchorPoint.applyMatrix4(matrix);
+        this.transformVector(this._textDirection, matrix);
+        (_f = (_e = this._blockContent) === null || _e === void 0 ? void 0 : _e.position) === null || _f === void 0 ? void 0 : _f.applyMatrix4(matrix);
+        if ((_g = this._blockContent) === null || _g === void 0 ? void 0 : _g.normal) {
+            this.transformVector(this._blockContent.normal, matrix);
+        }
+        if (this.blockContentScale) {
+            this.transformVector(this.blockContentScale, matrix);
+        }
+        (_h = this.planeOrigin) === null || _h === void 0 ? void 0 : _h.applyMatrix4(matrix);
+        if (this.planeXAxisDirection) {
+            this.transformVector(this.planeXAxisDirection, matrix);
+        }
+        if (this.planeYAxisDirection) {
+            this.transformVector(this.planeYAxisDirection, matrix);
+        }
+        return this;
+    };
+    Object.defineProperty(AcDbMLeader.prototype, "properties", {
+        get: function () {
+            var _this = this;
+            return {
+                type: this.type,
+                groups: [
+                    this.getGeneralProperties(),
+                    {
+                        groupName: 'leader',
+                        properties: [
+                            {
+                                name: 'contentType',
+                                type: 'enum',
+                                editable: true,
+                                options: [
+                                    {
+                                        label: AcDbMLeaderContentType[AcDbMLeaderContentType.NoneContent],
+                                        value: AcDbMLeaderContentType.NoneContent
+                                    },
+                                    {
+                                        label: AcDbMLeaderContentType[AcDbMLeaderContentType.BlockContent],
+                                        value: AcDbMLeaderContentType.BlockContent
+                                    },
+                                    {
+                                        label: AcDbMLeaderContentType[AcDbMLeaderContentType.MTextContent],
+                                        value: AcDbMLeaderContentType.MTextContent
+                                    },
+                                    {
+                                        label: AcDbMLeaderContentType[AcDbMLeaderContentType.ToleranceContent],
+                                        value: AcDbMLeaderContentType.ToleranceContent
+                                    }
+                                ],
+                                accessor: {
+                                    get: function () { return _this.contentType; },
+                                    set: function (value) {
+                                        _this.contentType = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'leaderLineType',
+                                type: 'enum',
+                                editable: true,
+                                options: [
+                                    {
+                                        label: AcDbMLeaderLineType[AcDbMLeaderLineType.InvisibleLeader],
+                                        value: AcDbMLeaderLineType.InvisibleLeader
+                                    },
+                                    {
+                                        label: AcDbMLeaderLineType[AcDbMLeaderLineType.StraightLeader],
+                                        value: AcDbMLeaderLineType.StraightLeader
+                                    },
+                                    {
+                                        label: AcDbMLeaderLineType[AcDbMLeaderLineType.SplineLeader],
+                                        value: AcDbMLeaderLineType.SplineLeader
+                                    }
+                                ],
+                                accessor: {
+                                    get: function () { return _this.leaderLineType; },
+                                    set: function (value) {
+                                        _this.leaderLineType = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'doglegEnabled',
+                                type: 'boolean',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.doglegEnabled; },
+                                    set: function (value) {
+                                        _this.doglegEnabled = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'doglegLength',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.doglegLength; },
+                                    set: function (value) {
+                                        _this.doglegLength = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'leaderCount',
+                                type: 'int',
+                                editable: false,
+                                accessor: {
+                                    get: function () { return _this.numberOfLeaders; }
+                                }
+                            }
+                        ]
+                    },
+                    {
+                        groupName: 'text',
+                        properties: [
+                            {
+                                name: 'contents',
+                                type: 'string',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.contents; },
+                                    set: function (value) {
+                                        _this.contents = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'textHeight',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.textHeight; },
+                                    set: function (value) {
+                                        _this.textHeight = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'textWidth',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.textWidth; },
+                                    set: function (value) {
+                                        _this.textWidth = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'textStyleName',
+                                type: 'string',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.textStyleName; },
+                                    set: function (value) {
+                                        _this.textStyleName = value;
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                ]
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Builds renderable primitives for this multileader entity.
+     *
+     * @param renderer Graphics renderer used to create draw entities.
+     * @returns A single entity, an entity group, or undefined when nothing is drawable.
+     */
+    AcDbMLeader.prototype.subWorldDraw = function (renderer) {
+        var _this = this;
+        var entities = [];
+        if (this.leaderLineType !== AcDbMLeaderLineType.InvisibleLeader) {
+            this._leaders.forEach(function (leader) {
+                leader.leaderLines.forEach(function (line) {
+                    var points = _this.getLeaderLineDrawPoints(leader, line);
+                    if (points.length > 0) {
+                        var leaderEntity = _this.drawLeaderLine(renderer, points);
+                        if (leaderEntity)
+                            entities.push(leaderEntity);
+                    }
+                });
+                var doglegPoints = _this.getDoglegPoints(leader);
+                if (doglegPoints) {
+                    entities.push(renderer.lines(doglegPoints));
+                }
+            });
+        }
+        var mtextContent = this.getRenderableMTextContent();
+        if (this.contentType === AcDbMLeaderContentType.MTextContent &&
+            mtextContent) {
+            var textHeight = this.getResolvedTextHeight();
+            var mtextData = {
+                text: mtextContent.text,
+                height: textHeight,
+                width: this.getMTextRenderWidth(mtextContent.text, textHeight),
+                position: mtextContent.anchorPoint,
+                rotation: this.textRotation,
+                directionVector: this.textDirection,
+                attachmentPoint: this.textAttachmentPoint,
+                drawingDirection: this.textDrawingDirection,
+                lineSpaceFactor: this.textLineSpacingFactor
+            };
+            // MLeader draws multiple primitives as a group. Delayed MText rendering is
+            // only scheduled for top-level entities, so render nested MText eagerly.
+            entities.push(renderer.mtext(mtextData, this.getTextStyle(), false));
+        }
+        if (entities.length === 0)
+            return undefined;
+        return entities.length === 1 ? entities[0] : renderer.group(entities);
+    };
+    /**
+     * Writes this multileader entity to DXF group codes.
+     *
+     * @param filer DXF filer that receives serialized values.
+     * @returns The current entity instance for chaining.
+     */
+    AcDbMLeader.prototype.dxfOutFields = function (filer) {
+        var _a;
+        _super.prototype.dxfOutFields.call(this, filer);
+        filer.writeSubclassMarker('AcDbMLeader');
+        filer.writeInt16(170, this.leaderLineType);
+        filer.writeBoolean(290, this.doglegEnabled);
+        filer.writeDouble(41, this.doglegLength);
+        filer.writeInt16(172, this.contentType);
+        filer.writeVector3d(210, this.normal);
+        filer.writeHandle(340, this.mleaderStyleId);
+        if (this._landingPoint)
+            filer.writePoint3d(10, this._landingPoint);
+        filer.writeVector3d(11, this.doglegVector);
+        if (this._mtextContent) {
+            filer.writeString(1, this._mtextContent.text);
+            filer.writePoint3d(12, this._mtextContent.anchorPoint);
+            filer.writeDouble(40, this.textHeight);
+            filer.writeDouble(42, this.textWidth);
+            filer.writeAngle(50, this.textRotation);
+            filer.writeString(7, this.textStyleName);
+        }
+        if (this._blockContent) {
+            filer.writeHandle(341, (_a = this._blockContent.blockContentId) !== null && _a !== void 0 ? _a : '');
+            if (this._blockContent.position) {
+                filer.writePoint3d(15, this._blockContent.position);
+            }
+            filer.writeVector3d(16, this._blockContent.scale);
+            filer.writeAngle(52, this._blockContent.rotation);
+        }
+        this._leaders.forEach(function (leader) {
+            if (leader.landingPoint)
+                filer.writePoint3d(110, leader.landingPoint);
+            if (leader.doglegVector)
+                filer.writeVector3d(111, leader.doglegVector);
+            filer.writeDouble(140, leader.doglegLength);
+            filer.writeInt16(171, leader.leaderLines.length);
+            leader.leaderLines.forEach(function (line) {
+                filer.writeInt16(90, line.vertices.length);
+                line.vertices.forEach(function (point) { return filer.writePoint3d(10, point); });
+            });
+        });
+        return this;
+    };
+    /**
+     * Creates a concrete point from point-like input.
+     *
+     * @param point Source point-like value.
+     * @returns A newly created point instance.
+     */
+    AcDbMLeader.prototype.createPoint = function (point) {
+        return new AcGePoint3d().copy(point);
+    };
+    /**
+     * Normalizes one leader-line payload into internal storage format.
+     *
+     * @param line Source leader-line payload.
+     * @returns A normalized leader line.
+     */
+    AcDbMLeader.prototype.createLeaderLine = function (line) {
+        var _this = this;
+        var _a, _b, _c, _d;
+        return {
+            vertices: (_b = (_a = line.vertices) === null || _a === void 0 ? void 0 : _a.map(function (point) { return _this.createPoint(point); })) !== null && _b !== void 0 ? _b : [],
+            breakPointIndexes: line.breakPointIndexes
+                ? __spreadArray([], __read(line.breakPointIndexes), false) : [],
+            leaderLineIndex: line.leaderLineIndex,
+            breaks: (_d = (_c = line.breaks) === null || _c === void 0 ? void 0 : _c.map(function (item) { return ({
+                index: item.index,
+                start: _this.createPoint(item.start),
+                end: _this.createPoint(item.end)
+            }); })) !== null && _d !== void 0 ? _d : []
+        };
+    };
+    /**
+     * Creates a deep clone of a leader branch.
+     *
+     * @param leader Leader branch to clone.
+     * @returns A deep-cloned leader branch.
+     */
+    AcDbMLeader.prototype.cloneLeader = function (leader) {
+        var _a, _b, _c;
+        return {
+            lastLeaderLinePoint: (_a = leader.lastLeaderLinePoint) === null || _a === void 0 ? void 0 : _a.clone(),
+            lastLeaderLinePointSet: leader.lastLeaderLinePointSet,
+            landingPoint: (_b = leader.landingPoint) === null || _b === void 0 ? void 0 : _b.clone(),
+            doglegVector: (_c = leader.doglegVector) === null || _c === void 0 ? void 0 : _c.clone(),
+            doglegVectorSet: leader.doglegVectorSet,
+            doglegLength: leader.doglegLength,
+            breaks: leader.breaks.map(function (item) { return ({
+                index: item.index,
+                start: item.start.clone(),
+                end: item.end.clone()
+            }); }),
+            leaderBranchIndex: leader.leaderBranchIndex,
+            directionType: leader.directionType,
+            leaderLines: leader.leaderLines.map(function (line) { return ({
+                vertices: line.vertices.map(function (point) { return point.clone(); }),
+                breakPointIndexes: __spreadArray([], __read(line.breakPointIndexes), false),
+                leaderLineIndex: line.leaderLineIndex,
+                breaks: line.breaks.map(function (item) { return ({
+                    index: item.index,
+                    start: item.start.clone(),
+                    end: item.end.clone()
+                }); })
+            }); })
+        };
+    };
+    /**
+     * Validates that a leader index is in range.
+     *
+     * @param leaderIndex Leader branch index to validate.
+     */
+    AcDbMLeader.prototype.checkLeaderIndex = function (leaderIndex) {
+        if (leaderIndex < 0 || leaderIndex >= this._leaders.length) {
+            throw new Error('The leader index is out of range!');
+        }
+    };
+    /**
+     * Gets a mutable leader line by branch and line index.
+     *
+     * @param leaderIndex Leader branch index.
+     * @param leaderLineIndex Leader-line index in the branch.
+     * @returns The mutable leader line reference.
+     */
+    AcDbMLeader.prototype.getMutableLeaderLine = function (leaderIndex, leaderLineIndex) {
+        this.checkLeaderIndex(leaderIndex);
+        var line = this._leaders[leaderIndex].leaderLines[leaderLineIndex];
+        if (!line) {
+            throw new Error('The leader line index is out of range!');
+        }
+        return line;
+    };
+    /**
+     * Collects all geometry points contributing to draw/extents calculations.
+     *
+     * @returns Geometry point collection.
+     */
+    AcDbMLeader.prototype.collectGeometryPoints = function () {
+        var _this = this;
+        var _a;
+        var points = [];
+        this._leaders.forEach(function (leader) {
+            if (leader.lastLeaderLinePoint)
+                points.push(leader.lastLeaderLinePoint);
+            if (leader.landingPoint)
+                points.push(leader.landingPoint);
+            leader.breaks.forEach(function (item) { return points.push(item.start, item.end); });
+            leader.leaderLines.forEach(function (line) {
+                points.push.apply(points, __spreadArray([], __read(line.vertices), false));
+                line.breaks.forEach(function (item) { return points.push(item.start, item.end); });
+            });
+            var doglegPoints = _this.getDoglegPoints(leader);
+            if (doglegPoints)
+                points.push.apply(points, __spreadArray([], __read(doglegPoints), false));
+            leader.leaderLines.forEach(function (line) {
+                var arrowPoints = _this.getArrowheadPoints(_this.getLeaderLineDrawPoints(leader, line));
+                if (arrowPoints)
+                    points.push.apply(points, __spreadArray([], __read(arrowPoints), false));
+            });
+        });
+        if (this._landingPoint)
+            points.push(this._landingPoint);
+        if (this.contentBasePosition)
+            points.push(this.contentBasePosition);
+        if (this.textAnchor)
+            points.push(this.textAnchor);
+        if (this._mtextContent)
+            points.push(this._mtextContent.anchorPoint);
+        if ((_a = this._blockContent) === null || _a === void 0 ? void 0 : _a.position)
+            points.push(this._blockContent.position);
+        if (this.planeOrigin)
+            points.push(this.planeOrigin);
+        return points;
+    };
+    /**
+     * Resolves the final draw points for a leader line.
+     *
+     * @param leader Owning leader branch.
+     * @param line Leader line to resolve.
+     * @returns The resolved draw-point sequence.
+     */
+    AcDbMLeader.prototype.getLeaderLineDrawPoints = function (leader, line) {
+        var _a, _b, _c;
+        if (line.vertices.length >= 2)
+            return line.vertices;
+        if (line.vertices.length === 0)
+            return [];
+        var end = (_c = (_b = (_a = leader.lastLeaderLinePoint) !== null && _a !== void 0 ? _a : leader.landingPoint) !== null && _b !== void 0 ? _b : this._landingPoint) !== null && _c !== void 0 ? _c : this.contentBasePosition;
+        if (!end || line.vertices[0].equals(end))
+            return line.vertices;
+        return [line.vertices[0], end];
+    };
+    /**
+     * Computes the dogleg segment points for a leader branch.
+     *
+     * @param leader Leader branch to evaluate.
+     * @returns Dogleg segment points, or `undefined` if not applicable.
+     */
+    AcDbMLeader.prototype.getDoglegPoints = function (leader) {
+        var _a, _b, _c, _d, _e;
+        if (!this.doglegEnabled)
+            return undefined;
+        var start = (_c = (_b = (_a = leader.lastLeaderLinePoint) !== null && _a !== void 0 ? _a : leader.landingPoint) !== null && _b !== void 0 ? _b : this._landingPoint) !== null && _c !== void 0 ? _c : this.getLastLeaderLineVertex(leader);
+        var vector = (_d = leader.doglegVector) !== null && _d !== void 0 ? _d : this._doglegVector;
+        var length = (_e = leader.doglegLength) !== null && _e !== void 0 ? _e : this._doglegLength;
+        if (!start || length === 0 || vector.lengthSq() === 0)
+            return undefined;
+        var end = start
+            .clone()
+            .add(vector.clone().normalize().multiplyScalar(length));
+        return [start, end];
+    };
+    /**
+     * Gets the last available vertex from all lines in one leader branch.
+     *
+     * @param leader Leader branch to inspect.
+     * @returns The last vertex, or `undefined` when no vertices exist.
+     */
+    AcDbMLeader.prototype.getLastLeaderLineVertex = function (leader) {
+        for (var i = leader.leaderLines.length - 1; i >= 0; i--) {
+            var line = leader.leaderLines[i];
+            if (line.vertices.length > 0) {
+                return line.vertices[line.vertices.length - 1];
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Builds arrowhead polyline points from leader-line points.
+     *
+     * @param points Leader-line points where the first point is treated as tip.
+     * @returns Arrowhead points, or `undefined` when no arrowhead is drawable.
+     */
+    AcDbMLeader.prototype.getArrowheadPoints = function (points) {
+        if (!this.isArrowheadVisible() || points.length < 2)
+            return undefined;
+        var frame = this.getArrowheadFrame(points);
+        if (!frame)
+            return undefined;
+        var size = this.getResolvedArrowheadSize();
+        var tip = frame.tip, unit = frame.unit;
+        var baseCenter = tip.clone().add(unit.clone().multiplyScalar(size));
+        var halfWidth = size / 6;
+        var perpendicular = new AcGeVector3d(-unit.y, unit.x, 0);
+        var left = baseCenter
+            .clone()
+            .add(perpendicular.clone().multiplyScalar(halfWidth));
+        var right = baseCenter
+            .clone()
+            .add(perpendicular.clone().multiplyScalar(-halfWidth));
+        return [tip, left, right, tip];
+    };
+    /**
+     * Checks whether an arrowhead should be rendered.
+     *
+     * @returns `true` if arrowhead configuration is visible.
+     */
+    AcDbMLeader.prototype.isArrowheadVisible = function () {
+        var arrowId = this.getResolvedArrowheadId();
+        if ((arrowId === null || arrowId === void 0 ? void 0 : arrowId.toUpperCase()) === '_NONE')
+            return false;
+        return this.getResolvedArrowheadSize() > 0;
+    };
+    /**
+     * Draws one leader line and applies arrow style from MLEADER/MLEADERSTYLE.
+     */
+    AcDbMLeader.prototype.drawLeaderLine = function (renderer, points) {
+        var entities = [renderer.lines(points)];
+        var arrow = this.drawArrowhead(renderer, points);
+        if (arrow)
+            entities.push(arrow);
+        return entities.length === 1 ? entities[0] : renderer.group(entities);
+    };
+    /**
+     * Draws one arrowhead primitive from leader-line points.
+     */
+    AcDbMLeader.prototype.drawArrowhead = function (renderer, points) {
+        if (!this.isArrowheadVisible())
+            return undefined;
+        var blockArrow = this.drawArrowheadBlock(renderer, points);
+        if (blockArrow)
+            return blockArrow;
+        var arrowPoints = this.getArrowheadPoints(points);
+        if (!arrowPoints)
+            return undefined;
+        var area = new AcGeArea2d();
+        area.add(new AcGePolyline2d(arrowPoints, true));
+        var traits = renderer.subEntityTraits;
+        var originalFillType = traits.fillType;
+        traits.fillType = {
+            solidFill: true,
+            patternAngle: 0,
+            definitionLines: []
+        };
+        var entity = renderer.area(area);
+        traits.fillType = originalFillType;
+        return entity;
+    };
+    /**
+     * Draws arrowhead by rendering entities from referenced arrow block record.
+     */
+    AcDbMLeader.prototype.drawArrowheadBlock = function (renderer, points) {
+        var _a;
+        var blockTableRecord = this.getResolvedArrowheadBlockTableRecord();
+        if (!blockTableRecord)
+            return undefined;
+        var frame = this.getArrowheadFrame(points);
+        if (!frame)
+            return undefined;
+        var tip = frame.tip, unit = frame.unit;
+        var size = this.getResolvedArrowheadSize();
+        var angle = Math.atan2(unit.y, unit.x);
+        var basePoint = (_a = blockTableRecord.origin) !== null && _a !== void 0 ? _a : AcGePoint3d.ORIGIN;
+        var mBase = new AcGeMatrix3d().makeTranslation(-basePoint.x, -basePoint.y, -basePoint.z);
+        var mScale = new AcGeMatrix3d().makeScale(size, size, size);
+        var mRot = new AcGeMatrix3d().makeRotationZ(angle);
+        var mInsert = new AcGeMatrix3d().makeTranslation(tip.x, tip.y, tip.z);
+        var transform = new AcGeMatrix3d()
+            .multiplyMatrices(mInsert, mRot)
+            .multiply(mScale)
+            .multiply(mBase);
+        return AcDbRenderingCache.instance.draw(renderer, blockTableRecord, this.rgbColor, [], true, transform, new AcGeVector3d(this.normal));
+    };
+    /**
+     * Resolves tip point and direction for arrowhead placement.
+     */
+    AcDbMLeader.prototype.getArrowheadFrame = function (points) {
+        if (points.length < 2)
+            return undefined;
+        var tip = points[0];
+        var next = points.find(function (point) { return !point.equals(tip); });
+        if (!next)
+            return undefined;
+        var direction = new AcGeVector3d().subVectors(next, tip);
+        if (direction.lengthSq() === 0)
+            return undefined;
+        return {
+            tip: tip,
+            unit: direction.normalize()
+        };
+    };
+    /**
+     * Resolves the effective arrowhead id.
+     *
+     * @returns Arrowhead id used for rendering.
+     */
+    AcDbMLeader.prototype.getResolvedArrowheadId = function () {
+        var _a, _b;
+        var styleArrowId = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.arrowSymbolId;
+        return (_b = this.arrowheadId) !== null && _b !== void 0 ? _b : styleArrowId;
+    };
+    /**
+     * Resolves arrowhead block record by Arrowhead ID handle.
+     */
+    AcDbMLeader.prototype.getResolvedArrowheadBlockTableRecord = function () {
+        var arrowId = this.getResolvedArrowheadId();
+        if (!arrowId)
+            return undefined;
+        return this.database.tables.blockTable.getIdAt(arrowId);
+    };
+    /**
+     * Resolves the effective arrowhead size.
+     *
+     * @returns Arrowhead size used for rendering.
+     */
+    AcDbMLeader.prototype.getResolvedArrowheadSize = function () {
+        var _a, _b, _c, _d;
+        var style = this.getMLeaderStyle();
+        var styleArrowSize = (_a = style === null || style === void 0 ? void 0 : style.arrowSize) !== null && _a !== void 0 ? _a : style === null || style === void 0 ? void 0 : style.scale;
+        return ((_d = (_c = (_b = this.arrowheadSize) !== null && _b !== void 0 ? _b : this.contentScale) !== null && _c !== void 0 ? _c : styleArrowSize) !== null && _d !== void 0 ? _d : this.getResolvedTextHeight());
+    };
+    /**
+     * Resolves effective text height by style and override-flag rules.
+     */
+    AcDbMLeader.prototype.getResolvedTextHeight = function () {
+        var _a;
+        var styleTextHeight = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.textHeight;
+        if (this.textHeight > 0)
+            return this.textHeight;
+        if (styleTextHeight != null && styleTextHeight > 0)
+            return styleTextHeight;
+        return 2.5;
+    };
+    /**
+     * Resolves renderable MText content using entity content first, with style fallback.
+     */
+    AcDbMLeader.prototype.getRenderableMTextContent = function () {
+        var _a, _b, _c;
+        if (this._mtextContent) {
+            return {
+                text: this._mtextContent.text,
+                anchorPoint: this._mtextContent.anchorPoint
+            };
+        }
+        var defaultText = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.defaultMTextContents;
+        var anchorPoint = (_c = (_b = this.textAnchor) !== null && _b !== void 0 ? _b : this.contentBasePosition) !== null && _c !== void 0 ? _c : this._landingPoint;
+        if (!defaultText || !anchorPoint)
+            return undefined;
+        return {
+            text: defaultText,
+            anchorPoint: anchorPoint
+        };
+    };
+    /**
+     * Computes render width for current MText content.
+     *
+     * @returns Explicit width or an estimated width based on plain text length.
+     */
+    AcDbMLeader.prototype.getMTextRenderWidth = function (text, textHeight) {
+        if (this._textWidth > 0)
+            return this._textWidth;
+        if (!text)
+            return this._textWidth;
+        var plainText = text
+            .replace(/\\[PpNn]/g, '\n')
+            .replace(/\\[A-Za-z][^;]*;/g, '')
+            .replace(/[{}]/g, '');
+        var longestLineLength = Math.max.apply(Math, __spreadArray(__spreadArray([], __read(plainText.split(/\r\n|\r|\n/g).map(function (line) { return line.length; })), false), [1], false));
+        return Math.max(textHeight, longestLineLength * textHeight);
+    };
+    /**
+     * Transforms a direction vector with an affine matrix.
+     *
+     * @param vector Vector to mutate.
+     * @param matrix Transformation matrix.
+     */
+    AcDbMLeader.prototype.transformVector = function (vector, matrix) {
+        var origin = new AcGePoint3d();
+        var endpoint = new AcGePoint3d(vector.x, vector.y, vector.z);
+        origin.applyMatrix4(matrix);
+        endpoint.applyMatrix4(matrix);
+        vector.set(endpoint.x - origin.x, endpoint.y - origin.y, endpoint.z - origin.z);
+    };
+    /**
+     * Resolves the referenced MLeader style object.
+     */
+    AcDbMLeader.prototype.getMLeaderStyle = function () {
+        var dictionary = this.database.objects.mleaderStyle;
+        var styleId = this.mleaderStyleId || this.leaderStyleId;
+        if (styleId) {
+            var style = dictionary.getIdAt(styleId);
+            if (style)
+                return style;
+        }
+        return dictionary.newIterator().toArray()[0];
+    };
+    /**
+     * Resolves text style name considering entity values, ids and style fallback.
+     */
+    AcDbMLeader.prototype.getResolvedTextStyleName = function () {
+        var _a, _b;
+        var textStyleTable = this.database.tables.textStyleTable;
+        var styleIdFromStyle = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.textStyleId;
+        var styleNameFromStyleId = styleIdFromStyle
+            ? (_b = textStyleTable.getIdAt(styleIdFromStyle)) === null || _b === void 0 ? void 0 : _b.name
+            : undefined;
+        if (this.textStyleName)
+            return this.textStyleName;
+        var directStyle = this.textStyleId
+            ? textStyleTable.getIdAt(this.textStyleId)
+            : undefined;
+        if (directStyle === null || directStyle === void 0 ? void 0 : directStyle.name)
+            return directStyle.name;
+        return styleNameFromStyleId;
+    };
+    /**
+     * Resolves the text style used by renderer-side MText drawing.
+     *
+     * @returns A valid text style object.
+     */
+    AcDbMLeader.prototype.getTextStyle = function () {
+        var _a, _b;
+        var textStyleTable = this.database.tables.textStyleTable;
+        var textStyleName = this.getResolvedTextStyleName();
+        var style = (_b = (_a = (textStyleName ? textStyleTable.getAt(textStyleName) : undefined)) !== null && _a !== void 0 ? _a : textStyleTable.getAt(this.database.textstyle)) !== null && _b !== void 0 ? _b : textStyleTable.getAt(DEFAULT_TEXT_STYLE);
+        if (!style) {
+            throw new Error('No valid text style found in text style table.');
+        }
+        return style.textStyle;
+    };
+    /** The entity type name. */
+    AcDbMLeader.typeName = 'MLeader';
+    return AcDbMLeader;
+}(AcDbEntity));
+export { AcDbMLeader };
+//# sourceMappingURL=AcDbMLeader.js.map