@mlightcad/data-model 1.7.27 → 1.7.29

package/lib/entity/AcDbMLeader.js

@@ -0,0 +1,2553 @@
+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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcGeArea2d, AcGeBox3d, AcGeMatrix3d, AcGePoint3d, AcGePolyline2d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcGiMTextAttachmentPoint, AcGiMTextFlowDirection } from '@mlightcad/graphic-interface';
+import { AcDbRenderingCache, decodeMLeaderStyleRawColor, DEFAULT_MLEADER_STYLE, 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 = {}));
+var MLEADER_OVERRIDE_LEADER_LINE_TYPE = 1 << 0;
+var MLEADER_OVERRIDE_LEADER_LINE_COLOR = 1 << 1;
+var MLEADER_OVERRIDE_LEADER_LINE_TYPE_ID = 1 << 2;
+var MLEADER_OVERRIDE_LEADER_LINE_WEIGHT = 1 << 3;
+var MLEADER_OVERRIDE_DOGLEG_ENABLED = 1 << 6;
+var MLEADER_OVERRIDE_DOGLEG_LENGTH = 1 << 7;
+var MLEADER_OVERRIDE_TEXT_COLOR = 1 << 15;
+/**
+ * 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.
+     *
+     * @remarks
+     * Initializes geometry, text, and block-related members to defaults that
+     * are compatible with common MLEADER behavior.
+     */
+    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.
+     *
+     * @param leader Optional leader payload used to initialize branch data.
+     * @returns Index of the newly added leader branch.
+     */
+    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.
+     *
+     * @param leaderIndex Zero-based index of the leader branch to remove.
+     * @returns The current entity instance for chaining.
+     */
+    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.
+     *
+     * @param leaderIndex Index of the target leader branch.
+     * @param vertices Optional initial vertices for the leader line.
+     * @returns Index of the newly added leader line.
+     */
+    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.
+     *
+     * @param leaderIndex Index of the target leader branch.
+     * @param leaderLineIndex Index of the target leader line.
+     * @param point Vertex to append.
+     * @returns The current entity instance for chaining.
+     */
+    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.
+     *
+     * @param leaderIndex Index of the target leader branch.
+     * @param leaderLineIndex Index of the target leader line.
+     * @param vertices New vertex sequence.
+     * @returns The current entity instance for chaining.
+     */
+    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
+    });
+    /**
+     * @inheritdoc
+     *
+     * @returns The current entity instance with effective properties resolved.
+     */
+    AcDbMLeader.prototype.resolveEffectiveProperties = function () {
+        _super.prototype.resolveEffectiveProperties.call(this);
+        if (this._mleaderStyleId)
+            return;
+        var style = this.getDefaultMLeaderStyle();
+        if (style) {
+            this._mleaderStyleId = style.objectId;
+        }
+    };
+    /**
+     * 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 = [];
+        var traits = renderer.subEntityTraits;
+        var originalColor = traits.color;
+        var originalRgbColor = traits.rgbColor;
+        var originalLineType = traits.lineType;
+        var originalLineWeight = traits.lineWeight;
+        var leaderLineColor = this.getResolvedLeaderLineColor();
+        var leaderLineStyle = this.getResolvedLeaderLineStyle();
+        var leaderLineWeight = this.getResolvedLeaderLineWeight();
+        var textColor = this.getResolvedTextColor();
+        if (this.getResolvedLeaderLineType() !== AcDbMLeaderLineType.InvisibleLeader) {
+            this.applyColorTraits(traits, leaderLineColor, originalColor, originalRgbColor);
+            this.applyLineTraits(traits, leaderLineStyle, leaderLineWeight);
+            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) {
+            this.applyColorTraits(traits, textColor, originalColor, originalRgbColor);
+            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));
+        }
+        traits.color = originalColor;
+        traits.rgbColor = originalRgbColor;
+        traits.lineType = originalLineType;
+        traits.lineWeight = originalLineWeight;
+        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.
+     * @throws {Error} Thrown when `leaderIndex` is outside valid range.
+     * @returns `void`.
+     */
+    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;
+        if (!this.getResolvedDoglegEnabled())
+            return undefined;
+        var start = (_b = (_a = leader.lastLeaderLinePoint) !== null && _a !== void 0 ? _a : leader.landingPoint) !== null && _b !== void 0 ? _b : this._landingPoint;
+        var vector = (_c = leader.doglegVector) !== null && _c !== void 0 ? _c : this._doglegVector;
+        var length = (_d = leader.doglegLength) !== null && _d !== void 0 ? _d : this.getResolvedDoglegLength();
+        if (!start || length == null || length === 0 || vector.lengthSq() === 0) {
+            return undefined;
+        }
+        var end = start
+            .clone()
+            .add(vector.clone().normalize().multiplyScalar(length));
+        return [start, end];
+    };
+    /**
+     * 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.
+     *
+     * @param renderer Graphics renderer used to create primitives.
+     * @param points Leader-line draw points.
+     * @returns One entity or an entity group representing the full leader line.
+     */
+    AcDbMLeader.prototype.drawLeaderLine = function (renderer, points) {
+        var entities = [];
+        var linePoints = this.getLeaderLinePointsForDraw(points);
+        if (linePoints.length >= 2) {
+            entities.push(renderer.lines(linePoints));
+        }
+        var arrow = this.drawArrowhead(renderer, points);
+        if (arrow)
+            entities.push(arrow);
+        if (entities.length === 0)
+            return undefined;
+        return entities.length === 1 ? entities[0] : renderer.group(entities);
+    };
+    /**
+     * Resolves leader-line points used for stroke drawing after arrow overlap trim.
+     *
+     * @param points Original leader polyline points.
+     * @returns Trimmed points used to draw the leader stroke.
+     */
+    AcDbMLeader.prototype.getLeaderLinePointsForDraw = function (points) {
+        var trimDistance = this.getArrowheadLeaderLineTrimDistance();
+        if (trimDistance <= 0)
+            return points;
+        return this.trimPolylineStart(points, trimDistance);
+    };
+    /**
+     * Resolves how much of leader start should be trimmed to avoid arrow overlap.
+     *
+     * @returns Trim distance in drawing units.
+     */
+    AcDbMLeader.prototype.getArrowheadLeaderLineTrimDistance = function () {
+        var e_1, _a;
+        var _b;
+        if (!this.isArrowheadVisible())
+            return 0;
+        var blockTableRecord = this.getResolvedArrowheadBlockTableRecord();
+        if (!blockTableRecord)
+            return 0;
+        var size = this.getResolvedArrowheadSize();
+        if (size <= 0)
+            return 0;
+        var basePoint = (_b = blockTableRecord.origin) !== null && _b !== void 0 ? _b : AcGePoint3d.ORIGIN;
+        var maxX = basePoint.x;
+        try {
+            for (var _c = __values(blockTableRecord.newIterator()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var entity = _d.value;
+                var extents = entity.geometricExtents;
+                if (extents.isEmpty())
+                    continue;
+                if (extents.max.x > maxX)
+                    maxX = extents.max.x;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return Math.max(0, (maxX - basePoint.x) * size);
+    };
+    /**
+     * Trims the start of a polyline by a given distance.
+     *
+     * @param points Polyline points.
+     * @param trimDistance Distance to trim from the start.
+     * @returns Trimmed polyline points.
+     */
+    AcDbMLeader.prototype.trimPolylineStart = function (points, trimDistance) {
+        if (points.length < 2 || trimDistance <= 0)
+            return points;
+        var remaining = trimDistance;
+        for (var i = 0; i < points.length - 1; i++) {
+            var start = points[i];
+            var end = points[i + 1];
+            var segment = end.distanceTo(start);
+            if (segment <= 0)
+                continue;
+            if (remaining < segment) {
+                var direction = new AcGeVector3d().subVectors(end, start);
+                var newStart = start
+                    .clone()
+                    .add(direction.multiplyScalar(remaining / segment));
+                return __spreadArray([newStart], __read(points.slice(i + 1)), false);
+            }
+            remaining -= segment;
+        }
+        return [points[points.length - 1]];
+    };
+    /**
+     * Draws one arrowhead primitive from leader-line points.
+     *
+     * @param renderer Graphics renderer used to create primitives.
+     * @param points Leader-line points where the first point is treated as tip.
+     * @returns Arrowhead entity, or `undefined` when no arrowhead is drawable.
+     */
+    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.
+     *
+     * @param renderer Graphics renderer used to create primitives.
+     * @param points Leader-line points where the first point is treated as tip.
+     * @returns Rendered block-based arrowhead entity, or `undefined`.
+     */
+    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.
+     *
+     * @param points Leader-line points where the first point is treated as tip.
+     * @returns Tip and normalized direction, or `undefined` when unavailable.
+     */
+    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.
+     *
+     * @returns Arrowhead block table record, or `undefined` when not found.
+     */
+    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.
+     *
+     * @returns Effective text height used for rendering.
+     */
+    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.
+     *
+     * @returns Renderable text payload, or `undefined` when unavailable.
+     */
+    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.
+     *
+     * @param text Source MText content string.
+     * @param textHeight Effective text height used for fallback estimation.
+     * @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.
+     * @returns `void`.
+     */
+    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.
+     *
+     * @returns Resolved style object or `undefined` when not available.
+     */
+    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 this.getDefaultMLeaderStyle();
+    };
+    /**
+     * Resolves the default MLEADER style from CMLEADERSTYLE, with first-entry fallback.
+     *
+     * @returns Default style object or `undefined` when style dictionary is empty.
+     */
+    AcDbMLeader.prototype.getDefaultMLeaderStyle = function () {
+        var bySysVar = this.resolveMLeaderStyleByName(this.getDefaultMLeaderStyleName());
+        if (bySysVar)
+            return bySysVar;
+        return this.database.objects.mleaderStyle.newIterator().toArray()[0];
+    };
+    /**
+     * Resolves one MLEADER style by style name (dictionary key) or object ID.
+     *
+     * @param styleName Style name or object id candidate.
+     * @returns Matching style object, or `undefined` when not found.
+     */
+    AcDbMLeader.prototype.resolveMLeaderStyleByName = function (styleName) {
+        var e_2, _a;
+        var rawName = styleName === null || styleName === void 0 ? void 0 : styleName.trim();
+        if (!rawName)
+            return undefined;
+        var dictionary = this.database.objects.mleaderStyle;
+        var directByName = dictionary.getAt(rawName);
+        if (directByName)
+            return directByName;
+        var directById = dictionary.getIdAt(rawName);
+        if (directById)
+            return directById;
+        var normalizedStyleName = rawName.toUpperCase();
+        try {
+            for (var _b = __values(dictionary.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), name_1 = _d[0], style = _d[1];
+                if (name_1.toUpperCase() === normalizedStyleName) {
+                    return style;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return undefined;
+    };
+    /**
+     * Resolves current CMLEADERSTYLE value with a stable default fallback.
+     *
+     * @returns Preferred default style name.
+     */
+    AcDbMLeader.prototype.getDefaultMLeaderStyleName = function () {
+        try {
+            return this.database.cmleaderstyle || DEFAULT_MLEADER_STYLE;
+        }
+        catch (_a) {
+            return DEFAULT_MLEADER_STYLE;
+        }
+    };
+    /**
+     * Resolves text style name considering entity values, ids and style fallback.
+     *
+     * @returns Resolved text style name, or `undefined` when unresolved.
+     */
+    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;
+    };
+    /**
+     * Resolves effective leader-line color by override-flag and style rules.
+     *
+     * @returns Effective leader-line color.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineColor = function () {
+        var _a;
+        return this.getResolvedComponentColor(this.leaderLineColor, (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineColor, MLEADER_OVERRIDE_LEADER_LINE_COLOR);
+    };
+    /**
+     * Resolves effective leader-line geometry type.
+     *
+     * @returns Effective leader-line type.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineType = function () {
+        var _a;
+        var styleLineType = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineType;
+        return this.getResolvedStyleDrivenValue(this.leaderLineType, styleLineType, MLEADER_OVERRIDE_LEADER_LINE_TYPE);
+    };
+    /**
+     * Resolves effective leader-line linetype id/handle.
+     *
+     * @returns Effective linetype id, or `undefined` when not available.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineTypeId = function () {
+        var _a;
+        return this.getResolvedStyleDrivenValue(this.leaderLineTypeId, (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineTypeId, MLEADER_OVERRIDE_LEADER_LINE_TYPE_ID);
+    };
+    /**
+     * Resolves renderer linetype style for leader lines.
+     *
+     * @returns User-specified renderer linetype style, or `undefined`.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineStyle = function () {
+        var lineTypeId = this.getResolvedLeaderLineTypeId();
+        if (!lineTypeId)
+            return undefined;
+        var lineTypeRecord = this.database.tables.linetypeTable.getIdAt(lineTypeId);
+        if (!lineTypeRecord)
+            return undefined;
+        return __assign({ type: 'UserSpecified' }, lineTypeRecord.linetype);
+    };
+    /**
+     * Resolves effective leader-line weight by override-flag and style rules.
+     *
+     * @returns Effective line weight, or `undefined`.
+     */
+    AcDbMLeader.prototype.getResolvedLeaderLineWeight = function () {
+        var _a;
+        var styleLineWeight = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.leaderLineWeight;
+        var lineWeight = this.getResolvedStyleDrivenValue(this.leaderLineWeight, styleLineWeight, MLEADER_OVERRIDE_LEADER_LINE_WEIGHT);
+        if (lineWeight == null)
+            return undefined;
+        return lineWeight;
+    };
+    /**
+     * Resolves whether dogleg drawing is effectively enabled.
+     *
+     * @returns Effective dogleg-enabled state.
+     */
+    AcDbMLeader.prototype.getResolvedDoglegEnabled = function () {
+        var _a;
+        var styleEnabled = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.doglegEnabled;
+        return this.getResolvedStyleDrivenValue(this.doglegEnabled, styleEnabled, MLEADER_OVERRIDE_DOGLEG_ENABLED);
+    };
+    /**
+     * Resolves effective dogleg length by override-flag and style rules.
+     *
+     * @returns Effective dogleg length.
+     */
+    AcDbMLeader.prototype.getResolvedDoglegLength = function () {
+        var _a;
+        var styleLength = (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.doglegLength;
+        return this.getResolvedStyleDrivenValue(this.doglegLength, styleLength, MLEADER_OVERRIDE_DOGLEG_LENGTH);
+    };
+    /**
+     * Resolves effective text color by override-flag and style rules.
+     *
+     * @returns Effective text color.
+     */
+    AcDbMLeader.prototype.getResolvedTextColor = function () {
+        var _a;
+        return this.getResolvedComponentColor(this.textColor, (_a = this.getMLeaderStyle()) === null || _a === void 0 ? void 0 : _a.textColor, MLEADER_OVERRIDE_TEXT_COLOR);
+    };
+    /**
+     * Resolves effective component color from entity raw value and style fallback.
+     *
+     * @param rawEntityColor Raw DXF color value stored on the entity.
+     * @param styleColor Style-level fallback color.
+     * @param overrideFlagMask Property-override flag mask for this component.
+     * @returns Effective color used for rendering and trait application.
+     */
+    AcDbMLeader.prototype.getResolvedComponentColor = function (rawEntityColor, styleColor, overrideFlagMask) {
+        var entityColor = rawEntityColor != null
+            ? decodeMLeaderStyleRawColor(rawEntityColor)
+            : undefined;
+        if (!entityColor)
+            return styleColor;
+        var overrideEnabled = this.isPropertyOverrideEnabled(overrideFlagMask);
+        if (overrideEnabled === true)
+            return entityColor;
+        if (overrideEnabled === false)
+            return styleColor !== null && styleColor !== void 0 ? styleColor : entityColor;
+        // Some DXF producers always write entity color fields as ByBlock/ByLayer even
+        // when no override flag is enabled. Prefer style color in that ambiguous case.
+        if (!entityColor.isByBlock && !entityColor.isByLayer) {
+            return entityColor;
+        }
+        return styleColor !== null && styleColor !== void 0 ? styleColor : entityColor;
+    };
+    /**
+     * Resolves effective value using override-flag and style fallback rules.
+     *
+     * @typeParam T Value type.
+     * @param entityValue Value stored on the entity.
+     * @param styleValue Value provided by style.
+     * @param overrideFlagMask Property-override flag mask for this component.
+     * @returns Effective resolved value.
+     */
+    AcDbMLeader.prototype.getResolvedStyleDrivenValue = function (entityValue, styleValue, overrideFlagMask) {
+        var overrideEnabled = this.isPropertyOverrideEnabled(overrideFlagMask);
+        if (overrideEnabled === true)
+            return entityValue !== null && entityValue !== void 0 ? entityValue : styleValue;
+        if (overrideEnabled === false)
+            return styleValue !== null && styleValue !== void 0 ? styleValue : entityValue;
+        return styleValue !== null && styleValue !== void 0 ? styleValue : entityValue;
+    };
+    /**
+     * Checks whether a specific property-override bit is enabled.
+     *
+     * @param flagMask Bit mask for the property being queried.
+     * @returns `true` if enabled, `false` if disabled, or `undefined` when flag is absent.
+     */
+    AcDbMLeader.prototype.isPropertyOverrideEnabled = function (flagMask) {
+        if (this.propertyOverrideFlag == null)
+            return undefined;
+        return (this.propertyOverrideFlag & flagMask) !== 0;
+    };
+    /**
+     * Applies color traits while preserving original values for reset.
+     *
+     * @param traits Renderer traits object to mutate.
+     * @param color Effective component color to apply.
+     * @param originalColor Original trait color value.
+     * @param originalRgbColor Original trait RGB value.
+     * @returns `void`.
+     */
+    AcDbMLeader.prototype.applyColorTraits = function (traits, color, originalColor, originalRgbColor) {
+        traits.color = originalColor;
+        traits.rgbColor = originalRgbColor;
+        if (!color)
+            return;
+        traits.color = color;
+        traits.rgbColor = this.resolveColorToRgb(color);
+    };
+    /**
+     * Applies line style traits when resolved values are available.
+     *
+     * @param traits Renderer traits object to mutate.
+     * @param lineType Resolved linetype style.
+     * @param lineWeight Resolved line weight.
+     * @returns `void`.
+     */
+    AcDbMLeader.prototype.applyLineTraits = function (traits, lineType, lineWeight) {
+        if (lineType) {
+            traits.lineType = lineType;
+        }
+        if (lineWeight != null) {
+            traits.lineWeight = lineWeight;
+        }
+    };
+    /**
+     * Converts an `AcCmColor` to resolved RGB for rendering.
+     *
+     * @param color Source color definition.
+     * @returns Resolved RGB integer color.
+     */
+    AcDbMLeader.prototype.resolveColorToRgb = function (color) {
+        var _a;
+        if (color.isByLayer) {
+            var layerColor = this.getLayerColor();
+            if ((layerColor === null || layerColor === void 0 ? void 0 : layerColor.RGB) != null)
+                return layerColor.RGB;
+            return this.rgbColor;
+        }
+        if (color.isByBlock)
+            return this.rgbColor;
+        return (_a = color.RGB) !== null && _a !== void 0 ? _a : this.rgbColor;
+    };
+    /** The entity type name. */
+    AcDbMLeader.typeName = 'MLeader';
+    return AcDbMLeader;
+}(AcDbEntity));
+export { AcDbMLeader };
+//# sourceMappingURL=AcDbMLeader.js.map