@mlightcad/data-model 1.7.27 → 1.7.29

package/lib/entity/AcDbMLine.js

@@ -0,0 +1,1510 @@
+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, 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 = {}));
+/**
+ * Bit flags used by MLINE entities.
+ */
+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 = '';
+        _this._styleObjectHandle = '';
+        _this._scale = 1;
+        _this._justification = AcDbMLineJustification.Zero;
+        _this._flags = 0;
+        _this._styleCount = 0;
+        _this._startPosition = new AcGePoint3d();
+        _this._normal = new AcGeVector3d(0, 0, 1);
+        _this._segments = [];
+        return _this;
+    }
+    Object.defineProperty(AcDbMLine.prototype, "dxfTypeName", {
+        /**
+         * DXF entity type token written to or read from drawing files.
+         */
+        get: function () {
+            return 'MLINE';
+        },
+        enumerable: false,
+        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 || this.getDefaultStyleName();
+        },
+        /**
+         * Sets the style name used to resolve the MLINE style object.
+         *
+         * @param value New style name.
+         */
+        set: function (value) {
+            this._styleName = value;
+        },
+        enumerable: false,
+        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;
+        },
+        enumerable: false,
+        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;
+        },
+        enumerable: false,
+        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;
+        },
+        enumerable: false,
+        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;
+        },
+        enumerable: false,
+        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);
+        },
+        enumerable: false,
+        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);
+        },
+        enumerable: false,
+        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);
+        },
+        enumerable: false,
+        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); });
+            this.updateHasVertexFlag();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbMLine.prototype, "vertexCount", {
+        /**
+         * Gets the number of stored segment vertices.
+         *
+         * @returns Vertex count.
+         */
+        get: function () {
+            return this._segments.length;
+        },
+        enumerable: false,
+        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);
+        },
+        enumerable: false,
+        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);
+        },
+        enumerable: false,
+        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();
+            return box.setFromPoints(points);
+        },
+        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);
+        this._segments.forEach(function (segment) {
+            segment.position.applyMatrix4(matrix);
+            _this.transformVector(segment.direction, matrix);
+            _this.transformVector(segment.miterDirection, matrix);
+        });
+        this.transformVector(this._normal, matrix);
+        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 {
+                type: this.type,
+                groups: [
+                    this.getGeneralProperties(),
+                    {
+                        groupName: 'mline',
+                        properties: [
+                            {
+                                name: 'styleName',
+                                type: 'string',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.styleName; },
+                                    set: function (value) {
+                                        _this.styleName = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'scale',
+                                type: 'float',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.scale; },
+                                    set: function (value) {
+                                        _this.scale = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'justification',
+                                type: 'int',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.justification; },
+                                    set: function (value) {
+                                        _this.justification = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'closed',
+                                type: 'boolean',
+                                editable: true,
+                                accessor: {
+                                    get: function () { return _this.closed; },
+                                    set: function (value) {
+                                        _this.closed = value;
+                                    }
+                                }
+                            },
+                            {
+                                name: 'vertexCount',
+                                type: 'int',
+                                editable: false,
+                                accessor: {
+                                    get: function () { return _this.vertexCount; }
+                                }
+                            }
+                        ]
+                    }
+                ]
+            };
+        },
+        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;
+        var entities = [];
+        var mlineStyle = this.getMLineStyle();
+        var elementCount = this.getRenderableElementCount(mlineStyle);
+        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)
+                entities.push(renderer.lines(reference));
+        }
+        else {
+            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.writeHandle(340, this._styleObjectHandle);
+        filer.writeDouble(40, this._scale);
+        filer.writeInt16(70, this._justification);
+        filer.writeInt16(71, this._flags);
+        filer.writeInt16(72, this.vertexCount);
+        filer.writeInt16(73, this._styleCount);
+        filer.writePoint3d(10, this._startPosition);
+        filer.writeVector3d(210, this._normal);
+        this._segments.forEach(function (segment) {
+            filer.writePoint3d(11, segment.position);
+            filer.writeVector3d(12, segment.direction);
+            filer.writeVector3d(13, segment.miterDirection);
+            segment.elements.forEach(function (element) {
+                filer.writeInt16(74, element.parameterCount);
+                element.parameters.forEach(function (parameter) {
+                    return filer.writeDouble(41, parameter);
+                });
+                filer.writeInt16(75, element.fillCount);
+                element.fillParameters.forEach(function (parameter) {
+                    return filer.writeDouble(42, parameter);
+                });
+            });
+        });
+        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;
+        }
+        else {
+            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;
+        return {
+            position: new AcGePoint3d().copy(segment.position),
+            direction: new AcGeVector3d().copy(segment.direction),
+            miterDirection: new AcGeVector3d().copy(segment.miterDirection),
+            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) : [];
+        var fillParameters = element.fillParameters
+            ? __spreadArray([], __read(element.fillParameters), false) : [];
+        return {
+            parameterCount: (_a = element.parameterCount) !== null && _a !== void 0 ? _a : parameters.length,
+            parameters: parameters,
+            fillCount: (_b = element.fillCount) !== null && _b !== void 0 ? _b : fillParameters.length,
+            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(),
+            direction: segment.direction.clone(),
+            miterDirection: segment.miterDirection.clone(),
+            elements: segment.elements.map(function (element) { return ({
+                parameterCount: element.parameterCount,
+                parameters: __spreadArray([], __read(element.parameters), false),
+                fillCount: element.fillCount,
+                fillParameters: __spreadArray([], __read(element.fillParameters), false)
+            }); })
+        };
+    };
+    /**
+     * 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)
+            return points;
+        var mlineStyle = this.getMLineStyle();
+        var elementCount = this.getRenderableElementCount(mlineStyle);
+        if (elementCount <= 0) {
+            this._segments.forEach(function (segment) { return points.push(segment.position); });
+            return points;
+        }
+        for (var i = 0; i < elementCount; i++) {
+            points.push.apply(points, __spreadArray([], __read(this.getElementPath(i, mlineStyle)), false));
+        }
+        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 () {
+        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];
+        points.push(this.getElementBoundaryPoint('start', first, elementIndex, mlineStyle));
+        this._segments.forEach(function (segment) {
+            points.push(_this.offsetPoint(segment.position, segment.miterDirection, _this.getElementMiterOffset(segment, elementIndex, mlineStyle)));
+        });
+        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;
+        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];
+        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();
+        }
+        var direction = miterDirection
+            .clone()
+            .normalize()
+            .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);
+        origin.applyMatrix4(matrix);
+        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_2, _a;
+        var _b;
+        var dictionary = this.database.objects.mlineStyle;
+        var byHandle = this.styleObjectHandle
+            ? dictionary.getIdAt(this.styleObjectHandle)
+            : undefined;
+        if (byHandle)
+            return byHandle;
+        var directByName = this.styleName
+            ? dictionary.getAt(this.styleName)
+            : undefined;
+        if (directByName)
+            return directByName;
+        var normalizedStyleName = (_b = this.styleName) === null || _b === void 0 ? void 0 : _b.toUpperCase();
+        if (normalizedStyleName) {
+            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];
+                    var styleName = (style.styleName || name_1).toUpperCase();
+                    if (name_1.toUpperCase() === normalizedStyleName ||
+                        styleName === normalizedStyleName) {
+                        return style;
+                    }
+                }
+            }
+            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_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 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;
+        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));
+export { AcDbMLine };
+//# sourceMappingURL=AcDbMLine.js.map