@linkiez/dxf-renew 7.1.0 → 7.2.0

package/dist/dxf.js

@@ -2730,6 +2730,7 @@ var dxf = (() => {
     denormalise: () => denormalise,
     groupEntitiesByLayer: () => groupEntitiesByLayer,
     parseString: () => parseString,
+    toJson: () => toJson,
     toPolylines: () => toPolylines,
     toSVG: () => toSVG
   });
@@ -2742,6 +2743,9 @@ var dxf = (() => {
   };
   var config_default = config;
 
+  // src/denormalise.ts
+  var import_cloneDeep = __toESM(require_cloneDeep(), 1);
+
   // src/util/logger.ts
   function info(...args) {
     if (config_default.verbose) {
@@ -2762,6 +2766,172 @@ var dxf = (() => {
     error
   };
 
+  // src/denormalise.ts
+  function adjustLineForBlockBasePoint(entity, block) {
+    const line = entity;
+    line.start.x -= block.x;
+    line.start.y -= block.y;
+    line.end.x -= block.x;
+    line.end.y -= block.y;
+  }
+  function adjustPolylineForBlockBasePoint(entity, block) {
+    const poly = entity;
+    for (const v of poly.vertices) {
+      if (v.x !== void 0) v.x -= block.x;
+      if (v.y !== void 0) v.y -= block.y;
+    }
+  }
+  function adjustCircleForBlockBasePoint(entity, block) {
+    const circle2 = entity;
+    circle2.x -= block.x;
+    circle2.y -= block.y;
+  }
+  function adjustEllipseForBlockBasePoint(entity, block) {
+    const ellipse2 = entity;
+    ellipse2.x -= block.x;
+    ellipse2.y -= block.y;
+  }
+  function adjustArcForBlockBasePoint(entity, block) {
+    const arc2 = entity;
+    arc2.x -= block.x;
+    arc2.y -= block.y;
+  }
+  function adjustSplineForBlockBasePoint(entity, block) {
+    const spline = entity;
+    for (const cp of spline.controlPoints) {
+      cp.x -= block.x;
+      cp.y -= block.y;
+    }
+  }
+  function adjustTextForBlockBasePoint(entity, block) {
+    const text2 = entity;
+    if (text2.x !== void 0) text2.x -= block.x;
+    if (text2.y !== void 0) text2.y -= block.y;
+    if (text2.x2 !== void 0) text2.x2 -= block.x;
+    if (text2.y2 !== void 0) text2.y2 -= block.y;
+  }
+  function adjustMTextForBlockBasePoint(entity, block) {
+    const mtext2 = entity;
+    if (mtext2.x !== void 0) mtext2.x -= block.x;
+    if (mtext2.y !== void 0) mtext2.y -= block.y;
+  }
+  function adjustDimensionForBlockBasePoint(entity, block) {
+    const dim = entity;
+    dim.start.x -= block.x;
+    dim.start.y -= block.y;
+    dim.textMidpoint.x -= block.x;
+    dim.textMidpoint.y -= block.y;
+    dim.measureStart.x -= block.x;
+    dim.measureStart.y -= block.y;
+    dim.measureEnd.x -= block.x;
+    dim.measureEnd.y -= block.y;
+  }
+  var BLOCK_BASEPOINT_ADJUSTERS = {
+    LINE: adjustLineForBlockBasePoint,
+    LWPOLYLINE: adjustPolylineForBlockBasePoint,
+    POLYLINE: adjustPolylineForBlockBasePoint,
+    CIRCLE: adjustCircleForBlockBasePoint,
+    ELLIPSE: adjustEllipseForBlockBasePoint,
+    ARC: adjustArcForBlockBasePoint,
+    SPLINE: adjustSplineForBlockBasePoint,
+    TEXT: adjustTextForBlockBasePoint,
+    MTEXT: adjustMTextForBlockBasePoint,
+    DIMENSION: adjustDimensionForBlockBasePoint
+  };
+  function applyBlockBasePointAdjustment(entity, block) {
+    const adjust = BLOCK_BASEPOINT_ADJUSTERS[entity.type];
+    if (adjust) adjust(entity, block);
+  }
+  function computeRectangularArrayVectors(insert) {
+    const rowCount = insert.rowCount ?? 1;
+    const columnCount = insert.columnCount ?? 1;
+    const rowSpacing = insert.rowSpacing ?? 0;
+    const columnSpacing = insert.columnSpacing ?? 0;
+    const rotation = insert.rotation ?? 0;
+    if (rowCount <= 1 && columnCount <= 1) {
+      return { rowVec: { x: 0, y: 0 }, colVec: { x: 0, y: 0 } };
+    }
+    const cos = Math.cos(rotation * Math.PI / 180);
+    const sin = Math.sin(rotation * Math.PI / 180);
+    return {
+      rowVec: { x: -sin * rowSpacing, y: cos * rowSpacing },
+      colVec: { x: cos * columnSpacing, y: sin * columnSpacing }
+    };
+  }
+  function expandInsert(insert, blocksByName, transforms, gatherEntities) {
+    const block = blocksByName[insert.block];
+    if (!block) {
+      logger_default.error("no block found for insert. block:", insert.block);
+      return [];
+    }
+    const rowCount = insert.rowCount ?? 1;
+    const columnCount = insert.columnCount ?? 1;
+    const { rowVec, colVec } = computeRectangularArrayVectors(insert);
+    const current = [];
+    for (let r = 0; r < rowCount; r++) {
+      for (let c = 0; c < columnCount; c++) {
+        const t = {
+          x: insert.x + rowVec.x * r + colVec.x * c,
+          y: insert.y + rowVec.y * r + colVec.y * c,
+          scaleX: insert.scaleX,
+          scaleY: insert.scaleY,
+          scaleZ: insert.scaleZ,
+          extrusionX: insert.extrusionX,
+          extrusionY: insert.extrusionY,
+          extrusionZ: insert.extrusionZ,
+          rotation: insert.rotation
+        };
+        const transforms2 = transforms.slice(0);
+        transforms2.push(t);
+        const blockEntities = block.entities.map((be) => {
+          const be2 = (0, import_cloneDeep.default)(be);
+          be2.layer = insert.layer;
+          applyBlockBasePointAdjustment(be2, block);
+          return be2;
+        });
+        current.push(...gatherEntities(blockEntities, transforms2));
+      }
+    }
+    return current;
+  }
+  function denormalise(parseResult) {
+    const blocksByName = parseResult.blocks.reduce(
+      (acc, b) => {
+        acc[b.name] = b;
+        return acc;
+      },
+      {}
+    );
+    const gatherEntities = (entities, transforms) => {
+      const current = [];
+      for (const e of entities) {
+        if (e.type === "INSERT") {
+          current.push(
+            ...expandInsert(e, blocksByName, transforms, gatherEntities)
+          );
+        } else {
+          const e2 = (0, import_cloneDeep.default)(e);
+          e2.transforms = transforms.slice().reverse();
+          current.push(e2);
+        }
+      }
+      return current;
+    };
+    return gatherEntities(parseResult.entities, []);
+  }
+
+  // src/groupEntitiesByLayer.ts
+  function groupEntitiesByLayer(entities) {
+    return entities.reduce((acc, entity) => {
+      const layer = entity.layer ?? "0";
+      if (!acc[layer]) {
+        acc[layer] = [];
+      }
+      acc[layer].push(entity);
+      return acc;
+    }, {});
+  }
+
   // src/handlers/entity/common.ts
   function parseCommonEntityProperties(type, value) {
     switch (type) {
@@ -3635,75 +3805,9 @@ var dxf = (() => {
   };
   var dwfUnderlay_default = { TYPE: TYPE9, process: process9 };
 
-  // src/handlers/entity/pdfUnderlay.ts
-  var TYPE10 = "PDFUNDERLAY";
-  var process10 = (tuples) => {
-    return tuples.reduce(
-      (entity, tuple) => {
-        const type = tuple[0];
-        const value = tuple[1];
-        switch (type) {
-          case 340:
-            entity.underlayDefinitionHandle = String(value);
-            break;
-          case 10:
-            entity.insertionPoint.x = value;
-            break;
-          case 20:
-            entity.insertionPoint.y = value;
-            break;
-          case 30:
-            entity.insertionPoint.z = value;
-            break;
-          case 41:
-            entity.scale.x = value;
-            break;
-          case 42:
-            entity.scale.y = value;
-            break;
-          case 43:
-            entity.scale.z = value;
-            break;
-          case 50:
-            entity.rotation = value;
-            break;
-          case 210:
-            entity.normal.x = value;
-            break;
-          case 220:
-            entity.normal.y = value;
-            break;
-          case 230:
-            entity.normal.z = value;
-            break;
-          case 280:
-            entity.flags = value;
-            break;
-          case 281:
-            entity.contrast = value;
-            break;
-          case 282:
-            entity.fade = value;
-            break;
-          default:
-            Object.assign(entity, parseCommonEntityProperties(type, value));
-            break;
-        }
-        return entity;
-      },
-      {
-        type: TYPE10,
-        insertionPoint: { x: 0, y: 0, z: 0 },
-        scale: { x: 1, y: 1, z: 1 },
-        normal: { x: 0, y: 0, z: 1 }
-      }
-    );
-  };
-  var pdfUnderlay_default = { TYPE: TYPE10, process: process10 };
-
   // src/handlers/entity/ellipse.ts
-  var TYPE11 = "ELLIPSE";
-  var process11 = (tuples) => {
+  var TYPE10 = "ELLIPSE";
+  var process10 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -3743,14 +3847,14 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE11
+        type: TYPE10
       }
     );
   };
-  var ellipse_default = { TYPE: TYPE11, process: process11 };
+  var ellipse_default = { TYPE: TYPE10, process: process10 };
 
   // src/handlers/entity/hatch.ts
-  var TYPE12 = "HATCH";
+  var TYPE11 = "HATCH";
   var status = "IDLE";
   var drawEntity = {};
   var drawType = 0;
@@ -3758,7 +3862,7 @@ var dxf = (() => {
   var seed = null;
   var loop = { references: [], entities: [] };
   var polyPoint = null;
-  var process12 = (tuples) => {
+  var process11 = (tuples) => {
     status = "IDLE";
     drawEntity = {};
     drawType = 0;
@@ -3967,7 +4071,7 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE12,
+        type: TYPE11,
         elevation: { x: 0, y: 0, z: 0 },
         extrusionDir: { x: 0, y: 0, z: 1 },
         pattern: {
@@ -3997,7 +4101,7 @@ var dxf = (() => {
       }
     );
   };
-  var hatch_default = { TYPE: TYPE12, process: process12 };
+  var hatch_default = { TYPE: TYPE11, process: process11 };
   function createDrawEntity(type) {
     if (isPolyline) return {};
     switch (type) {
@@ -4180,8 +4284,8 @@ var dxf = (() => {
   }
 
   // src/handlers/entity/image.ts
-  var TYPE13 = "IMAGE";
-  var process13 = (tuples) => {
+  var TYPE12 = "IMAGE";
+  var process12 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4251,7 +4355,7 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE13,
+        type: TYPE12,
         insertionPoint: {},
         uVector: {},
         vVector: {},
@@ -4260,11 +4364,11 @@ var dxf = (() => {
       }
     );
   };
-  var image_default = { TYPE: TYPE13, process: process13 };
+  var image_default = { TYPE: TYPE12, process: process12 };
 
   // src/handlers/entity/insert.ts
-  var TYPE14 = "INSERT";
-  var process14 = (tuples) => {
+  var TYPE13 = "INSERT";
+  var process13 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4322,19 +4426,19 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE14
+        type: TYPE13
       }
     );
   };
-  var insert_default = { TYPE: TYPE14, process: process14 };
+  var insert_default = { TYPE: TYPE13, process: process13 };
 
   // src/handlers/entity/leader.ts
-  var TYPE15 = "LEADER";
+  var TYPE14 = "LEADER";
   function ensureVector3(entity, key) {
     if (!entity[key]) entity[key] = { x: 0, y: 0, z: 0 };
     return entity[key];
   }
-  var process15 = (tuples) => {
+  var process14 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4429,16 +4533,16 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE15,
+        type: TYPE14,
         vertices: []
       }
     );
   };
-  var leader_default = { TYPE: TYPE15, process: process15 };
+  var leader_default = { TYPE: TYPE14, process: process14 };
 
   // src/handlers/entity/line.ts
-  var TYPE16 = "LINE";
-  var process16 = (tuples) => {
+  var TYPE15 = "LINE";
+  var process15 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4472,17 +4576,17 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE16,
+        type: TYPE15,
         start: {},
         end: {}
       }
     );
   };
-  var line_default = { TYPE: TYPE16, process: process16 };
+  var line_default = { TYPE: TYPE15, process: process15 };
 
   // src/handlers/entity/lwpolyline.ts
-  var TYPE17 = "LWPOLYLINE";
-  var process17 = (tuples) => {
+  var TYPE16 = "LWPOLYLINE";
+  var process16 = (tuples) => {
     let vertex;
     return tuples.reduce(
       (entity, tuple) => {
@@ -4515,19 +4619,99 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE17,
+        type: TYPE16,
         vertices: []
       }
     );
   };
-  var lwpolyline_default = { TYPE: TYPE17, process: process17 };
+  var lwpolyline_default = { TYPE: TYPE16, process: process16 };
 
-  // src/handlers/entity/ole2Frame.ts
-  var TYPE18 = "OLE2FRAME";
-  var process18 = (tuples) => {
+  // src/handlers/entity/mleader.ts
+  var TYPE17 = "MLEADER";
+  var process17 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
-        const type = tuple[0];
+        const code = tuple[0];
+        const value = tuple[1];
+        switch (code) {
+          // Style name
+          case 2:
+            entity.styleName = String(value);
+            break;
+          // Text string (simplified). MLEADER text can also be stored in more complex structures.
+          case 1:
+            entity.text = String(value);
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(code, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE17
+      }
+    );
+  };
+  var mleader_default = { TYPE: TYPE17, process: process17 };
+
+  // src/handlers/entity/mline.ts
+  var TYPE18 = "MLINE";
+  function ensurePoint3(entity, key) {
+    entity[key] ??= {};
+    return entity[key];
+  }
+  var process18 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const code = tuple[0];
+        const value = tuple[1];
+        switch (code) {
+          // Start point
+          case 10:
+            ensurePoint3(entity, "startPoint").x = value;
+            break;
+          case 20:
+            ensurePoint3(entity, "startPoint").y = value;
+            break;
+          case 30:
+            ensurePoint3(entity, "startPoint").z = value;
+            break;
+          // End point
+          case 11:
+            ensurePoint3(entity, "endPoint").x = value;
+            break;
+          case 21:
+            ensurePoint3(entity, "endPoint").y = value;
+            break;
+          case 31:
+            ensurePoint3(entity, "endPoint").z = value;
+            break;
+          case 71:
+            entity.vertexCount = value;
+            break;
+          case 2:
+            entity.styleName = String(value);
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(code, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE18
+      }
+    );
+  };
+  var mline_default = { TYPE: TYPE18, process: process18 };
+
+  // src/handlers/entity/ole2Frame.ts
+  var TYPE19 = "OLE2FRAME";
+  var process19 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
         const value = tuple[1];
         switch (type) {
           case 70:
@@ -4573,16 +4757,140 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE18,
+        type: TYPE19,
+        data: ""
+      }
+    );
+  };
+  var ole2Frame_default = { TYPE: TYPE19, process: process19 };
+
+  // src/handlers/entity/oleframe.ts
+  var TYPE20 = "OLEFRAME";
+  var process20 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 70:
+            entity.version = value;
+            break;
+          case 3:
+            entity.name = value;
+            break;
+          case 10:
+            entity.upperLeftX = value;
+            break;
+          case 20:
+            entity.upperLeftY = value;
+            break;
+          case 30:
+            entity.upperLeftZ = value;
+            break;
+          case 11:
+            entity.lowerRightX = value;
+            break;
+          case 21:
+            entity.lowerRightY = value;
+            break;
+          case 31:
+            entity.lowerRightZ = value;
+            break;
+          case 71:
+            entity.objectType = value;
+            break;
+          case 72:
+            entity.tile = value;
+            break;
+          case 90:
+            entity.length = value;
+            break;
+          case 310:
+            entity.data += String(value);
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE20,
         data: ""
       }
     );
   };
-  var ole2Frame_default = { TYPE: TYPE18, process: process18 };
+  var oleframe_default = { TYPE: TYPE20, process: process20 };
+
+  // src/handlers/entity/pdfUnderlay.ts
+  var TYPE21 = "PDFUNDERLAY";
+  var process21 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 340:
+            entity.underlayDefinitionHandle = String(value);
+            break;
+          case 10:
+            entity.insertionPoint.x = value;
+            break;
+          case 20:
+            entity.insertionPoint.y = value;
+            break;
+          case 30:
+            entity.insertionPoint.z = value;
+            break;
+          case 41:
+            entity.scale.x = value;
+            break;
+          case 42:
+            entity.scale.y = value;
+            break;
+          case 43:
+            entity.scale.z = value;
+            break;
+          case 50:
+            entity.rotation = value;
+            break;
+          case 210:
+            entity.normal.x = value;
+            break;
+          case 220:
+            entity.normal.y = value;
+            break;
+          case 230:
+            entity.normal.z = value;
+            break;
+          case 280:
+            entity.flags = value;
+            break;
+          case 281:
+            entity.contrast = value;
+            break;
+          case 282:
+            entity.fade = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE21,
+        insertionPoint: { x: 0, y: 0, z: 0 },
+        scale: { x: 1, y: 1, z: 1 },
+        normal: { x: 0, y: 0, z: 1 }
+      }
+    );
+  };
+  var pdfUnderlay_default = { TYPE: TYPE21, process: process21 };
 
   // src/handlers/entity/point.ts
-  var TYPE19 = "POINT";
-  var process19 = (tuples) => {
+  var TYPE22 = "POINT";
+  var process22 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4607,15 +4915,15 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE19
+        type: TYPE22
       }
     );
   };
-  var point_default = { TYPE: TYPE19, process: process19 };
+  var point_default = { TYPE: TYPE22, process: process22 };
 
   // src/handlers/entity/polyline.ts
-  var TYPE20 = "POLYLINE";
-  var process20 = (tuples) => {
+  var TYPE23 = "POLYLINE";
+  var process23 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4626,8 +4934,131 @@ var dxf = (() => {
             entity.polygonMesh = (value & 16) === 16;
             entity.polyfaceMesh = (value & 64) === 64;
             break;
-          case 39:
-            entity.thickness = value;
+          case 39:
+            entity.thickness = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE23,
+        vertices: []
+      }
+    );
+  };
+  var polyline_default = { TYPE: TYPE23, process: process23 };
+
+  // src/handlers/entity/ray.ts
+  var TYPE24 = "RAY";
+  var process24 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 10:
+            entity.start.x = value;
+            break;
+          case 20:
+            entity.start.y = value;
+            break;
+          case 30:
+            entity.start.z = value;
+            break;
+          case 11:
+            entity.direction.x = value;
+            break;
+          case 21:
+            entity.direction.y = value;
+            break;
+          case 31:
+            entity.direction.z = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE24,
+        start: {},
+        direction: {}
+      }
+    );
+  };
+  var ray_default = { TYPE: TYPE24, process: process24 };
+
+  // src/handlers/entity/region.ts
+  var TYPE25 = "REGION";
+  var process25 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const code = tuple[0];
+        const value = tuple[1];
+        switch (code) {
+          // ACIS data text (first line: 1, additional lines: 3)
+          case 1:
+          case 3:
+            entity.acisData ??= [];
+            entity.acisData.push(String(value));
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(code, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE25
+      }
+    );
+  };
+  var region_default = { TYPE: TYPE25, process: process25 };
+
+  // src/handlers/entity/shape.ts
+  var TYPE26 = "SHAPE";
+  var process26 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 10:
+            entity.insertionPoint.x = value;
+            break;
+          case 20:
+            entity.insertionPoint.y = value;
+            break;
+          case 30:
+            entity.insertionPoint.z = value;
+            break;
+          case 2:
+            entity.name = String(value);
+            break;
+          case 39:
+            entity.thickness = value;
+            break;
+          case 40:
+            entity.size = value;
+            break;
+          case 41:
+            entity.relativeXScale = value;
+            break;
+          case 50:
+            entity.rotation = value;
+            break;
+          case 51:
+            entity.oblique = value;
+            break;
+          case 210:
+            entity.extrusionX = value;
+            break;
+          case 220:
+            entity.extrusionY = value;
             break;
           default:
             Object.assign(entity, parseCommonEntityProperties(type, value));
@@ -4636,16 +5067,16 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE20,
-        vertices: []
+        type: TYPE26,
+        insertionPoint: {}
       }
     );
   };
-  var polyline_default = { TYPE: TYPE20, process: process20 };
+  var shape_default = { TYPE: TYPE26, process: process26 };
 
   // src/handlers/entity/solid.ts
-  var TYPE21 = "SOLID";
-  var process21 = (tuples) => {
+  var TYPE27 = "SOLID";
+  var process27 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4697,16 +5128,16 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE21,
+        type: TYPE27,
         corners: [{}, {}, {}, {}]
       }
     );
   };
-  var solid_default = { TYPE: TYPE21, process: process21 };
+  var solid_default = { TYPE: TYPE27, process: process27 };
 
   // src/handlers/entity/spline.ts
-  var TYPE22 = "SPLINE";
-  var process22 = (tuples) => {
+  var TYPE28 = "SPLINE";
+  var process28 = (tuples) => {
     let controlPoint;
     return tuples.reduce(
       (entity, tuple) => {
@@ -4765,17 +5196,48 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE22,
+        type: TYPE28,
         controlPoints: [],
         knots: []
       }
     );
   };
-  var spline_default = { TYPE: TYPE22, process: process22 };
+  var spline_default = { TYPE: TYPE28, process: process28 };
+
+  // src/handlers/entity/table.ts
+  var TYPE29 = "TABLE";
+  var process29 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const code = tuple[0];
+        const value = tuple[1];
+        switch (code) {
+          case 90:
+            entity.rows = value;
+            break;
+          case 91:
+            entity.columns = value;
+            break;
+          case 1:
+            entity.cellText ??= [];
+            entity.cellText.push(String(value));
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(code, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE29
+      }
+    );
+  };
+  var table_default = { TYPE: TYPE29, process: process29 };
 
   // src/handlers/entity/threeDFace.ts
-  var TYPE23 = "3DFACE";
-  var process23 = (tuples) => {
+  var TYPE30 = "3DFACE";
+  var process30 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4824,20 +5286,20 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE23,
+        type: TYPE30,
         vertices: [{}, {}, {}, {}]
       }
     );
   };
-  var threeDFace_default = { TYPE: TYPE23, process: process23 };
+  var threeDFace_default = { TYPE: TYPE30, process: process30 };
 
   // src/handlers/entity/tolerance.ts
-  var TYPE24 = "TOLERANCE";
+  var TYPE31 = "TOLERANCE";
   function ensureVector32(entity, key) {
     entity[key] ??= { x: 0, y: 0, z: 0 };
     return entity[key];
   }
-  var process24 = (tuples) => {
+  var process31 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const code = tuple[0];
@@ -4874,22 +5336,83 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE24,
+        type: TYPE31,
         insertionPoint: { x: 0, y: 0, z: 0 }
       }
     );
   };
-  var tolerance_default = { TYPE: TYPE24, process: process24 };
+  var tolerance_default = { TYPE: TYPE31, process: process31 };
+
+  // src/handlers/entity/trace.ts
+  var TYPE32 = "TRACE";
+  var process32 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 10:
+            entity.corners[0].x = value;
+            break;
+          case 20:
+            entity.corners[0].y = value;
+            break;
+          case 30:
+            entity.corners[0].z = value;
+            break;
+          case 11:
+            entity.corners[1].x = value;
+            break;
+          case 21:
+            entity.corners[1].y = value;
+            break;
+          case 31:
+            entity.corners[1].z = value;
+            break;
+          case 12:
+            entity.corners[2].x = value;
+            break;
+          case 22:
+            entity.corners[2].y = value;
+            break;
+          case 32:
+            entity.corners[2].z = value;
+            break;
+          case 13:
+            entity.corners[3].x = value;
+            break;
+          case 23:
+            entity.corners[3].y = value;
+            break;
+          case 33:
+            entity.corners[3].z = value;
+            break;
+          case 39:
+            entity.thickness = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE32,
+        corners: [{}, {}, {}, {}]
+      }
+    );
+  };
+  var trace_default = { TYPE: TYPE32, process: process32 };
 
   // src/handlers/entity/vertex.ts
-  var TYPE25 = "VERTEX";
+  var TYPE33 = "VERTEX";
   var ensureFaces = (entity) => {
     entity.faces = entity.faces || [];
     if ("x" in entity && !entity.x) delete entity.x;
     if ("y" in entity && !entity.y) delete entity.y;
     if ("z" in entity && !entity.z) delete entity.z;
   };
-  var process25 = (tuples) => {
+  var process33 = (tuples) => {
     return tuples.reduce((entity, tuple) => {
       const type = tuple[0];
       const value = tuple[1];
@@ -4928,11 +5451,11 @@ var dxf = (() => {
       return entity;
     }, {});
   };
-  var vertex_default = { TYPE: TYPE25, process: process25 };
+  var vertex_default = { TYPE: TYPE33, process: process33 };
 
   // src/handlers/entity/viewport.ts
-  var TYPE26 = "VIEWPORT";
-  var process26 = (tuples) => {
+  var TYPE34 = "VIEWPORT";
+  var process34 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -5030,7 +5553,7 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE26,
+        type: TYPE34,
         center: {},
         centerDCS: {},
         snap: {},
@@ -5041,26 +5564,156 @@ var dxf = (() => {
       }
     );
   };
-  var viewport_default = { TYPE: TYPE26, process: process26 };
+  var viewport_default = { TYPE: TYPE34, process: process34 };
+
+  // src/handlers/entity/wipeout.ts
+  var TYPE35 = "WIPEOUT";
+  var process35 = (tuples) => {
+    let pendingBoundaryX = null;
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 90:
+            entity.classVersion = value;
+            break;
+          case 10:
+            entity.insertionPoint.x = value;
+            break;
+          case 20:
+            entity.insertionPoint.y = value;
+            break;
+          case 30:
+            entity.insertionPoint.z = value;
+            break;
+          case 11:
+            entity.uVector.x = value;
+            break;
+          case 21:
+            entity.uVector.y = value;
+            break;
+          case 31:
+            entity.uVector.z = value;
+            break;
+          case 12:
+            entity.vVector.x = value;
+            break;
+          case 22:
+            entity.vVector.y = value;
+            break;
+          case 32:
+            entity.vVector.z = value;
+            break;
+          case 13:
+            entity.imageSizePixels ??= { u: 0, v: 0 };
+            entity.imageSizePixels.u = value;
+            break;
+          case 23:
+            entity.imageSizePixels ??= { u: 0, v: 0 };
+            entity.imageSizePixels.v = value;
+            break;
+          case 70:
+            entity.displayProperties = value;
+            break;
+          case 280:
+            entity.clippingState = value;
+            break;
+          case 71:
+            entity.clipBoundaryType = value;
+            break;
+          case 14:
+            pendingBoundaryX = value;
+            break;
+          case 24:
+            if (pendingBoundaryX !== null) {
+              entity.clipBoundaryVertices ??= [];
+              entity.clipBoundaryVertices.push({ x: pendingBoundaryX, y: value });
+              pendingBoundaryX = null;
+            }
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE35,
+        insertionPoint: {},
+        uVector: {},
+        vVector: {}
+      }
+    );
+  };
+  var wipeout_default = { TYPE: TYPE35, process: process35 };
+
+  // src/handlers/entity/xline.ts
+  var TYPE36 = "XLINE";
+  var process36 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 10:
+            entity.basePoint.x = value;
+            break;
+          case 20:
+            entity.basePoint.y = value;
+            break;
+          case 30:
+            entity.basePoint.z = value;
+            break;
+          case 11:
+            entity.direction.x = value;
+            break;
+          case 21:
+            entity.direction.y = value;
+            break;
+          case 31:
+            entity.direction.z = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE36,
+        basePoint: {},
+        direction: {}
+      }
+    );
+  };
+  var xline_default = { TYPE: TYPE36, process: process36 };
 
   // src/handlers/entities.ts
   var handlers = [
     point_default,
     line_default,
     lwpolyline_default,
+    mline_default,
+    mleader_default,
     polyline_default,
     vertex_default,
     circle_default,
     arc_default,
     ellipse_default,
     spline_default,
+    table_default,
     solid_default,
+    trace_default,
     hatch_default,
     image_default,
     leader_default,
+    ray_default,
+    region_default,
     dwfUnderlay_default,
     dgnUnderlay_default,
     pdfUnderlay_default,
+    shape_default,
     mtext_default,
     tolerance_default,
     attdef_default,
@@ -5070,7 +5723,10 @@ var dxf = (() => {
     dimension_default,
     threeDFace_default,
     viewport_default,
-    ole2Frame_default
+    ole2Frame_default,
+    oleframe_default,
+    xline_default,
+    wipeout_default
   ].reduce((acc, mod) => {
     acc[mod.TYPE] = mod;
     return acc;
@@ -5475,6 +6131,36 @@ var dxf = (() => {
     }
     return reactor;
   }
+  function parseDimAssocObject(group) {
+    if (group[0]?.[1] !== "DIMASSOC") return void 0;
+    const tuples = group.slice(1);
+    const dimAssoc = {
+      type: "DIMASSOC",
+      tuples
+    };
+    for (const tuple of tuples) {
+      const type = tuple[0];
+      const value = tuple[1];
+      if (type === 5) dimAssoc.handle = value;
+      if (type === 330) dimAssoc.ownerHandle = value;
+    }
+    return dimAssoc;
+  }
+  function parseFieldObject(group) {
+    if (group[0]?.[1] !== "FIELD") return void 0;
+    const tuples = group.slice(1);
+    const field = {
+      type: "FIELD",
+      tuples
+    };
+    for (const tuple of tuples) {
+      const type = tuple[0];
+      const value = tuple[1];
+      if (type === 5) field.handle = value;
+      if (type === 330) field.ownerHandle = value;
+    }
+    return field;
+  }
   var UNDERLAY_DEFINITION_OBJECT_TYPES = /* @__PURE__ */ new Set([
     "UNDERLAYDEFINITION",
     "PDFDEFINITION",
@@ -5544,6 +6230,16 @@ var dxf = (() => {
       const def = parseUnderlayDefinitionObject(group);
       const handle = def?.handle ? String(def.handle) : void 0;
       if (def && handle) objects.underlayDefinitions[handle] = def;
+    },
+    DIMASSOC: (objects, group) => {
+      const dimAssoc = parseDimAssocObject(group);
+      const handle = dimAssoc?.handle ? String(dimAssoc.handle) : void 0;
+      if (dimAssoc && handle) objects.dimAssocs[handle] = dimAssoc;
+    },
+    FIELD: (objects, group) => {
+      const field = parseFieldObject(group);
+      const handle = field?.handle ? String(field.handle) : void 0;
+      if (field && handle) objects.fields[handle] = field;
     }
   };
   function parseObjects(tuples) {
@@ -5553,7 +6249,9 @@ var dxf = (() => {
       xRecords: {},
       imageDefs: {},
       imageDefReactors: {},
-      underlayDefinitions: {}
+      underlayDefinitions: {},
+      dimAssocs: {},
+      fields: {}
     };
     const groups = groupObjectsByZero(tuples);
     for (const group of groups) {
@@ -5723,6 +6421,7 @@ var dxf = (() => {
         const type = tuple[0];
         const value = tuple[1];
         switch (type) {
+          // NOSONAR
           case 2:
             vport.name = value;
             break;
@@ -5804,36 +6503,112 @@ var dxf = (() => {
           case 121:
             vport.xAxisY = Number.parseFloat(String(value));
             break;
-          case 131:
-            vport.xAxisZ = Number.parseFloat(String(value));
+          case 131:
+            vport.xAxisZ = Number.parseFloat(String(value));
+            break;
+          case 112:
+            vport.xAxisX = Number.parseFloat(String(value));
+            break;
+          case 122:
+            vport.xAxisY = Number.parseFloat(String(value));
+            break;
+          case 132:
+            vport.xAxisZ = Number.parseFloat(String(value));
+            break;
+          case 146:
+            vport.elevation = Number.parseFloat(String(value));
+            break;
+          default:
+        }
+        return vport;
+      },
+      {
+        type: "VPORT",
+        center: {},
+        lowerLeft: {},
+        upperRight: {},
+        snap: {},
+        snapSpacing: {},
+        gridSpacing: {},
+        direction: {},
+        target: {}
+      }
+    );
+  };
+  var appIdHandler = (tuples) => {
+    return tuples.reduce(
+      (appId, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 2:
+            appId.name = value;
+            break;
+          case 70:
+            appId.flags = value;
+            break;
+          default:
+        }
+        return appId;
+      },
+      { type: "APPID" }
+    );
+  };
+  var blockRecordHandler = (tuples) => {
+    return tuples.reduce(
+      (blockRecord, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 2:
+            blockRecord.name = value;
+            break;
+          case 70:
+            blockRecord.flags = value;
             break;
-          case 112:
-            vport.xAxisX = Number.parseFloat(String(value));
+          default:
+        }
+        return blockRecord;
+      },
+      { type: "BLOCK_RECORD" }
+    );
+  };
+  var ucsHandler = (tuples) => {
+    return tuples.reduce(
+      (ucs, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 2:
+            ucs.name = value;
             break;
-          case 122:
-            vport.xAxisY = Number.parseFloat(String(value));
+          case 70:
+            ucs.flags = value;
             break;
-          case 132:
-            vport.xAxisZ = Number.parseFloat(String(value));
+          default:
+        }
+        return ucs;
+      },
+      { type: "UCS" }
+    );
+  };
+  var viewHandler = (tuples) => {
+    return tuples.reduce(
+      (view, tuple) => {
+        const type = tuple[0];
+        const value = tuple[1];
+        switch (type) {
+          case 2:
+            view.name = value;
             break;
-          case 146:
-            vport.elevation = Number.parseFloat(String(value));
+          case 70:
+            view.flags = value;
             break;
           default:
         }
-        return vport;
+        return view;
       },
-      {
-        type: "VPORT",
-        center: {},
-        lowerLeft: {},
-        upperRight: {},
-        snap: {},
-        snapSpacing: {},
-        gridSpacing: {},
-        direction: {},
-        target: {}
-      }
+      { type: "VIEW" }
     );
   };
   var dimStyleHandler = (tuples) => {
@@ -5842,6 +6617,7 @@ var dxf = (() => {
         const type = tuple[0];
         const value = tuple[1];
         switch (type) {
+          // NOSONAR
           case 2:
             dimStyle.name = value;
             break;
@@ -6092,30 +6868,31 @@ var dxf = (() => {
         tableTuples.push(tuple);
       }
     }
-    let stylesTuples = [];
-    let layersTuples = [];
-    let vPortTuples = [];
-    let ltypeTuples = [];
-    let dimStyleTuples = [];
+    const groupsByName = {};
     for (const group of tableGroups) {
-      if (group[0]?.[1] === "STYLE") {
-        stylesTuples = group;
-      } else if (group[0]?.[1] === "LTYPE") {
-        ltypeTuples = group;
-      } else if (group[0]?.[1] === "LAYER") {
-        layersTuples = group;
-      } else if (group[0]?.[1] === "VPORT") {
-        vPortTuples = group;
-      } else if (group[0]?.[1] === "DIMSTYLE") {
-        dimStyleTuples = group;
-      }
-    }
+      const name = String(group[0]?.[1] ?? "");
+      if (!name) continue;
+      groupsByName[name] = group;
+    }
+    const stylesTuples = groupsByName.STYLE ?? [];
+    const layersTuples = groupsByName.LAYER ?? [];
+    const vPortTuples = groupsByName.VPORT ?? [];
+    const ltypeTuples = groupsByName.LTYPE ?? [];
+    const dimStyleTuples = groupsByName.DIMSTYLE ?? [];
+    const appIdTuples = groupsByName.APPID ?? [];
+    const blockRecordTuples = groupsByName.BLOCK_RECORD ?? [];
+    const ucsTuples = groupsByName.UCS ?? [];
+    const viewTuples = groupsByName.VIEW ?? [];
     return {
       layers: tableHandler(layersTuples, "LAYER", layerHandler),
       styles: tableHandler(stylesTuples, "STYLE", styleHandler),
       vports: tableHandler(vPortTuples, "VPORT", vPortHandler),
       ltypes: tableHandler(ltypeTuples, "LTYPE", ltypeHandler),
-      dimStyles: tableHandler(dimStyleTuples, "DIMSTYLE", dimStyleHandler)
+      dimStyles: tableHandler(dimStyleTuples, "DIMSTYLE", dimStyleHandler),
+      appids: tableHandler(appIdTuples, "APPID", appIdHandler),
+      blockRecords: tableHandler(blockRecordTuples, "BLOCK_RECORD", blockRecordHandler),
+      ucs: tableHandler(ucsTuples, "UCS", ucsHandler),
+      views: tableHandler(viewTuples, "VIEW", viewHandler)
     };
   }
 
@@ -6199,171 +6976,11 @@ var dxf = (() => {
     return result;
   }
 
-  // src/denormalise.ts
-  var import_cloneDeep = __toESM(require_cloneDeep(), 1);
-  function adjustLineForBlockBasePoint(entity, block) {
-    const line = entity;
-    line.start.x -= block.x;
-    line.start.y -= block.y;
-    line.end.x -= block.x;
-    line.end.y -= block.y;
-  }
-  function adjustPolylineForBlockBasePoint(entity, block) {
-    const poly = entity;
-    for (const v of poly.vertices) {
-      if (v.x !== void 0) v.x -= block.x;
-      if (v.y !== void 0) v.y -= block.y;
-    }
-  }
-  function adjustCircleForBlockBasePoint(entity, block) {
-    const circle2 = entity;
-    circle2.x -= block.x;
-    circle2.y -= block.y;
-  }
-  function adjustEllipseForBlockBasePoint(entity, block) {
-    const ellipse2 = entity;
-    ellipse2.x -= block.x;
-    ellipse2.y -= block.y;
-  }
-  function adjustArcForBlockBasePoint(entity, block) {
-    const arc2 = entity;
-    arc2.x -= block.x;
-    arc2.y -= block.y;
-  }
-  function adjustSplineForBlockBasePoint(entity, block) {
-    const spline = entity;
-    for (const cp of spline.controlPoints) {
-      cp.x -= block.x;
-      cp.y -= block.y;
-    }
-  }
-  function adjustTextForBlockBasePoint(entity, block) {
-    const text2 = entity;
-    if (text2.x !== void 0) text2.x -= block.x;
-    if (text2.y !== void 0) text2.y -= block.y;
-    if (text2.x2 !== void 0) text2.x2 -= block.x;
-    if (text2.y2 !== void 0) text2.y2 -= block.y;
-  }
-  function adjustMTextForBlockBasePoint(entity, block) {
-    const mtext2 = entity;
-    if (mtext2.x !== void 0) mtext2.x -= block.x;
-    if (mtext2.y !== void 0) mtext2.y -= block.y;
-  }
-  function adjustDimensionForBlockBasePoint(entity, block) {
-    const dim = entity;
-    dim.start.x -= block.x;
-    dim.start.y -= block.y;
-    dim.textMidpoint.x -= block.x;
-    dim.textMidpoint.y -= block.y;
-    dim.measureStart.x -= block.x;
-    dim.measureStart.y -= block.y;
-    dim.measureEnd.x -= block.x;
-    dim.measureEnd.y -= block.y;
-  }
-  var BLOCK_BASEPOINT_ADJUSTERS = {
-    LINE: adjustLineForBlockBasePoint,
-    LWPOLYLINE: adjustPolylineForBlockBasePoint,
-    POLYLINE: adjustPolylineForBlockBasePoint,
-    CIRCLE: adjustCircleForBlockBasePoint,
-    ELLIPSE: adjustEllipseForBlockBasePoint,
-    ARC: adjustArcForBlockBasePoint,
-    SPLINE: adjustSplineForBlockBasePoint,
-    TEXT: adjustTextForBlockBasePoint,
-    MTEXT: adjustMTextForBlockBasePoint,
-    DIMENSION: adjustDimensionForBlockBasePoint
-  };
-  function applyBlockBasePointAdjustment(entity, block) {
-    const adjust = BLOCK_BASEPOINT_ADJUSTERS[entity.type];
-    if (adjust) adjust(entity, block);
-  }
-  function computeRectangularArrayVectors(insert) {
-    const rowCount = insert.rowCount ?? 1;
-    const columnCount = insert.columnCount ?? 1;
-    const rowSpacing = insert.rowSpacing ?? 0;
-    const columnSpacing = insert.columnSpacing ?? 0;
-    const rotation = insert.rotation ?? 0;
-    if (rowCount <= 1 && columnCount <= 1) {
-      return { rowVec: { x: 0, y: 0 }, colVec: { x: 0, y: 0 } };
-    }
-    const cos = Math.cos(rotation * Math.PI / 180);
-    const sin = Math.sin(rotation * Math.PI / 180);
-    return {
-      rowVec: { x: -sin * rowSpacing, y: cos * rowSpacing },
-      colVec: { x: cos * columnSpacing, y: sin * columnSpacing }
-    };
-  }
-  function expandInsert(insert, blocksByName, transforms, gatherEntities) {
-    const block = blocksByName[insert.block];
-    if (!block) {
-      logger_default.error("no block found for insert. block:", insert.block);
-      return [];
-    }
-    const rowCount = insert.rowCount ?? 1;
-    const columnCount = insert.columnCount ?? 1;
-    const { rowVec, colVec } = computeRectangularArrayVectors(insert);
-    const current = [];
-    for (let r = 0; r < rowCount; r++) {
-      for (let c = 0; c < columnCount; c++) {
-        const t = {
-          x: insert.x + rowVec.x * r + colVec.x * c,
-          y: insert.y + rowVec.y * r + colVec.y * c,
-          scaleX: insert.scaleX,
-          scaleY: insert.scaleY,
-          scaleZ: insert.scaleZ,
-          extrusionX: insert.extrusionX,
-          extrusionY: insert.extrusionY,
-          extrusionZ: insert.extrusionZ,
-          rotation: insert.rotation
-        };
-        const transforms2 = transforms.slice(0);
-        transforms2.push(t);
-        const blockEntities = block.entities.map((be) => {
-          const be2 = (0, import_cloneDeep.default)(be);
-          be2.layer = insert.layer;
-          applyBlockBasePointAdjustment(be2, block);
-          return be2;
-        });
-        current.push(...gatherEntities(blockEntities, transforms2));
-      }
-    }
-    return current;
-  }
-  function denormalise(parseResult) {
-    const blocksByName = parseResult.blocks.reduce(
-      (acc, b) => {
-        acc[b.name] = b;
-        return acc;
-      },
-      {}
-    );
-    const gatherEntities = (entities, transforms) => {
-      const current = [];
-      for (const e of entities) {
-        if (e.type === "INSERT") {
-          current.push(
-            ...expandInsert(e, blocksByName, transforms, gatherEntities)
-          );
-        } else {
-          const e2 = (0, import_cloneDeep.default)(e);
-          e2.transforms = transforms.slice().reverse();
-          current.push(e2);
-        }
-      }
-      return current;
-    };
-    return gatherEntities(parseResult.entities, []);
-  }
-
-  // src/groupEntitiesByLayer.ts
-  function groupEntitiesByLayer(entities) {
-    return entities.reduce((acc, entity) => {
-      const layer = entity.layer ?? "0";
-      if (!acc[layer]) {
-        acc[layer] = [];
-      }
-      acc[layer].push(entity);
-      return acc;
-    }, {});
+  // src/toJson.ts
+  function toJson(parsed, options = {}) {
+    const shouldPrettyPrint = options.pretty === true;
+    const indentation = shouldPrettyPrint ? options.space ?? 2 : void 0;
+    return JSON.stringify(parsed, null, indentation);
   }
 
   // src/toPolylines.ts
@@ -6655,12 +7272,95 @@ var dxf = (() => {
   function entityToPolyline(entity, options) {
     options = options || {};
     let polyline2;
+    const INFINITE_LINE_LENGTH = 1e3;
+    const normalize2 = (x, y) => {
+      const len = Math.hypot(x, y);
+      if (len === 0) return null;
+      return { x: x / len, y: y / len };
+    };
     if (entity.type === "LINE") {
       polyline2 = [
         [entity.start.x, entity.start.y],
         [entity.end.x, entity.end.y]
       ];
     }
+    if (entity.type === "LEADER") {
+      if (entity.vertices.length >= 2) {
+        polyline2 = entity.vertices.map((v) => [v.x, v.y]);
+      } else {
+        logger_default.warn("LEADER entity with insufficient vertices");
+        polyline2 = [];
+      }
+    }
+    if (entity.type === "RAY") {
+      const dir = normalize2(entity.direction.x, entity.direction.y);
+      if (dir === null) {
+        logger_default.warn("RAY entity with zero direction vector");
+        polyline2 = [];
+      } else {
+        polyline2 = [
+          [entity.start.x, entity.start.y],
+          [
+            entity.start.x + dir.x * INFINITE_LINE_LENGTH,
+            entity.start.y + dir.y * INFINITE_LINE_LENGTH
+          ]
+        ];
+      }
+    }
+    if (entity.type === "XLINE") {
+      const dir = normalize2(entity.direction.x, entity.direction.y);
+      if (dir === null) {
+        logger_default.warn("XLINE entity with zero direction vector");
+        polyline2 = [];
+      } else {
+        polyline2 = [
+          [
+            entity.basePoint.x - dir.x * INFINITE_LINE_LENGTH,
+            entity.basePoint.y - dir.y * INFINITE_LINE_LENGTH
+          ],
+          [
+            entity.basePoint.x + dir.x * INFINITE_LINE_LENGTH,
+            entity.basePoint.y + dir.y * INFINITE_LINE_LENGTH
+          ]
+        ];
+      }
+    }
+    if (entity.type === "SHAPE") {
+      const x = entity.insertionPoint?.x ?? 0;
+      const y = entity.insertionPoint?.y ?? 0;
+      const size = entity.size ?? 0;
+      const scaleX = entity.relativeXScale ?? 1;
+      const length = size * scaleX;
+      polyline2 = [
+        [x, y],
+        [x + length, y]
+      ];
+    }
+    if (entity.type === "WIPEOUT") {
+      const verts = entity.clipBoundaryVertices;
+      if (!verts || verts.length < 2) {
+        logger_default.warn("WIPEOUT entity with missing clip boundary vertices");
+        polyline2 = [];
+      } else {
+        const insX = entity.insertionPoint?.x ?? 0;
+        const insY = entity.insertionPoint?.y ?? 0;
+        const ux = entity.uVector?.x ?? 1;
+        const uy = entity.uVector?.y ?? 0;
+        const vx = entity.vVector?.x ?? 0;
+        const vy = entity.vVector?.y ?? 1;
+        polyline2 = verts.map((p) => [
+          insX + ux * p.x + vx * p.y,
+          insY + uy * p.x + vy * p.y
+        ]);
+        if (polyline2.length > 0) {
+          const first = polyline2[0];
+          const last = polyline2[polyline2.length - 1];
+          if (first[0] !== last[0] || first[1] !== last[1]) {
+            polyline2.push(first);
+          }
+        }
+      }
+    }
     if (entity.type === "LWPOLYLINE" || entity.type === "POLYLINE") {
       polyline2 = [];
       if (entity.polyfaceMesh) {
@@ -6745,6 +7445,18 @@ var dxf = (() => {
         entity.weights
       );
     }
+    if (entity.type === "SOLID" || entity.type === "TRACE") {
+      const corners = entity.corners ?? entity.points;
+      if (corners && corners.length >= 4) {
+        polyline2 = [
+          [corners[0].x, corners[0].y],
+          [corners[1].x, corners[1].y],
+          [corners[2].x, corners[2].y],
+          [corners[3].x, corners[3].y],
+          [corners[0].x, corners[0].y]
+        ];
+      }
+    }
     if (!polyline2) {
       logger_default.warn("unsupported entity for converting to polyline:", entity.type);
       return [];
@@ -8029,6 +8741,22 @@ var dxf = (() => {
     });
     return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? []);
   };
+  var shape = (entity) => {
+    const x = entity.insertionPoint?.x ?? 0;
+    const y = entity.insertionPoint?.y ?? 0;
+    const height = entity.size ?? 1;
+    const rotation = entity.rotation ?? 0;
+    const content = entity.name ?? "";
+    const textWidth = content.length * height * 0.6;
+    const bbox0 = new import_vecks5.Box2().expandByPoint({ x, y }).expandByPoint({ x: x + textWidth, y: y + height });
+    const rotationDegrees = rotation * 180 / Math.PI;
+    const element0 = `<text x="${x}" y="${y}" font-size="${height}" transform="rotate(${-rotationDegrees} ${x} ${y}) scale(1,-1) translate(0 ${-2 * y})">${escapeXmlText(content)}</text>`;
+    const { bbox, element } = addFlipXIfApplicable(entity, {
+      bbox: bbox0,
+      element: element0
+    });
+    return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? []);
+  };
   var dimension = (entity, dimStyle, options, viewport) => {
     const result = dimensionToSVG(entity, dimStyle, options, viewport);
     return transformBoundingBoxAndElement(
@@ -8103,18 +8831,30 @@ var dxf = (() => {
         }
       }
       case "LINE":
+      case "RAY":
+      case "XLINE":
       case "POLYLINE": {
         return polyline(entity);
       }
+      case "SOLID":
+      case "TRACE": {
+        return polyline(entity);
+      }
       case "LWPOLYLINE": {
         return lwpolyline(entity);
       }
+      case "WIPEOUT": {
+        return polyline(entity);
+      }
       case "LEADER": {
         return leader(entity);
       }
       case "TOLERANCE": {
         return tolerance(entity);
       }
+      case "SHAPE": {
+        return shape(entity);
+      }
       default:
         logger_default.warn("entity type not supported in SVG rendering:", entity.type);
         return null;
@@ -8156,9 +8896,12 @@ var dxf = (() => {
             acc.bbox.expandByPoint(bbox2.min);
             acc.bbox.expandByPoint(bbox2.max);
           }
-          acc.elements.push(
-            `<g stroke="${rgbToColorAttribute(rgb)}">${element}</g>`
-          );
+          const color = rgbToColorAttribute(rgb);
+          if (entity.type === "SOLID" || entity.type === "TRACE") {
+            acc.elements.push(`<g fill="${color}" stroke="none">${element}</g>`);
+          } else {
+            acc.elements.push(`<g stroke="${color}">${element}</g>`);
+          }
         }
         return acc;
       },
@@ -8238,6 +8981,9 @@ var dxf = (() => {
     toSVG(options) {
       return toSVG(this.parsed, options);
     }
+    toJson(options) {
+      return toJson(this.parsed, options);
+    }
     toPolylines() {
       return toPolylines(this.parsed);
     }