@linkiez/dxf-renew 7.0.0 → 7.2.0

package/dist/dxf.js

@@ -1391,8 +1391,8 @@ var dxf = (() => {
     "node_modules/lodash/_Set.js"(exports, module) {
       var getNative = require_getNative();
       var root = require_root();
-      var Set = getNative(root, "Set");
-      module.exports = Set;
+      var Set2 = getNative(root, "Set");
+      module.exports = Set2;
     }
   });
 
@@ -1412,7 +1412,7 @@ var dxf = (() => {
       var DataView = require_DataView();
       var Map = require_Map();
       var Promise2 = require_Promise();
-      var Set = require_Set();
+      var Set2 = require_Set();
       var WeakMap = require_WeakMap();
       var baseGetTag = require_baseGetTag();
       var toSource = require_toSource();
@@ -1425,10 +1425,10 @@ var dxf = (() => {
       var dataViewCtorString = toSource(DataView);
       var mapCtorString = toSource(Map);
       var promiseCtorString = toSource(Promise2);
-      var setCtorString = toSource(Set);
+      var setCtorString = toSource(Set2);
       var weakMapCtorString = toSource(WeakMap);
       var getTag = baseGetTag;
-      if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+      if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise2 && getTag(Promise2.resolve()) != promiseTag || Set2 && getTag(new Set2()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
         getTag = function(value) {
           var result = baseGetTag(value), Ctor = result == objectTag ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
           if (ctorString) {
@@ -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) {
@@ -3316,9 +3486,75 @@ var dxf = (() => {
   };
   var circle_default = { TYPE: TYPE6, process: process6 };
 
-  // src/handlers/entity/dimension.ts
-  var TYPE7 = "DIMENSION";
+  // src/handlers/entity/dgnUnderlay.ts
+  var TYPE7 = "DGNUNDERLAY";
   var process7 = (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: TYPE7,
+        insertionPoint: { x: 0, y: 0, z: 0 },
+        scale: { x: 1, y: 1, z: 1 },
+        normal: { x: 0, y: 0, z: 1 }
+      }
+    );
+  };
+  var dgnUnderlay_default = { TYPE: TYPE7, process: process7 };
+
+  // src/handlers/entity/dimension.ts
+  var TYPE8 = "DIMENSION";
+  var process8 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -3369,6 +3605,30 @@ var dxf = (() => {
           case 34:
             entity.measureEnd.z = value;
             break;
+          case 15:
+            entity.angleVertex = entity.angleVertex || { x: 0, y: 0, z: 0 };
+            entity.angleVertex.x = value;
+            break;
+          case 25:
+            entity.angleVertex = entity.angleVertex || { x: 0, y: 0, z: 0 };
+            entity.angleVertex.y = value;
+            break;
+          case 35:
+            entity.angleVertex = entity.angleVertex || { x: 0, y: 0, z: 0 };
+            entity.angleVertex.z = value;
+            break;
+          case 16:
+            entity.arcPoint = entity.arcPoint || { x: 0, y: 0, z: 0 };
+            entity.arcPoint.x = value;
+            break;
+          case 26:
+            entity.arcPoint = entity.arcPoint || { x: 0, y: 0, z: 0 };
+            entity.arcPoint.y = value;
+            break;
+          case 36:
+            entity.arcPoint = entity.arcPoint || { x: 0, y: 0, z: 0 };
+            entity.arcPoint.z = value;
+            break;
           case 50:
             entity.rotation = value;
             break;
@@ -3429,7 +3689,7 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE7,
+        type: TYPE8,
         start: { x: 0, y: 0, z: 0 },
         measureStart: { x: 0, y: 0, z: 0 },
         measureEnd: { x: 0, y: 0, z: 0 },
@@ -3477,11 +3737,77 @@ var dxf = (() => {
       userDefinedLocation
     };
   }
-  var dimension_default = { TYPE: TYPE7, process: process7 };
+  var dimension_default = { TYPE: TYPE8, process: process8 };
+
+  // src/handlers/entity/dwfUnderlay.ts
+  var TYPE9 = "DWFUNDERLAY";
+  var process9 = (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: TYPE9,
+        insertionPoint: { x: 0, y: 0, z: 0 },
+        scale: { x: 1, y: 1, z: 1 },
+        normal: { x: 0, y: 0, z: 1 }
+      }
+    );
+  };
+  var dwfUnderlay_default = { TYPE: TYPE9, process: process9 };
 
   // src/handlers/entity/ellipse.ts
-  var TYPE8 = "ELLIPSE";
-  var process8 = (tuples) => {
+  var TYPE10 = "ELLIPSE";
+  var process10 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -3521,14 +3847,14 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE8
+        type: TYPE10
       }
     );
   };
-  var ellipse_default = { TYPE: TYPE8, process: process8 };
+  var ellipse_default = { TYPE: TYPE10, process: process10 };
 
   // src/handlers/entity/hatch.ts
-  var TYPE9 = "HATCH";
+  var TYPE11 = "HATCH";
   var status = "IDLE";
   var drawEntity = {};
   var drawType = 0;
@@ -3536,7 +3862,7 @@ var dxf = (() => {
   var seed = null;
   var loop = { references: [], entities: [] };
   var polyPoint = null;
-  var process9 = (tuples) => {
+  var process11 = (tuples) => {
     status = "IDLE";
     drawEntity = {};
     drawType = 0;
@@ -3745,7 +4071,7 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE9,
+        type: TYPE11,
         elevation: { x: 0, y: 0, z: 0 },
         extrusionDir: { x: 0, y: 0, z: 1 },
         pattern: {
@@ -3775,7 +4101,7 @@ var dxf = (() => {
       }
     );
   };
-  var hatch_default = { TYPE: TYPE9, process: process9 };
+  var hatch_default = { TYPE: TYPE11, process: process11 };
   function createDrawEntity(type) {
     if (isPolyline) return {};
     switch (type) {
@@ -3957,9 +4283,92 @@ var dxf = (() => {
     }
   }
 
+  // src/handlers/entity/image.ts
+  var TYPE12 = "IMAGE";
+  var process12 = (tuples) => {
+    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.pixelSizeX = value;
+            break;
+          case 23:
+            entity.pixelSizeY = value;
+            break;
+          case 340:
+            entity.imageDefHandle = String(value);
+            break;
+          case 360:
+            entity.imageDefReactorHandle = String(value);
+            break;
+          case 70:
+            entity.displayProperties = value;
+            break;
+          case 280:
+            entity.clippingState = value;
+            break;
+          case 281:
+            entity.brightness = value;
+            break;
+          case 282:
+            entity.contrast = value;
+            break;
+          case 283:
+            entity.fade = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE12,
+        insertionPoint: {},
+        uVector: {},
+        vVector: {},
+        pixelSizeX: 0,
+        pixelSizeY: 0
+      }
+    );
+  };
+  var image_default = { TYPE: TYPE12, process: process12 };
+
   // src/handlers/entity/insert.ts
-  var TYPE10 = "INSERT";
-  var process10 = (tuples) => {
+  var TYPE13 = "INSERT";
+  var process13 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4017,36 +4426,144 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE10
+        type: TYPE13
       }
     );
   };
-  var insert_default = { TYPE: TYPE10, process: process10 };
+  var insert_default = { TYPE: TYPE13, process: process13 };
 
-  // src/handlers/entity/line.ts
-  var TYPE11 = "LINE";
-  var process11 = (tuples) => {
+  // src/handlers/entity/leader.ts
+  var TYPE14 = "LEADER";
+  function ensureVector3(entity, key) {
+    if (!entity[key]) entity[key] = { x: 0, y: 0, z: 0 };
+    return entity[key];
+  }
+  var process14 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
         const value = tuple[1];
         switch (type) {
-          case 10:
-            entity.start.x = value;
+          case 3:
+            entity.dimensionStyleName = String(value);
             break;
-          case 20:
-            entity.start.y = value;
+          case 71:
+            entity.arrowheadFlag = value;
             break;
-          case 30:
-            entity.start.z = value;
+          case 72:
+            entity.pathType = value;
             break;
-          case 39:
-            entity.thickness = value;
+          case 73:
+            entity.creationFlag = value;
             break;
-          case 11:
-            entity.end.x = value;
+          case 74:
+            entity.hooklineDirectionFlag = value;
             break;
-          case 21:
+          case 75:
+            entity.hooklineFlag = value;
+            break;
+          case 40:
+            entity.textHeight = value;
+            break;
+          case 41:
+            entity.textWidth = value;
+            break;
+          case 76:
+            entity.vertexCount = value;
+            break;
+          case 10:
+            entity.vertices.push({ x: value, y: 0, z: 0 });
+            break;
+          case 20: {
+            const current = entity.vertices[entity.vertices.length - 1];
+            if (current) current.y = value;
+            break;
+          }
+          case 30: {
+            const current = entity.vertices[entity.vertices.length - 1];
+            if (current) current.z = value;
+            break;
+          }
+          case 77:
+            entity.color = value;
+            break;
+          case 340:
+            entity.annotationHandle = String(value);
+            break;
+          case 210:
+            ensureVector3(entity, "normal").x = value;
+            break;
+          case 220:
+            ensureVector3(entity, "normal").y = value;
+            break;
+          case 230:
+            ensureVector3(entity, "normal").z = value;
+            break;
+          case 211:
+            ensureVector3(entity, "horizontalDirection").x = value;
+            break;
+          case 221:
+            ensureVector3(entity, "horizontalDirection").y = value;
+            break;
+          case 231:
+            ensureVector3(entity, "horizontalDirection").z = value;
+            break;
+          case 212:
+            ensureVector3(entity, "blockOffset").x = value;
+            break;
+          case 222:
+            ensureVector3(entity, "blockOffset").y = value;
+            break;
+          case 232:
+            ensureVector3(entity, "blockOffset").z = value;
+            break;
+          case 213:
+            ensureVector3(entity, "annotationOffset").x = value;
+            break;
+          case 223:
+            ensureVector3(entity, "annotationOffset").y = value;
+            break;
+          case 233:
+            ensureVector3(entity, "annotationOffset").z = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE14,
+        vertices: []
+      }
+    );
+  };
+  var leader_default = { TYPE: TYPE14, process: process14 };
+
+  // src/handlers/entity/line.ts
+  var TYPE15 = "LINE";
+  var process15 = (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 39:
+            entity.thickness = value;
+            break;
+          case 11:
+            entity.end.x = value;
+            break;
+          case 21:
             entity.end.y = value;
             break;
           case 31:
@@ -4059,17 +4576,17 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE11,
+        type: TYPE15,
         start: {},
         end: {}
       }
     );
   };
-  var line_default = { TYPE: TYPE11, process: process11 };
+  var line_default = { TYPE: TYPE15, process: process15 };
 
   // src/handlers/entity/lwpolyline.ts
-  var TYPE12 = "LWPOLYLINE";
-  var process12 = (tuples) => {
+  var TYPE16 = "LWPOLYLINE";
+  var process16 = (tuples) => {
     let vertex;
     return tuples.reduce(
       (entity, tuple) => {
@@ -4102,16 +4619,96 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE12,
+        type: TYPE16,
         vertices: []
       }
     );
   };
-  var lwpolyline_default = { TYPE: TYPE12, process: process12 };
+  var lwpolyline_default = { TYPE: TYPE16, process: process16 };
+
+  // src/handlers/entity/mleader.ts
+  var TYPE17 = "MLEADER";
+  var process17 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        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 TYPE13 = "OLE2FRAME";
-  var process13 = (tuples) => {
+  var TYPE19 = "OLE2FRAME";
+  var process19 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4160,16 +4757,140 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE13,
+        type: TYPE19,
         data: ""
       }
     );
   };
-  var ole2Frame_default = { TYPE: TYPE13, process: process13 };
+  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 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 TYPE14 = "POINT";
-  var process14 = (tuples) => {
+  var TYPE22 = "POINT";
+  var process22 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4194,15 +4915,15 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE14
+        type: TYPE22
       }
     );
   };
-  var point_default = { TYPE: TYPE14, process: process14 };
+  var point_default = { TYPE: TYPE22, process: process22 };
 
   // src/handlers/entity/polyline.ts
-  var TYPE15 = "POLYLINE";
-  var process15 = (tuples) => {
+  var TYPE23 = "POLYLINE";
+  var process23 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4223,16 +4944,139 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE15,
+        type: TYPE23,
         vertices: []
       }
     );
   };
-  var polyline_default = { TYPE: TYPE15, process: process15 };
+  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));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE26,
+        insertionPoint: {}
+      }
+    );
+  };
+  var shape_default = { TYPE: TYPE26, process: process26 };
 
   // src/handlers/entity/solid.ts
-  var TYPE16 = "SOLID";
-  var process16 = (tuples) => {
+  var TYPE27 = "SOLID";
+  var process27 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4284,16 +5128,16 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE16,
+        type: TYPE27,
         corners: [{}, {}, {}, {}]
       }
     );
   };
-  var solid_default = { TYPE: TYPE16, process: process16 };
+  var solid_default = { TYPE: TYPE27, process: process27 };
 
   // src/handlers/entity/spline.ts
-  var TYPE17 = "SPLINE";
-  var process17 = (tuples) => {
+  var TYPE28 = "SPLINE";
+  var process28 = (tuples) => {
     let controlPoint;
     return tuples.reduce(
       (entity, tuple) => {
@@ -4352,17 +5196,48 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE17,
+        type: TYPE28,
         controlPoints: [],
         knots: []
       }
     );
   };
-  var spline_default = { TYPE: TYPE17, process: process17 };
+  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 TYPE18 = "3DFACE";
-  var process18 = (tuples) => {
+  var TYPE30 = "3DFACE";
+  var process30 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4372,37 +5247,148 @@ var dxf = (() => {
             entity.vertices[0].x = value;
             break;
           case 20:
-            entity.vertices[0].y = value;
+            entity.vertices[0].y = value;
+            break;
+          case 30:
+            entity.vertices[0].z = value;
+            break;
+          case 11:
+            entity.vertices[1].x = value;
+            break;
+          case 21:
+            entity.vertices[1].y = value;
+            break;
+          case 31:
+            entity.vertices[1].z = value;
+            break;
+          case 12:
+            entity.vertices[2].x = value;
+            break;
+          case 22:
+            entity.vertices[2].y = value;
+            break;
+          case 32:
+            entity.vertices[2].z = value;
+            break;
+          case 13:
+            entity.vertices[3].x = value;
+            break;
+          case 23:
+            entity.vertices[3].y = value;
+            break;
+          case 33:
+            entity.vertices[3].z = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(type, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE30,
+        vertices: [{}, {}, {}, {}]
+      }
+    );
+  };
+  var threeDFace_default = { TYPE: TYPE30, process: process30 };
+
+  // src/handlers/entity/tolerance.ts
+  var TYPE31 = "TOLERANCE";
+  function ensureVector32(entity, key) {
+    entity[key] ??= { x: 0, y: 0, z: 0 };
+    return entity[key];
+  }
+  var process31 = (tuples) => {
+    return tuples.reduce(
+      (entity, tuple) => {
+        const code = tuple[0];
+        const value = tuple[1];
+        switch (code) {
+          case 3:
+            entity.dimensionStyleName = String(value);
+            break;
+          case 10:
+            ensureVector32(entity, "insertionPoint").x = value;
+            break;
+          case 20:
+            ensureVector32(entity, "insertionPoint").y = value;
+            break;
+          case 30:
+            ensureVector32(entity, "insertionPoint").z = value;
+            break;
+          case 1:
+            entity.text = String(value);
+            break;
+          case 11:
+            ensureVector32(entity, "xAxisDirection").x = value;
+            break;
+          case 21:
+            ensureVector32(entity, "xAxisDirection").y = value;
+            break;
+          case 31:
+            ensureVector32(entity, "xAxisDirection").z = value;
+            break;
+          default:
+            Object.assign(entity, parseCommonEntityProperties(code, value));
+            break;
+        }
+        return entity;
+      },
+      {
+        type: TYPE31,
+        insertionPoint: { x: 0, y: 0, z: 0 }
+      }
+    );
+  };
+  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.vertices[0].z = value;
+            entity.corners[0].z = value;
             break;
           case 11:
-            entity.vertices[1].x = value;
+            entity.corners[1].x = value;
             break;
           case 21:
-            entity.vertices[1].y = value;
+            entity.corners[1].y = value;
             break;
           case 31:
-            entity.vertices[1].z = value;
+            entity.corners[1].z = value;
             break;
           case 12:
-            entity.vertices[2].x = value;
+            entity.corners[2].x = value;
             break;
           case 22:
-            entity.vertices[2].y = value;
+            entity.corners[2].y = value;
             break;
           case 32:
-            entity.vertices[2].z = value;
+            entity.corners[2].z = value;
             break;
           case 13:
-            entity.vertices[3].x = value;
+            entity.corners[3].x = value;
             break;
           case 23:
-            entity.vertices[3].y = value;
+            entity.corners[3].y = value;
             break;
           case 33:
-            entity.vertices[3].z = value;
+            entity.corners[3].z = value;
+            break;
+          case 39:
+            entity.thickness = value;
             break;
           default:
             Object.assign(entity, parseCommonEntityProperties(type, value));
@@ -4411,22 +5397,22 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE18,
-        vertices: [{}, {}, {}, {}]
+        type: TYPE32,
+        corners: [{}, {}, {}, {}]
       }
     );
   };
-  var threeDFace_default = { TYPE: TYPE18, process: process18 };
+  var trace_default = { TYPE: TYPE32, process: process32 };
 
   // src/handlers/entity/vertex.ts
-  var TYPE19 = "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 process19 = (tuples) => {
+  var process33 = (tuples) => {
     return tuples.reduce((entity, tuple) => {
       const type = tuple[0];
       const value = tuple[1];
@@ -4465,11 +5451,11 @@ var dxf = (() => {
       return entity;
     }, {});
   };
-  var vertex_default = { TYPE: TYPE19, process: process19 };
+  var vertex_default = { TYPE: TYPE33, process: process33 };
 
   // src/handlers/entity/viewport.ts
-  var TYPE20 = "VIEWPORT";
-  var process20 = (tuples) => {
+  var TYPE34 = "VIEWPORT";
+  var process34 = (tuples) => {
     return tuples.reduce(
       (entity, tuple) => {
         const type = tuple[0];
@@ -4567,7 +5553,7 @@ var dxf = (() => {
         return entity;
       },
       {
-        type: TYPE20,
+        type: TYPE34,
         center: {},
         centerDCS: {},
         snap: {},
@@ -4578,22 +5564,158 @@ var dxf = (() => {
       }
     );
   };
-  var viewport_default = { TYPE: TYPE20, process: process20 };
+  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,
     attrib_default,
     text_default,
@@ -4601,13 +5723,92 @@ 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;
   }, {});
+  var EntityGroupProcessor = class {
+    constructor() {
+      this.entities = [];
+    }
+    getEntities() {
+      return this.entities;
+    }
+    finalize() {
+      this.flushOpenPolyline("DXF ended with an open POLYLINE (missing SEQEND); flushing open polyline");
+    }
+    processGroup(tuples) {
+      const entityType = String(tuples[0][1]);
+      const contentTuples = tuples.slice(1);
+      switch (entityType) {
+        case "SEQEND":
+          this.endSequence();
+          break;
+        case "POLYLINE":
+          this.startPolyline(contentTuples);
+          break;
+        case "VERTEX":
+          this.addVertex(contentTuples);
+          break;
+        default:
+          this.addEntity(entityType, contentTuples);
+          break;
+      }
+    }
+    parseEntity(entityType, contentTuples) {
+      const handler = handlers[entityType];
+      if (!handler) {
+        logger_default.warn("unsupported type in ENTITIES section:", entityType);
+        return void 0;
+      }
+      return handler.process(contentTuples);
+    }
+    flushOpenPolyline(reason) {
+      if (!this.currentPolyline) return;
+      logger_default.warn(reason);
+      this.currentPolyline = void 0;
+    }
+    endSequence() {
+      this.currentPolyline = void 0;
+    }
+    startPolyline(contentTuples) {
+      this.flushOpenPolyline(
+        "POLYLINE started while previous POLYLINE is still open; flushing previous polyline"
+      );
+      const e = this.parseEntity("POLYLINE", contentTuples);
+      if (!e) return;
+      this.currentPolyline = e;
+      this.entities.push(e);
+    }
+    addVertex(contentTuples) {
+      const e = this.parseEntity("VERTEX", contentTuples);
+      if (!e) return;
+      if (!this.currentPolyline) {
+        logger_default.error("ignoring invalid VERTEX entity");
+        return;
+      }
+      this.currentPolyline.vertices.push(e);
+    }
+    addEntity(entityType, contentTuples) {
+      this.flushOpenPolyline("POLYLINE sequence ended without SEQEND; flushing open polyline");
+      const e = this.parseEntity(entityType, contentTuples);
+      if (!e) return;
+      this.entities.push(e);
+    }
+  };
+  function processEntityGroups(entityGroups) {
+    const processor = new EntityGroupProcessor();
+    for (const tuples of entityGroups) {
+      processor.processGroup(tuples);
+    }
+    processor.finalize();
+    return processor.getEntities();
+  }
   function parseEntities(tuples) {
-    const entities = [];
     const entityGroups = [];
     let currentEntityTuples = [];
     for (const tuple of tuples) {
@@ -4618,31 +5819,7 @@ var dxf = (() => {
       }
       currentEntityTuples.push(tuple);
     }
-    let currentPolyline;
-    for (const tuples2 of entityGroups) {
-      const entityType = tuples2[0][1];
-      const contentTuples = tuples2.slice(1);
-      if (entityType in handlers) {
-        const e = handlers[entityType].process(contentTuples);
-        if (entityType === "POLYLINE") {
-          currentPolyline = e;
-          entities.push(e);
-        } else if (entityType === "VERTEX") {
-          if (currentPolyline) {
-            currentPolyline.vertices.push(e);
-          } else {
-            logger_default.error("ignoring invalid VERTEX entity");
-          }
-        } else if (entityType === "SEQEND") {
-          currentPolyline = void 0;
-        } else {
-          entities.push(e);
-        }
-      } else {
-        logger_default.warn("unsupported type in ENTITIES section:", entityType);
-      }
-    }
-    return entities;
+    return processEntityGroups(entityGroups);
   }
 
   // src/handlers/blocks.ts
@@ -4776,150 +5953,313 @@ var dxf = (() => {
   }
 
   // src/handlers/objects.ts
-  function parseObjects(tuples) {
-    let state;
-    const objects = {
-      layouts: []
-    };
-    let layout;
+  function groupObjectsByZero(tuples) {
+    const groups = [];
+    let current;
     for (const tuple of tuples) {
+      const code = tuple[0];
+      if (code === 0) {
+        if (current && current.length > 0) groups.push(current);
+        current = [tuple];
+        continue;
+      }
+      if (!current) continue;
+      current.push(tuple);
+    }
+    if (current && current.length > 0) groups.push(current);
+    return groups;
+  }
+  var LAYOUT_FLOAT_FIELDS = {
+    10: "minLimitX",
+    20: "minLimitY",
+    11: "maxLimitX",
+    21: "maxLimitY",
+    12: "x",
+    22: "y",
+    32: "z",
+    14: "minX",
+    24: "minY",
+    34: "minZ",
+    15: "maxX",
+    25: "maxY",
+    35: "maxZ",
+    146: "elevation",
+    13: "ucsX",
+    23: "ucsY",
+    33: "ucsZ",
+    16: "ucsXaxisX",
+    26: "ucsXaxisY",
+    36: "ucsXaxisZ",
+    17: "ucsYaxisX",
+    27: "ucsYaxisY",
+    37: "ucsYaxisZ"
+  };
+  var LAYOUT_DIRECT_FIELDS = {
+    1: "name",
+    5: "handle",
+    71: "tabOrder",
+    330: "tableRecord",
+    331: "lastActiveViewport",
+    333: "shadePlot"
+  };
+  var LAYOUT_UCS_TYPE = {
+    0: "NOT ORTHOGRAPHIC",
+    1: "TOP",
+    2: "BOTTOM",
+    3: "FRONT",
+    4: "BACK",
+    5: "LEFT",
+    6: "RIGHT"
+  };
+  function consumeLayoutStartTuple(current, tuple) {
+    if (tuple[1] === "LAYOUT") return { state: "layout", layout: {} };
+    return { state: "IDLE", layout: current.layout };
+  }
+  function consumeLayoutSubclassTuple(current, tuple) {
+    if (tuple[0] === 100 && tuple[1] === "AcDbLayout") return { state: "AcDbLayout", layout: current.layout };
+    return current;
+  }
+  function applyLayoutFieldTuple(layout, tuple) {
+    const type = tuple[0];
+    const value = tuple[1];
+    const floatKey = LAYOUT_FLOAT_FIELDS[type];
+    if (floatKey) {
+      ;
+      layout[floatKey] = Number.parseFloat(String(value));
+      return;
+    }
+    const directKey = LAYOUT_DIRECT_FIELDS[type];
+    if (directKey) {
+      ;
+      layout[directKey] = value;
+      return;
+    }
+    if (type === 70) {
+      layout.flag = value === 1 ? "PSLTSCALE" : "LIMCHECK";
+      return;
+    }
+    if (type === 76) {
+      const ucsType = LAYOUT_UCS_TYPE[Number(value)];
+      if (ucsType) layout.ucsType = ucsType;
+    }
+  }
+  function consumeLayoutTuple(current, tuple) {
+    if (tuple[0] === 0) return consumeLayoutStartTuple(current, tuple);
+    if (current.state === "layout") return consumeLayoutSubclassTuple(current, tuple);
+    if (current.state === "AcDbLayout" && current.layout) applyLayoutFieldTuple(current.layout, tuple);
+    return current;
+  }
+  function parseLayoutObject(group) {
+    let current = { state: "IDLE" };
+    for (const tuple of group) current = consumeLayoutTuple(current, tuple);
+    return current.layout;
+  }
+  function parseDictionaryObject(group) {
+    if (group[0]?.[1] !== "DICTIONARY") return void 0;
+    const dict = {
+      type: "DICTIONARY",
+      entries: {}
+    };
+    let pendingKey;
+    for (const tuple of group.slice(1)) {
       const type = tuple[0];
       const value = tuple[1];
-      if (type === 0) {
-        state = "IDLE";
+      if (type === 5) {
+        dict.handle = value;
+        continue;
       }
-      if (value === "LAYOUT") {
-        state = "layout";
-        layout = {};
-        objects.layouts.push(layout);
+      if (type === 330) {
+        dict.ownerHandle = value;
+        continue;
       }
-      if (state === "layout" && type !== 0) {
-        switch (type) {
-          case 100:
-            if (value === "AcDbLayout") state = "AcDbLayout";
-            break;
-        }
+      if (type === 3) {
+        pendingKey = String(value);
+        continue;
       }
-      if (state === "AcDbLayout" && type !== 0 && layout) {
-        switch (type) {
-          case 1:
-            layout.name = value;
-            break;
-          case 5:
-            layout.handle = value;
-            break;
-          case 10:
-            layout.minLimitX = Number.parseFloat(String(value));
-            break;
-          case 20:
-            layout.minLimitY = Number.parseFloat(String(value));
-            break;
-          case 11:
-            layout.maxLimitX = Number.parseFloat(String(value));
-            break;
-          case 21:
-            layout.maxLimitY = Number.parseFloat(String(value));
-            break;
-          case 12:
-            layout.x = Number.parseFloat(String(value));
-            break;
-          case 22:
-            layout.y = Number.parseFloat(String(value));
-            break;
-          case 32:
-            layout.z = Number.parseFloat(String(value));
-            break;
-          case 14:
-            layout.minX = Number.parseFloat(String(value));
-            break;
-          case 24:
-            layout.minY = Number.parseFloat(String(value));
-            break;
-          case 34:
-            layout.minZ = Number.parseFloat(String(value));
-            break;
-          case 15:
-            layout.maxX = Number.parseFloat(String(value));
-            break;
-          case 25:
-            layout.maxY = Number.parseFloat(String(value));
-            break;
-          case 35:
-            layout.maxZ = Number.parseFloat(String(value));
-            break;
-          case 70:
-            layout.flag = value === 1 ? "PSLTSCALE" : "LIMCHECK";
-            break;
-          case 71:
-            layout.tabOrder = value;
-            break;
-          case 146:
-            layout.elevation = Number.parseFloat(String(value));
-            break;
-          case 13:
-            layout.ucsX = Number.parseFloat(String(value));
-            break;
-          case 23:
-            layout.ucsY = Number.parseFloat(String(value));
-            break;
-          case 33:
-            layout.ucsZ = Number.parseFloat(String(value));
-            break;
-          case 16:
-            layout.ucsXaxisX = Number.parseFloat(String(value));
-            break;
-          case 26:
-            layout.ucsXaxisY = Number.parseFloat(String(value));
-            break;
-          case 36:
-            layout.ucsXaxisZ = Number.parseFloat(String(value));
-            break;
-          case 17:
-            layout.ucsYaxisX = Number.parseFloat(String(value));
-            break;
-          case 27:
-            layout.ucsYaxisY = Number.parseFloat(String(value));
-            break;
-          case 37:
-            layout.ucsYaxisZ = Number.parseFloat(String(value));
-            break;
-          case 76:
-            switch (value) {
-              case 0:
-                layout.ucsType = "NOT ORTHOGRAPHIC";
-                break;
-              case 1:
-                layout.ucsType = "TOP";
-                break;
-              case 2:
-                layout.ucsType = "BOTTOM";
-                break;
-              case 3:
-                layout.ucsType = "FRONT";
-                break;
-              case 4:
-                layout.ucsType = "BACK";
-                break;
-              case 5:
-                layout.ucsType = "LEFT";
-                break;
-              case 6:
-                layout.ucsType = "RIGHT";
-                break;
-            }
-            break;
-          case 330:
-            layout.tableRecord = value;
-            break;
-          case 331:
-            layout.lastActiveViewport = value;
-            break;
-          case 333:
-            layout.shadePlot = value;
-            break;
-        }
+      if ((type === 350 || type === 360) && pendingKey) {
+        dict.entries[pendingKey] = String(value);
+        pendingKey = void 0;
       }
     }
+    return dict;
+  }
+  function parseXRecordObject(group) {
+    if (group[0]?.[1] !== "XRECORD") return void 0;
+    const tuples = group.slice(1);
+    const xRecord = {
+      type: "XRECORD",
+      tuples
+    };
+    for (const tuple of tuples) {
+      const type = tuple[0];
+      const value = tuple[1];
+      if (type === 5) xRecord.handle = value;
+      if (type === 330) xRecord.ownerHandle = value;
+    }
+    return xRecord;
+  }
+  function parseImageDefObject(group) {
+    if (group[0]?.[1] !== "IMAGEDEF") return void 0;
+    const tuples = group.slice(1);
+    const imageDef = {
+      type: "IMAGEDEF",
+      tuples
+    };
+    for (const tuple of tuples) {
+      const type = tuple[0];
+      const value = tuple[1];
+      if (type === 5) imageDef.handle = value;
+      if (type === 330 && imageDef.ownerHandle === void 0) imageDef.ownerHandle = value;
+      if (type === 1) imageDef.fileName = String(value);
+      if (type === 10) imageDef.pixelSizeX = Number(value);
+      if (type === 20) imageDef.pixelSizeY = Number(value);
+    }
+    return imageDef;
+  }
+  function parseImageDefReactorObject(group) {
+    if (group[0]?.[1] !== "IMAGEDEF_REACTOR") return void 0;
+    const tuples = group.slice(1);
+    const reactor = {
+      type: "IMAGEDEF_REACTOR",
+      tuples
+    };
+    for (const tuple of tuples) {
+      const type = tuple[0];
+      const value = tuple[1];
+      if (type === 5) reactor.handle = value;
+      if (type === 330) reactor.imageHandle = value;
+    }
+    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",
+    "DWFDEFINITION",
+    "DGNDEFINITION"
+  ]);
+  function parseUnderlayDefinitionObject(group) {
+    const objectType = group[0]?.[1];
+    if (typeof objectType !== "string") return void 0;
+    if (!UNDERLAY_DEFINITION_OBJECT_TYPES.has(objectType)) return void 0;
+    const tuples = group.slice(1);
+    const def = {
+      type: objectType,
+      tuples
+    };
+    for (const tuple of tuples) {
+      const type = tuple[0];
+      const value = tuple[1];
+      if (type === 5) def.handle = value;
+      if (type === 330 && def.ownerHandle === void 0) def.ownerHandle = value;
+      if (type === 1) def.fileName = String(value);
+      if (type === 2) def.underlayName = String(value);
+    }
+    return def;
+  }
+  var OBJECT_GROUP_HANDLERS = {
+    LAYOUT: (objects, group) => {
+      const layout = parseLayoutObject(group);
+      if (layout) objects.layouts.push(layout);
+    },
+    DICTIONARY: (objects, group) => {
+      const dict = parseDictionaryObject(group);
+      const handle = dict?.handle ? String(dict.handle) : void 0;
+      if (dict && handle) objects.dictionaries[handle] = dict;
+    },
+    XRECORD: (objects, group) => {
+      const xRecord = parseXRecordObject(group);
+      const handle = xRecord?.handle ? String(xRecord.handle) : void 0;
+      if (xRecord && handle) objects.xRecords[handle] = xRecord;
+    },
+    IMAGEDEF: (objects, group) => {
+      const imageDef = parseImageDefObject(group);
+      const handle = imageDef?.handle ? String(imageDef.handle) : void 0;
+      if (imageDef && handle) objects.imageDefs[handle] = imageDef;
+    },
+    IMAGEDEF_REACTOR: (objects, group) => {
+      const reactor = parseImageDefReactorObject(group);
+      const handle = reactor?.handle ? String(reactor.handle) : void 0;
+      if (reactor && handle) objects.imageDefReactors[handle] = reactor;
+    },
+    UNDERLAYDEFINITION: (objects, group) => {
+      const def = parseUnderlayDefinitionObject(group);
+      const handle = def?.handle ? String(def.handle) : void 0;
+      if (def && handle) objects.underlayDefinitions[handle] = def;
+    },
+    PDFDEFINITION: (objects, group) => {
+      const def = parseUnderlayDefinitionObject(group);
+      const handle = def?.handle ? String(def.handle) : void 0;
+      if (def && handle) objects.underlayDefinitions[handle] = def;
+    },
+    DWFDEFINITION: (objects, group) => {
+      const def = parseUnderlayDefinitionObject(group);
+      const handle = def?.handle ? String(def.handle) : void 0;
+      if (def && handle) objects.underlayDefinitions[handle] = def;
+    },
+    DGNDEFINITION: (objects, group) => {
+      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) {
+    const objects = {
+      layouts: [],
+      dictionaries: {},
+      xRecords: {},
+      imageDefs: {},
+      imageDefReactors: {},
+      underlayDefinitions: {},
+      dimAssocs: {},
+      fields: {}
+    };
+    const groups = groupObjectsByZero(tuples);
+    for (const group of groups) {
+      const objectType = group[0]?.[1];
+      if (typeof objectType !== "string") continue;
+      const handler = OBJECT_GROUP_HANDLERS[objectType];
+      if (handler) handler(objects, group);
+    }
     return objects;
   }
 
@@ -5081,6 +6421,7 @@ var dxf = (() => {
         const type = tuple[0];
         const value = tuple[1];
         switch (type) {
+          // NOSONAR
           case 2:
             vport.name = value;
             break;
@@ -5194,12 +6535,89 @@ var dxf = (() => {
       }
     );
   };
+  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;
+          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 70:
+            ucs.flags = value;
+            break;
+          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 70:
+            view.flags = value;
+            break;
+          default:
+        }
+        return view;
+      },
+      { type: "VIEW" }
+    );
+  };
   var dimStyleHandler = (tuples) => {
     return tuples.reduce(
       (dimStyle, tuple) => {
         const type = tuple[0];
         const value = tuple[1];
         switch (type) {
+          // NOSONAR
           case 2:
             dimStyle.name = value;
             break;
@@ -5450,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)
     };
   }
 
@@ -5557,131 +6976,11 @@ var dxf = (() => {
     return result;
   }
 
-  // src/denormalise.ts
-  var import_cloneDeep = __toESM(require_cloneDeep(), 1);
-  function denormalise(parseResult) {
-    const blocksByName = parseResult.blocks.reduce(
-      (acc, b) => {
-        acc[b.name] = b;
-        return acc;
-      },
-      {}
-    );
-    const gatherEntities = (entities, transforms) => {
-      let current = [];
-      for (const e of entities) {
-        if (e.type === "INSERT") {
-          const insert = e;
-          const block = blocksByName[insert.block];
-          if (!block) {
-            logger_default.error("no block found for insert. block:", insert.block);
-            continue;
-          }
-          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;
-          let rowVec;
-          let colVec;
-          if (rowCount > 1 || columnCount > 1) {
-            const cos = Math.cos(rotation * Math.PI / 180);
-            const sin = Math.sin(rotation * Math.PI / 180);
-            rowVec = { x: -sin * rowSpacing, y: cos * rowSpacing };
-            colVec = { x: cos * columnSpacing, y: sin * columnSpacing };
-          } else {
-            rowVec = { x: 0, y: 0 };
-            colVec = { x: 0, y: 0 };
-          }
-          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;
-                switch (be2.type) {
-                  case "LINE": {
-                    const line = be2;
-                    line.start.x -= block.x;
-                    line.start.y -= block.y;
-                    line.end.x -= block.x;
-                    line.end.y -= block.y;
-                    break;
-                  }
-                  case "LWPOLYLINE":
-                  case "POLYLINE": {
-                    const poly = be2;
-                    for (const v of poly.vertices) {
-                      if (v.x !== void 0) v.x -= block.x;
-                      if (v.y !== void 0) v.y -= block.y;
-                    }
-                    break;
-                  }
-                  case "CIRCLE": {
-                    const circle2 = be2;
-                    circle2.x -= block.x;
-                    circle2.y -= block.y;
-                    break;
-                  }
-                  case "ELLIPSE": {
-                    const ellipse2 = be2;
-                    ellipse2.x -= block.x;
-                    ellipse2.y -= block.y;
-                    break;
-                  }
-                  case "ARC": {
-                    const arc2 = be2;
-                    arc2.x -= block.x;
-                    arc2.y -= block.y;
-                    break;
-                  }
-                  case "SPLINE": {
-                    const spline = be2;
-                    for (const cp of spline.controlPoints) {
-                      cp.x -= block.x;
-                      cp.y -= block.y;
-                    }
-                    break;
-                  }
-                }
-                return be2;
-              });
-              current = current.concat(gatherEntities(blockEntities, transforms2));
-            }
-          }
-        } 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
@@ -5973,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) {
@@ -6063,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 [];
@@ -6367,6 +7761,173 @@ var dxf = (() => {
 
   // src/dimensionToSVG.ts
   var import_vecks3 = __toESM(require_lib(), 1);
+
+  // src/util/escapeXmlText.ts
+  function escapeXmlText(value) {
+    return value.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;").split('"').join("&quot;").split("'").join("&apos;");
+  }
+
+  // src/dimensionToSVG.ts
+  var DEFAULT_DIMENSION_DECIMALS = 2;
+  var AUTOSCALE_VIEWPORT_REFERENCE = 40;
+  var computeViewportAutoScaleFactor = (viewport, options) => {
+    const viewportMin = Math.min(Math.abs(viewport.width), Math.abs(viewport.height));
+    if (!Number.isFinite(viewportMin) || viewportMin <= 0) return 1;
+    const reference = options?.dimension?.autoScaleViewportReference;
+    const safeReference = Number.isFinite(reference) && (reference ?? 0) > 0 ? reference : AUTOSCALE_VIEWPORT_REFERENCE;
+    return viewportMin / safeReference;
+  };
+  var getViewportMin = (viewport) => {
+    const viewportMin = Math.min(Math.abs(viewport.width), Math.abs(viewport.height));
+    return Number.isFinite(viewportMin) ? viewportMin : Number.NaN;
+  };
+  var getViewportPercentageSize = (viewport, percent) => {
+    if (!Number.isFinite(percent) || (percent ?? 0) <= 0) return void 0;
+    const viewportMin = getViewportMin(viewport);
+    if (!Number.isFinite(viewportMin) || viewportMin <= 0) return void 0;
+    return viewportMin * (percent / 100);
+  };
+  var getDimensionGeometryBBox = (entity) => {
+    const bbox = new import_vecks3.Box2();
+    const points = [
+      entity.start,
+      entity.angleVertex,
+      entity.arcPoint,
+      entity.textMidpoint,
+      entity.measureStart,
+      entity.measureEnd
+    ];
+    for (const p of points) {
+      if (!p) continue;
+      const x = p.x;
+      const y = p.y;
+      if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
+      bbox.expandByPoint({ x, y });
+    }
+    return bbox;
+  };
+  var getScaledDimensionSizes = (dimStyle, options, viewport) => {
+    const autoScale = options?.dimension?.autoScale === true;
+    const baseArrowSize = dimStyle?.dimAsz ?? 2.5;
+    const baseTextHeight = dimStyle?.dimTxt ?? 2.5;
+    const baseExtLineOffset = dimStyle?.dimExo ?? 0.625;
+    const baseExtLineExtension = dimStyle?.dimExe ?? 1.25;
+    if (!autoScale || !viewport) {
+      return {
+        arrowSize: baseArrowSize,
+        textHeight: baseTextHeight,
+        extLineOffset: baseExtLineOffset,
+        extLineExtension: baseExtLineExtension
+      };
+    }
+    const scale = computeViewportAutoScaleFactor(viewport, options);
+    const perc = options?.dimension?.autoScaleViewportPercentages;
+    const arrowFromPct = getViewportPercentageSize(viewport, perc?.arrowSize);
+    const textFromPct = getViewportPercentageSize(viewport, perc?.textHeight);
+    const offsetFromPct = getViewportPercentageSize(viewport, perc?.extLineOffset);
+    const extensionFromPct = getViewportPercentageSize(viewport, perc?.extLineExtension);
+    return {
+      arrowSize: arrowFromPct ?? baseArrowSize * scale,
+      textHeight: textFromPct ?? baseTextHeight * scale,
+      extLineOffset: offsetFromPct ?? baseExtLineOffset * scale,
+      extLineExtension: extensionFromPct ?? baseExtLineExtension * scale
+    };
+  };
+  var formatDimensionValue = (value, decimals = DEFAULT_DIMENSION_DECIMALS) => {
+    if (!Number.isFinite(value)) return "";
+    const rounded = round10(value, -decimals);
+    return rounded.toFixed(decimals);
+  };
+  var computeRadiusFallback = (entity) => {
+    const cx = entity.start?.x ?? 0;
+    const cy = entity.start?.y ?? 0;
+    const x1 = entity.measureStart?.x ?? 0;
+    const y1 = entity.measureStart?.y ?? 0;
+    const x2 = entity.measureEnd?.x ?? 0;
+    const y2 = entity.measureEnd?.y ?? 0;
+    const r1 = Math.hypot(x1 - cx, y1 - cy);
+    const r2 = Math.hypot(x2 - cx, y2 - cy);
+    const chord = Math.hypot(x2 - x1, y2 - y1);
+    return Math.max(r1, r2, chord);
+  };
+  var computeLinearDistance = (x1, y1, x2, y2) => Math.hypot(x2 - x1, y2 - y1);
+  var computeAngularDegreesMinimal = (cx, cy, x1, y1, x2, y2) => {
+    const a1 = Math.atan2(y1 - cy, x1 - cx);
+    const a2 = Math.atan2(y2 - cy, x2 - cx);
+    let delta = Math.abs(a2 - a1);
+    while (delta > Math.PI * 2) delta -= Math.PI * 2;
+    if (delta > Math.PI) delta = Math.PI * 2 - delta;
+    return delta * 180 / Math.PI;
+  };
+  var computeAngularDegreesCCW = (cx, cy, x1, y1, x2, y2) => {
+    const a1 = Math.atan2(y1 - cy, x1 - cx);
+    const a2 = Math.atan2(y2 - cy, x2 - cx);
+    let delta = a2 - a1;
+    while (delta < 0) delta += Math.PI * 2;
+    while (delta >= Math.PI * 2) delta -= Math.PI * 2;
+    return delta * 180 / Math.PI;
+  };
+  var computeDimensionMeasurement = (entity) => {
+    const x1 = entity.measureStart?.x ?? 0;
+    const y1 = entity.measureStart?.y ?? 0;
+    const x2 = entity.measureEnd?.x ?? 0;
+    const y2 = entity.measureEnd?.y ?? 0;
+    switch (entity.dimensionType) {
+      case 0:
+      case 1:
+      case 6: {
+        const dist = computeLinearDistance(x1, y1, x2, y2);
+        return formatDimensionValue(dist);
+      }
+      case 3: {
+        const dist = computeLinearDistance(x1, y1, x2, y2);
+        if (dist > 0) return formatDimensionValue(dist);
+        const radius = computeRadiusFallback(entity);
+        return formatDimensionValue(radius * 2);
+      }
+      case 4: {
+        const dist = computeLinearDistance(x1, y1, x2, y2);
+        if (dist > 0) return formatDimensionValue(dist);
+        const radius = computeRadiusFallback(entity);
+        return formatDimensionValue(radius);
+      }
+      case 2: {
+        const cx = entity.start?.x ?? 0;
+        const cy = entity.start?.y ?? 0;
+        const degrees = computeAngularDegreesMinimal(cx, cy, x1, y1, x2, y2);
+        const formatted = formatDimensionValue(degrees);
+        return formatted ? `${formatted}\xB0` : "";
+      }
+      case 5: {
+        const cx = entity.angleVertex?.x ?? 0;
+        const cy = entity.angleVertex?.y ?? 0;
+        const degrees = computeAngularDegreesCCW(cx, cy, x1, y1, x2, y2);
+        const formatted = formatDimensionValue(degrees);
+        return formatted ? `${formatted}\xB0` : "";
+      }
+      default:
+        return "";
+    }
+  };
+  var resolveDimensionText = (entity) => {
+    const raw = typeof entity.text === "string" ? entity.text : "";
+    const trimmed = raw.trim();
+    const measured = computeDimensionMeasurement(entity);
+    if (!trimmed) return measured;
+    if (trimmed.includes("<>")) {
+      return trimmed.split("<>").join(measured);
+    }
+    return trimmed;
+  };
+  var expandBBoxForMarker = (bbox, x, y, size) => {
+    bbox.expandByPoint({ x: x - size, y: y - size });
+    bbox.expandByPoint({ x: x + size, y: y + size });
+  };
+  var expandBBoxForText = (bbox, x, y, height, content) => {
+    const textWidth = content.length * height * 0.6;
+    bbox.expandByPoint({ x: x - textWidth / 2, y: y - height });
+    bbox.expandByPoint({ x: x + textWidth / 2, y: y + height });
+  };
   function colorNumberToSVG(colorNumber) {
     if (colorNumber === void 0 || colorNumber < 0) {
       return "currentColor";
@@ -6389,38 +7950,117 @@ var dxf = (() => {
       extLineWeight: dimStyle?.dimLwe ?? 0.5
     };
   }
-  function dimensionToSVG(entity, dimStyle) {
+  function dimensionToSVG(entity, dimStyle, options, viewport) {
     switch (entity.dimensionType) {
       case 0:
       // Rotated, horizontal, or vertical
       case 1:
-        return renderLinearDimension(entity, dimStyle);
+        return renderLinearDimension(entity, dimStyle, options, viewport);
       case 2:
-        return renderAngularDimension(entity, dimStyle);
+        return renderAngularDimension(entity, dimStyle, options, viewport);
+      case 5:
+        return renderAngular3PointDimension(entity, dimStyle, options, viewport);
       case 3:
-        return renderDiameterDimension(entity, dimStyle);
+        return renderDiameterDimension(entity, dimStyle, options, viewport);
       case 4:
-        return renderRadialDimension(entity, dimStyle);
+        return renderRadialDimension(entity, dimStyle, options, viewport);
       case 6:
-        return renderOrdinateDimension(entity, dimStyle);
+        return renderOrdinateDimension(entity, dimStyle, options, viewport);
       default:
         return renderFallbackDimension(entity);
     }
   }
-  function createArrowMarker(id, size, color) {
-    const arrowPath = `M 0 0 L ${size} ${size / 2} L 0 ${size} z`;
-    return `<marker id="${id}" markerWidth="${size}" markerHeight="${size}" refX="${size}" refY="${size / 2}" orient="auto" markerUnits="strokeWidth">
+  function renderAngular3PointDimension(entity, dimStyle, options, viewport) {
+    const bbox = new import_vecks3.Box2();
+    const elements = [];
+    const markers = [];
+    const { arrowSize, textHeight } = getScaledDimensionSizes(dimStyle, options, viewport);
+    const { dimLineColor, extLineColor, textColor, dimLineWeight, extLineWeight } = getDimensionColors(dimStyle);
+    const vertexX = entity.angleVertex?.x ?? 0;
+    const vertexY = entity.angleVertex?.y ?? 0;
+    const x1 = entity.measureStart?.x ?? 0;
+    const y1 = entity.measureStart?.y ?? 0;
+    const x2 = entity.measureEnd?.x ?? 0;
+    const y2 = entity.measureEnd?.y ?? 0;
+    const startArcX = entity.start?.x ?? 0;
+    const startArcY = entity.start?.y ?? 0;
+    const arcPointX = entity.arcPoint?.x;
+    const arcPointY = entity.arcPoint?.y;
+    const arcPointRadius = Number.isFinite(arcPointX) && Number.isFinite(arcPointY) ? Math.hypot(arcPointX - vertexX, arcPointY - vertexY) : Number.NaN;
+    const useArcPoint = Number.isFinite(arcPointRadius) && arcPointRadius > 1e-9;
+    const arcLocationX = useArcPoint ? arcPointX : startArcX;
+    const arcLocationY = useArcPoint ? arcPointY : startArcY;
+    const textX = entity.textMidpoint?.x ?? arcLocationX;
+    const textY = entity.textMidpoint?.y ?? arcLocationY;
+    bbox.expandByPoint({ x: vertexX, y: vertexY });
+    bbox.expandByPoint({ x: x1, y: y1 });
+    bbox.expandByPoint({ x: x2, y: y2 });
+    bbox.expandByPoint({ x: arcLocationX, y: arcLocationY });
+    bbox.expandByPoint({ x: textX, y: textY });
+    const a1 = Math.atan2(y1 - vertexY, x1 - vertexX);
+    const a2 = Math.atan2(y2 - vertexY, x2 - vertexX);
+    let radius = Math.hypot(arcLocationX - vertexX, arcLocationY - vertexY);
+    if (!Number.isFinite(radius) || radius <= 1e-9) {
+      radius = Math.hypot(textX - vertexX, textY - vertexY);
+    }
+    if (!Number.isFinite(radius) || radius <= 1e-9) {
+      radius = Math.max(
+        Math.hypot(x1 - vertexX, y1 - vertexY),
+        Math.hypot(x2 - vertexX, y2 - vertexY)
+      );
+    }
+    const arcStartX = vertexX + radius * Math.cos(a1);
+    const arcStartY = vertexY + radius * Math.sin(a1);
+    const arcEndX = vertexX + radius * Math.cos(a2);
+    const arcEndY = vertexY + radius * Math.sin(a2);
+    bbox.expandByPoint({ x: arcStartX, y: arcStartY });
+    bbox.expandByPoint({ x: arcEndX, y: arcEndY });
+    const markerId1 = `dim-angular-3p-arrow-start-${Date.now()}`;
+    const markerId2 = `dim-angular-3p-arrow-end-${Date.now()}`;
+    markers.push(
+      createArrowMarker(markerId1, arrowSize, dimLineColor, "backward"),
+      createArrowMarker(markerId2, arrowSize, dimLineColor, "forward")
+    );
+    elements.push(
+      `<line x1="${x1}" y1="${y1}" x2="${arcStartX}" y2="${arcStartY}" stroke="${extLineColor}" stroke-width="${extLineWeight}" />`,
+      `<line x1="${x2}" y1="${y2}" x2="${arcEndX}" y2="${arcEndY}" stroke="${extLineColor}" stroke-width="${extLineWeight}" />`
+    );
+    let delta = a2 - a1;
+    while (delta < 0) delta += Math.PI * 2;
+    while (delta >= Math.PI * 2) delta -= Math.PI * 2;
+    const largeArcFlag = delta > Math.PI ? 1 : 0;
+    const sweepFlag = 1;
+    expandBBoxForMarker(bbox, arcStartX, arcStartY, arrowSize);
+    expandBBoxForMarker(bbox, arcEndX, arcEndY, arrowSize);
+    elements.push(
+      `<path d="M ${arcStartX} ${arcStartY} A ${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${arcEndX} ${arcEndY}" fill="none" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" marker-start="url(#${markerId1})" marker-end="url(#${markerId2})" />`
+    );
+    const resolvedText = resolveDimensionText(entity);
+    if (resolvedText) {
+      const midAngle = a1 + delta / 2;
+      const textRotation = midAngle * 180 / Math.PI;
+      expandBBoxForText(bbox, textX, textY, textHeight, resolvedText);
+      elements.push(
+        `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${escapeXmlText(resolvedText)}</text>`
+      );
+    }
+    return {
+      bbox,
+      element: `<defs>${markers.join("")}</defs><g>${elements.join("")}</g>`
+    };
+  }
+  function createArrowMarker(id, size, color, direction = "forward") {
+    const arrowPath = direction === "forward" ? `M 0 0 L ${size} ${size / 2} L 0 ${size} z` : `M ${size} 0 L 0 ${size / 2} L ${size} ${size} z`;
+    const refX = direction === "forward" ? size : 0;
+    return `<marker id="${id}" markerWidth="${size}" markerHeight="${size}" refX="${refX}" refY="${size / 2}" orient="auto" markerUnits="userSpaceOnUse">
     <path d="${arrowPath}" fill="${color}" />
   </marker>`;
   }
-  function renderLinearDimension(entity, dimStyle) {
+  function renderLinearDimension(entity, dimStyle, options, viewport) {
     const bbox = new import_vecks3.Box2();
     const elements = [];
     const markers = [];
-    const arrowSize = dimStyle?.dimAsz ?? 2.5;
-    const textHeight = dimStyle?.dimTxt ?? 2.5;
-    const extLineOffset = dimStyle?.dimExo ?? 0.625;
-    const extLineExtension = dimStyle?.dimExe ?? 1.25;
+    const { arrowSize, textHeight, extLineOffset, extLineExtension } = getScaledDimensionSizes(dimStyle, options, viewport);
     const { dimLineColor, extLineColor, textColor, dimLineWeight, extLineWeight } = getDimensionColors(dimStyle);
     const defPoint1X = entity.measureStart?.x ?? 0;
     const defPoint1Y = entity.measureStart?.y ?? 0;
@@ -6443,8 +8083,8 @@ var dxf = (() => {
     const markerId1 = `dim-arrow-start-${Date.now()}`;
     const markerId2 = `dim-arrow-end-${Date.now()}`;
     markers.push(
-      createArrowMarker(markerId1, arrowSize, dimLineColor),
-      createArrowMarker(markerId2, arrowSize, dimLineColor)
+      createArrowMarker(markerId1, arrowSize, dimLineColor, "backward"),
+      createArrowMarker(markerId2, arrowSize, dimLineColor, "forward")
     );
     const extLine1StartX = defPoint1X + Math.cos(perpAngle) * extLineOffset;
     const extLine1StartY = defPoint1Y + Math.sin(perpAngle) * extLineOffset;
@@ -6454,15 +8094,23 @@ var dxf = (() => {
     const extLine2StartY = defPoint2Y + Math.sin(perpAngle) * extLineOffset;
     const extLine2EndX = dimLine2X + Math.cos(perpAngle) * extLineExtension;
     const extLine2EndY = dimLine2Y + Math.sin(perpAngle) * extLineExtension;
+    bbox.expandByPoint({ x: extLine1StartX, y: extLine1StartY });
+    bbox.expandByPoint({ x: extLine1EndX, y: extLine1EndY });
+    bbox.expandByPoint({ x: extLine2StartX, y: extLine2StartY });
+    bbox.expandByPoint({ x: extLine2EndX, y: extLine2EndY });
+    expandBBoxForMarker(bbox, dimLine1X, dimLine1Y, arrowSize);
+    expandBBoxForMarker(bbox, dimLine2X, dimLine2Y, arrowSize);
     elements.push(
       `<line x1="${extLine1StartX}" y1="${extLine1StartY}" x2="${extLine1EndX}" y2="${extLine1EndY}" stroke="${extLineColor}" stroke-width="${extLineWeight}" />`,
       `<line x1="${extLine2StartX}" y1="${extLine2StartY}" x2="${extLine2EndX}" y2="${extLine2EndY}" stroke="${extLineColor}" stroke-width="${extLineWeight}" />`,
       `<line x1="${dimLine1X}" y1="${dimLine1Y}" x2="${dimLine2X}" y2="${dimLine2Y}" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" marker-start="url(#${markerId1})" marker-end="url(#${markerId2})" />`
     );
-    if (entity.text) {
+    const resolvedText = resolveDimensionText(entity);
+    if (resolvedText) {
       const textRotation = angle * 180 / Math.PI;
+      expandBBoxForText(bbox, textX, textY, textHeight, resolvedText);
       elements.push(
-        `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${entity.text}</text>`
+        `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${escapeXmlText(resolvedText)}</text>`
       );
     }
     return {
@@ -6470,12 +8118,11 @@ var dxf = (() => {
       element: `<defs>${markers.join("")}</defs><g>${elements.join("")}</g>`
     };
   }
-  function renderAngularDimension(entity, dimStyle) {
+  function renderAngularDimension(entity, dimStyle, options, viewport) {
     const bbox = new import_vecks3.Box2();
     const elements = [];
     const markers = [];
-    const arrowSize = dimStyle?.dimAsz ?? 2.5;
-    const textHeight = dimStyle?.dimTxt ?? 2.5;
+    const { arrowSize, textHeight } = getScaledDimensionSizes(dimStyle, options, viewport);
     const { dimLineColor, extLineColor, textColor, dimLineWeight, extLineWeight } = getDimensionColors(dimStyle);
     const centerX = entity.start?.x ?? 0;
     const centerY = entity.start?.y ?? 0;
@@ -6492,8 +8139,8 @@ var dxf = (() => {
     const markerId1 = `dim-angular-arrow-start-${Date.now()}`;
     const markerId2 = `dim-angular-arrow-end-${Date.now()}`;
     markers.push(
-      createArrowMarker(markerId1, arrowSize, dimLineColor),
-      createArrowMarker(markerId2, arrowSize, dimLineColor)
+      createArrowMarker(markerId1, arrowSize, dimLineColor, "backward"),
+      createArrowMarker(markerId2, arrowSize, dimLineColor, "forward")
     );
     elements.push(
       `<line x1="${centerX}" y1="${centerY}" x2="${x1}" y2="${y1}" stroke="${extLineColor}" stroke-width="${extLineWeight}" />`,
@@ -6510,11 +8157,13 @@ var dxf = (() => {
     elements.push(
       `<path d="M ${arcStartX} ${arcStartY} A ${radius} ${radius} 0 ${largeArcFlag} 1 ${arcEndX} ${arcEndY}" fill="none" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" marker-start="url(#${markerId1})" marker-end="url(#${markerId2})" />`
     );
-    if (entity.text) {
+    const resolvedText = resolveDimensionText(entity);
+    if (resolvedText) {
       const midAngle = (startAngle + endAngle) / 2;
       const textRotation = midAngle * 180 / Math.PI;
+      expandBBoxForText(bbox, textX, textY, textHeight, resolvedText);
       elements.push(
-        `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${entity.text}</text>`
+        `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${escapeXmlText(resolvedText)}</text>`
       );
     }
     return {
@@ -6522,12 +8171,11 @@ var dxf = (() => {
       element: `<defs>${markers.join("")}</defs><g>${elements.join("")}</g>`
     };
   }
-  function renderDiameterDimension(entity, dimStyle) {
+  function renderDiameterDimension(entity, dimStyle, options, viewport) {
     const bbox = new import_vecks3.Box2();
     const elements = [];
     const markers = [];
-    const arrowSize = dimStyle?.dimAsz ?? 2.5;
-    const textHeight = dimStyle?.dimTxt ?? 2.5;
+    const { arrowSize, textHeight } = getScaledDimensionSizes(dimStyle, options, viewport);
     const { dimLineColor, textColor, dimLineWeight } = getDimensionColors(dimStyle);
     const x1 = entity.measureStart?.x ?? 0;
     const y1 = entity.measureStart?.y ?? 0;
@@ -6538,28 +8186,33 @@ var dxf = (() => {
     bbox.expandByPoint({ x: x1, y: y1 });
     bbox.expandByPoint({ x: x2, y: y2 });
     bbox.expandByPoint({ x: textX, y: textY });
-    const markerId = `dim-diameter-arrow-${Date.now()}`;
-    markers.push(createArrowMarker(markerId, arrowSize, dimLineColor));
-    elements.push(
-      `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" marker-end="url(#${markerId})" />`
-    );
-    const diameterText = entity.text ? `\u2300${entity.text}` : "\u2300";
+    const diameterLen = Math.hypot(x2 - x1, y2 - y1);
+    if (Number.isFinite(diameterLen) && diameterLen > 1e-6) {
+      const markerId = `dim-diameter-arrow-${Date.now()}`;
+      markers.push(createArrowMarker(markerId, arrowSize, dimLineColor, "backward"));
+      elements.push(
+        `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" marker-end="url(#${markerId})" />`
+      );
+      expandBBoxForMarker(bbox, x2, y2, arrowSize);
+    }
+    const resolvedText = resolveDimensionText(entity);
+    const diameterText = resolvedText ? `\u2300${resolvedText}` : "\u2300";
     const angle = Math.atan2(y2 - y1, x2 - x1);
     const textRotation = angle * 180 / Math.PI;
+    expandBBoxForText(bbox, textX, textY, textHeight, diameterText);
     elements.push(
-      `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${diameterText}</text>`
+      `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${escapeXmlText(diameterText)}</text>`
     );
     return {
       bbox,
       element: `<defs>${markers.join("")}</defs><g>${elements.join("")}</g>`
     };
   }
-  function renderRadialDimension(entity, dimStyle) {
+  function renderRadialDimension(entity, dimStyle, options, viewport) {
     const bbox = new import_vecks3.Box2();
     const elements = [];
     const markers = [];
-    const arrowSize = dimStyle?.dimAsz ?? 2.5;
-    const textHeight = dimStyle?.dimTxt ?? 2.5;
+    const { arrowSize, textHeight } = getScaledDimensionSizes(dimStyle, options, viewport);
     const { dimLineColor, textColor, dimLineWeight } = getDimensionColors(dimStyle);
     const x1 = entity.measureStart?.x ?? 0;
     const y1 = entity.measureStart?.y ?? 0;
@@ -6570,26 +8223,32 @@ var dxf = (() => {
     bbox.expandByPoint({ x: x1, y: y1 });
     bbox.expandByPoint({ x: x2, y: y2 });
     bbox.expandByPoint({ x: textX, y: textY });
-    const markerId = `dim-radius-arrow-${Date.now()}`;
-    markers.push(createArrowMarker(markerId, arrowSize, dimLineColor));
-    elements.push(
-      `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" marker-end="url(#${markerId})" />`
-    );
-    const radiusText = entity.text ? `R${entity.text}` : "R";
+    const radiusLen = Math.hypot(x2 - x1, y2 - y1);
+    if (Number.isFinite(radiusLen) && radiusLen > 1e-6) {
+      const markerId = `dim-radius-arrow-${Date.now()}`;
+      markers.push(createArrowMarker(markerId, arrowSize, dimLineColor, "backward"));
+      elements.push(
+        `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" marker-end="url(#${markerId})" />`
+      );
+      expandBBoxForMarker(bbox, x2, y2, arrowSize);
+    }
+    const resolvedText = resolveDimensionText(entity);
+    const radiusText = resolvedText ? `R${resolvedText}` : "R";
     const angle = Math.atan2(y2 - y1, x2 - x1);
     const textRotation = angle * 180 / Math.PI;
+    expandBBoxForText(bbox, textX, textY, textHeight, radiusText);
     elements.push(
-      `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${radiusText}</text>`
+      `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${escapeXmlText(radiusText)}</text>`
     );
     return {
       bbox,
       element: `<defs>${markers.join("")}</defs><g>${elements.join("")}</g>`
     };
   }
-  function renderOrdinateDimension(entity, dimStyle) {
+  function renderOrdinateDimension(entity, dimStyle, options, viewport) {
     const bbox = new import_vecks3.Box2();
     const elements = [];
-    const textHeight = dimStyle?.dimTxt ?? 2.5;
+    const { textHeight } = getScaledDimensionSizes(dimStyle, options, viewport);
     const { dimLineColor, textColor, dimLineWeight } = getDimensionColors(dimStyle);
     const x1 = entity.measureStart?.x ?? 0;
     const y1 = entity.measureStart?.y ?? 0;
@@ -6603,11 +8262,13 @@ var dxf = (() => {
     elements.push(
       `<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${dimLineColor}" stroke-width="${dimLineWeight}" />`
     );
-    if (entity.text) {
+    const resolvedText = resolveDimensionText(entity);
+    if (resolvedText) {
       const angle = Math.atan2(y2 - y1, x2 - x1);
       const textRotation = angle * 180 / Math.PI;
+      expandBBoxForText(bbox, textX, textY, textHeight, resolvedText);
       elements.push(
-        `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${entity.text}</text>`
+        `<text x="${textX}" y="${textY}" font-size="${textHeight}" fill="${textColor}" text-anchor="middle" transform="rotate(${-textRotation} ${textX} ${textY}) scale(1,-1) translate(0 ${-2 * textY})">${escapeXmlText(resolvedText)}</text>`
       );
     }
     return {
@@ -6622,9 +8283,10 @@ var dxf = (() => {
       const textX = entity.textMidpoint.x ?? 0;
       const textY = entity.textMidpoint.y ?? 0;
       bbox.expandByPoint({ x: textX, y: textY });
-      if (entity.text) {
+      const resolvedText = resolveDimensionText(entity);
+      if (resolvedText) {
         elements.push(
-          `<text x="${textX}" y="${textY}" font-size="2.5" text-anchor="middle" transform="scale(1,-1) translate(0 ${-2 * textY})">${entity.text}</text>`
+          `<text x="${textX}" y="${textY}" font-size="2.5" text-anchor="middle" transform="scale(1,-1) translate(0 ${-2 * textY})">${escapeXmlText(resolvedText)}</text>`
         );
       }
     }
@@ -6884,6 +8546,23 @@ var dxf = (() => {
       entity.transforms ?? []
     );
   };
+  var leader = (entity) => {
+    if (!entity.vertices || entity.vertices.length < 2) return null;
+    const bbox0 = entity.vertices.reduce(
+      (acc, p) => acc.expandByPoint({ x: p.x, y: p.y }),
+      new import_vecks5.Box2()
+    );
+    const d = entity.vertices.reduce((acc, p, i) => {
+      acc += i === 0 ? "M" : "L";
+      acc += p.x + "," + p.y;
+      return acc;
+    }, "");
+    return transformBoundingBoxAndElement(
+      bbox0,
+      `<path d="${d}" />`,
+      entity.transforms ?? []
+    );
+  };
   var circle = (entity) => {
     const bbox0 = new import_vecks5.Box2().expandByPoint({
       x: entity.x + entity.r,
@@ -7023,7 +8702,7 @@ var dxf = (() => {
     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})">${content}</text>`;
+    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
@@ -7039,15 +8718,47 @@ var dxf = (() => {
     const bbox0 = new import_vecks5.Box2().expandByPoint({ x, y }).expandByPoint({ x: x + textWidth, y: y + height });
     const rotation = entity.xAxisX !== void 0 && entity.xAxisY !== void 0 ? Math.atan2(entity.xAxisY, entity.xAxisX) : 0;
     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})">${content}</text>`;
+    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 tolerance = (entity) => {
+    const x = entity.insertionPoint?.x ?? 0;
+    const y = entity.insertionPoint?.y ?? 0;
+    const height = 1;
+    const content = entity.text ?? "";
+    const rotation = entity.xAxisDirection ? Math.atan2(entity.xAxisDirection.y, entity.xAxisDirection.x) : 0;
+    const rotationDegrees = rotation * 180 / Math.PI;
+    const textWidth = content.length * height * 0.6;
+    const bbox0 = new import_vecks5.Box2().expandByPoint({ x, y }).expandByPoint({ x: x + textWidth, y: y + height });
+    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 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) => {
-    const result = dimensionToSVG(entity, dimStyle);
+  var dimension = (entity, dimStyle, options, viewport) => {
+    const result = dimensionToSVG(entity, dimStyle, options, viewport);
     return transformBoundingBoxAndElement(
       result.bbox,
       result.element,
@@ -7086,7 +8797,7 @@ var dxf = (() => {
     const element = `<g>${paths.join("")}</g>`;
     return transformBoundingBoxAndElement(bbox, element, entity.transforms ?? []);
   };
-  var entityToBoundsAndElement = (entity, dimStyles) => {
+  var entityToBoundsAndElement = (entity, dimStyles, options, viewport) => {
     switch (entity.type) {
       case "CIRCLE":
         return circle(entity);
@@ -7102,7 +8813,7 @@ var dxf = (() => {
         const dimEntity = entity;
         const styleName = typeof dimEntity.styleName === "string" ? dimEntity.styleName : void 0;
         const dimStyle = styleName && dimStyles ? dimStyles[styleName] : void 0;
-        return dimension(dimEntity, dimStyle);
+        return dimension(dimEntity, dimStyle, options, viewport);
       }
       case "SPLINE": {
         const splineEntity = entity;
@@ -7120,33 +8831,77 @@ 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;
     }
   };
-  function toSVG(parsed) {
+  function toSVG(parsed, options = {}) {
     const entities = denormalise(parsed);
     const dimStyles = parsed.tables.dimStyles;
+    const geometryBBox = entities.reduce((acc, entity) => {
+      if (entity.type === "DIMENSION") {
+        const bbox2 = getDimensionGeometryBBox(entity);
+        if (bbox2.valid) {
+          acc.expandByPoint(bbox2.min);
+          acc.expandByPoint(bbox2.max);
+        }
+        return acc;
+      }
+      const boundsAndElement = entityToBoundsAndElement(entity, dimStyles, options);
+      if (boundsAndElement?.bbox.valid) {
+        acc.expandByPoint(boundsAndElement.bbox.min);
+        acc.expandByPoint(boundsAndElement.bbox.max);
+      }
+      return acc;
+    }, new import_vecks5.Box2());
+    const viewport = geometryBBox.valid ? {
+      width: geometryBBox.max.x - geometryBBox.min.x,
+      height: geometryBBox.max.y - geometryBBox.min.y
+    } : {
+      width: 0,
+      height: 0
+    };
     const { bbox, elements } = entities.reduce(
       (acc, entity) => {
         const rgb = getRGBForEntity(parsed.tables.layers, entity);
-        const boundsAndElement = entityToBoundsAndElement(entity, dimStyles);
+        const boundsAndElement = entityToBoundsAndElement(entity, dimStyles, options, viewport);
         if (boundsAndElement) {
           const { bbox: bbox2, element } = boundsAndElement;
           if (bbox2.valid) {
             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;
       },
@@ -7223,8 +8978,11 @@ var dxf = (() => {
       }
       return this._groups;
     }
-    toSVG() {
-      return toSVG(this.parsed);
+    toSVG(options) {
+      return toSVG(this.parsed, options);
+    }
+    toJson(options) {
+      return toJson(this.parsed, options);
     }
     toPolylines() {
       return toPolylines(this.parsed);