@mlightcad/data-model 1.7.28 → 1.7.29

package/lib/entity/AcDbMLine.js

@@ -13,6 +13,17 @@ var __extends = (this && this.__extends) || (function () {
         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;
@@ -49,16 +60,25 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { AcCmColor } from '@mlightcad/common';
-import { AcGeBox3d, AcGePoint3d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { AcGeArea2d, AcGeBox3d, AcGeCircArc3d, AcGePoint3d, AcGePolyline2d, AcGeVector3d } from '@mlightcad/geometry-engine';
+import { ByBlock, ByLayer, DEFAULT_LINE_TYPE, DEFAULT_MLINE_STYLE } from '../misc';
 import { AcDbEntity } from './AcDbEntity';
 /**
  * Defines MLINE justification relative to the style element offsets.
  */
 export var AcDbMLineJustification;
 (function (AcDbMLineJustification) {
+    /**
+     * Places all style elements below or on the reference path.
+     */
     AcDbMLineJustification[AcDbMLineJustification["Top"] = 0] = "Top";
+    /**
+     * Centers style elements around the reference path.
+     */
     AcDbMLineJustification[AcDbMLineJustification["Zero"] = 1] = "Zero";
+    /**
+     * Places all style elements above or on the reference path.
+     */
     AcDbMLineJustification[AcDbMLineJustification["Bottom"] = 2] = "Bottom";
 })(AcDbMLineJustification || (AcDbMLineJustification = {}));
 /**
@@ -66,19 +86,72 @@ export var AcDbMLineJustification;
  */
 export var AcDbMLineFlags;
 (function (AcDbMLineFlags) {
+    /**
+     * Indicates the MLINE currently contains at least one segment vertex.
+     */
     AcDbMLineFlags[AcDbMLineFlags["HasVertex"] = 1] = "HasVertex";
+    /**
+     * Indicates the MLINE should be treated as a closed loop.
+     */
     AcDbMLineFlags[AcDbMLineFlags["Closed"] = 2] = "Closed";
+    /**
+     * Suppresses cap geometry at the start of the MLINE.
+     */
     AcDbMLineFlags[AcDbMLineFlags["SuppressStartCaps"] = 4] = "SuppressStartCaps";
+    /**
+     * Suppresses cap geometry at the end of the MLINE.
+     */
     AcDbMLineFlags[AcDbMLineFlags["SuppressEndCaps"] = 8] = "SuppressEndCaps";
 })(AcDbMLineFlags || (AcDbMLineFlags = {}));
+/**
+ * Bit flags used by MLINESTYLE objects.
+ */
+var AcDbMLineStyleFlags;
+(function (AcDbMLineStyleFlags) {
+    /**
+     * Enables fill rendering between the outer and inner style elements.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["FillOn"] = 1] = "FillOn";
+    /**
+     * Enables drawing miter connector lines at polyline joints.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["DisplayMiters"] = 2] = "DisplayMiters";
+    /**
+     * Enables square-line start cap.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["StartSquareCap"] = 16] = "StartSquareCap";
+    /**
+     * Enables inner-arc start cap pairs.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["StartInnerArcs"] = 32] = "StartInnerArcs";
+    /**
+     * Enables outer-arc start cap.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["StartRoundCap"] = 64] = "StartRoundCap";
+    /**
+     * Enables square-line end cap.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["EndSquareCap"] = 256] = "EndSquareCap";
+    /**
+     * Enables inner-arc end cap pairs.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["EndInnerArcs"] = 512] = "EndInnerArcs";
+    /**
+     * Enables outer-arc end cap.
+     */
+    AcDbMLineStyleFlags[AcDbMLineStyleFlags["EndRoundCap"] = 1024] = "EndRoundCap";
+})(AcDbMLineStyleFlags || (AcDbMLineStyleFlags = {}));
 /**
  * Represents the AutoCAD MLINE entity.
  */
 var AcDbMLine = /** @class */ (function (_super) {
     __extends(AcDbMLine, _super);
+    /**
+     * Creates a new MLINE entity initialized with AutoCAD-compatible defaults.
+     */
     function AcDbMLine() {
         var _this = _super.call(this) || this;
-        _this._styleName = 'STANDARD';
+        _this._styleName = '';
         _this._styleObjectHandle = '';
         _this._scale = 1;
         _this._justification = AcDbMLineJustification.Zero;
@@ -90,6 +163,9 @@ var AcDbMLine = /** @class */ (function (_super) {
         return _this;
     }
     Object.defineProperty(AcDbMLine.prototype, "dxfTypeName", {
+        /**
+         * DXF entity type token written to or read from drawing files.
+         */
         get: function () {
             return 'MLINE';
         },
@@ -97,9 +173,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "styleName", {
+        /**
+         * Gets the style name used to resolve the MLINE style object.
+         *
+         * @returns Current style name.
+         */
         get: function () {
-            return this._styleName;
+            return this._styleName || this.getDefaultStyleName();
         },
+        /**
+         * Sets the style name used to resolve the MLINE style object.
+         *
+         * @param value New style name.
+         */
         set: function (value) {
             this._styleName = value;
         },
@@ -107,9 +193,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "styleObjectHandle", {
+        /**
+         * Gets the handle of the referenced MLINESTYLE object.
+         *
+         * @returns Style object handle.
+         */
         get: function () {
             return this._styleObjectHandle;
         },
+        /**
+         * Sets the handle of the referenced MLINESTYLE object.
+         *
+         * @param value Style object handle.
+         */
         set: function (value) {
             this._styleObjectHandle = value;
         },
@@ -117,9 +213,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "scale", {
+        /**
+         * Gets the global scale factor applied to style offsets.
+         *
+         * @returns MLINE scale.
+         */
         get: function () {
             return this._scale;
         },
+        /**
+         * Sets the global scale factor applied to style offsets.
+         *
+         * @param value MLINE scale.
+         */
         set: function (value) {
             this._scale = value;
         },
@@ -127,9 +233,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "justification", {
+        /**
+         * Gets the current justification mode.
+         *
+         * @returns Justification enum value.
+         */
         get: function () {
             return this._justification;
         },
+        /**
+         * Sets the current justification mode.
+         *
+         * @param value Justification enum value.
+         */
         set: function (value) {
             this._justification = value;
         },
@@ -137,9 +253,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "flags", {
+        /**
+         * Gets the raw MLINE bit flags.
+         *
+         * @returns Bitwise combination of {@link AcDbMLineFlags}.
+         */
         get: function () {
             return this._flags;
         },
+        /**
+         * Sets the raw MLINE bit flags.
+         *
+         * @param value Bitwise combination of {@link AcDbMLineFlags}.
+         */
         set: function (value) {
             this._flags = value;
         },
@@ -147,9 +273,20 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "styleCount", {
+        /**
+         * Gets the number of style elements expected by the entity.
+         *
+         * @returns Style element count.
+         */
         get: function () {
             return this._styleCount;
         },
+        /**
+         * Sets the style element count.
+         * Negative values are clamped to `0`.
+         *
+         * @param value Requested style element count.
+         */
         set: function (value) {
             this._styleCount = Math.max(0, value);
         },
@@ -157,9 +294,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "startPosition", {
+        /**
+         * Gets the MLINE start point in world coordinates.
+         *
+         * @returns Start point instance.
+         */
         get: function () {
             return this._startPosition;
         },
+        /**
+         * Sets the MLINE start point in world coordinates.
+         *
+         * @param value New start point.
+         */
         set: function (value) {
             this._startPosition.copy(value);
         },
@@ -167,9 +314,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "normal", {
+        /**
+         * Gets the MLINE plane normal.
+         *
+         * @returns Normal vector instance.
+         */
         get: function () {
             return this._normal;
         },
+        /**
+         * Sets the MLINE plane normal.
+         *
+         * @param value New normal vector.
+         */
         set: function (value) {
             this._normal.copy(value);
         },
@@ -177,10 +334,22 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "segments", {
+        /**
+         * Gets a deep-cloned snapshot of all segments.
+         * Mutating the returned array or objects will not affect internal state.
+         *
+         * @returns Cloned segment collection.
+         */
         get: function () {
             var _this = this;
             return this._segments.map(function (segment) { return _this.cloneSegment(segment); });
         },
+        /**
+         * Replaces all segments using normalized internal copies.
+         * Also updates the internal `HasVertex` flag.
+         *
+         * @param value Segment list to normalize and store.
+         */
         set: function (value) {
             var _this = this;
             this._segments = value.map(function (segment) { return _this.createSegment(segment); });
@@ -190,6 +359,11 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "vertexCount", {
+        /**
+         * Gets the number of stored segment vertices.
+         *
+         * @returns Vertex count.
+         */
         get: function () {
             return this._segments.length;
         },
@@ -197,9 +371,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "closed", {
+        /**
+         * Indicates whether the MLINE is closed.
+         *
+         * @returns `true` when the `Closed` flag is set.
+         */
         get: function () {
             return (this._flags & AcDbMLineFlags.Closed) !== 0;
         },
+        /**
+         * Enables or disables closed-loop behavior.
+         *
+         * @param value `true` to close the path, otherwise `false`.
+         */
         set: function (value) {
             this.setFlag(AcDbMLineFlags.Closed, value);
         },
@@ -207,9 +391,19 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "suppressStartCaps", {
+        /**
+         * Indicates whether start caps are suppressed during rendering.
+         *
+         * @returns `true` when the `SuppressStartCaps` flag is set.
+         */
         get: function () {
             return (this._flags & AcDbMLineFlags.SuppressStartCaps) !== 0;
         },
+        /**
+         * Enables or disables start cap suppression.
+         *
+         * @param value `true` to suppress start caps.
+         */
         set: function (value) {
             this.setFlag(AcDbMLineFlags.SuppressStartCaps, value);
         },
@@ -217,24 +411,48 @@ var AcDbMLine = /** @class */ (function (_super) {
         configurable: true
     });
     Object.defineProperty(AcDbMLine.prototype, "suppressEndCaps", {
+        /**
+         * Indicates whether end caps are suppressed during rendering.
+         *
+         * @returns `true` when the `SuppressEndCaps` flag is set.
+         */
         get: function () {
             return (this._flags & AcDbMLineFlags.SuppressEndCaps) !== 0;
         },
+        /**
+         * Enables or disables end cap suppression.
+         *
+         * @param value `true` to suppress end caps.
+         */
         set: function (value) {
             this.setFlag(AcDbMLineFlags.SuppressEndCaps, value);
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Appends one segment to the MLINE.
+     * The segment is normalized into internal geometry instances.
+     *
+     * @param segment Segment payload to append.
+     */
     AcDbMLine.prototype.appendSegment = function (segment) {
         this._segments.push(this.createSegment(segment));
         this.updateHasVertexFlag();
     };
+    /**
+     * Removes all segments and clears the `HasVertex` flag.
+     */
     AcDbMLine.prototype.clearSegments = function () {
         this._segments = [];
         this.updateHasVertexFlag();
     };
     Object.defineProperty(AcDbMLine.prototype, "geometricExtents", {
+        /**
+         * Computes a bounding box from renderable MLINE geometry.
+         *
+         * @returns Axis-aligned 3D extents box.
+         */
         get: function () {
             var points = this.collectGeometryPoints();
             var box = new AcGeBox3d();
@@ -243,6 +461,14 @@ var AcDbMLine = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Applies a transformation matrix to the full MLINE geometry.
+     * Points are transformed directly, while vectors are transformed without
+     * introducing translation components.
+     *
+     * @param matrix Matrix to apply.
+     * @returns The same entity instance for chaining.
+     */
     AcDbMLine.prototype.transformBy = function (matrix) {
         var _this = this;
         this._startPosition.applyMatrix4(matrix);
@@ -255,6 +481,11 @@ var AcDbMLine = /** @class */ (function (_super) {
         return this;
     };
     Object.defineProperty(AcDbMLine.prototype, "properties", {
+        /**
+         * Exposes editable property metadata for UI/property panels.
+         *
+         * @returns Entity property definition grouped by category.
+         */
         get: function () {
             var _this = this;
             return {
@@ -324,6 +555,13 @@ var AcDbMLine = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Renders this MLINE into one or more graphic interface entities.
+     * It draws optional fill first and then style element lines.
+     *
+     * @param renderer Active graphics renderer.
+     * @returns A single entity, an entity group, or `undefined` when nothing is drawable.
+     */
     AcDbMLine.prototype.subWorldDraw = function (renderer) {
         if (this._segments.length === 0)
             return undefined;
@@ -333,6 +571,24 @@ var AcDbMLine = /** @class */ (function (_super) {
         var traits = renderer.subEntityTraits;
         var originalColor = traits.color;
         var originalRgbColor = traits.rgbColor;
+        var originalLineType = traits.lineType;
+        var originalFillType = traits.fillType;
+        var originalDrawOrder = traits.drawOrder;
+        var fillArea = this.createFillArea(mlineStyle, elementCount);
+        if (fillArea) {
+            traits.color = originalColor;
+            traits.rgbColor = originalRgbColor;
+            this.applyFillTraits(mlineStyle, traits);
+            traits.fillType = {
+                solidFill: true,
+                patternAngle: 0,
+                definitionLines: []
+            };
+            traits.drawOrder = -1;
+            entities.push(renderer.area(fillArea));
+            traits.fillType = originalFillType;
+            traits.drawOrder = originalDrawOrder;
+        }
         if (elementCount <= 0) {
             var reference = this.getReferencePath();
             if (reference.length >= 2)
@@ -342,23 +598,34 @@ var AcDbMLine = /** @class */ (function (_super) {
             for (var elementIndex = 0; elementIndex < elementCount; elementIndex++) {
                 traits.color = originalColor;
                 traits.rgbColor = originalRgbColor;
+                traits.lineType = originalLineType;
                 this.applyStyleElementTraits(mlineStyle, elementIndex, traits);
                 var points = this.getElementPath(elementIndex, mlineStyle);
                 if (points.length >= 2) {
                     entities.push(renderer.lines(points));
                 }
             }
+            this.appendStyleDrivenJointAndCapEntities(renderer, entities, mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType);
         }
         traits.color = originalColor;
         traits.rgbColor = originalRgbColor;
+        traits.lineType = originalLineType;
+        traits.fillType = originalFillType;
+        traits.drawOrder = originalDrawOrder;
         if (entities.length === 0)
             return undefined;
         return entities.length === 1 ? entities[0] : renderer.group(entities);
     };
+    /**
+     * Serializes MLINE-specific fields to the DXF filer.
+     *
+     * @param filer DXF writer context.
+     * @returns The current entity instance.
+     */
     AcDbMLine.prototype.dxfOutFields = function (filer) {
         _super.prototype.dxfOutFields.call(this, filer);
         filer.writeSubclassMarker('AcDbMline');
-        filer.writeString(2, this._styleName);
+        filer.writeString(2, this.styleName);
         filer.writeHandle(340, this._styleObjectHandle);
         filer.writeDouble(40, this._scale);
         filer.writeInt16(70, this._justification);
@@ -384,6 +651,12 @@ var AcDbMLine = /** @class */ (function (_super) {
         });
         return this;
     };
+    /**
+     * Sets or clears a single MLINE bit flag.
+     *
+     * @param flag Flag bit to update.
+     * @param enabled Whether the flag should be set.
+     */
     AcDbMLine.prototype.setFlag = function (flag, enabled) {
         if (enabled) {
             this._flags |= flag;
@@ -392,9 +665,18 @@ var AcDbMLine = /** @class */ (function (_super) {
             this._flags &= ~flag;
         }
     };
+    /**
+     * Synchronizes the `HasVertex` flag with current segment count.
+     */
     AcDbMLine.prototype.updateHasVertexFlag = function () {
         this.setFlag(AcDbMLineFlags.HasVertex, this._segments.length > 0);
     };
+    /**
+     * Normalizes segment-like input into internal segment storage.
+     *
+     * @param segment Segment-like payload.
+     * @returns Normalized segment.
+     */
     AcDbMLine.prototype.createSegment = function (segment) {
         var _this = this;
         var _a, _b;
@@ -405,6 +687,12 @@ var AcDbMLine = /** @class */ (function (_super) {
             elements: (_b = (_a = segment.elements) === null || _a === void 0 ? void 0 : _a.map(function (element) { return _this.createElement(element); })) !== null && _b !== void 0 ? _b : []
         };
     };
+    /**
+     * Normalizes element-like input and infers count fields when missing.
+     *
+     * @param element Element-like payload.
+     * @returns Normalized element.
+     */
     AcDbMLine.prototype.createElement = function (element) {
         var _a, _b;
         var parameters = element.parameters ? __spreadArray([], __read(element.parameters), false) : [];
@@ -417,6 +705,12 @@ var AcDbMLine = /** @class */ (function (_super) {
             fillParameters: fillParameters
         };
     };
+    /**
+     * Produces a deep clone of one normalized segment.
+     *
+     * @param segment Source segment.
+     * @returns Deep-cloned segment.
+     */
     AcDbMLine.prototype.cloneSegment = function (segment) {
         return {
             position: segment.position.clone(),
@@ -430,6 +724,11 @@ var AcDbMLine = /** @class */ (function (_super) {
             }); })
         };
     };
+    /**
+     * Collects points that represent all drawable geometry for extents calculation.
+     *
+     * @returns Geometry point list in world coordinates.
+     */
     AcDbMLine.prototype.collectGeometryPoints = function () {
         var points = [this._startPosition];
         if (this._segments.length === 0)
@@ -445,37 +744,365 @@ var AcDbMLine = /** @class */ (function (_super) {
         }
         return points;
     };
+    /**
+     * Calculates how many element paths should be rendered.
+     * Uses the max of entity style count, style definition count, and segment data.
+     *
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Renderable element count.
+     */
     AcDbMLine.prototype.getRenderableElementCount = function (mlineStyle) {
         var _a;
         var styleElementCount = (_a = mlineStyle === null || mlineStyle === void 0 ? void 0 : mlineStyle.elementCount) !== null && _a !== void 0 ? _a : 0;
         return Math.max.apply(Math, __spreadArray(__spreadArray([this._styleCount,
             styleElementCount], __read(this._segments.map(function (segment) { return segment.elements.length; })), false), [0], false));
     };
+    /**
+     * Builds the un-offset reference polyline path from start point and segments.
+     *
+     * @returns Reference path points, optionally closed when needed.
+     */
     AcDbMLine.prototype.getReferencePath = function () {
-        return __spreadArray([
+        var points = __spreadArray([
             this._startPosition.clone()
         ], __read(this._segments.map(function (segment) { return segment.position.clone(); })), false);
+        return this.closePathIfNeeded(points);
     };
+    /**
+     * Computes one style element path by offsetting every segment along its miter direction.
+     *
+     * @param elementIndex Style element index to evaluate.
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Offset path points, optionally closed when needed.
+     */
     AcDbMLine.prototype.getElementPath = function (elementIndex, mlineStyle) {
         var _this = this;
         var points = [];
         var first = this._segments[0];
-        var startOffset = this.getElementMiterOffset(first, elementIndex, mlineStyle);
-        points.push(this.offsetPoint(this._startPosition, first.miterDirection, startOffset));
+        points.push(this.getElementBoundaryPoint('start', first, elementIndex, mlineStyle));
         this._segments.forEach(function (segment) {
-            var offset = _this.getElementMiterOffset(segment, elementIndex, mlineStyle);
-            points.push(_this.offsetPoint(segment.position, segment.miterDirection, offset));
+            points.push(_this.offsetPoint(segment.position, segment.miterDirection, _this.getElementMiterOffset(segment, elementIndex, mlineStyle)));
         });
-        return points;
+        points[points.length - 1] = this.getElementBoundaryPoint('end', this._segments[this._segments.length - 1], elementIndex, mlineStyle);
+        return this.closePathIfNeeded(points);
     };
+    /**
+     * Resolves the offset distance for an element at a specific segment.
+     * Prefers segment element parameters and falls back to style offsets.
+     *
+     * @param segment Segment to evaluate.
+     * @param elementIndex Style element index.
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Miter offset distance.
+     */
     AcDbMLine.prototype.getElementMiterOffset = function (segment, elementIndex, mlineStyle) {
-        var _a, _b;
+        var _a;
         var element = segment.elements[elementIndex];
         if ((_a = element === null || element === void 0 ? void 0 : element.parameters) === null || _a === void 0 ? void 0 : _a.length)
             return element.parameters[0];
+        return this.getStyleElementOffset(elementIndex, mlineStyle);
+    };
+    /**
+     * Resolves one element boundary point at the start/end of open MLINE paths.
+     *
+     * @param side `start` or `end`.
+     * @param segment Segment data used to resolve miter offset.
+     * @param elementIndex Style element index.
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Boundary point after cap-angle cut adjustment.
+     */
+    AcDbMLine.prototype.getElementBoundaryPoint = function (side, segment, elementIndex, mlineStyle) {
+        var offset = this.getElementMiterOffset(segment, elementIndex, mlineStyle);
+        var basePoint = side === 'start' ? this._startPosition : segment.position;
+        var point = this.offsetPoint(basePoint, segment.miterDirection, offset);
+        if (!this.shouldApplyCapCutAtSide(side, mlineStyle)) {
+            return point;
+        }
+        var capAngle = side === 'start' ? mlineStyle === null || mlineStyle === void 0 ? void 0 : mlineStyle.startAngle : mlineStyle === null || mlineStyle === void 0 ? void 0 : mlineStyle.endAngle;
+        var cutDistance = this.computeCapCutDistance(offset, capAngle, side);
+        if (cutDistance === 0)
+            return point;
+        var direction = side === 'start'
+            ? this.getStartSegmentDirection()
+            : this.getEndSegmentDirection();
+        if (direction.lengthSq() === 0)
+            return point;
+        return point.add(direction.multiplyScalar(cutDistance));
+    };
+    /**
+     * Indicates whether cap-angle cut should be applied at the given side.
+     *
+     * @param side `start` or `end`.
+     * @param mlineStyle Resolved style object, if available.
+     * @returns `true` when side has cap components and is not suppressed.
+     */
+    AcDbMLine.prototype.shouldApplyCapCutAtSide = function (side, mlineStyle) {
+        if (!mlineStyle || this.closed)
+            return false;
+        if (side === 'start') {
+            if (this.suppressStartCaps)
+                return false;
+            return ((mlineStyle.flags &
+                (AcDbMLineStyleFlags.StartSquareCap |
+                    AcDbMLineStyleFlags.StartInnerArcs |
+                    AcDbMLineStyleFlags.StartRoundCap)) !==
+                0);
+        }
+        if (this.suppressEndCaps)
+            return false;
+        return ((mlineStyle.flags &
+            (AcDbMLineStyleFlags.EndSquareCap |
+                AcDbMLineStyleFlags.EndInnerArcs |
+                AcDbMLineStyleFlags.EndRoundCap)) !==
+            0);
+    };
+    /**
+     * Computes longitudinal cut distance based on cap angle and style-element offset.
+     *
+     * @param offset Element offset along miter direction.
+     * @param angleDegrees Cap angle in degree units.
+     * @param side `start` or `end`.
+     * @returns Signed distance to move along segment direction.
+     */
+    AcDbMLine.prototype.computeCapCutDistance = function (offset, angleDegrees, side) {
+        var angle = this.normalizeCapAngle(angleDegrees);
+        var tan = Math.tan(angle);
+        if (Math.abs(tan) < 1e-6)
+            return 0;
+        var distance = offset / tan;
+        return side === 'start' ? distance : distance;
+    };
+    /**
+     * Normalizes cap angle from DXF degree units to radians.
+     *
+     * @param angleDegrees Cap angle in degree units.
+     * @returns Safe radian value in `(0, PI)` with 90-degree fallback.
+     */
+    AcDbMLine.prototype.normalizeCapAngle = function (angleDegrees) {
+        if (angleDegrees == null || !Number.isFinite(angleDegrees)) {
+            return Math.PI / 2;
+        }
+        var degrees = angleDegrees % 180;
+        if (degrees < 0)
+            degrees += 180;
+        if (degrees < 1 || degrees > 179) {
+            degrees = 90;
+        }
+        return (degrees * Math.PI) / 180;
+    };
+    /**
+     * Resolves forward direction at MLINE start.
+     *
+     * @returns Unit vector along the first segment.
+     */
+    AcDbMLine.prototype.getStartSegmentDirection = function () {
+        var first = this._segments[0];
+        var direction = new AcGeVector3d();
+        if (first) {
+            // Prefer actual geometry direction. The serialized first segment direction can be noisy
+            // in some files and may not match the true start-edge direction.
+            direction.subVectors(first.position, this._startPosition);
+            if (direction.lengthSq() === 0) {
+                direction.copy(first.direction);
+            }
+        }
+        if (direction.lengthSq() > 0)
+            direction.normalize();
+        return direction;
+    };
+    /**
+     * Resolves forward direction at MLINE end.
+     *
+     * @returns Unit vector along the last visible segment.
+     */
+    AcDbMLine.prototype.getEndSegmentDirection = function () {
+        var last = this._segments[this._segments.length - 1];
+        if (!last)
+            return new AcGeVector3d();
+        var direction = new AcGeVector3d();
+        var previousPoint = this._segments.length > 1
+            ? this._segments[this._segments.length - 2].position
+            : this._startPosition;
+        // Prefer actual geometry direction. Some DXF producers write a final segment direction
+        // that does not represent the visible last edge, which flips end caps.
+        direction.subVectors(last.position, previousPoint);
+        if (direction.lengthSq() === 0) {
+            direction.copy(last.direction);
+        }
+        if (direction.lengthSq() > 0)
+            direction.normalize();
+        return direction;
+    };
+    /**
+     * Creates a fill area between outermost and innermost element paths when style fill is enabled.
+     *
+     * @param mlineStyle Resolved style object.
+     * @param elementCount Total renderable element count.
+     * @returns Fill area polygon(s), or `undefined` when fill cannot be formed.
+     */
+    AcDbMLine.prototype.createFillArea = function (mlineStyle, elementCount) {
+        if (!mlineStyle ||
+            (mlineStyle.flags & AcDbMLineStyleFlags.FillOn) === 0 ||
+            elementCount < 2) {
+            return undefined;
+        }
+        var boundary = this.getFillBoundaryElementIndices(elementCount, mlineStyle);
+        if (!boundary)
+            return undefined;
+        var outerPath = this.getElementPath(boundary.outerIndex, mlineStyle);
+        var innerPath = this.getElementPath(boundary.innerIndex, mlineStyle);
+        var outerPoints = this.stripClosingPoint(outerPath);
+        var innerPoints = this.stripClosingPoint(innerPath);
+        if (outerPoints.length < 2 || innerPoints.length < 2) {
+            return undefined;
+        }
+        var area = new AcGeArea2d();
+        if (this.closed) {
+            if (outerPoints.length < 3 || innerPoints.length < 3)
+                return undefined;
+            area.add(new AcGePolyline2d(outerPoints.map(function (point) { return ({ x: point.x, y: point.y }); }), true));
+            area.add(new AcGePolyline2d(innerPoints.map(function (point) { return ({ x: point.x, y: point.y }); }), true));
+        }
+        else {
+            var ringPoints = __spreadArray(__spreadArray([], __read(outerPoints), false), __read(innerPoints.slice().reverse()), false).map(function (point) { return ({ x: point.x, y: point.y }); });
+            if (ringPoints.length < 3)
+                return undefined;
+            area.add(new AcGePolyline2d(ringPoints, true));
+        }
+        return area;
+    };
+    /**
+     * Finds the element indices that define fill boundaries by minimum and maximum reference offsets.
+     *
+     * @param elementCount Total renderable element count.
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Outer/inner boundary indices, or `undefined` when not resolvable.
+     */
+    AcDbMLine.prototype.getFillBoundaryElementIndices = function (elementCount, mlineStyle) {
+        var minOffset = Number.POSITIVE_INFINITY;
+        var maxOffset = Number.NEGATIVE_INFINITY;
+        var minIndex = -1;
+        var maxIndex = -1;
+        for (var i = 0; i < elementCount; i++) {
+            var offset = this.getElementReferenceOffset(i, mlineStyle);
+            if (offset < minOffset) {
+                minOffset = offset;
+                minIndex = i;
+            }
+            if (offset > maxOffset) {
+                maxOffset = offset;
+                maxIndex = i;
+            }
+        }
+        if (minIndex < 0 || maxIndex < 0 || minIndex === maxIndex) {
+            return undefined;
+        }
+        return {
+            outerIndex: maxIndex,
+            innerIndex: minIndex
+        };
+    };
+    /**
+     * Resolves an element's reference offset from first-segment data or style defaults.
+     *
+     * @param elementIndex Style element index.
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Reference offset used for boundary comparison.
+     */
+    AcDbMLine.prototype.getElementReferenceOffset = function (elementIndex, mlineStyle) {
+        var _a;
+        var firstSegment = this._segments[0];
+        if (firstSegment) {
+            var element = firstSegment.elements[elementIndex];
+            if ((_a = element === null || element === void 0 ? void 0 : element.parameters) === null || _a === void 0 ? void 0 : _a.length) {
+                return element.parameters[0];
+            }
+        }
+        return this.getStyleElementOffset(elementIndex, mlineStyle);
+    };
+    /**
+     * Resolves style-defined element offset to world offset under current
+     * justification and entity scale.
+     *
+     * @param elementIndex Style element index.
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Final offset distance used for miter displacement.
+     */
+    AcDbMLine.prototype.getStyleElementOffset = function (elementIndex, mlineStyle) {
         var styleElement = mlineStyle === null || mlineStyle === void 0 ? void 0 : mlineStyle.elements[elementIndex];
-        return (_b = styleElement === null || styleElement === void 0 ? void 0 : styleElement.offset) !== null && _b !== void 0 ? _b : 0;
+        if (!styleElement)
+            return 0;
+        var shift = this.getStyleJustificationShift(mlineStyle);
+        return (styleElement.offset + shift) * this._scale;
+    };
+    /**
+     * Calculates justification shift in style-offset space.
+     *
+     * - `Zero`: shift = 0
+     * - `Top`: highest style offset is moved to 0
+     * - `Bottom`: lowest style offset is moved to 0
+     *
+     * @param mlineStyle Resolved style object, if available.
+     * @returns Offset shift before scaling.
+     */
+    AcDbMLine.prototype.getStyleJustificationShift = function (mlineStyle) {
+        var e_1, _a;
+        var _b;
+        var elements = (_b = mlineStyle === null || mlineStyle === void 0 ? void 0 : mlineStyle.elements) !== null && _b !== void 0 ? _b : [];
+        if (elements.length <= 0)
+            return 0;
+        var minOffset = Number.POSITIVE_INFINITY;
+        var maxOffset = Number.NEGATIVE_INFINITY;
+        try {
+            for (var elements_1 = __values(elements), elements_1_1 = elements_1.next(); !elements_1_1.done; elements_1_1 = elements_1.next()) {
+                var element = elements_1_1.value;
+                var offset = element.offset;
+                if (offset < minOffset)
+                    minOffset = offset;
+                if (offset > maxOffset)
+                    maxOffset = offset;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (elements_1_1 && !elements_1_1.done && (_a = elements_1.return)) _a.call(elements_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (this._justification === AcDbMLineJustification.Top) {
+            return -maxOffset;
+        }
+        if (this._justification === AcDbMLineJustification.Bottom) {
+            return -minOffset;
+        }
+        return 0;
+    };
+    /**
+     * Removes a duplicated closing vertex when the first and last points are numerically equal.
+     *
+     * @param points Candidate closed path.
+     * @returns Path without duplicated terminal point.
+     */
+    AcDbMLine.prototype.stripClosingPoint = function (points) {
+        if (points.length < 2)
+            return points;
+        var first = points[0];
+        var last = points[points.length - 1];
+        var epsilon = 1e-9;
+        var isClosed = Math.abs(first.x - last.x) <= epsilon &&
+            Math.abs(first.y - last.y) <= epsilon &&
+            Math.abs(first.z - last.z) <= epsilon;
+        return isClosed ? points.slice(0, -1) : points;
     };
+    /**
+     * Offsets a point along a miter direction by a scalar distance.
+     *
+     * @param point Base point.
+     * @param miterDirection Offset direction.
+     * @param distance Offset distance.
+     * @returns Offset point clone.
+     */
     AcDbMLine.prototype.offsetPoint = function (point, miterDirection, distance) {
         if (distance === 0 || miterDirection.lengthSq() === 0) {
             return point.clone();
@@ -486,6 +1113,245 @@ var AcDbMLine = /** @class */ (function (_super) {
             .multiplyScalar(distance);
         return point.clone().add(direction);
     };
+    /**
+     * Appends the first point to the end of a path when closed mode requires an explicit closure.
+     *
+     * @param points Path points to inspect.
+     * @returns Original or explicitly closed path array.
+     */
+    AcDbMLine.prototype.closePathIfNeeded = function (points) {
+        if (!this.closed || points.length < 2)
+            return points;
+        var first = points[0];
+        var last = points[points.length - 1];
+        var epsilon = 1e-9;
+        var isClosed = Math.abs(first.x - last.x) <= epsilon &&
+            Math.abs(first.y - last.y) <= epsilon &&
+            Math.abs(first.z - last.z) <= epsilon;
+        if (!isClosed)
+            points.push(first.clone());
+        return points;
+    };
+    /**
+     * Appends style-driven joint/cap entities after element path rendering.
+     *
+     * @param renderer Active graphics renderer.
+     * @param entities Output entity list to append into.
+     * @param mlineStyle Resolved style object, if available.
+     * @param elementCount Renderable style element count.
+     * @param originalColor Original trait color.
+     * @param originalRgbColor Original trait RGB.
+     * @param originalLineType Original trait linetype.
+     */
+    AcDbMLine.prototype.appendStyleDrivenJointAndCapEntities = function (renderer, entities, mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType) {
+        if (!mlineStyle || elementCount < 2)
+            return;
+        entities.push.apply(entities, __spreadArray([], __read(this.drawMiterJointEntities(renderer, mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType)), false));
+        entities.push.apply(entities, __spreadArray([], __read(this.drawCapEntities(renderer, mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType)), false));
+    };
+    /**
+     * Draws miter connector lines at interior joints when style enables it.
+     *
+     * @param renderer Active graphics renderer.
+     * @param mlineStyle Resolved style object.
+     * @param elementCount Renderable style element count.
+     * @param originalColor Original trait color.
+     * @param originalRgbColor Original trait RGB.
+     * @param originalLineType Original trait linetype.
+     * @returns Drawn joint entities.
+     */
+    AcDbMLine.prototype.drawMiterJointEntities = function (renderer, mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType) {
+        var _this = this;
+        if (this.closed ||
+            this._segments.length < 2 ||
+            (mlineStyle.flags & AcDbMLineStyleFlags.DisplayMiters) === 0) {
+            return [];
+        }
+        var entities = [];
+        var traits = renderer.subEntityTraits;
+        var _loop_1 = function (segmentIndex) {
+            var segment = this_1._segments[segmentIndex];
+            var points = Array.from({ length: elementCount }, function (_, elementIndex) {
+                var offset = _this.getElementMiterOffset(segment, elementIndex, mlineStyle);
+                return {
+                    elementIndex: elementIndex,
+                    offset: offset,
+                    point: _this.offsetPoint(segment.position, segment.miterDirection, offset)
+                };
+            }).sort(function (a, b) { return b.offset - a.offset; });
+            for (var i = 0; i < points.length - 1; i++) {
+                this_1.applyElementDrawTraits(traits, originalColor, originalRgbColor, originalLineType, mlineStyle, points[i].elementIndex);
+                entities.push(renderer.lines([points[i].point, points[i + 1].point]));
+            }
+        };
+        var this_1 = this;
+        for (var segmentIndex = 0; segmentIndex < this._segments.length - 1; segmentIndex++) {
+            _loop_1(segmentIndex);
+        }
+        return entities;
+    };
+    /**
+     * Draws start/end cap entities according to MLINESTYLE cap flags.
+     *
+     * @param renderer Active graphics renderer.
+     * @param mlineStyle Resolved style object.
+     * @param elementCount Renderable style element count.
+     * @param originalColor Original trait color.
+     * @param originalRgbColor Original trait RGB.
+     * @param originalLineType Original trait linetype.
+     * @returns Drawn cap entities.
+     */
+    AcDbMLine.prototype.drawCapEntities = function (renderer, mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType) {
+        if (this.closed || this._segments.length <= 0)
+            return [];
+        var entities = [];
+        entities.push.apply(entities, __spreadArray([], __read(this.drawCapEntitiesForSide(renderer, 'start', mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType)), false));
+        entities.push.apply(entities, __spreadArray([], __read(this.drawCapEntitiesForSide(renderer, 'end', mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType)), false));
+        return entities;
+    };
+    /**
+     * Draws one-side cap entities (line/outer-arc/inner-arcs).
+     *
+     * @param renderer Active graphics renderer.
+     * @param side `start` or `end`.
+     * @param mlineStyle Resolved style object.
+     * @param elementCount Renderable style element count.
+     * @param originalColor Original trait color.
+     * @param originalRgbColor Original trait RGB.
+     * @param originalLineType Original trait linetype.
+     * @returns Drawn one-side cap entities.
+     */
+    AcDbMLine.prototype.drawCapEntitiesForSide = function (renderer, side, mlineStyle, elementCount, originalColor, originalRgbColor, originalLineType) {
+        if (side === 'start' && this.suppressStartCaps)
+            return [];
+        if (side === 'end' && this.suppressEndCaps)
+            return [];
+        var flags = mlineStyle.flags;
+        var isStart = side === 'start';
+        var hasSquare = isStart
+            ? (flags & AcDbMLineStyleFlags.StartSquareCap) !== 0
+            : (flags & AcDbMLineStyleFlags.EndSquareCap) !== 0;
+        var hasOuterArc = isStart
+            ? (flags & AcDbMLineStyleFlags.StartRoundCap) !== 0
+            : (flags & AcDbMLineStyleFlags.EndRoundCap) !== 0;
+        var hasInnerArcs = isStart
+            ? (flags & AcDbMLineStyleFlags.StartInnerArcs) !== 0
+            : (flags & AcDbMLineStyleFlags.EndInnerArcs) !== 0;
+        if (!hasSquare && !hasOuterArc && !hasInnerArcs)
+            return [];
+        var points = this.getCapElementPoints(side, elementCount, mlineStyle);
+        if (points.length < 2)
+            return [];
+        var entities = [];
+        var traits = renderer.subEntityTraits;
+        if (hasSquare) {
+            for (var i = 0; i < points.length - 1; i++) {
+                this.applyElementDrawTraits(traits, originalColor, originalRgbColor, originalLineType, mlineStyle, points[i].elementIndex);
+                entities.push(renderer.lines([points[i].point, points[i + 1].point]));
+            }
+        }
+        var capDirection = isStart
+            ? this.getStartSegmentDirection().multiplyScalar(-1)
+            : this.getEndSegmentDirection().clone();
+        if (hasOuterArc) {
+            var outer = this.drawCapArcBetweenElements(renderer, side, points[0], points[points.length - 1], capDirection, traits, originalColor, originalRgbColor, originalLineType, mlineStyle);
+            if (outer)
+                entities.push(outer);
+        }
+        if (hasInnerArcs) {
+            for (var i = 1; i < Math.floor(points.length / 2); i++) {
+                var left = points[i];
+                var right = points[points.length - 1 - i];
+                if (!left || !right || left === right)
+                    continue;
+                var inner = this.drawCapArcBetweenElements(renderer, side, left, right, capDirection, traits, originalColor, originalRgbColor, originalLineType, mlineStyle);
+                if (inner)
+                    entities.push(inner);
+            }
+        }
+        return entities;
+    };
+    /**
+     * Creates sorted element boundary points for one cap side.
+     *
+     * @param side `start` or `end`.
+     * @param elementCount Renderable style element count.
+     * @param mlineStyle Resolved style object.
+     * @returns Cap points sorted by descending element offset.
+     */
+    AcDbMLine.prototype.getCapElementPoints = function (side, elementCount, mlineStyle) {
+        var _this = this;
+        var segment = side === 'start'
+            ? this._segments[0]
+            : this._segments[this._segments.length - 1];
+        if (!segment)
+            return [];
+        return Array.from({ length: elementCount }, function (_, elementIndex) { return ({
+            elementIndex: elementIndex,
+            offset: _this.getElementMiterOffset(segment, elementIndex, mlineStyle),
+            point: _this.getElementBoundaryPoint(side, segment, elementIndex, mlineStyle)
+        }); }).sort(function (a, b) { return b.offset - a.offset; });
+    };
+    /**
+     * Draws one cap arc between two cap element points.
+     *
+     * @param renderer Active graphics renderer.
+     * @param startPointPair Start element point.
+     * @param endPointPair End element point.
+     * @param capDirection Outward cap direction.
+     * @param traits Mutable renderer traits.
+     * @param originalColor Original trait color.
+     * @param originalRgbColor Original trait RGB.
+     * @param originalLineType Original trait linetype.
+     * @param mlineStyle Resolved style object.
+     * @returns Arc entity, or `undefined` when arc cannot be constructed.
+     */
+    AcDbMLine.prototype.drawCapArcBetweenElements = function (renderer, side, startPointPair, endPointPair, capDirection, traits, originalColor, originalRgbColor, originalLineType, mlineStyle) {
+        // For 180-degree cap arcs, start/end point order determines whether
+        // the renderer takes the left or right semicircle. End caps need reverse order.
+        var arcStartPoint = side === 'end' ? endPointPair.point : startPointPair.point;
+        var arcEndPoint = side === 'end' ? startPointPair.point : endPointPair.point;
+        var chord = arcStartPoint.distanceTo(arcEndPoint);
+        if (chord <= 1e-9 || capDirection.lengthSq() === 0)
+            return undefined;
+        var midpoint = arcStartPoint
+            .clone()
+            .add(new AcGeVector3d()
+            .subVectors(arcEndPoint, arcStartPoint)
+            .multiplyScalar(0.5));
+        var pointOnArc = midpoint.add(capDirection
+            .clone()
+            .normalize()
+            .multiplyScalar(chord / 2));
+        var arc = AcGeCircArc3d.createByThreePoints(arcStartPoint, arcEndPoint, pointOnArc);
+        if (!arc)
+            return undefined;
+        this.applyElementDrawTraits(traits, originalColor, originalRgbColor, originalLineType, mlineStyle, side === 'end' ? endPointPair.elementIndex : startPointPair.elementIndex);
+        return renderer.circularArc(arc);
+    };
+    /**
+     * Applies per-element traits while restoring baseline traits first.
+     *
+     * @param traits Mutable renderer traits.
+     * @param originalColor Original trait color.
+     * @param originalRgbColor Original trait RGB.
+     * @param originalLineType Original trait linetype.
+     * @param mlineStyle Resolved style object.
+     * @param elementIndex Style element index.
+     */
+    AcDbMLine.prototype.applyElementDrawTraits = function (traits, originalColor, originalRgbColor, originalLineType, mlineStyle, elementIndex) {
+        traits.color = originalColor;
+        traits.rgbColor = originalRgbColor;
+        traits.lineType = originalLineType;
+        this.applyStyleElementTraits(mlineStyle, elementIndex, traits);
+    };
+    /**
+     * Transforms a vector by matrix rotation/scale only.
+     * Translation is canceled by transforming an origin-endpoint pair.
+     *
+     * @param vector Vector to transform in place.
+     * @param matrix Transformation matrix.
+     */
     AcDbMLine.prototype.transformVector = function (vector, matrix) {
         var origin = new AcGePoint3d();
         var endpoint = new AcGePoint3d(vector.x, vector.y, vector.z);
@@ -493,8 +1359,14 @@ var AcDbMLine = /** @class */ (function (_super) {
         endpoint.applyMatrix4(matrix);
         vector.set(endpoint.x - origin.x, endpoint.y - origin.y, endpoint.z - origin.z);
     };
+    /**
+     * Resolves the effective MLINE style from database dictionary.
+     * Lookup order: handle, exact name, then case-insensitive name match.
+     *
+     * @returns Matching style object, or `undefined` when no style is found.
+     */
     AcDbMLine.prototype.getMLineStyle = function () {
-        var e_1, _a;
+        var e_2, _a;
         var _b;
         var dictionary = this.database.objects.mlineStyle;
         var byHandle = this.styleObjectHandle
@@ -512,35 +1384,125 @@ var AcDbMLine = /** @class */ (function (_super) {
             try {
                 for (var _c = __values(dictionary.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var _e = __read(_d.value, 2), name_1 = _e[0], style = _e[1];
-                    if (name_1.toUpperCase() === normalizedStyleName) {
+                    var styleName = (style.styleName || name_1).toUpperCase();
+                    if (name_1.toUpperCase() === normalizedStyleName ||
+                        styleName === normalizedStyleName) {
                         return style;
                     }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_2) throw e_2.error; }
             }
         }
         return undefined;
     };
+    /**
+     * Applies style-element color and linetype traits to renderer traits.
+     * BYBLOCK and BYLAYER colors are ignored.
+     *
+     * @param mlineStyle Resolved style object.
+     * @param elementIndex Style element index.
+     * @param traits Mutable renderer trait set.
+     */
     AcDbMLine.prototype.applyStyleElementTraits = function (mlineStyle, elementIndex, traits) {
+        var _a;
         var styleElement = mlineStyle === null || mlineStyle === void 0 ? void 0 : mlineStyle.elements[elementIndex];
         if (!styleElement)
             return;
-        var colorIndex = styleElement.color;
-        if (colorIndex === 0 || colorIndex === 256)
+        var lineType = this.resolveStyleElementLineType(styleElement.lineType);
+        if (lineType) {
+            traits.lineType = lineType;
+        }
+        if (styleElement.color.isByBlock || styleElement.color.isByLayer)
+            return;
+        traits.color = styleElement.color.clone();
+        traits.rgbColor = (_a = styleElement.color.RGB) !== null && _a !== void 0 ? _a : this.rgbColor;
+    };
+    /**
+     * Applies fill color traits from style definition to the renderer traits object.
+     * BYBLOCK and BYLAYER colors are ignored.
+     *
+     * @param mlineStyle Resolved style object.
+     * @param traits Mutable renderer trait set.
+     */
+    AcDbMLine.prototype.applyFillTraits = function (mlineStyle, traits) {
+        var _a;
+        var fillColor = mlineStyle === null || mlineStyle === void 0 ? void 0 : mlineStyle.fillColor;
+        if (!fillColor || fillColor.isByBlock || fillColor.isByLayer)
             return;
-        var color = new AcCmColor();
-        color.colorIndex = colorIndex;
-        traits.color = color;
-        if (color.RGB != null) {
-            traits.rgbColor = color.RGB;
+        traits.color = fillColor.clone();
+        traits.rgbColor = (_a = fillColor.RGB) !== null && _a !== void 0 ? _a : this.rgbColor;
+    };
+    /**
+     * Resolves a style-element linetype token to concrete renderer linetype traits.
+     *
+     * @param rawLineType Style element linetype token.
+     * @returns Resolved linetype traits, or `undefined` when no override is needed.
+     */
+    AcDbMLine.prototype.resolveStyleElementLineType = function (rawLineType) {
+        var _a;
+        var lineTypeName = rawLineType === null || rawLineType === void 0 ? void 0 : rawLineType.trim();
+        if (!lineTypeName)
+            return undefined;
+        var normalized = lineTypeName.toUpperCase();
+        var byLayer = ByLayer.toUpperCase();
+        var byBlock = ByBlock.toUpperCase();
+        var type = 'UserSpecified';
+        var resolvedName = lineTypeName;
+        if (normalized === byLayer) {
+            type = 'ByLayer';
+            var layerLineType = (_a = this.database.tables.layerTable.getAt(this.layer)) === null || _a === void 0 ? void 0 : _a.linetype;
+            resolvedName =
+                layerLineType &&
+                    layerLineType.toUpperCase() !== byLayer &&
+                    layerLineType.toUpperCase() !== byBlock
+                    ? layerLineType
+                    : DEFAULT_LINE_TYPE;
+        }
+        else if (normalized === byBlock) {
+            type = 'ByBlock';
+            resolvedName = DEFAULT_LINE_TYPE;
+        }
+        var lineTypeRecord = this.database.tables.linetypeTable.getAt(resolvedName);
+        if (lineTypeRecord) {
+            return __assign({ type: type }, lineTypeRecord.linetype);
+        }
+        return {
+            type: type,
+            name: resolvedName,
+            standardFlag: 0,
+            description: '',
+            totalPatternLength: 0
+        };
+    };
+    /**
+     * @inheritdoc
+     */
+    AcDbMLine.prototype.resolveEffectiveProperties = function () {
+        _super.prototype.resolveEffectiveProperties.call(this);
+        if (!this._styleName) {
+            this._styleName = this.getDefaultStyleName();
+        }
+    };
+    /**
+     * Resolves the default style name for newly created MLINE entities.
+     */
+    AcDbMLine.prototype.getDefaultStyleName = function () {
+        try {
+            return this.database.cmlstyle || DEFAULT_MLINE_STYLE;
+        }
+        catch (_a) {
+            return DEFAULT_MLINE_STYLE;
         }
     };
+    /**
+     * Runtime type name used by the entity factory and RTTI helpers.
+     */
     AcDbMLine.typeName = 'MLine';
     return AcDbMLine;
 }(AcDbEntity));