@mlightcad/data-model 1.7.27 → 1.7.28

package/lib/converter/AcDbEntitiyConverter.js

@@ -34,10 +34,21 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     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 { AcCmTransparency } from '@mlightcad/common';
 import { HatchSolidFill, SmoothType, VertexFlag } from '@mlightcad/dxf-json';
 import { AcGeCircArc2d, AcGeEllipseArc2d, AcGeLine2d, AcGeLoop2d, AcGeMathUtil, AcGePoint2d, AcGePoint3d, AcGePolyline2d, AcGeSpline3d, AcGeVector2d, AcGeVector3d, transformOcsPointToWcs } from '@mlightcad/geometry-engine';
-import { AcDb2dPolyline, AcDb3dPolyline, AcDb3PointAngularDimension, AcDbAlignedDimension, AcDbArc, AcDbAttribute, AcDbAttributeDefinition, AcDbAttributeFlags, AcDbAttributeMTextFlag, AcDbBlockReference, AcDbCircle, AcDbDiametricDimension, AcDbEllipse, AcDbFace, AcDbHatch, AcDbHatchObjectType, AcDbLeader, AcDbLine, AcDbMText, AcDbOrdinateDimension, AcDbPoint, AcDbPoly2dType, AcDbPoly3dType, AcDbPolyFaceMesh, AcDbPolygonMesh, AcDbPolyline, AcDbRadialDimension, AcDbRasterImage, AcDbRay, AcDbRotatedDimension, AcDbSpline, AcDbTable, AcDbText, AcDbTrace, AcDbViewport, AcDbWipeout, AcDbXline } from '../entity';
+import { 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, AcDbSpline, AcDbTable, AcDbText, AcDbTrace, AcDbViewport, AcDbWipeout, AcDbXline } from '../entity';
 /**
  * Converts DXF entities to AcDbEntity objects.
  *
@@ -138,6 +149,12 @@ var AcDbEntityConverter = /** @class */ (function () {
         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);
         }
@@ -616,16 +633,331 @@ var AcDbEntityConverter = /** @class */ (function () {
         return dbEntity;
     };
     AcDbEntityConverter.prototype.convertLeader = function (leader) {
+        var _a, _b, _c, _d, _e;
         var dbEntity = new AcDbLeader();
-        leader.vertices.forEach(function (point) {
+        (_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 = leader.styleName;
+        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 _this = this;
+        var _a;
+        var dbEntity = new AcDbMLine();
+        var raw = mline;
+        dbEntity.styleName = mline.name;
+        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;
+        if (Array.isArray(mline.segments) && mline.segments.length > 0) {
+            dbEntity.segments = mline.segments.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 : []
+                });
+            });
+        }
+        else {
+            var vertices_1 = Array.isArray(raw.vertices)
+                ? raw.vertices.filter(function (point) { return _this.isPointLike(point); })
+                : [];
+            var segmentDirections_1 = Array.isArray(raw.segmentDirections)
+                ? raw.segmentDirections.filter(function (point) { return _this.isPointLike(point); })
+                : [];
+            var miterDirections_1 = Array.isArray(raw.miterDirections)
+                ? raw.miterDirections.filter(function (point) { return _this.isPointLike(point); })
+                : [];
+            var count = Math.min(vertices_1.length, segmentDirections_1.length, miterDirections_1.length);
+            if (count > 0) {
+                dbEntity.segments = Array.from({ length: count }, function (_, index) { return ({
+                    position: vertices_1[index],
+                    direction: segmentDirections_1[index],
+                    miterDirection: miterDirections_1[index],
+                    elements: []
+                }); });
+            }
+        }
+        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) {
@@ -844,6 +1176,223 @@ var AcDbEntityConverter = /** @class */ (function () {
             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 };