@mlightcad/data-model 1.11.3 → 1.12.1

package/lib/entity/AcDbHatch.js

@@ -49,7 +49,7 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-import { AcCmColor, AcCmColorMethod, AcCmTransparency } from '@mlightcad/common';
+import { AcCmColor, AcCmColorMethod, AcCmColorUtil, AcCmTransparency } from '@mlightcad/common';
 import { AcGeArea2d, AcGeBox3d, AcGeCircArc2d, AcGeEllipseArc2d, AcGeLine2d, AcGeLoop2d, AcGeMatrix2d, AcGePoint2d, AcGePoint3d, AcGePolyline2d, AcGeSpline3d } from '@mlightcad/geometry-engine';
 import { AcDbSystemVariables } from '../database/AcDbSystemVariables';
 import { AcDbSysVarManager } from '../database/AcDbSysVarManager';
@@ -218,6 +218,7 @@ var AcDbHatch = /** @class */ (function (_super) {
         _this._shadeTintValue = 0;
         _this._gradientStartColor = undefined;
         _this._gradientEndColor = undefined;
+        _this._pixelSize = undefined;
         _this._gradientType = AcDbGradientPatternType.PreDefinedGradient;
         _this._gradientName = '';
         _this._gradientOneColorMode = false;
@@ -604,6 +605,24 @@ var AcDbHatch = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcDbHatch.prototype, "pixelSize", {
+        /**
+         * Gets the pixel size used for intersection/ray-casting density
+         * calculations (DXF group 47), for associative or Flood-method hatches.
+         */
+        get: function () {
+            return this._pixelSize;
+        },
+        /**
+         * Sets the pixel size used for intersection/ray-casting density
+         * calculations (DXF group 47).
+         */
+        set: function (value) {
+            this._pixelSize = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * Applies the current hatch-related system variables as persistent defaults
      * when this hatch is first added to a database.
@@ -1593,19 +1612,625 @@ var AcDbHatch = /** @class */ (function (_super) {
             filer.writeInt16(79, line.dashLengths.length);
             line.dashLengths.forEach(function (length) { return filer.writeDouble(49, length); });
         });
-        // Gradient fill parameters
+        if (this._pixelSize != null) {
+            filer.writeDouble(47, this._pixelSize);
+        }
+        // Gradient fill parameters (DXF group 460 is radians, not degrees).
         if (this.isGradient) {
             filer.writeInt16(450, this._hatchObjectType);
             filer.writeInt16(451, 0);
-            filer.writeInt16(452, this._gradientOneColorMode ? 1 : 0);
-            filer.writeAngle(460, this._gradientAngle);
+            filer.writeDouble(460, this._gradientAngle);
             filer.writeDouble(461, this._gradientShift);
+            filer.writeInt16(452, this._gradientOneColorMode ? 1 : 0);
+            filer.writeDouble(462, this._shadeTintValue);
+            var startColor = this._gradientStartColor;
+            var endColor = this._gradientEndColor;
+            var colorCount = startColor != null && endColor != null
+                ? 2
+                : startColor != null || endColor != null
+                    ? 1
+                    : 0;
+            filer.writeInt16(453, colorCount);
+            var writeGradientColor = function (position, rgb) {
+                filer.writeDouble(463, position);
+                var aci = AcCmColorUtil.getIndexByColor(rgb);
+                if (aci != null) {
+                    filer.writeInt16(63, aci);
+                }
+                filer.writeInt32(421, rgb);
+            };
+            if (startColor != null) {
+                writeGradientColor(0, startColor);
+            }
+            if (endColor != null) {
+                writeGradientColor(1, endColor);
+            }
             filer.writeString(470, this.gradientName);
         }
         // TODO: Write the number of seed points
         filer.writeInt16(98, 0);
         return this;
     };
+    AcDbHatch.prototype.dxfInFields = function (filer) {
+        var _this = this;
+        _super.prototype.dxfInFields.call(this, filer);
+        filer.atSubclassData('AcDbHatch');
+        this.definitionLines.length = 0;
+        var elevation = this.elevation;
+        var patternAngleDeg = (this.patternAngle * 180) / Math.PI;
+        var boundaryFlag = 0;
+        var isPolylineBoundary = false;
+        var hasBulge = false;
+        var polyClosed = false;
+        var expectedVertices = 0;
+        var expectedEdges = 0;
+        var pendingVertices = [];
+        var pendingVertex = null;
+        var edges = [];
+        var currentEdge = null;
+        var edgePhase = 'type';
+        var loopsRemaining = 0;
+        var inPatternLines = false;
+        var currentPatternLine = null;
+        var expectedDashes = 0;
+        void expectedDashes;
+        var afterBoundaries = false;
+        var gradientColorIndex = 0;
+        var pendingGradientAci;
+        var applyGradientRgb = function (rgb) {
+            if (gradientColorIndex === 0) {
+                _this.gradientStartColor = rgb;
+            }
+            else {
+                _this.gradientEndColor = rgb;
+            }
+            gradientColorIndex++;
+            pendingGradientAci = undefined;
+        };
+        var flushPendingGradientAci = function () {
+            if (pendingGradientAci == null)
+                return;
+            var rgb = AcCmColorUtil.getColorByIndex(pendingGradientAci);
+            if (rgb != null) {
+                applyGradientRgb(rgb);
+            }
+            else {
+                pendingGradientAci = undefined;
+            }
+        };
+        var flushVertex = function () {
+            if (pendingVertex) {
+                pendingVertices.push(pendingVertex);
+                pendingVertex = null;
+            }
+        };
+        var flushPolylineLoop = function () {
+            flushVertex();
+            if (pendingVertices.length === 0)
+                return;
+            var polyline = new AcGePolyline2d();
+            polyline.closed = polyClosed;
+            pendingVertices.forEach(function (vertex, index) {
+                var _a;
+                polyline.addVertexAt(index, {
+                    x: vertex.x,
+                    y: vertex.y,
+                    bulge: (_a = vertex.bulge) !== null && _a !== void 0 ? _a : 0
+                });
+            });
+            _this.add(polyline);
+            pendingVertices = [];
+        };
+        var flushEdgeLoop = function () {
+            var e_3, _a;
+            if (edges.length === 0)
+                return;
+            var built = [];
+            // Convert edges to geometry types (mirrors AcDbEntityConverter.convertHatch).
+            var geoEdges = [];
+            var _loop_3 = function (edge) {
+                if (edge.kind === 'line') {
+                    geoEdges.push(new AcGeLine2d({ x: edge.sx, y: edge.sy }, { x: edge.ex, y: edge.ey }));
+                }
+                else if (edge.kind === 'arc') {
+                    geoEdges.push(new AcGeCircArc2d({ x: edge.cx, y: edge.cy }, edge.radius, (edge.startDeg * Math.PI) / 180, (edge.endDeg * Math.PI) / 180, !edge.isCcw));
+                }
+                else if (edge.kind === 'ellipse') {
+                    var majorAxisRadius = Math.hypot(edge.mx, edge.my);
+                    var minorAxisRadius = majorAxisRadius * edge.ratio;
+                    var startAngle = (edge.startDeg * Math.PI) / 180;
+                    var endAngle = (edge.endDeg * Math.PI) / 180;
+                    var rotation = Math.atan2(edge.my, edge.mx);
+                    if (!edge.isCcw) {
+                        startAngle = Math.PI * 2 - startAngle;
+                        endAngle = Math.PI * 2 - endAngle;
+                    }
+                    geoEdges.push(new AcGeEllipseArc2d({ x: edge.cx, y: edge.cy, z: 0 }, majorAxisRadius, minorAxisRadius, startAngle, endAngle, !edge.isCcw, rotation));
+                }
+                else {
+                    var spline = AcGeSpline3d.fromDwgSplineEdge({
+                        degree: edge.degree,
+                        numberOfControlPoints: edge.controlPoints.length,
+                        numberOfKnots: edge.knots.length,
+                        numberOfFitData: edge.fitPoints.length,
+                        knots: edge.knots,
+                        controlPoints: edge.controlPoints.map(function (p) {
+                            var _a;
+                            return ({
+                                x: p.x,
+                                y: p.y,
+                                z: 0,
+                                weight: edge.rational ? ((_a = p.weight) !== null && _a !== void 0 ? _a : 1) : undefined
+                            });
+                        }),
+                        fitDatum: edge.fitPoints.map(function (p) { return ({ x: p.x, y: p.y, z: 0 }); }),
+                        startTangent: null,
+                        endTangent: null
+                    });
+                    if (spline)
+                        geoEdges.push(spline);
+                }
+            };
+            try {
+                for (var edges_1 = __values(edges), edges_1_1 = edges_1.next(); !edges_1_1.done; edges_1_1 = edges_1.next()) {
+                    var edge = edges_1_1.value;
+                    _loop_3(edge);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (edges_1_1 && !edges_1_1.done && (_a = edges_1.return)) _a.call(edges_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            var loops = AcGeLoop2d.buildFromEdges(geoEdges);
+            if (loops.length === 0 && geoEdges.length > 0) {
+                _this.add(new AcGeLoop2d(geoEdges));
+            }
+            else {
+                loops.forEach(function (loop) { return _this.add(loop); });
+            }
+            void built;
+            edges = [];
+            currentEdge = null;
+        };
+        var flushCurrentLoop = function () {
+            if (isPolylineBoundary) {
+                flushPolylineLoop();
+            }
+            else {
+                flushEdgeLoop();
+            }
+        };
+        /** Commit the in-progress edge into `edges` before ending a path. */
+        var commitCurrentEdge = function () {
+            if (currentEdge) {
+                edges.push(currentEdge);
+                currentEdge = null;
+            }
+        };
+        /**
+         * End the current boundary path (source-boundary count / next path).
+         * Matches dxf-json: spline edge owns its own group 97 (fit count); the
+         * following group 97 is the path-level source-boundary object count.
+         */
+        var endCurrentPath = function () {
+            commitCurrentEdge();
+            flushCurrentLoop();
+            loopsRemaining = Math.max(0, loopsRemaining - 1);
+            if (loopsRemaining === 0) {
+                afterBoundaries = true;
+            }
+        };
+        while (!filer.atEndOfObject && !filer.atEof && !filer.atExtendedData) {
+            var item = filer.readItem();
+            if (!item)
+                break;
+            var code = Number(item.code);
+            var n = Number(item.value);
+            // Pattern definition lines after boundaries.
+            if (inPatternLines || afterBoundaries) {
+                switch (code) {
+                    case 75:
+                        this.hatchStyle = n;
+                        afterBoundaries = true;
+                        break;
+                    case 76:
+                        this.patternType = n;
+                        break;
+                    case 52:
+                        patternAngleDeg = n;
+                        break;
+                    case 41:
+                        this.patternScale = n;
+                        break;
+                    case 77:
+                        break;
+                    case 78:
+                        inPatternLines = true;
+                        break;
+                    case 53:
+                        if (currentPatternLine) {
+                            this.definitionLines.push(currentPatternLine);
+                        }
+                        currentPatternLine = {
+                            angle: (n * Math.PI) / 180,
+                            base: { x: 0, y: 0 },
+                            offset: { x: 0, y: 0 },
+                            dashLengths: []
+                        };
+                        break;
+                    case 43:
+                        if (currentPatternLine)
+                            currentPatternLine.base.x = n;
+                        break;
+                    case 44:
+                        if (currentPatternLine)
+                            currentPatternLine.base.y = n;
+                        break;
+                    case 45:
+                        if (currentPatternLine)
+                            currentPatternLine.offset.x = n;
+                        break;
+                    case 46:
+                        if (currentPatternLine)
+                            currentPatternLine.offset.y = n;
+                        break;
+                    case 79:
+                        expectedDashes = n;
+                        break;
+                    case 49:
+                        if (currentPatternLine) {
+                            currentPatternLine.dashLengths.push(n);
+                        }
+                        break;
+                    case 47:
+                        this.pixelSize = n;
+                        break;
+                    case 99:
+                        // MPolygon-only: number of degenerate boundary paths; not
+                        // applicable to HATCH entities.
+                        break;
+                    case 450:
+                        this.hatchObjectType = n;
+                        this.gradientStartColor = undefined;
+                        this.gradientEndColor = undefined;
+                        gradientColorIndex = 0;
+                        pendingGradientAci = undefined;
+                        break;
+                    case 451:
+                        break;
+                    case 452:
+                        this.gradientOneColorMode = n !== 0;
+                        break;
+                    case 453:
+                        // Number of gradient colors (0 or 2); colors follow via 463/63/421.
+                        break;
+                    case 460:
+                        // DXF group 460 stores gradient rotation in radians.
+                        this.gradientAngle = n;
+                        break;
+                    case 461:
+                        this.gradientShift = n;
+                        break;
+                    case 462:
+                        this.shadeTintValue = n;
+                        break;
+                    case 463:
+                        flushPendingGradientAci();
+                        break;
+                    case 63:
+                        // Gradient color ACI (optional when true-color 421 follows).
+                        pendingGradientAci = n;
+                        break;
+                    case 421:
+                        applyGradientRgb(n);
+                        break;
+                    case 470:
+                        flushPendingGradientAci();
+                        this.gradientName = String(item.value);
+                        break;
+                    case 98:
+                        // Seed point count — skip seed points.
+                        break;
+                    case 10:
+                    case 20:
+                        // Seed points after 98 — ignore.
+                        break;
+                    default:
+                        break;
+                }
+                continue;
+            }
+            switch (code) {
+                case 10:
+                    if (isPolylineBoundary || (currentEdge && currentEdge.kind !== 'line' && currentEdge.kind !== 'arc' && currentEdge.kind !== 'ellipse' && currentEdge.kind !== 'spline')) {
+                        // handled below in boundary context
+                    }
+                    if (loopsRemaining > 0 && isPolylineBoundary) {
+                        flushVertex();
+                        pendingVertex = { x: n, y: 0 };
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'line' && edgePhase === 'type') {
+                        currentEdge.sx = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'arc') {
+                        currentEdge.cx = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.cx = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.controlPoints.push({ x: n, y: 0 });
+                    }
+                    else if (loopsRemaining <= 0) {
+                        // Elevation point (0,0,elevation) or seed — use z via 30.
+                    }
+                    // First 10 before boundaries is elevation origin x (ignored).
+                    break;
+                case 20:
+                    if (loopsRemaining > 0 && isPolylineBoundary && pendingVertex) {
+                        pendingVertex.y = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'line' && edgePhase === 'type') {
+                        currentEdge.sy = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'arc') {
+                        currentEdge.cy = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.cy = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline' &&
+                        currentEdge.controlPoints.length > 0) {
+                        currentEdge.controlPoints[currentEdge.controlPoints.length - 1].y =
+                            n;
+                    }
+                    break;
+                case 30:
+                    if (loopsRemaining <= 0 && !afterBoundaries) {
+                        elevation = n;
+                    }
+                    break;
+                case 2:
+                    this.patternName = String(item.value);
+                    break;
+                case 70:
+                    this.isSolidFill = n !== 0;
+                    break;
+                case 71:
+                    this.associative = n !== 0;
+                    break;
+                case 91:
+                    loopsRemaining = n;
+                    break;
+                case 92:
+                    if (loopsRemaining > 0 &&
+                        (pendingVertices.length > 0 || edges.length > 0 || currentEdge)) {
+                        commitCurrentEdge();
+                        flushCurrentLoop();
+                    }
+                    boundaryFlag = n;
+                    isPolylineBoundary = (boundaryFlag & 0x02) !== 0;
+                    hasBulge = false;
+                    polyClosed = false;
+                    expectedVertices = 0;
+                    expectedEdges = 0;
+                    pendingVertices = [];
+                    edges = [];
+                    currentEdge = null;
+                    edgePhase = 'type';
+                    break;
+                case 72:
+                    if (isPolylineBoundary) {
+                        hasBulge = n !== 0;
+                    }
+                    else {
+                        // Edge type.
+                        commitCurrentEdge();
+                        if (n === 1) {
+                            currentEdge = {
+                                kind: 'line',
+                                sx: 0,
+                                sy: 0,
+                                ex: 0,
+                                ey: 0
+                            };
+                            edgePhase = 'type';
+                        }
+                        else if (n === 2) {
+                            currentEdge = {
+                                kind: 'arc',
+                                cx: 0,
+                                cy: 0,
+                                radius: 0,
+                                startDeg: 0,
+                                endDeg: 0,
+                                isCcw: true
+                            };
+                        }
+                        else if (n === 3) {
+                            currentEdge = {
+                                kind: 'ellipse',
+                                cx: 0,
+                                cy: 0,
+                                mx: 0,
+                                my: 0,
+                                ratio: 1,
+                                startDeg: 0,
+                                endDeg: 0,
+                                isCcw: true
+                            };
+                        }
+                        else if (n === 4) {
+                            currentEdge = {
+                                kind: 'spline',
+                                degree: 3,
+                                rational: false,
+                                closed: false,
+                                knots: [],
+                                controlPoints: [],
+                                fitPoints: [],
+                                expectedKnots: 0,
+                                expectedControls: 0,
+                                expectedFits: 0,
+                                fitCountSeen: false
+                            };
+                        }
+                        else {
+                            currentEdge = null;
+                        }
+                    }
+                    break;
+                case 73:
+                    if (isPolylineBoundary) {
+                        polyClosed = n !== 0;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'arc') {
+                        currentEdge.isCcw = n !== 0;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.isCcw = n !== 0;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.rational = n !== 0;
+                    }
+                    break;
+                case 74:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.closed = n !== 0;
+                    }
+                    break;
+                case 93:
+                    if (isPolylineBoundary) {
+                        expectedVertices = n;
+                    }
+                    else {
+                        expectedEdges = n;
+                    }
+                    void expectedVertices;
+                    void expectedEdges;
+                    break;
+                case 42:
+                    if (isPolylineBoundary && hasBulge && pendingVertex) {
+                        pendingVertex.bulge = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline' &&
+                        currentEdge.rational &&
+                        currentEdge.controlPoints.length > 0) {
+                        currentEdge.controlPoints[currentEdge.controlPoints.length - 1].weight = n;
+                    }
+                    break;
+                case 11:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'line') {
+                        currentEdge.ex = n;
+                        edgePhase = 'line-end';
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.mx = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.fitPoints.push({ x: n, y: 0 });
+                    }
+                    break;
+                case 21:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'line') {
+                        currentEdge.ey = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.my = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline' &&
+                        currentEdge.fitPoints.length > 0) {
+                        currentEdge.fitPoints[currentEdge.fitPoints.length - 1].y = n;
+                    }
+                    break;
+                case 40:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'arc') {
+                        currentEdge.radius = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.ratio = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.knots.push(n);
+                    }
+                    break;
+                case 50:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'arc') {
+                        currentEdge.startDeg = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.startDeg = n;
+                    }
+                    break;
+                case 51:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'arc') {
+                        currentEdge.endDeg = n;
+                    }
+                    else if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'ellipse') {
+                        currentEdge.endDeg = n;
+                    }
+                    break;
+                case 94:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.degree = n;
+                    }
+                    break;
+                case 95:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.expectedKnots = n;
+                    }
+                    break;
+                case 96:
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline') {
+                        currentEdge.expectedControls = n;
+                    }
+                    break;
+                case 97:
+                    // Spline edges carry their own group 97 (fit-point count), which may
+                    // be 0. The next group 97 is the path-level source-boundary count
+                    // (dxf-json: SplineEdgeSnippets vs CommonBoundaryPathDataSnippets).
+                    if ((currentEdge === null || currentEdge === void 0 ? void 0 : currentEdge.kind) === 'spline' &&
+                        !currentEdge.fitCountSeen &&
+                        (currentEdge.controlPoints.length > 0 ||
+                            currentEdge.knots.length > 0)) {
+                        currentEdge.expectedFits = n;
+                        currentEdge.fitCountSeen = true;
+                        break;
+                    }
+                    endCurrentPath();
+                    break;
+                case 75:
+                    commitCurrentEdge();
+                    flushCurrentLoop();
+                    loopsRemaining = 0;
+                    afterBoundaries = true;
+                    this.hatchStyle = n;
+                    break;
+                case 210:
+                case 220:
+                case 230:
+                    // Extrusion — hatch currently stores elevation only.
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (currentEdge) {
+            edges.push(currentEdge);
+            currentEdge = null;
+        }
+        flushCurrentLoop();
+        if (currentPatternLine) {
+            this.definitionLines.push(currentPatternLine);
+        }
+        flushPendingGradientAci();
+        this.elevation = elevation;
+        this.patternAngle = (patternAngleDeg * Math.PI) / 180;
+        return this;
+    };
     /** The entity type name */
     AcDbHatch.typeName = 'Hatch';
     return AcDbHatch;