@mlightcad/dxf-json-converter 1.9.0

package/lib/AcDbEntitiyConverter.js

@@ -0,0 +1,1424 @@
+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 { AcCmColor, AcCmTransparency, AcDb2dPolyline, AcDb3dPolyline, AcDb3PointAngularDimension, AcDbAlignedDimension, AcDbArc, AcDbAttribute, AcDbAttributeDefinition, AcDbAttributeFlags, AcDbAttributeMTextFlag, AcDbBlockReference, AcDbCircle, AcDbDiametricDimension, AcDbEllipse, AcDbFace, AcDbHatch, AcDbHatchObjectType, AcDbLeader, AcDbLine, AcDbMLeader, AcDbMLeaderContentType, AcDbMLeaderLineType, AcDbMLine, AcDbMText, AcDbOrdinateDimension, AcDbPoint, AcDbPoly2dType, AcDbPoly3dType, AcDbPolyFaceMesh, AcDbPolygonMesh, AcDbPolyline, AcDbRadialDimension, AcDbRasterImage, AcDbRay, AcDbRotatedDimension, AcDbShape, AcDbSpline, AcDbTable, AcDbText, AcDbTrace, AcDbViewport, AcDbWipeout, AcDbXline, AcGeCircArc2d, AcGeEllipseArc2d, AcGeLine2d, AcGeLoop2d, AcGeMathUtil, AcGePoint2d, AcGePoint3d, AcGePolyline2d, AcGeSpline3d, AcGeVector2d, AcGeVector3d, transformOcsPointToWcs } from '@mlightcad/data-model';
+import { HatchSolidFill, SmoothType, VertexFlag } from '@mlightcad/dxf-json/types';
+/**
+ * Converts DXF entities to AcDbEntity objects.
+ *
+ * This class provides functionality to convert various DXF entity types
+ * (such as lines, circles, arcs, text, etc.) into their corresponding
+ * AcDbEntity objects. It handles the conversion of geometric data,
+ * properties, and attributes from DXF format to the internal database format.
+ *
+ * @example
+ * ```typescript
+ * const converter = new AcDbEntityConverter();
+ * const dxfEntity = { type: 'LINE', startPoint: [0, 0, 0], endPoint: [10, 10, 0] };
+ * const acDbEntity = converter.convert(dxfEntity);
+ * ```
+ */
+var AcDbEntityConverter = /** @class */ (function () {
+    function AcDbEntityConverter() {
+    }
+    /**
+     * Converts a DXF entity to an AcDbEntity.
+     *
+     * This method takes a DXF entity and converts it to the corresponding
+     * AcDbEntity type. It first creates the entity using createEntity(),
+     * then processes common attributes using processCommonAttrs().
+     *
+     * @param entity - The DXF entity to convert
+     * @returns The converted AcDbEntity, or null if conversion fails
+     *
+     * @example
+     * ```typescript
+     * const dxfLine = { type: 'LINE', startPoint: [0, 0, 0], endPoint: [10, 10, 0] };
+     * const acDbLine = converter.convert(dxfLine);
+     * if (acDbLine) {
+     *   console.log('Converted to:', acDbLine.type);
+     * }
+     * ```
+     */
+    AcDbEntityConverter.prototype.convert = function (entity) {
+        var dbEntity = this.createEntity(entity);
+        if (dbEntity) {
+            this.processCommonAttrs(entity, dbEntity);
+        }
+        return dbEntity;
+    };
+    /**
+     * Creates the corresponding drawing database entity from DXF format data.
+     *
+     * This method acts as a factory that routes DXF entities to their specific
+     * conversion methods based on the entity type. It handles all supported
+     * DXF entity types including geometric entities, text entities, and special entities.
+     *
+     * @param entity - Input entity data in DXF format
+     * @returns The converted drawing database entity, or null if the entity type is not supported
+     *
+     * @example
+     * ```typescript
+     * const dxfEntity = { type: 'CIRCLE', center: [0, 0, 0], radius: 5 };
+     * const acDbEntity = converter.createEntity(dxfEntity);
+     * ```
+     */
+    AcDbEntityConverter.prototype.createEntity = function (entity) {
+        if (entity.type == '3DFACE') {
+            return this.convertFace(entity);
+        }
+        else if (entity.type == 'ARC') {
+            return this.convertArc(entity);
+        }
+        else if (entity.type == 'ATTDEF') {
+            return this.convertAttributeDefinition(entity);
+        }
+        else if (entity.type == 'ATTRIB') {
+            return this.convertAttribute(entity);
+        }
+        else if (entity.type == 'CIRCLE') {
+            return this.convertCirle(entity);
+        }
+        else if (entity.type == 'DIMENSION') {
+            return this.convertDimension(entity);
+        }
+        else if (entity.type == 'ELLIPSE') {
+            return this.convertEllipse(entity);
+        }
+        else if (entity.type == 'HATCH') {
+            return this.convertHatch(entity);
+        }
+        else if (entity.type == 'IMAGE') {
+            return this.convertImage(entity);
+        }
+        else if (entity.type == 'LEADER') {
+            return this.convertLeader(entity);
+        }
+        else if (entity.type == 'LINE') {
+            return this.convertLine(entity);
+        }
+        else if (entity.type == 'LWPOLYLINE') {
+            return this.convertLWPolyline(entity);
+        }
+        else if (entity.type == 'MTEXT') {
+            return this.convertMText(entity);
+        }
+        else if (entity.type == 'MLINE') {
+            return this.convertMLine(entity);
+        }
+        else if (entity.type == 'MULTILEADER' || entity.type == 'MLEADER') {
+            return this.convertMLeader(entity);
+        }
+        else if (entity.type == 'POLYLINE') {
+            return this.convertPolyline(entity);
+        }
+        else if (entity.type == 'POINT') {
+            return this.convertPoint(entity);
+        }
+        else if (entity.type == 'RAY') {
+            return this.convertRay(entity);
+        }
+        else if (entity.type == 'SPLINE') {
+            return this.convertSpline(entity);
+        }
+        else if (entity.type == 'ACAD_TABLE') {
+            return this.convertTable(entity);
+        }
+        else if (entity.type == 'TEXT') {
+            return this.convertText(entity);
+        }
+        else if (entity.type == 'SHAPE') {
+            return this.convertShape(entity);
+        }
+        else if (entity.type == 'SOLID') {
+            return this.convertSolid(entity);
+        }
+        else if (entity.type == 'VIEWPORT') {
+            return this.convertViewport(entity);
+        }
+        else if (entity.type == 'WIPEOUT') {
+            return this.convertWipeout(entity);
+        }
+        else if (entity.type == 'XLINE') {
+            return this.convertXline(entity);
+        }
+        else if (entity.type == 'INSERT') {
+            return this.convertBlockReference(entity);
+        }
+        return null;
+    };
+    /**
+     * Converts a DXF 3DFACE entity to an AcDbFace.
+     *
+     * @param face - The DXF 3DFace entity to convert
+     * @returns The converted AcDbFace entity
+     */
+    AcDbEntityConverter.prototype.convertFace = function (face) {
+        var dbEntity = new AcDbFace();
+        face.vertices.forEach(function (vertex, index) {
+            return dbEntity.setVertexAt(index, vertex);
+        });
+        return dbEntity;
+    };
+    /**
+     * Converts a DXF arc entity to an AcDbArc.
+     *
+     * @param arc - The DXF arc entity to convert
+     * @returns The converted AcDbArc entity
+     *
+     * @example
+     * ```typescript
+     * const dxfArc = { type: 'ARC', center: [0, 0, 0], radius: 5, startAngle: 0, endAngle: 90 };
+     * const acDbArc = converter.convertArc(dxfArc);
+     * ```
+     */
+    AcDbEntityConverter.prototype.convertArc = function (arc) {
+        var _a;
+        var normal = (_a = arc.extrusionDirection) !== null && _a !== void 0 ? _a : AcGeVector3d.Z_AXIS;
+        var dbEntity = new AcDbArc(transformOcsPointToWcs(arc.center, normal), arc.radius, AcGeMathUtil.degToRad(arc.startAngle), AcGeMathUtil.degToRad(arc.endAngle), normal);
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertAttributeCommon = function (attrib, dbAttrib) {
+        var _a, _b;
+        dbAttrib.textString = attrib.text;
+        dbAttrib.height = attrib.textHeight;
+        dbAttrib.position.copy(attrib.startPoint);
+        // Propagate DXF group 11 (alignment point) used when halign/valign are
+        // non-default. Falls back to startPoint when missing or zero so the
+        // alignment anchor never collapses to the world origin — see notes in
+        // `libredwg-converter` for the same defensive handling.
+        var ap = attrib.alignmentPoint;
+        var isApZero = !ap || (ap.x === 0 && ap.y === 0 && ((_a = ap.z) !== null && _a !== void 0 ? _a : 0) === 0);
+        if (ap && !isApZero) {
+            dbAttrib.alignmentPoint.copy(ap);
+        }
+        else {
+            dbAttrib.alignmentPoint.copy(attrib.startPoint);
+        }
+        dbAttrib.rotation = attrib.rotation;
+        dbAttrib.oblique = (_b = attrib.obliqueAngle) !== null && _b !== void 0 ? _b : 0;
+        dbAttrib.thickness = attrib.thickness;
+        dbAttrib.tag = attrib.tag;
+        dbAttrib.fieldLength = 0; // dxf-json doesn't have this field
+        dbAttrib.isInvisible =
+            (attrib.attributeFlag & AcDbAttributeFlags.Invisible) !== 0;
+        dbAttrib.isConst = (attrib.attributeFlag & AcDbAttributeFlags.Const) !== 0;
+        dbAttrib.isVerifiable =
+            (attrib.attributeFlag & AcDbAttributeFlags.Verifiable) !== 0;
+        dbAttrib.isPreset = (attrib.attributeFlag & AcDbAttributeFlags.Preset) !== 0;
+        dbAttrib.isReallyLocked = !!attrib.isReallyLocked;
+        dbAttrib.isMTextAttribute =
+            (attrib.mtextFlag & AcDbAttributeMTextFlag.MultiLine) !== 0;
+        dbAttrib.isConstMTextAttribute =
+            (attrib.mtextFlag & AcDbAttributeMTextFlag.ConstMultiLine) !== 0;
+    };
+    AcDbEntityConverter.prototype.convertAttribute = function (attrib) {
+        var _a;
+        var dbAttrib = new AcDbAttribute();
+        this.convertAttributeCommon(attrib, dbAttrib);
+        dbAttrib.styleName = attrib.textStyle;
+        dbAttrib.horizontalMode =
+            attrib.horizontalJustification;
+        dbAttrib.verticalMode = attrib.verticalJustification;
+        dbAttrib.widthFactor = (_a = attrib.scale) !== null && _a !== void 0 ? _a : 1;
+        dbAttrib.lockPositionInBlock = attrib.lockPositionFlag;
+        return dbAttrib;
+    };
+    AcDbEntityConverter.prototype.convertAttributeDefinition = function (attrib) {
+        var _a;
+        var dbAttDef = new AcDbAttributeDefinition();
+        this.convertAttributeCommon(attrib, dbAttDef);
+        dbAttDef.styleName = attrib.styleName;
+        dbAttDef.horizontalMode = attrib.halign;
+        dbAttDef.verticalMode = attrib.valign;
+        dbAttDef.widthFactor = (_a = attrib.xScale) !== null && _a !== void 0 ? _a : 1;
+        dbAttDef.prompt = attrib.prompt;
+        return dbAttDef;
+    };
+    /**
+     * Converts a DXF circle entity to an AcDbCircle.
+     *
+     * @param circle - The DXF circle entity to convert
+     * @returns The converted AcDbCircle entity
+     *
+     * @example
+     * ```typescript
+     * const dxfCircle = { type: 'CIRCLE', center: [0, 0, 0], radius: 5 };
+     * const acDbCircle = converter.convertCirle(dxfCircle);
+     * ```
+     */
+    AcDbEntityConverter.prototype.convertCirle = function (circle) {
+        var _a;
+        var normal = (_a = circle.extrusionDirection) !== null && _a !== void 0 ? _a : AcGeVector3d.Z_AXIS;
+        var dbEntity = new AcDbCircle(transformOcsPointToWcs(circle.center, normal), circle.radius, normal);
+        return dbEntity;
+    };
+    /**
+     * Converts a DXF ellipse entity to an AcDbEllipse.
+     *
+     * @param ellipse - The DXF ellipse entity to convert
+     * @returns The converted AcDbEllipse entity
+     *
+     * @example
+     * ```typescript
+     * const dxfEllipse = { type: 'ELLIPSE', center: [0, 0, 0], majorAxisEndPoint: [5, 0, 0] };
+     * const acDbEllipse = converter.convertEllipse(dxfEllipse);
+     * ```
+     */
+    AcDbEntityConverter.prototype.convertEllipse = function (ellipse) {
+        var _a;
+        var majorAxis = new AcGeVector3d(ellipse.majorAxisEndPoint);
+        var majorAxisRadius = majorAxis.length();
+        var dbEntity = new AcDbEllipse(ellipse.center, (_a = ellipse.extrusionDirection) !== null && _a !== void 0 ? _a : AcGeVector3d.Z_AXIS, majorAxis, majorAxisRadius, majorAxisRadius * ellipse.axisRatio, ellipse.startAngle, ellipse.endAngle);
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertLine = function (line) {
+        var start = line.startPoint;
+        var end = line.endPoint;
+        var dbEntity = new AcDbLine(new AcGePoint3d(start.x, start.y, start.z || 0), new AcGePoint3d(end.x, end.y, end.z || 0));
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertSpline = function (spline) {
+        // Catch error to construct spline because it maybe one spline in one block.
+        // If don't catch the error, the block conversion may be interruptted.
+        try {
+            if (spline.numberOfControlPoints > 0 && spline.numberOfKnots > 0) {
+                return new AcDbSpline(spline.controlPoints, spline.knots, spline.weights, spline.degree, !!(spline.flag & 0x01));
+            }
+            else if (spline.numberOfFitPoints > 0) {
+                return new AcDbSpline(spline.fitPoints, 'Uniform', spline.degree, !!(spline.flag & 0x01));
+            }
+        }
+        catch (error) {
+            console.log("Failed to convert spline with error: ".concat(error));
+        }
+        return null;
+    };
+    AcDbEntityConverter.prototype.convertPoint = function (point) {
+        var dbEntity = new AcDbPoint();
+        dbEntity.position = point.position;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertShape = function (shape) {
+        var _a, _b, _c;
+        var dbEntity = new AcDbShape();
+        dbEntity.position.copy(shape.insertionPoint);
+        dbEntity.size = shape.size;
+        dbEntity.name = shape.shapeName;
+        dbEntity.rotation = AcGeMathUtil.degToRad(shape.rotation || 0);
+        dbEntity.widthFactor = (_a = shape.xScale) !== null && _a !== void 0 ? _a : 1;
+        dbEntity.oblique = AcGeMathUtil.degToRad(shape.obliqueAngle || 0);
+        dbEntity.thickness = (_b = shape.thickness) !== null && _b !== void 0 ? _b : 0;
+        dbEntity.normal.copy((_c = shape.extrusionDirection) !== null && _c !== void 0 ? _c : { x: 0, y: 0, z: 1 });
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertSolid = function (solid) {
+        var dbEntity = new AcDbTrace();
+        solid.points.forEach(function (point, index) { return dbEntity.setPointAt(index, point); });
+        dbEntity.thickness = solid.thickness;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertPolyline = function (polyline) {
+        var _a;
+        // Polyline flag (bit-coded; default = 0):
+        // https://help.autodesk.com/view/OARX/2023/ENU/?guid=GUID-ABF6B778-BE20-4B49-9B58-A94E64CEFFF3
+        //
+        // 1 = This is a closed polyline (or a polygon mesh closed in the M direction)
+        // 2 = Curve-fit vertices have been added
+        // 4 = Spline-fit vertices have been added
+        // 8 = This is a 3D polyline
+        // 16 = This is a 3D polygon mesh
+        // 32 = The polygon mesh is closed in the N direction
+        // 64 = The polyline is a polyface mesh
+        // 128 = The linetype pattern is generated continuously around the vertices of this polyline
+        var isClosed = !!(polyline.flag & 0x01);
+        var is3dPolyline = !!(polyline.flag & 0x08);
+        var isPolygonMesh = !!(polyline.flag & 0x10); // 16
+        var isPolyfaceMesh = !!(polyline.flag & 0x40); // 64
+        var isClosedN = !!(polyline.flag & 0x20); // 32
+        // Filter out spline control points
+        var vertices = [];
+        var bulges = [];
+        var faces = [];
+        (_a = polyline.vertices) === null || _a === void 0 ? void 0 : _a.map(function (vertex) {
+            var _a, _b;
+            if (!(vertex.flag & VertexFlag.SPLINE_CONTROL_POINT)) {
+                // For polyface mesh, vertex flag 128 bit is set for all vertices
+                if (isPolyfaceMesh && vertex.flag & 0x80) {
+                    // 128 bit set
+                    // Check if this is a face vertex (64 bit not set)
+                    if (!(vertex.flag & 0x40)) {
+                        // 64 bit not set
+                        if (vertex.faces && vertex.faces.length >= 3) {
+                            faces.push(__spreadArray([], __read(vertex.faces), false));
+                        }
+                    }
+                    else {
+                        // This is a regular vertex (64 bit set)
+                        vertices.push({
+                            x: vertex.x,
+                            y: vertex.y,
+                            z: vertex.z
+                        });
+                        bulges.push((_a = vertex.bulge) !== null && _a !== void 0 ? _a : 0);
+                    }
+                }
+                else {
+                    // This is a regular vertex
+                    vertices.push({
+                        x: vertex.x,
+                        y: vertex.y,
+                        z: vertex.z
+                    });
+                    bulges.push((_b = vertex.bulge) !== null && _b !== void 0 ? _b : 0);
+                }
+            }
+        });
+        if (isPolygonMesh) {
+            // For polygon mesh, we need M and N counts
+            // In DXF, these are stored in the polyline entity as 71 and 72 group codes
+            var mCount = polyline.meshMVertexCount;
+            var nCount = polyline.meshNVertexCount;
+            return new AcDbPolygonMesh(mCount, nCount, vertices, isClosed, isClosedN);
+        }
+        else if (isPolyfaceMesh) {
+            return new AcDbPolyFaceMesh(vertices, faces);
+        }
+        else if (is3dPolyline) {
+            var polyType = AcDbPoly3dType.SimplePoly;
+            if (polyline.flag & 0x04) {
+                if (polyline.smoothType == SmoothType.CUBIC) {
+                    polyType = AcDbPoly3dType.CubicSplinePoly;
+                }
+                else if (polyline.smoothType == SmoothType.QUADRATIC) {
+                    polyType = AcDbPoly3dType.QuadSplinePoly;
+                }
+            }
+            return new AcDb3dPolyline(polyType, vertices, isClosed);
+        }
+        else {
+            var polyType = AcDbPoly2dType.SimplePoly;
+            if (polyline.flag & 0x02) {
+                polyType = AcDbPoly2dType.FitCurvePoly;
+            }
+            else if (polyline.flag & 0x04) {
+                if (polyline.smoothType == SmoothType.CUBIC) {
+                    polyType = AcDbPoly2dType.CubicSplinePoly;
+                }
+                else if (polyline.smoothType == SmoothType.QUADRATIC) {
+                    polyType = AcDbPoly2dType.QuadSplinePoly;
+                }
+            }
+            return new AcDb2dPolyline(polyType, vertices, 0, isClosed, polyline.startWidth, polyline.endWidth, bulges);
+        }
+    };
+    AcDbEntityConverter.prototype.convertLWPolyline = function (polyline) {
+        var _a, _b;
+        var dbEntity = new AcDbPolyline();
+        dbEntity.closed = !!(polyline.flag & 0x01);
+        var defaultWidth = (_a = polyline.constantWidth) !== null && _a !== void 0 ? _a : -1;
+        (_b = polyline.vertices) === null || _b === void 0 ? void 0 : _b.forEach(function (vertex, index) {
+            var _a, _b;
+            dbEntity.addVertexAt(index, new AcGePoint2d(vertex.x, vertex.y), vertex.bulge, (_a = vertex.startWidth) !== null && _a !== void 0 ? _a : defaultWidth, (_b = vertex.endWidth) !== null && _b !== void 0 ? _b : defaultWidth);
+        });
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertHatch = function (hatch) {
+        var _a, _b, _c, _d;
+        var dbEntity = new AcDbHatch();
+        (_a = hatch.definitionLines) === null || _a === void 0 ? void 0 : _a.forEach(function (item) {
+            dbEntity.definitionLines.push({
+                angle: AcGeMathUtil.degToRad(item.angle || 0),
+                base: item.base,
+                offset: item.offset,
+                dashLengths: item.numberOfDashLengths > 0 ? item.dashLengths : []
+            });
+        });
+        dbEntity.isSolidFill = hatch.solidFill == HatchSolidFill.SolidFill;
+        dbEntity.hatchStyle = hatch.hatchStyle;
+        dbEntity.patternName = hatch.patternName;
+        dbEntity.patternType = hatch.patternType;
+        dbEntity.patternAngle =
+            hatch.patternAngle == null ? 0 : AcGeMathUtil.degToRad(hatch.patternAngle);
+        dbEntity.patternScale = hatch.patternScale == null ? 0 : hatch.patternScale;
+        var paths = hatch.boundaryPaths;
+        paths.forEach(function (path) {
+            var flag = path.boundaryPathTypeFlag;
+            // Check whether it is a polyline
+            if (flag & 0x02) {
+                var polylinePath = path;
+                var polyline_1 = new AcGePolyline2d();
+                polyline_1.closed = polylinePath.isClosed;
+                polylinePath.vertices.forEach(function (vertex, index) {
+                    polyline_1.addVertexAt(index, {
+                        x: vertex.x,
+                        y: vertex.y,
+                        bulge: vertex.bulge
+                    });
+                });
+                dbEntity.add(polyline_1);
+            }
+            else {
+                var edgePath = path;
+                var edges_1 = [];
+                edgePath.edges.forEach(function (edge) {
+                    if (edge.type == 1) {
+                        var line = edge;
+                        edges_1.push(new AcGeLine2d(line.start, line.end));
+                    }
+                    else if (edge.type == 2) {
+                        var arc = edge;
+                        edges_1.push(new AcGeCircArc2d(arc.center, arc.radius, AcGeMathUtil.degToRad(arc.startAngle || 0), AcGeMathUtil.degToRad(arc.endAngle || 0), !arc.isCCW));
+                    }
+                    else if (edge.type == 3) {
+                        var ellipse = edge;
+                        var majorAxis = new AcGeVector2d();
+                        majorAxis.subVectors(ellipse.end, ellipse.center);
+                        var majorAxisRadius = Math.sqrt(Math.pow(ellipse.end.x, 2) + Math.pow(ellipse.end.y, 2));
+                        // Property name 'lengthOfMinorAxis' is really confusing.
+                        // Actually length of minor axis means percentage of major axis length.
+                        var minorAxisRadius = majorAxisRadius * ellipse.lengthOfMinorAxis;
+                        var startAngle = AcGeMathUtil.degToRad(ellipse.startAngle || 0);
+                        var endAngle = AcGeMathUtil.degToRad(ellipse.endAngle || 0);
+                        var rotation = Math.atan2(ellipse.end.y, ellipse.end.x);
+                        if (!ellipse.isCCW) {
+                            // when clockwise, need to handle start/end angles
+                            startAngle = Math.PI * 2 - startAngle;
+                            endAngle = Math.PI * 2 - endAngle;
+                        }
+                        edges_1.push(new AcGeEllipseArc2d(__assign(__assign({}, ellipse.center), { z: 0 }), majorAxisRadius, minorAxisRadius, startAngle, endAngle, !ellipse.isCCW, rotation));
+                    }
+                    else if (edge.type == 4) {
+                        var spline = edge;
+                        if (spline.numberOfControlPoints > 0 && spline.numberOfKnots > 0) {
+                            var controlPoints = spline.controlPoints.map(function (item) {
+                                return {
+                                    x: item.x,
+                                    y: item.y,
+                                    z: 0
+                                };
+                            });
+                            var hasWeights_1 = true;
+                            var weights = spline.controlPoints.map(function (item) {
+                                if (item.weight == null)
+                                    hasWeights_1 = false;
+                                return item.weight || 1;
+                            });
+                            edges_1.push(new AcGeSpline3d(controlPoints, spline.knots, hasWeights_1 ? weights : undefined));
+                        }
+                        else if (spline.numberOfFitData > 0) {
+                            var fitPoints = spline.fitDatum.map(function (item) {
+                                return {
+                                    x: item.x,
+                                    y: item.y,
+                                    z: 0
+                                };
+                            });
+                            edges_1.push(new AcGeSpline3d(fitPoints, 'Uniform'));
+                        }
+                    }
+                });
+                var loops = AcGeLoop2d.buildFromEdges(edges_1);
+                if (loops.length == 0 && edges_1.length > 0) {
+                    // Fallback: keep original order if we failed to build any loop.
+                    dbEntity.add(new AcGeLoop2d(edges_1));
+                }
+                else {
+                    loops.forEach(function (loop) { return dbEntity.add(loop); });
+                }
+            }
+        });
+        // Handle gradient fill properties
+        // The meaning of gradientFlag is as follows.
+        // - 0: Solid hatch
+        // - 1: Gradient
+        if (hatch.gradientFlag) {
+            var gradientHatch = hatch;
+            dbEntity.hatchObjectType = AcDbHatchObjectType.GradientObject;
+            dbEntity.gradientName = gradientHatch.gradientName;
+            dbEntity.gradientAngle = (_b = gradientHatch.gradientRotation) !== null && _b !== void 0 ? _b : 0;
+            dbEntity.gradientShift = (_c = gradientHatch.gradientDefinition) !== null && _c !== void 0 ? _c : 0;
+            dbEntity.gradientOneColorMode = gradientHatch.gradientColorFlag == 1;
+            dbEntity.shadeTintValue = (_d = gradientHatch.colorTint) !== null && _d !== void 0 ? _d : 0;
+            if (gradientHatch.gradientColors) {
+                var length_1 = gradientHatch.gradientColors.length;
+                if (length_1 > 1) {
+                    dbEntity.gradientStartColor = gradientHatch.gradientColors[0].rgb;
+                    dbEntity.gradientEndColor = gradientHatch.gradientColors[1].rgb;
+                }
+                else if (length_1 > 0) {
+                    dbEntity.gradientStartColor = gradientHatch.gradientColors[0].rgb;
+                }
+            }
+        }
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertTable = function (table) {
+        var dbEntity = new AcDbTable(table.name, table.rowCount, table.columnCount);
+        dbEntity.tableDataVersion = table.version;
+        dbEntity.tableStyleId = table.tableStyleId;
+        dbEntity.owningBlockRecordId = table.blockRecordHandle;
+        if (table.directionVector) {
+            dbEntity.horizontalDirection = new AcGeVector3d(table.directionVector);
+        }
+        dbEntity.attachmentPoint =
+            table.attachmentPoint;
+        dbEntity.position.copy(table.startPoint);
+        dbEntity.tableValueFlag = table.tableValue;
+        dbEntity.tableOverrideFlag = table.overrideFlag;
+        dbEntity.borderColorOverrideFlag = table.borderColorOverrideFlag;
+        dbEntity.borderLineweightOverrideFlag = table.borderLineWeightOverrideFlag;
+        dbEntity.borderVisibilityOverrideFlag = table.borderVisibilityOverrideFlag;
+        table.columnWidthArr.forEach(function (width, index) {
+            return dbEntity.setColumnWidth(index, width);
+        });
+        table.rowHeightArr.forEach(function (height, index) {
+            return dbEntity.setRowHeight(index, height);
+        });
+        table.cells.forEach(function (cell, index) {
+            dbEntity.setCell(index, cell);
+        });
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertText = function (text) {
+        var _a, _b, _c;
+        var dbEntity = new AcDbText();
+        dbEntity.textString = text.text;
+        dbEntity.styleName = text.styleName;
+        dbEntity.height = text.textHeight;
+        dbEntity.position.copy(text.startPoint);
+        // dxf-json calls DXF group 11 `endPoint` on TEXT; this is the alignment
+        // point used when halign/valign deviate from Left/Baseline. Fall back to
+        // startPoint when missing or zero — same defensive handling as in
+        // `convertAttributeCommon`.
+        var ep = text.endPoint;
+        var isEpZero = !ep || (ep.x === 0 && ep.y === 0 && ((_a = ep.z) !== null && _a !== void 0 ? _a : 0) === 0);
+        if (ep && !isEpZero) {
+            dbEntity.alignmentPoint.copy(ep);
+        }
+        else {
+            dbEntity.alignmentPoint.copy(text.startPoint);
+        }
+        dbEntity.rotation = AcGeMathUtil.degToRad(text.rotation || 0);
+        dbEntity.oblique = (_b = text.obliqueAngle) !== null && _b !== void 0 ? _b : 0;
+        dbEntity.thickness = text.thickness;
+        dbEntity.horizontalMode = text.halign;
+        dbEntity.verticalMode = text.valign;
+        dbEntity.widthFactor = (_c = text.xScale) !== null && _c !== void 0 ? _c : 1;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertMText = function (mtext) {
+        var dbEntity = new AcDbMText();
+        dbEntity.contents = mtext.text;
+        if (mtext.styleName != null) {
+            dbEntity.styleName = mtext.styleName;
+        }
+        dbEntity.height = mtext.height;
+        dbEntity.width = mtext.width;
+        dbEntity.rotation = AcGeMathUtil.degToRad(mtext.rotation || 0);
+        dbEntity.location = mtext.insertionPoint;
+        dbEntity.attachmentPoint =
+            mtext.attachmentPoint;
+        if (mtext.direction) {
+            dbEntity.direction = new AcGeVector3d(mtext.direction);
+        }
+        dbEntity.drawingDirection =
+            mtext.drawingDirection;
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertLeader = function (leader) {
+        var _a, _b, _c, _d, _e;
+        var dbEntity = new AcDbLeader();
+        (_a = leader.vertices) === null || _a === void 0 ? void 0 : _a.forEach(function (point) {
+            dbEntity.appendVertex(point);
+        });
+        dbEntity.hasArrowHead = leader.isArrowheadEnabled;
+        dbEntity.hasHookLine = leader.isHooklineExists;
+        dbEntity.isHookLineSameDirection = leader.isHooklineSameDirection;
+        dbEntity.isSplined = leader.isSpline;
+        dbEntity.dimensionStyle = (_b = leader.styleName) !== null && _b !== void 0 ? _b : '';
+        dbEntity.annoType =
+            leader.leaderCreationFlag;
+        dbEntity.textHeight = (_c = leader.textHeight) !== null && _c !== void 0 ? _c : 0;
+        dbEntity.textWidth = (_d = leader.textWidth) !== null && _d !== void 0 ? _d : 0;
+        dbEntity.byBlockColor = leader.byBlockColor;
+        dbEntity.associatedAnnotation = (_e = leader.associatedAnnotation) !== null && _e !== void 0 ? _e : '';
+        if (leader.normal)
+            dbEntity.normal = leader.normal;
+        if (leader.horizontalDirection) {
+            dbEntity.horizontalDirection = leader.horizontalDirection;
+        }
+        if (leader.offsetFromBlock)
+            dbEntity.offsetFromBlock = leader.offsetFromBlock;
+        if (leader.offsetFromAnnotation) {
+            dbEntity.offsetFromAnnotation = leader.offsetFromAnnotation;
+        }
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertMLine = function (mline) {
+        var _a, _b;
+        var dbEntity = new AcDbMLine();
+        dbEntity.styleName = mline.name || 'STANDARD';
+        dbEntity.styleObjectHandle = mline.styleObjectHandle;
+        dbEntity.scale = mline.scale;
+        dbEntity.justification =
+            mline.justification;
+        dbEntity.flags = mline.flags;
+        dbEntity.styleCount = mline.styleCount;
+        dbEntity.startPosition = mline.startPosition;
+        dbEntity.normal = (_a = mline.extrusionDirection) !== null && _a !== void 0 ? _a : AcGeVector3d.Z_AXIS;
+        dbEntity.segments = ((_b = mline.segments) !== null && _b !== void 0 ? _b : []).map(function (segment) {
+            var _a, _b;
+            return ({
+                position: segment.position,
+                direction: segment.direction,
+                miterDirection: segment.miterDirection,
+                elements: (_b = (_a = segment.elements) === null || _a === void 0 ? void 0 : _a.map(function (element) {
+                    var _a, _b;
+                    return ({
+                        parameterCount: element.parameterCount,
+                        parameters: (_a = element.parameters) !== null && _a !== void 0 ? _a : [],
+                        fillCount: element.fillCount,
+                        fillParameters: (_b = element.fillParameters) !== null && _b !== void 0 ? _b : []
+                    });
+                })) !== null && _b !== void 0 ? _b : []
+            });
+        });
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertMLeader = function (mleader) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        var dbEntity = new AcDbMLeader();
+        var raw = mleader;
+        dbEntity.version = mleader.version;
+        dbEntity.leaderStyleId = mleader.leaderStyleId;
+        if (mleader.leaderStyleId)
+            dbEntity.mleaderStyleId = mleader.leaderStyleId;
+        dbEntity.propertyOverrideFlag = mleader.propertyOverrideFlag;
+        dbEntity.leaderLineType = ((_a = mleader.leaderLineType) !== null && _a !== void 0 ? _a : AcDbMLeaderLineType.StraightLeader);
+        dbEntity.leaderLineColor = mleader.leaderLineColor;
+        dbEntity.leaderLineTypeId = mleader.leaderLineTypeId;
+        dbEntity.leaderLineWeight = mleader.leaderLineWeight;
+        dbEntity.landingEnabled = mleader.landingEnabled;
+        dbEntity.doglegEnabled = (_b = mleader.doglegEnabled) !== null && _b !== void 0 ? _b : false;
+        dbEntity.doglegLength = (_c = mleader.doglegLength) !== null && _c !== void 0 ? _c : 0;
+        dbEntity.arrowheadId = mleader.arrowheadId;
+        dbEntity.arrowheadSize = mleader.arrowheadSize;
+        dbEntity.textStyleId = mleader.textStyleId;
+        dbEntity.textLeftAttachmentType = mleader.textLeftAttachmentType;
+        dbEntity.textRightAttachmentType = mleader.textRightAttachmentType;
+        dbEntity.textAngleType = mleader.textAngleType;
+        dbEntity.textAlignmentType = mleader.textAlignmentType;
+        dbEntity.textColor = mleader.textColor;
+        dbEntity.textFrameEnabled = mleader.textFrameEnabled;
+        dbEntity.landingGap = mleader.landingGap;
+        dbEntity.textAttachment = mleader.textAttachment;
+        dbEntity.textFlowDirection = mleader.textFlowDirection;
+        dbEntity.blockContentId = mleader.blockContentId;
+        dbEntity.blockContentColor = mleader.blockContentColor;
+        dbEntity.blockContentRotation = mleader.blockContentRotation;
+        dbEntity.blockContentConnectionType = mleader.blockContentConnectionType;
+        dbEntity.annotativeScaleEnabled = mleader.annotativeScaleEnabled;
+        dbEntity.arrowheadOverrides = mleader.arrowheadOverrides
+            ? mleader.arrowheadOverrides.map(function (item) { return (__assign({}, item)); })
+            : [];
+        dbEntity.blockAttributes = mleader.blockAttributes
+            ? mleader.blockAttributes.map(function (item) { return (__assign({}, item)); })
+            : [];
+        dbEntity.textDirectionNegative = mleader.textDirectionNegative;
+        dbEntity.textAlignInIPE = mleader.textAlignInIPE;
+        dbEntity.bottomTextAttachmentDirection =
+            mleader.bottomTextAttachmentDirection;
+        dbEntity.topTextAttachmentDirection = mleader.topTextAttachmentDirection;
+        dbEntity.contentScale = mleader.contentScale;
+        dbEntity.textLineSpacingStyle = mleader.textLineSpacingStyle;
+        dbEntity.textBackgroundColor = mleader.textBackgroundColor;
+        dbEntity.textBackgroundScaleFactor = mleader.textBackgroundScaleFactor;
+        dbEntity.textBackgroundTransparency = mleader.textBackgroundTransparency;
+        dbEntity.textBackgroundColorOn = mleader.textBackgroundColorOn;
+        dbEntity.textFillOn = mleader.textFillOn;
+        dbEntity.textColumnType = mleader.textColumnType;
+        dbEntity.textUseAutoHeight = mleader.textUseAutoHeight;
+        dbEntity.textColumnWidth = mleader.textColumnWidth;
+        dbEntity.textColumnGutterWidth = mleader.textColumnGutterWidth;
+        dbEntity.textColumnFlowReversed = mleader.textColumnFlowReversed;
+        dbEntity.textColumnHeight = mleader.textColumnHeight;
+        dbEntity.textUseWordBreak = mleader.textUseWordBreak;
+        dbEntity.hasMText = mleader.hasMText;
+        dbEntity.hasBlock = mleader.hasBlock;
+        dbEntity.planeNormalReversed = mleader.planeNormalReversed;
+        if (mleader.blockContentScale) {
+            dbEntity.blockContentScale = new AcGeVector3d(mleader.blockContentScale);
+        }
+        if (mleader.contentBasePosition) {
+            dbEntity.contentBasePosition = new AcGePoint3d().copy(mleader.contentBasePosition);
+        }
+        if (mleader.textAnchor) {
+            dbEntity.textAnchor = new AcGePoint3d().copy(mleader.textAnchor);
+        }
+        if (mleader.planeOrigin) {
+            dbEntity.planeOrigin = new AcGePoint3d().copy(mleader.planeOrigin);
+        }
+        if (mleader.planeXAxisDirection) {
+            dbEntity.planeXAxisDirection = new AcGeVector3d(mleader.planeXAxisDirection);
+        }
+        if (mleader.planeYAxisDirection) {
+            dbEntity.planeYAxisDirection = new AcGeVector3d(mleader.planeYAxisDirection);
+        }
+        var rawTextContent = raw.textContent;
+        var rawTextContentRecord = rawTextContent && typeof rawTextContent === 'object'
+            ? rawTextContent
+            : undefined;
+        var hasMTextContent = (typeof rawTextContent === 'string' && rawTextContent.length > 0) ||
+            this.readString(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, ['text', 'contents']) !=
+                null ||
+            this.readString(raw, ['text', 'contents', 'mtext']) != null;
+        var contentType = (_d = mleader.contentType) !== null && _d !== void 0 ? _d : (hasMTextContent
+            ? AcDbMLeaderContentType.MTextContent
+            : mleader.blockContent
+                ? AcDbMLeaderContentType.BlockContent
+                : AcDbMLeaderContentType.NoneContent);
+        dbEntity.contentType = contentType;
+        var normal = this.readPoint(raw, ['normal', 'extrusionDirection']);
+        if (normal)
+            dbEntity.normal = normal;
+        var textStyleName = (_e = this.readString(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, [
+            'styleName',
+            'textStyleName',
+            'textStyle'
+        ])) !== null && _e !== void 0 ? _e : this.readString(raw, [
+            'textStyleName',
+            'textStyle',
+            'styleName',
+            'textStyleId'
+        ]);
+        if (textStyleName)
+            dbEntity.textStyleName = textStyleName;
+        var textHeight = (_g = (_f = this.readPositiveNumber(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, [
+            'textHeight',
+            'height'
+        ])) !== null && _f !== void 0 ? _f : this.readPositiveNumber(raw, [
+            'textHeight',
+            'mtextHeight',
+            'textContentHeight'
+        ])) !== null && _g !== void 0 ? _g : this.readPositiveNumber(raw, ['arrowheadSize', 'contentScale']);
+        if (textHeight != null)
+            dbEntity.textHeight = textHeight;
+        var textWidth = (_h = this.readPositiveNumber(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, [
+            'textWidth',
+            'width'
+        ])) !== null && _h !== void 0 ? _h : this.readPositiveNumber(raw, [
+            'textWidth',
+            'mtextWidth',
+            'textContentWidth'
+        ]);
+        if (textWidth != null)
+            dbEntity.textWidth = textWidth;
+        dbEntity.textLineSpacingFactor =
+            (_k = (_j = this.readNumber(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, [
+                'lineSpacingFactor',
+                'textLineSpacingFactor'
+            ])) !== null && _j !== void 0 ? _j : this.readNumber(raw, ['textLineSpacingFactor'])) !== null && _k !== void 0 ? _k : dbEntity.textLineSpacingFactor;
+        var textRotation = (_l = this.readNumber(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, [
+            'textRotation',
+            'rotation'
+        ])) !== null && _l !== void 0 ? _l : this.readNumber(raw, [
+            'textRotation',
+            'mtextRotation',
+            'textContentRotation'
+        ]);
+        if (textRotation != null) {
+            dbEntity.textRotation = AcGeMathUtil.degToRad(textRotation);
+        }
+        var textDirection = this.readPoint(raw, [
+            'textDirection',
+            'mtextDirection',
+            'textDirectionVector'
+        ]);
+        if (textDirection)
+            dbEntity.textDirection = textDirection;
+        var textAttachmentPoint = this.readNumber(raw, [
+            'textAttachmentPoint',
+            'attachmentPoint'
+        ]);
+        if (textAttachmentPoint != null) {
+            dbEntity.textAttachmentPoint =
+                textAttachmentPoint;
+        }
+        var textAttachmentDirection = mleader.textAttachmentDirection;
+        if (textAttachmentDirection != null) {
+            dbEntity.textAttachmentDirection =
+                textAttachmentDirection;
+        }
+        var textDrawingDirection = this.readNumber(raw, [
+            'textDrawingDirection',
+            'drawingDirection'
+        ]);
+        if (textDrawingDirection != null) {
+            dbEntity.textDrawingDirection =
+                textDrawingDirection;
+        }
+        var text = typeof rawTextContent === 'string'
+            ? rawTextContent
+            : ((_m = this.readString(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, ['text', 'contents'])) !== null && _m !== void 0 ? _m : this.readString(raw, ['text', 'contents', 'mtext']));
+        var anchorPoint = (_o = this.readPoint(rawTextContentRecord !== null && rawTextContentRecord !== void 0 ? rawTextContentRecord : {}, [
+            'anchorPoint',
+            'textAnchor',
+            'textLocation',
+            'textPosition',
+            'textAnchorPoint'
+        ])) !== null && _o !== void 0 ? _o : this.readPoint(raw, [
+            'textAnchor',
+            'textLocation',
+            'textPosition',
+            'textAnchorPoint',
+            'contentBasePosition'
+        ]);
+        if (text != null && anchorPoint) {
+            dbEntity.mtextContent = { text: text, anchorPoint: anchorPoint };
+        }
+        if (mleader.blockContent) {
+            var blockRecord = mleader.blockContent;
+            dbEntity.blockContent = {
+                blockContentId: mleader.blockContent.blockContentId,
+                normal: this.readPoint(blockRecord, ['normal']),
+                position: mleader.blockContent.position,
+                scale: this.readPoint(blockRecord, ['scale']),
+                rotation: this.readNumber(blockRecord, ['rotation']),
+                color: this.readNumber(blockRecord, ['color']),
+                transformationMatrix: Array.isArray(mleader.blockContent.transformationMatrix)
+                    ? mleader.blockContent.transformationMatrix
+                    : []
+            };
+        }
+        else if (mleader.blockContentId) {
+            dbEntity.blockContent = {
+                blockContentId: mleader.blockContentId,
+                scale: mleader.blockContentScale,
+                rotation: mleader.blockContentRotation,
+                color: mleader.blockContentColor,
+                transformationMatrix: []
+            };
+        }
+        (_p = this.readMLeaderLeaders(raw)) === null || _p === void 0 ? void 0 : _p.forEach(function (leader) {
+            var _a;
+            dbEntity.addLeader({
+                lastLeaderLinePoint: leader.lastLeaderLinePoint,
+                lastLeaderLinePointSet: leader.lastLeaderLinePointSet,
+                doglegVector: leader.doglegVector,
+                doglegVectorSet: leader.doglegVectorSet,
+                doglegLength: (_a = leader.doglegLength) !== null && _a !== void 0 ? _a : mleader.doglegLength,
+                breaks: leader.breaks,
+                leaderBranchIndex: leader.leaderBranchIndex,
+                leaderLines: leader.leaderLines
+            });
+        });
+        if (dbEntity.numberOfLeaders === 0) {
+            (_q = this.readLeaderLineArray(raw)) === null || _q === void 0 ? void 0 : _q.forEach(function (line) {
+                dbEntity.addLeader({
+                    doglegLength: mleader.doglegLength
+                });
+                dbEntity.addLeaderLine(dbEntity.numberOfLeaders - 1, line);
+            });
+        }
+        if (dbEntity.numberOfLeaders === 0 && mleader.contentBasePosition) {
+            dbEntity.addLeader({
+                lastLeaderLinePoint: mleader.contentBasePosition,
+                lastLeaderLinePointSet: true,
+                doglegLength: mleader.doglegLength
+            });
+        }
+        return dbEntity;
+    };
+    AcDbEntityConverter.prototype.convertDimension = function (dimension) {
+        if (dimension.subclassMarker == 'AcDbAlignedDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbAlignedDimension(entity.subDefinitionPoint1, entity.subDefinitionPoint2, entity.definitionPoint);
+            if (entity.insertionPoint) {
+                dbEntity.dimBlockPosition = __assign(__assign({}, entity.insertionPoint), { z: 0 });
+            }
+            dbEntity.rotation = AcGeMathUtil.degToRad(entity.rotationAngle || 0);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDbRotatedDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbRotatedDimension(entity.subDefinitionPoint1, entity.subDefinitionPoint2, entity.definitionPoint);
+            if (entity.insertionPoint) {
+                dbEntity.dimBlockPosition = __assign(__assign({}, entity.insertionPoint), { z: 0 });
+            }
+            dbEntity.rotation = AcGeMathUtil.degToRad(entity.rotationAngle || 0);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDb3PointAngularDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDb3PointAngularDimension(entity.centerPoint, entity.subDefinitionPoint1, entity.subDefinitionPoint2, entity.definitionPoint);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDbOrdinateDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbOrdinateDimension(entity.subDefinitionPoint1, entity.subDefinitionPoint2);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDbRadialDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbRadialDimension(entity.definitionPoint, entity.subDefinitionPoint, entity.leaderLength);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        else if (dimension.subclassMarker == 'AcDbDiametricDimension') {
+            var entity = dimension;
+            var dbEntity = new AcDbDiametricDimension(entity.definitionPoint, entity.subDefinitionPoint, entity.leaderLength);
+            this.processDimensionCommonAttrs(dimension, dbEntity);
+            return dbEntity;
+        }
+        return null;
+    };
+    AcDbEntityConverter.prototype.processImage = function (image, dbImage) {
+        dbImage.position.copy(image.position);
+        dbImage.brightness = image.brightness;
+        dbImage.contrast = image.contrast;
+        dbImage.fade = image.fade;
+        dbImage.imageSize.copy(image.imageSize);
+        dbImage.isShownClipped = (image.flags | 0x0004) > 0;
+        dbImage.isImageShown = (image.flags | 0x0003) > 0;
+        dbImage.isImageTransparent = (image.flags | 0x0008) > 0;
+        dbImage.imageDefId = image.imageDefHandle;
+        dbImage.isClipped = image.isClipped;
+        image.clippingBoundaryPath.forEach(function (point) {
+            dbImage.clipBoundary.push(new AcGePoint2d(point));
+        });
+        // Calculate the scale factors
+        dbImage.width =
+            Math.sqrt(Math.pow(image.uPixel.x, 2) + Math.pow(image.uPixel.y, 2) + Math.pow(image.uPixel.z, 2)) * image.imageSize.x;
+        dbImage.height =
+            Math.sqrt(Math.pow(image.vPixel.x, 2) + Math.pow(image.vPixel.y, 2) + Math.pow(image.vPixel.z, 2)) * image.imageSize.y;
+        // Calculate the rotation angle
+        // Rotation is determined by the angle of the U-vector relative to the X-axis
+        dbImage.rotation = Math.atan2(image.uPixel.y, image.uPixel.x);
+    };
+    AcDbEntityConverter.prototype.convertImage = function (image) {
+        var dbImage = new AcDbRasterImage();
+        this.processImage(image, dbImage);
+        dbImage.clipBoundaryType =
+            image.clippingBoundaryType;
+        return dbImage;
+    };
+    AcDbEntityConverter.prototype.processWipeout = function (wipeout, dbWipeout) {
+        dbWipeout.position.copy(wipeout.position);
+        dbWipeout.brightness = wipeout.brightness;
+        dbWipeout.contrast = wipeout.contrast;
+        dbWipeout.fade = wipeout.fade;
+        dbWipeout.imageSize.copy(wipeout.imageSize);
+        dbWipeout.isShownClipped = (wipeout.displayFlag | 0x0004) > 0;
+        dbWipeout.isImageShown = (wipeout.displayFlag | 0x0003) > 0;
+        dbWipeout.isImageTransparent = (wipeout.displayFlag | 0x0008) > 0;
+        dbWipeout.imageDefId = wipeout.imageDefHardId;
+        dbWipeout.isClipped = wipeout.isClipping;
+        wipeout.boundary.forEach(function (point) {
+            dbWipeout.clipBoundary.push(new AcGePoint2d(point));
+        });
+        dbWipeout.clipBoundaryType =
+            wipeout.boundaryType;
+        // Calculate the scale factors
+        dbWipeout.width =
+            Math.sqrt(Math.pow(wipeout.uDirection.x, 2) +
+                Math.pow(wipeout.uDirection.y, 2) +
+                Math.pow(wipeout.uDirection.z, 2)) * wipeout.imageSize.x;
+        dbWipeout.height =
+            Math.sqrt(Math.pow(wipeout.vDirection.x, 2) +
+                Math.pow(wipeout.vDirection.y, 2) +
+                Math.pow(wipeout.vDirection.z, 2)) * wipeout.imageSize.y;
+        // Calculate the rotation angle
+        // Rotation is determined by the angle of the U-vector relative to the X-axis
+        dbWipeout.rotation = Math.atan2(wipeout.uDirection.y, wipeout.uDirection.x);
+    };
+    AcDbEntityConverter.prototype.convertWipeout = function (wipeout) {
+        var dbWipeout = new AcDbWipeout();
+        this.processWipeout(wipeout, dbWipeout);
+        return dbWipeout;
+    };
+    AcDbEntityConverter.prototype.convertViewport = function (viewport) {
+        var dbViewport = new AcDbViewport();
+        dbViewport.number = viewport.viewportId;
+        dbViewport.centerPoint.copy(viewport.viewportCenter);
+        dbViewport.height = viewport.height;
+        dbViewport.width = viewport.width;
+        dbViewport.viewCenter.copy(viewport.displayCenter);
+        dbViewport.viewHeight = viewport.viewHeight;
+        return dbViewport;
+    };
+    AcDbEntityConverter.prototype.convertRay = function (ray) {
+        var dbRay = new AcDbRay();
+        dbRay.basePoint.copy(ray.position);
+        dbRay.unitDir.copy(ray.direction);
+        return dbRay;
+    };
+    AcDbEntityConverter.prototype.convertXline = function (xline) {
+        var dbXline = new AcDbXline();
+        dbXline.basePoint.copy(xline.position);
+        dbXline.unitDir.copy(xline.direction);
+        return dbXline;
+    };
+    AcDbEntityConverter.prototype.convertBlockReference = function (blockReference) {
+        var _a;
+        var dbBlockReference = new AcDbBlockReference(blockReference.name);
+        if (blockReference.insertionPoint)
+            dbBlockReference.position.copy(blockReference.insertionPoint);
+        dbBlockReference.scaleFactors.x = blockReference.xScale || 1;
+        dbBlockReference.scaleFactors.y = blockReference.yScale || 1;
+        dbBlockReference.scaleFactors.z = blockReference.zScale || 1;
+        dbBlockReference.rotation =
+            blockReference.rotation != null
+                ? AcGeMathUtil.degToRad(blockReference.rotation)
+                : 0;
+        dbBlockReference.normal.copy((_a = blockReference.extrusionDirection) !== null && _a !== void 0 ? _a : { x: 0, y: 0, z: 1 });
+        return dbBlockReference;
+    };
+    AcDbEntityConverter.prototype.processDimensionCommonAttrs = function (entity, dbEntity) {
+        var _a;
+        dbEntity.dimBlockId = entity.name;
+        dbEntity.textPosition.copy(entity.textPoint);
+        dbEntity.textRotation = entity.textRotation || 0;
+        if (entity.textLineSpacingFactor) {
+            dbEntity.textLineSpacingFactor = entity.textLineSpacingFactor;
+        }
+        if (entity.textLineSpacingStyle) {
+            dbEntity.textLineSpacingStyle =
+                entity.textLineSpacingStyle;
+        }
+        dbEntity.dimensionStyleName = entity.styleName;
+        dbEntity.dimensionText = entity.text || '';
+        dbEntity.measurement = entity.measurement;
+        dbEntity.normal.copy((_a = entity.extrusionDirection) !== null && _a !== void 0 ? _a : { x: 0, y: 0, z: 1 });
+    };
+    /**
+     * Processes common attributes from a DXF entity to an AcDbEntity.
+     *
+     * This method copies common properties like layer, object ID, owner ID,
+     * linetype, lineweight, color, visibility, and transparency from the
+     * DXF entity to the corresponding AcDbEntity.
+     *
+     * @param entity - The source DXF entity
+     * @param dbEntity - The target AcDbEntity to populate
+     *
+     * @example
+     * ```typescript
+     * converter.processCommonAttrs(dxfEntity, acDbEntity);
+     * ```
+     */
+    AcDbEntityConverter.prototype.processCommonAttrs = function (entity, dbEntity) {
+        dbEntity.layer = entity.layer || '0';
+        // I found some dxf file may have entity without handle. If so, let's use objectId
+        // created by AcDbObject constructor instead.
+        if (entity.handle)
+            dbEntity.objectId = entity.handle.toString();
+        dbEntity.ownerId = entity.ownerBlockRecordSoftId || '';
+        if (entity.lineType != null) {
+            dbEntity.lineType = entity.lineType;
+        }
+        if (entity.lineweight != null) {
+            dbEntity.lineWeight = entity.lineweight;
+        }
+        if (entity.lineTypeScale != null) {
+            dbEntity.linetypeScale = entity.lineTypeScale;
+        }
+        // Build the entity color in a fresh AcCmColor and assign it via the
+        // setter. The previous pattern (`dbEntity.color.<prop> = …`) read the
+        // getter and mutated the result, which works for entities whose getter
+        // returns the cached `_color` field but breaks for entities like
+        // AcDbHatch that override the getter to return a clone of an HPCOLOR /
+        // CECOLOR fallback (PR #78). Mutations on a clone are dropped, leaving
+        // the entity stuck on the sysvar default and losing the DXF's RGB.
+        if (entity.color != null || entity.colorIndex != null || entity.colorName) {
+            var color = new AcCmColor();
+            if (entity.color != null) {
+                color.setRGBValue(entity.color);
+            }
+            if (entity.colorIndex != null) {
+                color.colorIndex = entity.colorIndex;
+            }
+            if (entity.colorName) {
+                color.colorName = entity.colorName;
+            }
+            dbEntity.color = color;
+        }
+        if (entity.isVisible != null) {
+            // DXF group code 60 uses 0 => visible, 1 => invisible.
+            // dxf-json parses it with a generic boolean converter, so here:
+            // - false means 0 (visible)
+            // - true means 1 (invisible)
+            dbEntity.visibility = !entity.isVisible;
+        }
+        if (entity.transparency != null) {
+            dbEntity.transparency = AcCmTransparency.deserialize(entity.transparency);
+        }
+    };
+    AcDbEntityConverter.prototype.readNumber = function (source, names) {
+        var e_1, _a;
+        try {
+            for (var names_1 = __values(names), names_1_1 = names_1.next(); !names_1_1.done; names_1_1 = names_1.next()) {
+                var name_1 = names_1_1.value;
+                var value = source[name_1];
+                if (typeof value === 'number' && Number.isFinite(value))
+                    return value;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (names_1_1 && !names_1_1.done && (_a = names_1.return)) _a.call(names_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return undefined;
+    };
+    AcDbEntityConverter.prototype.readPositiveNumber = function (source, names) {
+        var value = this.readNumber(source, names);
+        return value != null && value > 0 ? value : undefined;
+    };
+    AcDbEntityConverter.prototype.readString = function (source, names) {
+        var e_2, _a;
+        try {
+            for (var names_2 = __values(names), names_2_1 = names_2.next(); !names_2_1.done; names_2_1 = names_2.next()) {
+                var name_2 = names_2_1.value;
+                var value = source[name_2];
+                if (typeof value === 'string')
+                    return value;
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (names_2_1 && !names_2_1.done && (_a = names_2.return)) _a.call(names_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return undefined;
+    };
+    AcDbEntityConverter.prototype.readBoolean = function (source, names) {
+        var e_3, _a;
+        try {
+            for (var names_3 = __values(names), names_3_1 = names_3.next(); !names_3_1.done; names_3_1 = names_3.next()) {
+                var name_3 = names_3_1.value;
+                var value = source[name_3];
+                if (typeof value === 'boolean')
+                    return value;
+                if (typeof value === 'number')
+                    return value !== 0;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (names_3_1 && !names_3_1.done && (_a = names_3.return)) _a.call(names_3);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return undefined;
+    };
+    AcDbEntityConverter.prototype.readPoint = function (source, names) {
+        var e_4, _a;
+        var _b;
+        try {
+            for (var names_4 = __values(names), names_4_1 = names_4.next(); !names_4_1.done; names_4_1 = names_4.next()) {
+                var name_4 = names_4_1.value;
+                var value = source[name_4];
+                if (this.isPointLike(value))
+                    return value;
+                if (Array.isArray(value) &&
+                    typeof value[0] === 'number' &&
+                    typeof value[1] === 'number') {
+                    return { x: value[0], y: value[1], z: (_b = value[2]) !== null && _b !== void 0 ? _b : 0 };
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (names_4_1 && !names_4_1.done && (_a = names_4.return)) _a.call(names_4);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return undefined;
+    };
+    AcDbEntityConverter.prototype.readLeaderLineArray = function (source) {
+        var _this = this;
+        var leaderLines = source.leaderLines;
+        if (Array.isArray(leaderLines)) {
+            return leaderLines
+                .map(function (line) {
+                if (!line || typeof line !== 'object')
+                    return undefined;
+                var vertices = line.vertices;
+                return Array.isArray(vertices)
+                    ? vertices.filter(function (point) { return _this.isPointLike(point); })
+                    : undefined;
+            })
+                .filter(function (line) { return !!line && line.length > 0; });
+        }
+        var vertices = source.vertices;
+        if (Array.isArray(vertices)) {
+            var line = vertices.filter(function (point) { return _this.isPointLike(point); });
+            return line.length > 0 ? [line] : undefined;
+        }
+        return undefined;
+    };
+    AcDbEntityConverter.prototype.readMLeaderLeaders = function (source) {
+        var _this = this;
+        var leaders = source.leaderSections;
+        if (!Array.isArray(leaders))
+            return undefined;
+        var dbLeaders = [];
+        leaders.forEach(function (leader) {
+            if (!leader || typeof leader !== 'object')
+                return;
+            var leaderRecord = leader;
+            var leaderLines = leaderRecord.leaderLines;
+            var lines = Array.isArray(leaderLines)
+                ? leaderLines.reduce(function (result, line) {
+                    var dbLine = _this.readMLeaderLine(line);
+                    if (dbLine)
+                        result.push(dbLine);
+                    return result;
+                }, [])
+                : undefined;
+            var dbLeader = {};
+            var lastLeaderLinePoint = _this.readPoint(leaderRecord, [
+                'lastLeaderLinePoint'
+            ]);
+            var doglegVector = _this.readPoint(leaderRecord, ['doglegVector']);
+            var doglegLength = _this.readNumber(leaderRecord, ['doglegLength']);
+            var leaderBreaks = _this.readMLeaderBreaks(leaderRecord.breaks);
+            var leaderBranchIndex = _this.readNumber(leaderRecord, [
+                'leaderBranchIndex'
+            ]);
+            if (lastLeaderLinePoint)
+                dbLeader.lastLeaderLinePoint = lastLeaderLinePoint;
+            if (leaderRecord.lastLeaderLinePointSet != null) {
+                dbLeader.lastLeaderLinePointSet = _this.readBoolean(leaderRecord, [
+                    'lastLeaderLinePointSet'
+                ]);
+            }
+            if (doglegVector)
+                dbLeader.doglegVector = doglegVector;
+            if (leaderRecord.doglegVectorSet != null) {
+                dbLeader.doglegVectorSet = _this.readBoolean(leaderRecord, [
+                    'doglegVectorSet'
+                ]);
+            }
+            if (doglegLength != null)
+                dbLeader.doglegLength = doglegLength;
+            if (leaderBreaks)
+                dbLeader.breaks = leaderBreaks;
+            if (leaderBranchIndex != null) {
+                dbLeader.leaderBranchIndex = leaderBranchIndex;
+            }
+            if (lines)
+                dbLeader.leaderLines = lines;
+            dbLeaders.push(dbLeader);
+        });
+        return dbLeaders;
+    };
+    AcDbEntityConverter.prototype.readMLeaderLine = function (value) {
+        var _this = this;
+        if (!value || typeof value !== 'object')
+            return undefined;
+        var lineRecord = value;
+        var vertices = lineRecord.vertices;
+        var dbVertices = Array.isArray(vertices)
+            ? vertices.filter(function (point) { return _this.isPointLike(point); })
+            : [];
+        var dbBreaks = this.readMLeaderBreaks(lineRecord.breaks);
+        var breakPointIndexes = Array.isArray(lineRecord.breakPointIndexes)
+            ? lineRecord.breakPointIndexes.filter(function (item) { return typeof item === 'number'; })
+            : undefined;
+        var leaderLineIndex = this.readNumber(lineRecord, ['leaderLineIndex']);
+        return dbVertices.length > 0 || (dbBreaks && dbBreaks.length > 0)
+            ? {
+                vertices: dbVertices,
+                breakPointIndexes: breakPointIndexes,
+                leaderLineIndex: leaderLineIndex,
+                breaks: dbBreaks
+            }
+            : undefined;
+    };
+    AcDbEntityConverter.prototype.readMLeaderBreaks = function (value) {
+        var _this = this;
+        if (!Array.isArray(value))
+            return undefined;
+        var breaks = value
+            .map(function (item) {
+            if (!item || typeof item !== 'object')
+                return undefined;
+            var breakRecord = item;
+            var start = _this.readPoint(breakRecord, ['start']);
+            var end = _this.readPoint(breakRecord, ['end']);
+            var index = _this.readNumber(breakRecord, ['index']);
+            if (!start || !end)
+                return undefined;
+            var parsed = { start: start, end: end };
+            if (index != null)
+                parsed.index = index;
+            return parsed;
+        })
+            .filter(function (item) { return !!item; });
+        return breaks.length > 0 ? breaks : undefined;
+    };
+    AcDbEntityConverter.prototype.isPointLike = function (value) {
+        return (!!value &&
+            typeof value === 'object' &&
+            typeof value.x === 'number' &&
+            typeof value.y === 'number');
+    };
+    return AcDbEntityConverter;
+}());
+export { AcDbEntityConverter };
+//# sourceMappingURL=AcDbEntitiyConverter.js.map