npm - @cadview/core - Versions diffs - 0.1.0 - Mend

@cadview/core 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.cjs ADDED Viewed

@@ -0,0 +1,4048 @@
+'use strict';
+var RBush = require('rbush');
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+var RBush__default = /*#__PURE__*/_interopDefault(RBush);
+// src/parser/tokenizer.ts
+function tokenize(content) {
+  const text = content.replace(/\r\n?/g, "\n");
+  const tokens = [];
+  const len = text.length;
+  let pos = 0;
+  while (pos < len) {
+    while (pos < len && text.charCodeAt(pos) === 10) pos++;
+    if (pos >= len) break;
+    let lineEnd = text.indexOf("\n", pos);
+    if (lineEnd === -1) lineEnd = len;
+    const codeLine = text.substring(pos, lineEnd).trim();
+    pos = lineEnd + 1;
+    const code = parseInt(codeLine, 10);
+    if (isNaN(code)) {
+      if (pos < len) {
+        lineEnd = text.indexOf("\n", pos);
+        if (lineEnd === -1) lineEnd = len;
+        pos = lineEnd + 1;
+      }
+      continue;
+    }
+    if (pos >= len) break;
+    lineEnd = text.indexOf("\n", pos);
+    if (lineEnd === -1) lineEnd = len;
+    const value = text.substring(pos, lineEnd).replace(/\s+$/, "");
+    pos = lineEnd + 1;
+    tokens.push({ code, value });
+  }
+  return tokens;
+}
+// src/parser/sections/header.ts
+function parseHeader(tokens, i, header) {
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.code === 0 && token.value === "ENDSEC") return i + 1;
+    if (token.code === 9) {
+      const varName = token.value;
+      i++;
+      switch (varName) {
+        case "$ACADVER":
+          if (i < tokens.length) {
+            header.acadVersion = tokens[i].value;
+            i++;
+          }
+          break;
+        case "$EXTMIN":
+          if (i < tokens.length) {
+            const result = readHeaderPoint3D(tokens, i);
+            header.extMin = result.point;
+            i = result.nextIndex;
+          }
+          break;
+        case "$EXTMAX":
+          if (i < tokens.length) {
+            const result = readHeaderPoint3D(tokens, i);
+            header.extMax = result.point;
+            i = result.nextIndex;
+          }
+          break;
+        case "$INSUNITS":
+          if (i < tokens.length) {
+            header.insUnits = parseInt(tokens[i].value, 10);
+            i++;
+          }
+          break;
+        case "$MEASUREMENT":
+          if (i < tokens.length) {
+            header.measurement = parseInt(tokens[i].value, 10);
+            i++;
+          }
+          break;
+        case "$LTSCALE":
+          if (i < tokens.length) {
+            header.ltScale = parseFloat(tokens[i].value);
+            i++;
+          }
+          break;
+        case "$DWGCODEPAGE":
+          if (i < tokens.length) {
+            header.dwgCodePage = tokens[i].value;
+            i++;
+          }
+          break;
+        case "$HANDSEED":
+          if (i < tokens.length) {
+            header.handleSeed = tokens[i].value;
+            i++;
+          }
+          break;
+        default:
+          while (i < tokens.length && tokens[i].code !== 9 && tokens[i].code !== 0) {
+            header[varName] = tokens[i].value;
+            i++;
+          }
+      }
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+function readHeaderPoint3D(tokens, i) {
+  const point = { x: 0, y: 0, z: 0 };
+  while (i < tokens.length) {
+    const code = tokens[i].code;
+    if (code === 10) {
+      point.x = parseFloat(tokens[i].value);
+      i++;
+    } else if (code === 20) {
+      point.y = parseFloat(tokens[i].value);
+      i++;
+    } else if (code === 30) {
+      point.z = parseFloat(tokens[i].value);
+      i++;
+    } else break;
+  }
+  return { point, nextIndex: i };
+}
+// src/parser/sections/tables.ts
+function parseTables(tokens, i, doc) {
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.code === 0 && token.value === "ENDSEC") return i + 1;
+    if (token.code === 0 && token.value === "TABLE") {
+      i++;
+      if (i >= tokens.length) break;
+      const tableType = tokens[i].value;
+      i++;
+      switch (tableType) {
+        case "LAYER":
+          i = parseLayerTable(tokens, i, doc.layers);
+          break;
+        case "LTYPE":
+          i = parseLTypeTable(tokens, i, doc.lineTypes);
+          break;
+        case "STYLE":
+          i = parseStyleTable(tokens, i, doc.styles);
+          break;
+        default:
+          i = skipTable(tokens, i);
+          break;
+      }
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+function skipTable(tokens, i) {
+  while (i < tokens.length) {
+    if (tokens[i].code === 0 && tokens[i].value === "ENDTAB") return i + 1;
+    i++;
+  }
+  return i;
+}
+function parseLayerTable(tokens, i, layers) {
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.code === 0 && token.value === "ENDTAB") return i + 1;
+    if (token.code === 0 && token.value === "LAYER") {
+      i++;
+      const layer = {
+        name: "0",
+        color: 7,
+        lineType: "Continuous",
+        flags: 0,
+        lineWeight: -3,
+        isOff: false,
+        isFrozen: false,
+        isLocked: false
+      };
+      while (i < tokens.length && tokens[i].code !== 0) {
+        const tag = tokens[i];
+        switch (tag.code) {
+          case 2:
+            layer.name = tag.value;
+            break;
+          case 6:
+            layer.lineType = tag.value;
+            break;
+          case 62:
+            layer.color = parseInt(tag.value, 10);
+            break;
+          case 70:
+            layer.flags = parseInt(tag.value, 10);
+            break;
+          case 370:
+            layer.lineWeight = parseInt(tag.value, 10);
+            break;
+          case 420:
+            layer.trueColor = parseInt(tag.value, 10);
+            break;
+        }
+        i++;
+      }
+      layers.set(layer.name, layer);
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+function parseLTypeTable(tokens, i, lineTypes) {
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.code === 0 && token.value === "ENDTAB") return i + 1;
+    if (token.code === 0 && token.value === "LTYPE") {
+      i++;
+      const lt = {
+        name: "",
+        description: "",
+        pattern: [],
+        totalLength: 0
+      };
+      while (i < tokens.length && tokens[i].code !== 0) {
+        const tag = tokens[i];
+        switch (tag.code) {
+          case 2:
+            lt.name = tag.value;
+            break;
+          case 3:
+            lt.description = tag.value;
+            break;
+          case 40:
+            lt.totalLength = parseFloat(tag.value);
+            break;
+          case 49:
+            lt.pattern.push(parseFloat(tag.value));
+            break;
+        }
+        i++;
+      }
+      if (lt.name) lineTypes.set(lt.name, lt);
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+function parseStyleTable(tokens, i, styles) {
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.code === 0 && token.value === "ENDTAB") return i + 1;
+    if (token.code === 0 && token.value === "STYLE") {
+      i++;
+      const style = {
+        name: "",
+        fontName: "",
+        bigFontName: "",
+        height: 0,
+        widthFactor: 1,
+        obliqueAngle: 0
+      };
+      while (i < tokens.length && tokens[i].code !== 0) {
+        const tag = tokens[i];
+        switch (tag.code) {
+          case 2:
+            style.name = tag.value;
+            break;
+          case 3:
+            style.fontName = tag.value;
+            break;
+          case 4:
+            style.bigFontName = tag.value;
+            break;
+          case 40:
+            style.height = parseFloat(tag.value);
+            break;
+          case 41:
+            style.widthFactor = parseFloat(tag.value);
+            break;
+          case 50:
+            style.obliqueAngle = parseFloat(tag.value);
+            break;
+        }
+        i++;
+      }
+      if (style.name) styles.set(style.name, style);
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+// src/parser/entities/base.ts
+function parseBaseEntity(tags) {
+  const base = {
+    type: "",
+    layer: "0",
+    color: 256,
+    // BYLAYER
+    lineType: "BYLAYER",
+    lineTypeScale: 1,
+    lineWeight: -1,
+    // BYLAYER
+    visible: true,
+    extrusion: { x: 0, y: 0, z: 1 }
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 5:
+        base.handle = tag.value;
+        break;
+      case 8:
+        base.layer = tag.value;
+        break;
+      case 6:
+        base.lineType = tag.value;
+        break;
+      case 48:
+        base.lineTypeScale = parseFloat(tag.value);
+        break;
+      case 60:
+        base.visible = tag.value === "0" || tag.value === "";
+        break;
+      case 62:
+        base.color = parseInt(tag.value, 10);
+        break;
+      case 370:
+        base.lineWeight = parseInt(tag.value, 10);
+        break;
+      case 420:
+        base.trueColor = parseInt(tag.value, 10);
+        break;
+      case 210:
+        base.extrusion.x = parseFloat(tag.value);
+        break;
+      case 220:
+        base.extrusion.y = parseFloat(tag.value);
+        break;
+      case 230:
+        base.extrusion.z = parseFloat(tag.value);
+        break;
+    }
+  }
+  return base;
+}
+// src/parser/entities/line.ts
+function parseLine(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "LINE",
+    start: { x: 0, y: 0, z: 0 },
+    end: { x: 0, y: 0, z: 0 }
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 10:
+        entity.start.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.start.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.start.z = parseFloat(tag.value);
+        break;
+      case 11:
+        entity.end.x = parseFloat(tag.value);
+        break;
+      case 21:
+        entity.end.y = parseFloat(tag.value);
+        break;
+      case 31:
+        entity.end.z = parseFloat(tag.value);
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/entities/circle.ts
+function parseCircle(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "CIRCLE",
+    center: { x: 0, y: 0, z: 0 },
+    radius: 0
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 10:
+        entity.center.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.center.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.center.z = parseFloat(tag.value);
+        break;
+      case 40:
+        entity.radius = parseFloat(tag.value);
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/entities/arc.ts
+function parseArc(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "ARC",
+    center: { x: 0, y: 0, z: 0 },
+    radius: 0,
+    startAngle: 0,
+    endAngle: 360
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 10:
+        entity.center.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.center.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.center.z = parseFloat(tag.value);
+        break;
+      case 40:
+        entity.radius = parseFloat(tag.value);
+        break;
+      case 50:
+        entity.startAngle = parseFloat(tag.value);
+        break;
+      case 51:
+        entity.endAngle = parseFloat(tag.value);
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/entities/lwpolyline.ts
+function parseLwPolyline(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "LWPOLYLINE",
+    vertices: [],
+    closed: false,
+    constantWidth: 0,
+    elevation: 0
+  };
+  let currentVertex = null;
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 70:
+        entity.closed = (parseInt(tag.value, 10) & 1) !== 0;
+        break;
+      case 38:
+        entity.elevation = parseFloat(tag.value);
+        break;
+      case 43:
+        entity.constantWidth = parseFloat(tag.value);
+        break;
+      case 10:
+        if (currentVertex) entity.vertices.push(currentVertex);
+        currentVertex = { x: parseFloat(tag.value), y: 0, bulge: 0, startWidth: 0, endWidth: 0 };
+        break;
+      case 20:
+        if (currentVertex) currentVertex.y = parseFloat(tag.value);
+        break;
+      case 40:
+        if (currentVertex) currentVertex.startWidth = parseFloat(tag.value);
+        break;
+      case 41:
+        if (currentVertex) currentVertex.endWidth = parseFloat(tag.value);
+        break;
+      case 42:
+        if (currentVertex) currentVertex.bulge = parseFloat(tag.value);
+        break;
+    }
+  }
+  if (currentVertex) entity.vertices.push(currentVertex);
+  return entity;
+}
+// src/parser/entities/polyline.ts
+function parsePolyline(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "POLYLINE",
+    vertices: [],
+    // filled in by entities dispatcher from VERTEX entities
+    closed: false,
+    is3d: false
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 70: {
+        const flags = parseInt(tag.value, 10);
+        entity.closed = (flags & 1) !== 0;
+        entity.is3d = (flags & 8) !== 0;
+        break;
+      }
+    }
+  }
+  return entity;
+}
+// src/parser/entities/ellipse.ts
+function parseEllipse(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "ELLIPSE",
+    center: { x: 0, y: 0, z: 0 },
+    majorAxis: { x: 1, y: 0, z: 0 },
+    minorRatio: 1,
+    startParam: 0,
+    endParam: Math.PI * 2
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 10:
+        entity.center.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.center.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.center.z = parseFloat(tag.value);
+        break;
+      case 11:
+        entity.majorAxis.x = parseFloat(tag.value);
+        break;
+      case 21:
+        entity.majorAxis.y = parseFloat(tag.value);
+        break;
+      case 31:
+        entity.majorAxis.z = parseFloat(tag.value);
+        break;
+      case 40:
+        entity.minorRatio = parseFloat(tag.value);
+        break;
+      case 41:
+        entity.startParam = parseFloat(tag.value);
+        break;
+      case 42:
+        entity.endParam = parseFloat(tag.value);
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/entities/spline.ts
+function parseSpline(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "SPLINE",
+    degree: 3,
+    flags: 0,
+    knots: [],
+    controlPoints: [],
+    fitPoints: [],
+    weights: []
+  };
+  let currentCP = null;
+  let currentFP = null;
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 70:
+        entity.flags = parseInt(tag.value, 10);
+        break;
+      case 71:
+        entity.degree = parseInt(tag.value, 10);
+        break;
+      // 72 = knot count, 73 = control point count, 74 = fit point count — informational, skip
+      case 40:
+        entity.knots.push(parseFloat(tag.value));
+        break;
+      case 41:
+        entity.weights.push(parseFloat(tag.value));
+        break;
+      case 10:
+        if (currentCP) entity.controlPoints.push(currentCP);
+        currentCP = { x: parseFloat(tag.value), y: 0, z: 0 };
+        break;
+      case 20:
+        if (currentCP) currentCP.y = parseFloat(tag.value);
+        break;
+      case 30:
+        if (currentCP) currentCP.z = parseFloat(tag.value);
+        break;
+      case 11:
+        if (currentFP) entity.fitPoints.push(currentFP);
+        currentFP = { x: parseFloat(tag.value), y: 0, z: 0 };
+        break;
+      case 21:
+        if (currentFP) currentFP.y = parseFloat(tag.value);
+        break;
+      case 31:
+        if (currentFP) currentFP.z = parseFloat(tag.value);
+        break;
+      case 12:
+        if (!entity.startTangent) entity.startTangent = { x: 0, y: 0, z: 0 };
+        entity.startTangent.x = parseFloat(tag.value);
+        break;
+      case 22:
+        if (entity.startTangent) entity.startTangent.y = parseFloat(tag.value);
+        break;
+      case 32:
+        if (entity.startTangent) entity.startTangent.z = parseFloat(tag.value);
+        break;
+      case 13:
+        if (!entity.endTangent) entity.endTangent = { x: 0, y: 0, z: 0 };
+        entity.endTangent.x = parseFloat(tag.value);
+        break;
+      case 23:
+        if (entity.endTangent) entity.endTangent.y = parseFloat(tag.value);
+        break;
+      case 33:
+        if (entity.endTangent) entity.endTangent.z = parseFloat(tag.value);
+        break;
+    }
+  }
+  if (currentCP) entity.controlPoints.push(currentCP);
+  if (currentFP) entity.fitPoints.push(currentFP);
+  return entity;
+}
+// src/parser/entities/text.ts
+function parseText(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "TEXT",
+    text: "",
+    insertionPoint: { x: 0, y: 0, z: 0 },
+    height: 1,
+    rotation: 0,
+    widthFactor: 1,
+    obliqueAngle: 0,
+    style: "STANDARD",
+    hAlign: 0,
+    vAlign: 0,
+    generationFlags: 0
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 1:
+        entity.text = tag.value;
+        break;
+      case 10:
+        entity.insertionPoint.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.insertionPoint.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.insertionPoint.z = parseFloat(tag.value);
+        break;
+      case 11:
+        if (!entity.alignmentPoint) entity.alignmentPoint = { x: 0, y: 0, z: 0 };
+        entity.alignmentPoint.x = parseFloat(tag.value);
+        break;
+      case 21:
+        if (!entity.alignmentPoint) entity.alignmentPoint = { x: 0, y: 0, z: 0 };
+        entity.alignmentPoint.y = parseFloat(tag.value);
+        break;
+      case 31:
+        if (!entity.alignmentPoint) entity.alignmentPoint = { x: 0, y: 0, z: 0 };
+        entity.alignmentPoint.z = parseFloat(tag.value);
+        break;
+      case 40:
+        entity.height = parseFloat(tag.value);
+        break;
+      case 41:
+        entity.widthFactor = parseFloat(tag.value);
+        break;
+      case 50:
+        entity.rotation = parseFloat(tag.value);
+        break;
+      case 51:
+        entity.obliqueAngle = parseFloat(tag.value);
+        break;
+      case 7:
+        entity.style = tag.value;
+        break;
+      case 71:
+        entity.generationFlags = parseInt(tag.value, 10);
+        break;
+      case 72:
+        entity.hAlign = parseInt(tag.value, 10);
+        break;
+      case 73:
+        entity.vAlign = parseInt(tag.value, 10);
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/entities/mtext.ts
+function parseMText(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "MTEXT",
+    text: "",
+    insertionPoint: { x: 0, y: 0, z: 0 },
+    height: 1,
+    width: 0,
+    attachmentPoint: 1,
+    drawingDirection: 1,
+    rotation: 0,
+    lineSpacingStyle: 1,
+    lineSpacingFactor: 1,
+    style: "STANDARD",
+    bgFill: 0,
+    bgFillScale: 1.5
+  };
+  const textChunks = [];
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 1:
+        textChunks.push(tag.value);
+        break;
+      case 3:
+        textChunks.push(tag.value);
+        break;
+      case 7:
+        entity.style = tag.value;
+        break;
+      case 10:
+        entity.insertionPoint.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.insertionPoint.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.insertionPoint.z = parseFloat(tag.value);
+        break;
+      case 11:
+        if (!entity.textDirection) entity.textDirection = { x: 0, y: 0, z: 0 };
+        entity.textDirection.x = parseFloat(tag.value);
+        break;
+      case 21:
+        if (!entity.textDirection) entity.textDirection = { x: 0, y: 0, z: 0 };
+        entity.textDirection.y = parseFloat(tag.value);
+        break;
+      case 31:
+        if (!entity.textDirection) entity.textDirection = { x: 0, y: 0, z: 0 };
+        entity.textDirection.z = parseFloat(tag.value);
+        break;
+      case 40:
+        entity.height = parseFloat(tag.value);
+        break;
+      case 41:
+        entity.width = parseFloat(tag.value);
+        break;
+      case 44:
+        entity.lineSpacingFactor = parseFloat(tag.value);
+        break;
+      case 50:
+        entity.rotation = parseFloat(tag.value);
+        break;
+      case 71:
+        entity.attachmentPoint = parseInt(tag.value, 10);
+        break;
+      case 72:
+        entity.drawingDirection = parseInt(tag.value, 10);
+        break;
+      case 73:
+        entity.lineSpacingStyle = parseInt(tag.value, 10);
+        break;
+      case 90:
+        entity.bgFill = parseInt(tag.value, 10);
+        break;
+    }
+  }
+  entity.text = textChunks.join("");
+  return entity;
+}
+// src/parser/entities/insert.ts
+function parseInsert(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "INSERT",
+    blockName: "",
+    insertionPoint: { x: 0, y: 0, z: 0 },
+    scaleX: 1,
+    scaleY: 1,
+    scaleZ: 1,
+    rotation: 0,
+    columnCount: 1,
+    rowCount: 1,
+    columnSpacing: 0,
+    rowSpacing: 0,
+    attribs: []
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 2:
+        entity.blockName = tag.value;
+        break;
+      case 10:
+        entity.insertionPoint.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.insertionPoint.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.insertionPoint.z = parseFloat(tag.value);
+        break;
+      case 41:
+        entity.scaleX = parseFloat(tag.value);
+        break;
+      case 42:
+        entity.scaleY = parseFloat(tag.value);
+        break;
+      case 43:
+        entity.scaleZ = parseFloat(tag.value);
+        break;
+      case 44:
+        entity.columnSpacing = parseFloat(tag.value);
+        break;
+      case 45:
+        entity.rowSpacing = parseFloat(tag.value);
+        break;
+      case 50:
+        entity.rotation = parseFloat(tag.value);
+        break;
+      case 70:
+        entity.columnCount = parseInt(tag.value, 10) || 1;
+        break;
+      case 71:
+        entity.rowCount = parseInt(tag.value, 10) || 1;
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/entities/dimension.ts
+function parseDimension(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "DIMENSION",
+    blockName: "",
+    dimStyle: "STANDARD",
+    dimType: 0,
+    defPoint: { x: 0, y: 0, z: 0 },
+    textMidpoint: { x: 0, y: 0, z: 0 },
+    textOverride: "",
+    rotation: 0,
+    textRotation: 0,
+    leaderLength: 0
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 1:
+        entity.textOverride = tag.value;
+        break;
+      case 2:
+        entity.blockName = tag.value;
+        break;
+      case 3:
+        entity.dimStyle = tag.value;
+        break;
+      case 10:
+        entity.defPoint.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.defPoint.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.defPoint.z = parseFloat(tag.value);
+        break;
+      case 11:
+        entity.textMidpoint.x = parseFloat(tag.value);
+        break;
+      case 21:
+        entity.textMidpoint.y = parseFloat(tag.value);
+        break;
+      case 31:
+        entity.textMidpoint.z = parseFloat(tag.value);
+        break;
+      case 13:
+        if (!entity.defPoint2) entity.defPoint2 = { x: 0, y: 0, z: 0 };
+        entity.defPoint2.x = parseFloat(tag.value);
+        break;
+      case 23:
+        if (!entity.defPoint2) entity.defPoint2 = { x: 0, y: 0, z: 0 };
+        entity.defPoint2.y = parseFloat(tag.value);
+        break;
+      case 33:
+        if (!entity.defPoint2) entity.defPoint2 = { x: 0, y: 0, z: 0 };
+        entity.defPoint2.z = parseFloat(tag.value);
+        break;
+      case 14:
+        if (!entity.defPoint3) entity.defPoint3 = { x: 0, y: 0, z: 0 };
+        entity.defPoint3.x = parseFloat(tag.value);
+        break;
+      case 24:
+        if (!entity.defPoint3) entity.defPoint3 = { x: 0, y: 0, z: 0 };
+        entity.defPoint3.y = parseFloat(tag.value);
+        break;
+      case 34:
+        if (!entity.defPoint3) entity.defPoint3 = { x: 0, y: 0, z: 0 };
+        entity.defPoint3.z = parseFloat(tag.value);
+        break;
+      case 15:
+        if (!entity.defPoint4) entity.defPoint4 = { x: 0, y: 0, z: 0 };
+        entity.defPoint4.x = parseFloat(tag.value);
+        break;
+      case 25:
+        if (!entity.defPoint4) entity.defPoint4 = { x: 0, y: 0, z: 0 };
+        entity.defPoint4.y = parseFloat(tag.value);
+        break;
+      case 35:
+        if (!entity.defPoint4) entity.defPoint4 = { x: 0, y: 0, z: 0 };
+        entity.defPoint4.z = parseFloat(tag.value);
+        break;
+      case 16:
+        if (!entity.defPoint5) entity.defPoint5 = { x: 0, y: 0, z: 0 };
+        entity.defPoint5.x = parseFloat(tag.value);
+        break;
+      case 26:
+        if (!entity.defPoint5) entity.defPoint5 = { x: 0, y: 0, z: 0 };
+        entity.defPoint5.y = parseFloat(tag.value);
+        break;
+      case 36:
+        if (!entity.defPoint5) entity.defPoint5 = { x: 0, y: 0, z: 0 };
+        entity.defPoint5.z = parseFloat(tag.value);
+        break;
+      case 40:
+        entity.leaderLength = parseFloat(tag.value);
+        break;
+      case 50:
+        entity.rotation = parseFloat(tag.value);
+        break;
+      case 53:
+        entity.textRotation = parseFloat(tag.value);
+        break;
+      case 70:
+        entity.dimType = parseInt(tag.value, 10);
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/entities/hatch.ts
+function parseHatch(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "HATCH",
+    patternName: "",
+    solidFill: true,
+    associative: false,
+    hatchStyle: 0,
+    patternType: 1,
+    patternAngle: 0,
+    patternScale: 1,
+    boundaryPaths: []
+  };
+  let i = 0;
+  while (i < tags.length) {
+    const tag = tags[i];
+    switch (tag.code) {
+      case 2:
+        entity.patternName = tag.value;
+        break;
+      case 41:
+        entity.patternScale = parseFloat(tag.value);
+        break;
+      case 52:
+        entity.patternAngle = parseFloat(tag.value);
+        break;
+      case 70:
+        entity.solidFill = tag.value === "1";
+        break;
+      case 71:
+        entity.associative = tag.value === "1";
+        break;
+      case 75:
+        entity.hatchStyle = parseInt(tag.value, 10);
+        break;
+      case 76:
+        entity.patternType = parseInt(tag.value, 10);
+        break;
+      case 91: {
+        const pathCount = parseInt(tag.value, 10);
+        i++;
+        for (let p = 0; p < pathCount && i < tags.length; p++) {
+          const result = parseBoundaryPath(tags, i);
+          entity.boundaryPaths.push(result.path);
+          i = result.nextIndex;
+        }
+        continue;
+      }
+    }
+    i++;
+  }
+  return entity;
+}
+function parseBoundaryPath(tags, i) {
+  let flags = 0;
+  if (i < tags.length && tags[i].code === 92) {
+    flags = parseInt(tags[i].value, 10);
+    i++;
+  }
+  const isPolyline = (flags & 2) !== 0;
+  if (isPolyline) {
+    return parsePolylinePath(tags, i, flags);
+  } else {
+    return parseEdgePath(tags, i, flags);
+  }
+}
+function parsePolylinePath(tags, i, flags) {
+  const path = {
+    type: "polyline",
+    vertices: [],
+    bulges: [],
+    flags
+  };
+  let hasBulge = false;
+  if (i < tags.length && tags[i].code === 72) {
+    hasBulge = tags[i].value === "1";
+    i++;
+  }
+  if (i < tags.length && tags[i].code === 73) {
+    path.isClosed = tags[i].value === "1";
+    i++;
+  }
+  let vertexCount = 0;
+  if (i < tags.length && tags[i].code === 93) {
+    vertexCount = parseInt(tags[i].value, 10);
+    i++;
+  }
+  for (let v = 0; v < vertexCount && i < tags.length; v++) {
+    const vertex = { x: 0, y: 0 };
+    if (tags[i].code === 10) {
+      vertex.x = parseFloat(tags[i].value);
+      i++;
+    }
+    if (i < tags.length && tags[i].code === 20) {
+      vertex.y = parseFloat(tags[i].value);
+      i++;
+    }
+    path.vertices.push(vertex);
+    if (hasBulge && i < tags.length && tags[i].code === 42) {
+      path.bulges.push(parseFloat(tags[i].value));
+      i++;
+    } else if (hasBulge) {
+      path.bulges.push(0);
+    }
+  }
+  while (i < tags.length && (tags[i].code === 97 || tags[i].code === 330)) {
+    if (tags[i].code === 97) {
+      const count = parseInt(tags[i].value, 10);
+      i++;
+      for (let s = 0; s < count && i < tags.length && tags[i].code === 330; s++) {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  return { path, nextIndex: i };
+}
+function parseEdgePath(tags, i, flags) {
+  const path = {
+    type: "edges",
+    edges: [],
+    flags
+  };
+  let edgeCount = 0;
+  if (i < tags.length && tags[i].code === 93) {
+    edgeCount = parseInt(tags[i].value, 10);
+    i++;
+  }
+  for (let e = 0; e < edgeCount && i < tags.length; e++) {
+    if (tags[i].code !== 72) break;
+    const edgeType = parseInt(tags[i].value, 10);
+    i++;
+    switch (edgeType) {
+      case 1: {
+        const edge = {
+          type: "line",
+          start: { x: 0, y: 0 },
+          end: { x: 0, y: 0 }
+        };
+        if (i < tags.length && tags[i].code === 10) {
+          edge.start.x = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 20) {
+          edge.start.y = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 11) {
+          edge.end.x = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 21) {
+          edge.end.y = parseFloat(tags[i].value);
+          i++;
+        }
+        path.edges.push(edge);
+        break;
+      }
+      case 2: {
+        const edge = {
+          type: "arc",
+          center: { x: 0, y: 0 },
+          radius: 0,
+          startAngle: 0,
+          endAngle: 360,
+          ccw: true
+        };
+        if (i < tags.length && tags[i].code === 10) {
+          edge.center.x = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 20) {
+          edge.center.y = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 40) {
+          edge.radius = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 50) {
+          edge.startAngle = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 51) {
+          edge.endAngle = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 73) {
+          edge.ccw = tags[i].value === "1";
+          i++;
+        }
+        path.edges.push(edge);
+        break;
+      }
+      case 3: {
+        const edge = {
+          type: "ellipse",
+          center: { x: 0, y: 0 },
+          majorAxis: { x: 1, y: 0 },
+          minorRatio: 1,
+          startAngle: 0,
+          endAngle: Math.PI * 2,
+          ccw: true
+        };
+        if (i < tags.length && tags[i].code === 10) {
+          edge.center.x = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 20) {
+          edge.center.y = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 11) {
+          edge.majorAxis.x = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 21) {
+          edge.majorAxis.y = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 40) {
+          edge.minorRatio = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 50) {
+          edge.startAngle = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 51) {
+          edge.endAngle = parseFloat(tags[i].value);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 73) {
+          edge.ccw = tags[i].value === "1";
+          i++;
+        }
+        path.edges.push(edge);
+        break;
+      }
+      case 4: {
+        let degree = 3;
+        const knots = [];
+        const controlPoints = [];
+        if (i < tags.length && tags[i].code === 94) {
+          degree = parseInt(tags[i].value, 10);
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 73) {
+          i++;
+        }
+        if (i < tags.length && tags[i].code === 74) {
+          i++;
+        }
+        let knotCount = 0;
+        if (i < tags.length && tags[i].code === 95) {
+          knotCount = parseInt(tags[i].value, 10);
+          i++;
+        }
+        let cpCount = 0;
+        if (i < tags.length && tags[i].code === 96) {
+          cpCount = parseInt(tags[i].value, 10);
+          i++;
+        }
+        for (let k = 0; k < knotCount && i < tags.length && tags[i].code === 40; k++) {
+          knots.push(parseFloat(tags[i].value));
+          i++;
+        }
+        for (let c = 0; c < cpCount && i < tags.length; c++) {
+          const pt = { x: 0, y: 0 };
+          if (tags[i].code === 10) {
+            pt.x = parseFloat(tags[i].value);
+            i++;
+          }
+          if (i < tags.length && tags[i].code === 20) {
+            pt.y = parseFloat(tags[i].value);
+            i++;
+          }
+          controlPoints.push(pt);
+        }
+        path.edges.push({ type: "spline", degree, knots, controlPoints });
+        break;
+      }
+    }
+  }
+  while (i < tags.length && (tags[i].code === 97 || tags[i].code === 330)) {
+    if (tags[i].code === 97) {
+      const count = parseInt(tags[i].value, 10);
+      i++;
+      for (let s = 0; s < count && i < tags.length && tags[i].code === 330; s++) {
+        i++;
+      }
+    } else {
+      i++;
+    }
+  }
+  return { path, nextIndex: i };
+}
+// src/parser/entities/point.ts
+function parsePoint(tags) {
+  const base = parseBaseEntity(tags);
+  const entity = {
+    ...base,
+    type: "POINT",
+    position: { x: 0, y: 0, z: 0 }
+  };
+  for (const tag of tags) {
+    switch (tag.code) {
+      case 10:
+        entity.position.x = parseFloat(tag.value);
+        break;
+      case 20:
+        entity.position.y = parseFloat(tag.value);
+        break;
+      case 30:
+        entity.position.z = parseFloat(tag.value);
+        break;
+    }
+  }
+  return entity;
+}
+// src/parser/sections/entities.ts
+function parseEntities(tokens, i, entities) {
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.code !== 0) {
+      i++;
+      continue;
+    }
+    const type = token.value;
+    if (type === "ENDSEC" || type === "ENDBLK") return i + 1;
+    i++;
+    const entityTags = [];
+    while (i < tokens.length && tokens[i].code !== 0) {
+      entityTags.push(tokens[i]);
+      i++;
+    }
+    switch (type) {
+      case "LINE":
+        entities.push(parseLine(entityTags));
+        break;
+      case "CIRCLE":
+        entities.push(parseCircle(entityTags));
+        break;
+      case "ARC":
+        entities.push(parseArc(entityTags));
+        break;
+      case "LWPOLYLINE":
+        entities.push(parseLwPolyline(entityTags));
+        break;
+      case "ELLIPSE":
+        entities.push(parseEllipse(entityTags));
+        break;
+      case "SPLINE":
+        entities.push(parseSpline(entityTags));
+        break;
+      case "TEXT":
+        entities.push(parseText(entityTags));
+        break;
+      case "MTEXT":
+        entities.push(parseMText(entityTags));
+        break;
+      case "INSERT": {
+        const insert = parseInsert(entityTags);
+        const hasAttribs = entityTags.some((t) => t.code === 66 && t.value === "1");
+        if (hasAttribs) {
+          i = parseAttribs(tokens, i, insert.attribs);
+        }
+        entities.push(insert);
+        break;
+      }
+      case "DIMENSION":
+        entities.push(parseDimension(entityTags));
+        break;
+      case "HATCH":
+        entities.push(parseHatch(entityTags));
+        break;
+      case "POINT":
+        entities.push(parsePoint(entityTags));
+        break;
+      case "POLYLINE": {
+        const polyline = parsePolyline(entityTags);
+        i = parseVertices(tokens, i, polyline.vertices);
+        entities.push(polyline);
+        break;
+      }
+    }
+  }
+  return i;
+}
+function parseVertices(tokens, i, vertices) {
+  while (i < tokens.length) {
+    if (tokens[i].code !== 0) {
+      i++;
+      continue;
+    }
+    const type = tokens[i].value;
+    if (type === "SEQEND") return i + 1;
+    if (type === "ENDSEC" || type === "ENDBLK") return i;
+    if (type === "VERTEX") {
+      i++;
+      const vertex = { x: 0, y: 0, bulge: 0, startWidth: 0, endWidth: 0 };
+      while (i < tokens.length && tokens[i].code !== 0) {
+        const tag = tokens[i];
+        switch (tag.code) {
+          case 10:
+            vertex.x = parseFloat(tag.value);
+            break;
+          case 20:
+            vertex.y = parseFloat(tag.value);
+            break;
+          case 42:
+            vertex.bulge = parseFloat(tag.value);
+            break;
+          case 40:
+            vertex.startWidth = parseFloat(tag.value);
+            break;
+          case 41:
+            vertex.endWidth = parseFloat(tag.value);
+            break;
+        }
+        i++;
+      }
+      vertices.push(vertex);
+    } else {
+      i++;
+      while (i < tokens.length && tokens[i].code !== 0) i++;
+    }
+  }
+  return i;
+}
+function parseAttribs(tokens, i, attribs) {
+  while (i < tokens.length) {
+    if (tokens[i].code !== 0) {
+      i++;
+      continue;
+    }
+    const type = tokens[i].value;
+    if (type === "SEQEND") return i + 1;
+    if (type === "ENDSEC" || type === "ENDBLK") return i;
+    if (type === "ATTRIB") {
+      i++;
+      const attrib = {
+        tag: "",
+        text: "",
+        insertionPoint: { x: 0, y: 0, z: 0 },
+        height: 1,
+        rotation: 0,
+        style: "STANDARD",
+        layer: "0",
+        color: 256
+      };
+      while (i < tokens.length && tokens[i].code !== 0) {
+        const tag = tokens[i];
+        switch (tag.code) {
+          case 1:
+            attrib.text = tag.value;
+            break;
+          case 2:
+            attrib.tag = tag.value;
+            break;
+          case 7:
+            attrib.style = tag.value;
+            break;
+          case 8:
+            attrib.layer = tag.value;
+            break;
+          case 10:
+            attrib.insertionPoint.x = parseFloat(tag.value);
+            break;
+          case 20:
+            attrib.insertionPoint.y = parseFloat(tag.value);
+            break;
+          case 30:
+            attrib.insertionPoint.z = parseFloat(tag.value);
+            break;
+          case 40:
+            attrib.height = parseFloat(tag.value);
+            break;
+          case 50:
+            attrib.rotation = parseFloat(tag.value);
+            break;
+          case 62:
+            attrib.color = parseInt(tag.value, 10);
+            break;
+        }
+        i++;
+      }
+      attribs.push(attrib);
+    } else {
+      i++;
+      while (i < tokens.length && tokens[i].code !== 0) i++;
+    }
+  }
+  return i;
+}
+// src/parser/sections/blocks.ts
+function parseBlocks(tokens, i, blocks) {
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.code === 0 && token.value === "ENDSEC") return i + 1;
+    if (token.code === 0 && token.value === "BLOCK") {
+      i++;
+      const block = {
+        name: "",
+        basePoint: { x: 0, y: 0, z: 0 },
+        entities: [],
+        flags: 0
+      };
+      while (i < tokens.length && tokens[i].code !== 0) {
+        const tag = tokens[i];
+        switch (tag.code) {
+          case 2:
+            block.name = tag.value;
+            break;
+          case 8:
+            break;
+          case 10:
+            block.basePoint.x = parseFloat(tag.value);
+            break;
+          case 20:
+            block.basePoint.y = parseFloat(tag.value);
+            break;
+          case 30:
+            block.basePoint.z = parseFloat(tag.value);
+            break;
+          case 70:
+            block.flags = parseInt(tag.value, 10);
+            break;
+        }
+        i++;
+      }
+      i = parseEntities(tokens, i, block.entities);
+      if (block.name && !block.name.startsWith("*Model_Space") && !block.name.startsWith("*Paper_Space")) {
+        blocks.set(block.name, block);
+      }
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+// src/parser/index.ts
+var BINARY_DXF_SENTINEL = "AutoCAD Binary DXF";
+var CODEPAGE_MAP = {
+  "ANSI_874": "windows-874",
+  "ANSI_932": "shift_jis",
+  "ANSI_936": "gbk",
+  "ANSI_949": "euc-kr",
+  "ANSI_950": "big5",
+  "ANSI_1250": "windows-1250",
+  "ANSI_1251": "windows-1251",
+  "ANSI_1252": "windows-1252",
+  "ANSI_1253": "windows-1253",
+  "ANSI_1254": "windows-1254",
+  "ANSI_1255": "windows-1255",
+  "ANSI_1256": "windows-1256",
+  "ANSI_1257": "windows-1257",
+  "ANSI_1258": "windows-1258"
+};
+var UTF8_MIN_VERSION = "AC1021";
+function createDefaultHeader() {
+  return {
+    acadVersion: "",
+    insUnits: 0,
+    measurement: 0,
+    ltScale: 1
+  };
+}
+function decodeUnicodeEscapes(text) {
+  return text.replace(
+    /\\U\+([0-9A-Fa-f]{4})/g,
+    (_, hex) => String.fromCodePoint(parseInt(hex, 16))
+  );
+}
+function decodeInput(input) {
+  if (typeof input === "string") {
+    return decodeUnicodeEscapes(input);
+  }
+  const bytes = new Uint8Array(input);
+  const sentinelBytes = new TextDecoder("ascii").decode(bytes.slice(0, BINARY_DXF_SENTINEL.length));
+  if (sentinelBytes === BINARY_DXF_SENTINEL) {
+    throw new Error("Binary DXF format is not supported. Please export as ASCII DXF.");
+  }
+  let text = new TextDecoder("utf-8").decode(input);
+  const versionMatch = text.match(/\$ACADVER[\s\S]*?\n\s*1\s*\n\s*(\S+)/);
+  const version = versionMatch?.[1] ?? "";
+  if (version && version < UTF8_MIN_VERSION) {
+    const cpMatch = text.match(/\$DWGCODEPAGE[\s\S]*?\n\s*3\s*\n\s*(\S+)/);
+    const codepage = cpMatch?.[1] ?? "";
+    const encoding = CODEPAGE_MAP[codepage] ?? "windows-1252";
+    if (encoding !== "utf-8") {
+      text = new TextDecoder(encoding).decode(input);
+    }
+  }
+  return decodeUnicodeEscapes(text);
+}
+function skipSection(tokens, i) {
+  while (i < tokens.length) {
+    if (tokens[i].code === 0 && tokens[i].value === "ENDSEC") {
+      return i + 1;
+    }
+    i++;
+  }
+  return i;
+}
+function ensureDefaultLayer(doc) {
+  if (!doc.layers.has("0")) {
+    doc.layers.set("0", {
+      name: "0",
+      color: 7,
+      lineType: "Continuous",
+      flags: 0,
+      lineWeight: -3,
+      isOff: false,
+      isFrozen: false,
+      isLocked: false
+    });
+  }
+}
+function computeDerivedLayerFlags(doc) {
+  for (const [, layer] of doc.layers) {
+    layer.isOff = layer.color < 0;
+    if (layer.isOff) {
+      layer.color = Math.abs(layer.color);
+    }
+    layer.isFrozen = (layer.flags & 1) !== 0;
+    layer.isLocked = (layer.flags & 4) !== 0;
+  }
+}
+var DxfParseError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "DxfParseError";
+  }
+};
+function parseDxf(input) {
+  if (typeof input === "string") {
+    if (input.length === 0) {
+      throw new DxfParseError("Input is empty. Expected a DXF string or ArrayBuffer.");
+    }
+  } else if (input instanceof ArrayBuffer) {
+    if (input.byteLength === 0) {
+      throw new DxfParseError("Input ArrayBuffer is empty.");
+    }
+  } else {
+    throw new DxfParseError("Invalid input type. Expected a string or ArrayBuffer.");
+  }
+  let text;
+  try {
+    text = decodeInput(input);
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("Binary DXF")) {
+      throw err;
+    }
+    throw new DxfParseError("Failed to decode DXF input.", err);
+  }
+  let tokens;
+  try {
+    tokens = tokenize(text);
+  } catch (err) {
+    throw new DxfParseError("Failed to tokenize DXF content.", err);
+  }
+  if (tokens.length === 0) {
+    throw new DxfParseError("DXF content produced no tokens. The input may not be a valid DXF file.");
+  }
+  const doc = {
+    header: createDefaultHeader(),
+    layers: /* @__PURE__ */ new Map(),
+    lineTypes: /* @__PURE__ */ new Map(),
+    styles: /* @__PURE__ */ new Map(),
+    blocks: /* @__PURE__ */ new Map(),
+    entities: []
+  };
+  try {
+    let i = 0;
+    while (i < tokens.length) {
+      const token = tokens[i];
+      if (token.code === 0 && token.value === "SECTION") {
+        i++;
+        if (i >= tokens.length) break;
+        const sectionName = tokens[i].value;
+        i++;
+        switch (sectionName) {
+          case "HEADER":
+            i = parseHeader(tokens, i, doc.header);
+            break;
+          case "TABLES":
+            i = parseTables(tokens, i, doc);
+            break;
+          case "BLOCKS":
+            i = parseBlocks(tokens, i, doc.blocks);
+            break;
+          case "ENTITIES":
+            i = parseEntities(tokens, i, doc.entities);
+            break;
+          default:
+            i = skipSection(tokens, i);
+            break;
+        }
+      } else if (token.code === 0 && token.value === "EOF") {
+        break;
+      } else {
+        i++;
+      }
+    }
+  } catch (err) {
+    throw new DxfParseError("Failed to parse DXF sections.", err);
+  }
+  ensureDefaultLayer(doc);
+  computeDerivedLayerFlags(doc);
+  return doc;
+}
+// src/parser/colors.ts
+var ACI_COLORS = [
+  "#000000",
+  // 0: BYBLOCK
+  "#FF0000",
+  // 1: Red
+  "#FFFF00",
+  // 2: Yellow
+  "#00FF00",
+  // 3: Green
+  "#00FFFF",
+  // 4: Cyan
+  "#0000FF",
+  // 5: Blue
+  "#FF00FF",
+  // 6: Magenta
+  "#FFFFFF",
+  // 7: White
+  "#808080",
+  // 8: Dark gray
+  "#C0C0C0",
+  // 9: Light gray
+  "#FF0000",
+  // 10
+  "#FF7F7F",
+  // 11
+  "#A50000",
+  // 12
+  "#A55252",
+  // 13
+  "#7F0000",
+  // 14
+  "#7F3F3F",
+  // 15
+  "#4C0000",
+  // 16
+  "#4C2626",
+  // 17
+  "#260000",
+  // 18
+  "#261313",
+  // 19
+  "#FF3F00",
+  // 20
+  "#FF9F7F",
+  // 21
+  "#A52900",
+  // 22
+  "#A56752",
+  // 23
+  "#7F1F00",
+  // 24
+  "#7F4F3F",
+  // 25
+  "#4C1300",
+  // 26
+  "#4C2F26",
+  // 27
+  "#260900",
+  // 28
+  "#261713",
+  // 29
+  "#FF7F00",
+  // 30
+  "#FFBF7F",
+  // 31
+  "#A55200",
+  // 32
+  "#A57C52",
+  // 33
+  "#7F3F00",
+  // 34
+  "#7F5F3F",
+  // 35
+  "#4C2600",
+  // 36
+  "#4C3926",
+  // 37
+  "#261300",
+  // 38
+  "#261C13",
+  // 39
+  "#FFBF00",
+  // 40
+  "#FFDF7F",
+  // 41
+  "#A57C00",
+  // 42
+  "#A59152",
+  // 43
+  "#7F5F00",
+  // 44
+  "#7F6F3F",
+  // 45
+  "#4C3900",
+  // 46
+  "#4C4226",
+  // 47
+  "#261C00",
+  // 48
+  "#262113",
+  // 49
+  "#FFFF00",
+  // 50
+  "#FFFF7F",
+  // 51
+  "#A5A500",
+  // 52
+  "#A5A552",
+  // 53
+  "#7F7F00",
+  // 54
+  "#7F7F3F",
+  // 55
+  "#4C4C00",
+  // 56
+  "#4C4C26",
+  // 57
+  "#262600",
+  // 58
+  "#262613",
+  // 59
+  "#BFFF00",
+  // 60
+  "#DFFF7F",
+  // 61
+  "#7CA500",
+  // 62
+  "#91A552",
+  // 63
+  "#5F7F00",
+  // 64
+  "#6F7F3F",
+  // 65
+  "#394C00",
+  // 66
+  "#424C26",
+  // 67
+  "#1C2600",
+  // 68
+  "#212613",
+  // 69
+  "#7FFF00",
+  // 70
+  "#BFFF7F",
+  // 71
+  "#52A500",
+  // 72
+  "#7CA552",
+  // 73
+  "#3F7F00",
+  // 74
+  "#5F7F3F",
+  // 75
+  "#264C00",
+  // 76
+  "#394C26",
+  // 77
+  "#132600",
+  // 78
+  "#1C2613",
+  // 79
+  "#3FFF00",
+  // 80
+  "#9FFF7F",
+  // 81
+  "#29A500",
+  // 82
+  "#67A552",
+  // 83
+  "#1F7F00",
+  // 84
+  "#4F7F3F",
+  // 85
+  "#134C00",
+  // 86
+  "#2F4C26",
+  // 87
+  "#092600",
+  // 88
+  "#172613",
+  // 89
+  "#00FF00",
+  // 90
+  "#7FFF7F",
+  // 91
+  "#00A500",
+  // 92
+  "#52A552",
+  // 93
+  "#007F00",
+  // 94
+  "#3F7F3F",
+  // 95
+  "#004C00",
+  // 96
+  "#264C26",
+  // 97
+  "#002600",
+  // 98
+  "#132613",
+  // 99
+  "#00FF3F",
+  // 100
+  "#7FFF9F",
+  // 101
+  "#00A529",
+  // 102
+  "#52A567",
+  // 103
+  "#007F1F",
+  // 104
+  "#3F7F4F",
+  // 105
+  "#004C13",
+  // 106
+  "#264C2F",
+  // 107
+  "#002609",
+  // 108
+  "#132617",
+  // 109
+  "#00FF7F",
+  // 110
+  "#7FFFBF",
+  // 111
+  "#00A552",
+  // 112
+  "#52A57C",
+  // 113
+  "#007F3F",
+  // 114
+  "#3F7F5F",
+  // 115
+  "#004C26",
+  // 116
+  "#264C39",
+  // 117
+  "#002613",
+  // 118
+  "#13261C",
+  // 119
+  "#00FFBF",
+  // 120
+  "#7FFFDF",
+  // 121
+  "#00A57C",
+  // 122
+  "#52A591",
+  // 123
+  "#007F5F",
+  // 124
+  "#3F7F6F",
+  // 125
+  "#004C39",
+  // 126
+  "#264C42",
+  // 127
+  "#00261C",
+  // 128
+  "#132621",
+  // 129
+  "#00FFFF",
+  // 130
+  "#7FFFFF",
+  // 131
+  "#00A5A5",
+  // 132
+  "#52A5A5",
+  // 133
+  "#007F7F",
+  // 134
+  "#3F7F7F",
+  // 135
+  "#004C4C",
+  // 136
+  "#264C4C",
+  // 137
+  "#002626",
+  // 138
+  "#132626",
+  // 139
+  "#00BFFF",
+  // 140
+  "#7FDFFF",
+  // 141
+  "#007CA5",
+  // 142
+  "#5291A5",
+  // 143
+  "#005F7F",
+  // 144
+  "#3F6F7F",
+  // 145
+  "#00394C",
+  // 146
+  "#26424C",
+  // 147
+  "#001C26",
+  // 148
+  "#132126",
+  // 149
+  "#007FFF",
+  // 150
+  "#7FBFFF",
+  // 151
+  "#0052A5",
+  // 152
+  "#527CA5",
+  // 153
+  "#003F7F",
+  // 154
+  "#3F5F7F",
+  // 155
+  "#00264C",
+  // 156
+  "#26394C",
+  // 157
+  "#001326",
+  // 158
+  "#131C26",
+  // 159
+  "#003FFF",
+  // 160
+  "#7F9FFF",
+  // 161
+  "#0029A5",
+  // 162
+  "#5267A5",
+  // 163
+  "#001F7F",
+  // 164
+  "#3F4F7F",
+  // 165
+  "#00134C",
+  // 166
+  "#262F4C",
+  // 167
+  "#000926",
+  // 168
+  "#131726",
+  // 169
+  "#0000FF",
+  // 170
+  "#7F7FFF",
+  // 171
+  "#0000A5",
+  // 172
+  "#5252A5",
+  // 173
+  "#00007F",
+  // 174
+  "#3F3F7F",
+  // 175
+  "#00004C",
+  // 176
+  "#26264C",
+  // 177
+  "#000026",
+  // 178
+  "#131326",
+  // 179
+  "#3F00FF",
+  // 180
+  "#9F7FFF",
+  // 181
+  "#2900A5",
+  // 182
+  "#6752A5",
+  // 183
+  "#1F007F",
+  // 184
+  "#4F3F7F",
+  // 185
+  "#13004C",
+  // 186
+  "#2F264C",
+  // 187
+  "#090026",
+  // 188
+  "#171326",
+  // 189
+  "#7F00FF",
+  // 190
+  "#BF7FFF",
+  // 191
+  "#5200A5",
+  // 192
+  "#7C52A5",
+  // 193
+  "#3F007F",
+  // 194
+  "#5F3F7F",
+  // 195
+  "#26004C",
+  // 196
+  "#39264C",
+  // 197
+  "#130026",
+  // 198
+  "#1C1326",
+  // 199
+  "#BF00FF",
+  // 200
+  "#DF7FFF",
+  // 201
+  "#7C00A5",
+  // 202
+  "#9152A5",
+  // 203
+  "#5F007F",
+  // 204
+  "#6F3F7F",
+  // 205
+  "#39004C",
+  // 206
+  "#42264C",
+  // 207
+  "#1C0026",
+  // 208
+  "#211326",
+  // 209
+  "#FF00FF",
+  // 210
+  "#FF7FFF",
+  // 211
+  "#A500A5",
+  // 212
+  "#A552A5",
+  // 213
+  "#7F007F",
+  // 214
+  "#7F3F7F",
+  // 215
+  "#4C004C",
+  // 216
+  "#4C264C",
+  // 217
+  "#260026",
+  // 218
+  "#261326",
+  // 219
+  "#FF00BF",
+  // 220
+  "#FF7FDF",
+  // 221
+  "#A5007C",
+  // 222
+  "#A55291",
+  // 223
+  "#7F005F",
+  // 224
+  "#7F3F6F",
+  // 225
+  "#4C0039",
+  // 226
+  "#4C2642",
+  // 227
+  "#26001C",
+  // 228
+  "#261321",
+  // 229
+  "#FF007F",
+  // 230
+  "#FF7FBF",
+  // 231
+  "#A50052",
+  // 232
+  "#A5527C",
+  // 233
+  "#7F003F",
+  // 234
+  "#7F3F5F",
+  // 235
+  "#4C0026",
+  // 236
+  "#4C2639",
+  // 237
+  "#260013",
+  // 238
+  "#26131C",
+  // 239
+  "#FF003F",
+  // 240
+  "#FF7F9F",
+  // 241
+  "#A50029",
+  // 242
+  "#A55267",
+  // 243
+  "#7F001F",
+  // 244
+  "#7F3F4F",
+  // 245
+  "#4C0013",
+  // 246
+  "#4C262F",
+  // 247
+  "#260009",
+  // 248
+  "#261317",
+  // 249
+  "#333333",
+  // 250: Gray (darkest)
+  "#505050",
+  // 251: Gray
+  "#696969",
+  // 252: Gray
+  "#828282",
+  // 253: Gray
+  "#BEBEBE",
+  // 254: Gray
+  "#FFFFFF"
+  // 255: Gray (lightest)
+];
+function aciToHex(aci) {
+  if (aci === 0 || aci === 256) return void 0;
+  if (aci < 0 || aci > 255) return void 0;
+  return ACI_COLORS[aci];
+}
+function aciToDisplayColor(aci, isDarkTheme) {
+  if (aci === 7) return isDarkTheme ? "#FFFFFF" : "#000000";
+  return ACI_COLORS[Math.abs(aci)] ?? (isDarkTheme ? "#FFFFFF" : "#000000");
+}
+function trueColorToHex(trueColor) {
+  const r = trueColor >> 16 & 255;
+  const g = trueColor >> 8 & 255;
+  const b = trueColor & 255;
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+// src/renderer/theme.ts
+var THEMES = {
+  dark: {
+    backgroundColor: "#1a1a2e",
+    defaultEntityColor: "#ffffff",
+    selectionColor: "#00ff88",
+    measureColor: "#ffaa00",
+    gridColor: "#333333",
+    crosshairColor: "#555555"
+  },
+  light: {
+    backgroundColor: "#ffffff",
+    defaultEntityColor: "#000000",
+    selectionColor: "#0066ff",
+    measureColor: "#ff6600",
+    gridColor: "#dddddd",
+    crosshairColor: "#cccccc"
+  }
+};
+// src/renderer/camera.ts
+function worldToScreen(vt, wx, wy) {
+  return [
+    wx * vt.scale + vt.offsetX,
+    -wy * vt.scale + vt.offsetY
+  ];
+}
+function screenToWorld(vt, sx, sy) {
+  return [
+    (sx - vt.offsetX) / vt.scale,
+    -(sy - vt.offsetY) / vt.scale
+  ];
+}
+function applyTransform(ctx, vt) {
+  const dpr = window.devicePixelRatio || 1;
+  ctx.setTransform(vt.scale * dpr, 0, 0, -vt.scale * dpr, vt.offsetX * dpr, vt.offsetY * dpr);
+}
+function fitToView(canvasWidth, canvasHeight, minX, minY, maxX, maxY, padding = 0.05) {
+  const worldWidth = maxX - minX;
+  const worldHeight = maxY - minY;
+  if (worldWidth <= 0 || worldHeight <= 0) {
+    return { scale: 1, offsetX: canvasWidth / 2, offsetY: canvasHeight / 2 };
+  }
+  const scaleX = canvasWidth / worldWidth;
+  const scaleY = canvasHeight / worldHeight;
+  const scale = Math.min(scaleX, scaleY) * (1 - padding * 2);
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  const offsetX = canvasWidth / 2 - centerX * scale;
+  const offsetY = canvasHeight / 2 + centerY * scale;
+  return { scale, offsetX, offsetY };
+}
+function zoomAtPoint(vt, screenX, screenY, zoomFactor, minScale = 1e-4, maxScale = 1e5) {
+  const newScale = Math.max(minScale, Math.min(maxScale, vt.scale * zoomFactor));
+  const actualFactor = newScale / vt.scale;
+  return {
+    scale: newScale,
+    offsetX: screenX - (screenX - vt.offsetX) * actualFactor,
+    offsetY: screenY - (screenY - vt.offsetY) * actualFactor
+  };
+}
+var Camera = class {
+  transform = { scale: 1, offsetX: 0, offsetY: 0 };
+  minScale;
+  maxScale;
+  constructor(options) {
+    this.minScale = options.minZoom;
+    this.maxScale = options.maxZoom;
+  }
+  getTransform() {
+    return this.transform;
+  }
+  setTransform(vt) {
+    this.transform = vt;
+  }
+  pan(dx, dy) {
+    this.transform = {
+      ...this.transform,
+      offsetX: this.transform.offsetX + dx,
+      offsetY: this.transform.offsetY + dy
+    };
+  }
+  zoom(screenX, screenY, factor) {
+    this.transform = zoomAtPoint(
+      this.transform,
+      screenX,
+      screenY,
+      factor,
+      this.minScale,
+      this.maxScale
+    );
+  }
+};
+// src/renderer/resolve-color.ts
+function getDisplayColor(aciColor, theme) {
+  if (aciColor === 7) {
+    return theme === "dark" ? "#ffffff" : "#000000";
+  }
+  return aciToHex(aciColor) ?? "#ffffff";
+}
+function resolveEntityColor(entity, layers, theme, parentColor) {
+  if (entity.trueColor !== void 0) {
+    const r = entity.trueColor >> 16 & 255;
+    const g = entity.trueColor >> 8 & 255;
+    const b = entity.trueColor & 255;
+    return `rgb(${r},${g},${b})`;
+  }
+  if (entity.color === 0) {
+    return parentColor ?? THEMES[theme].defaultEntityColor;
+  }
+  if (entity.color !== 256) {
+    return getDisplayColor(entity.color, theme);
+  }
+  const layer = layers.get(entity.layer);
+  if (layer) {
+    if (layer.trueColor !== void 0) {
+      const r = layer.trueColor >> 16 & 255;
+      const g = layer.trueColor >> 8 & 255;
+      const b = layer.trueColor & 255;
+      return `rgb(${r},${g},${b})`;
+    }
+    const layerAci = Math.abs(layer.color);
+    return getDisplayColor(layerAci, theme);
+  }
+  return THEMES[theme].defaultEntityColor;
+}
+// src/renderer/entities/draw-line.ts
+function drawLine(ctx, entity) {
+  ctx.beginPath();
+  ctx.moveTo(entity.start.x, entity.start.y);
+  ctx.lineTo(entity.end.x, entity.end.y);
+  ctx.stroke();
+}
+// src/renderer/entities/draw-circle.ts
+function drawCircle(ctx, entity) {
+  if (entity.radius <= 0) return;
+  ctx.beginPath();
+  ctx.arc(entity.center.x, entity.center.y, entity.radius, 0, Math.PI * 2);
+  ctx.stroke();
+}
+// src/renderer/entities/draw-arc.ts
+function drawArc(ctx, entity) {
+  if (entity.radius <= 0) return;
+  const startRad = entity.startAngle * Math.PI / 180;
+  const endRad = entity.endAngle * Math.PI / 180;
+  ctx.beginPath();
+  ctx.arc(
+    entity.center.x,
+    entity.center.y,
+    entity.radius,
+    startRad,
+    endRad,
+    false
+  );
+  ctx.stroke();
+}
+// src/utils/math.ts
+function bulgeToArc(x1, y1, x2, y2, bulge) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const chord = Math.sqrt(dx * dx + dy * dy);
+  if (chord < 1e-10) {
+    return { cx: x1, cy: y1, radius: 0, startAngle: 0, endAngle: 0, anticlockwise: false };
+  }
+  const sagitta = Math.abs(bulge) * chord / 2;
+  const radius = ((chord / 2) ** 2 + sagitta ** 2) / (2 * sagitta);
+  const mx = (x1 + x2) / 2;
+  const my = (y1 + y2) / 2;
+  const perpX = -dy / chord;
+  const perpY = dx / chord;
+  const d = radius - sagitta;
+  const sign = bulge > 0 ? 1 : -1;
+  const cx = mx + sign * d * perpX;
+  const cy = my + sign * d * perpY;
+  const startAngle = Math.atan2(y1 - cy, x1 - cx);
+  const endAngle = Math.atan2(y2 - cy, x2 - cx);
+  const anticlockwise = bulge < 0;
+  return { cx, cy, radius, startAngle, endAngle, anticlockwise };
+}
+function drawBulgeArc(ctx, x1, y1, x2, y2, bulge) {
+  const arc = bulgeToArc(x1, y1, x2, y2, bulge);
+  if (arc.radius < 1e-10) {
+    ctx.lineTo(x2, y2);
+    return;
+  }
+  ctx.arc(arc.cx, arc.cy, arc.radius, arc.startAngle, arc.endAngle, arc.anticlockwise);
+}
+// src/renderer/entities/draw-polyline.ts
+function drawLwPolyline(ctx, entity) {
+  const verts = entity.vertices;
+  if (verts.length < 2) return;
+  ctx.beginPath();
+  ctx.moveTo(verts[0].x, verts[0].y);
+  const count = entity.closed ? verts.length : verts.length - 1;
+  for (let i = 0; i < count; i++) {
+    const current = verts[i];
+    const next = verts[(i + 1) % verts.length];
+    if (Math.abs(current.bulge) < 1e-10) {
+      ctx.lineTo(next.x, next.y);
+    } else {
+      drawBulgeArc(ctx, current.x, current.y, next.x, next.y, current.bulge);
+    }
+  }
+  ctx.stroke();
+}
+function drawPolyline(ctx, entity) {
+  const verts = entity.vertices;
+  if (verts.length < 2) return;
+  ctx.beginPath();
+  ctx.moveTo(verts[0].x, verts[0].y);
+  const count = entity.closed ? verts.length : verts.length - 1;
+  for (let i = 0; i < count; i++) {
+    const current = verts[i];
+    const next = verts[(i + 1) % verts.length];
+    const bulge = current.bulge ?? 0;
+    if (Math.abs(bulge) < 1e-10) {
+      ctx.lineTo(next.x, next.y);
+    } else {
+      drawBulgeArc(ctx, current.x, current.y, next.x, next.y, bulge);
+    }
+  }
+  ctx.stroke();
+}
+// src/renderer/entities/draw-ellipse.ts
+function drawEllipse(ctx, entity) {
+  const majorLength = Math.sqrt(
+    entity.majorAxis.x ** 2 + entity.majorAxis.y ** 2 + entity.majorAxis.z ** 2
+  );
+  if (majorLength < 1e-10 || entity.minorRatio <= 0) return;
+  const minorLength = majorLength * entity.minorRatio;
+  const rotation = Math.atan2(entity.majorAxis.y, entity.majorAxis.x);
+  ctx.beginPath();
+  ctx.ellipse(
+    entity.center.x,
+    entity.center.y,
+    majorLength,
+    minorLength,
+    rotation,
+    entity.startParam,
+    entity.endParam,
+    false
+  );
+  ctx.stroke();
+}
+// src/utils/spline.ts
+function deBoor(degree, controlPoints, knots, t, weights) {
+  const n = controlPoints.length - 1;
+  let k = degree;
+  while (k < n && knots[k + 1] <= t) k++;
+  const d = [];
+  const w = [];
+  for (let j = 0; j <= degree; j++) {
+    const idx = k - degree + j;
+    d.push({ ...controlPoints[idx] });
+    w.push(weights ? weights[idx] : 1);
+  }
+  for (let r = 1; r <= degree; r++) {
+    for (let j = degree; j >= r; j--) {
+      const i = k - degree + j;
+      const denom = knots[i + degree - r + 1] - knots[i];
+      if (Math.abs(denom) < 1e-10) continue;
+      const alpha = (t - knots[i]) / denom;
+      if (weights) {
+        const w0 = w[j - 1] * (1 - alpha);
+        const w1 = w[j] * alpha;
+        const wSum = w0 + w1;
+        if (Math.abs(wSum) < 1e-10) continue;
+        d[j].x = (d[j - 1].x * w0 + d[j].x * w1) / wSum;
+        d[j].y = (d[j - 1].y * w0 + d[j].y * w1) / wSum;
+        d[j].z = (d[j - 1].z * w0 + d[j].z * w1) / wSum;
+        w[j] = wSum;
+      } else {
+        d[j].x = (1 - alpha) * d[j - 1].x + alpha * d[j].x;
+        d[j].y = (1 - alpha) * d[j - 1].y + alpha * d[j].y;
+        d[j].z = (1 - alpha) * d[j - 1].z + alpha * d[j].z;
+      }
+    }
+  }
+  return d[degree];
+}
+function fitPointsToPolyline(fitPoints) {
+  if (fitPoints.length < 2) return fitPoints.map((p) => ({ x: p.x, y: p.y }));
+  const result = [];
+  const n = fitPoints.length;
+  const segments = 10;
+  for (let i = 0; i < n - 1; i++) {
+    const p0 = fitPoints[Math.max(0, i - 1)];
+    const p1 = fitPoints[i];
+    const p2 = fitPoints[Math.min(n - 1, i + 1)];
+    const p3 = fitPoints[Math.min(n - 1, i + 2)];
+    for (let j = 0; j <= (i === n - 2 ? segments : segments - 1); j++) {
+      const t = j / segments;
+      const t2 = t * t;
+      const t3 = t2 * t;
+      const x = 0.5 * (2 * p1.x + (-p0.x + p2.x) * t + (2 * p0.x - 5 * p1.x + 4 * p2.x - p3.x) * t2 + (-p0.x + 3 * p1.x - 3 * p2.x + p3.x) * t3);
+      const y = 0.5 * (2 * p1.y + (-p0.y + p2.y) * t + (2 * p0.y - 5 * p1.y + 4 * p2.y - p3.y) * t2 + (-p0.y + 3 * p1.y - 3 * p2.y + p3.y) * t3);
+      result.push({ x, y });
+    }
+  }
+  return result;
+}
+function evaluateSpline(entity, pixelSize) {
+  if (entity.degree === 1) {
+    return entity.controlPoints.map((p) => ({ x: p.x, y: p.y }));
+  }
+  if (entity.controlPoints.length === 0 && entity.fitPoints.length >= 2) {
+    return fitPointsToPolyline(entity.fitPoints);
+  }
+  if (entity.controlPoints.length < entity.degree + 1) return [];
+  if (entity.knots.length < entity.controlPoints.length + entity.degree + 1) return [];
+  const points = [];
+  const tMin = entity.knots[entity.degree];
+  const tMax = entity.knots[entity.knots.length - entity.degree - 1];
+  if (tMax <= tMin) return [];
+  const numPoints = Math.max(
+    entity.controlPoints.length * 10,
+    Math.ceil((tMax - tMin) / pixelSize)
+  );
+  const cappedPoints = Math.min(numPoints, 5e3);
+  const weights = entity.weights.length > 0 ? entity.weights : void 0;
+  for (let i = 0; i <= cappedPoints; i++) {
+    const t = tMin + (tMax - tMin) * (i / cappedPoints);
+    const p = deBoor(entity.degree, entity.controlPoints, entity.knots, t, weights);
+    points.push({ x: p.x, y: p.y });
+  }
+  return points;
+}
+// src/renderer/entities/draw-spline.ts
+function drawSpline(ctx, entity, pixelSize) {
+  const points = evaluateSpline(entity, pixelSize);
+  if (points.length < 2) return;
+  ctx.beginPath();
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) {
+    ctx.lineTo(points[i].x, points[i].y);
+  }
+  if (entity.flags & 1) {
+    ctx.closePath();
+  }
+  ctx.stroke();
+}
+// src/renderer/entities/draw-text.ts
+var CAD_FONT_MAP = {
+  "standard": "Arial, sans-serif",
+  "arial": "Arial, sans-serif",
+  "arial.ttf": "Arial, sans-serif",
+  "romans.shx": '"Courier New", monospace',
+  "simplex.shx": '"Courier New", monospace',
+  "txt.shx": "monospace",
+  "monotxt.shx": "monospace",
+  "isocp.shx": '"Courier New", monospace',
+  "isocpeur.shx": '"Courier New", monospace',
+  "times.ttf": '"Times New Roman", serif',
+  "timesnr.ttf": '"Times New Roman", serif',
+  "gothic.ttf": '"Century Gothic", sans-serif'
+};
+function mapCADFont(styleName) {
+  const key = styleName.toLowerCase().trim();
+  return CAD_FONT_MAP[key] || "sans-serif";
+}
+function drawText(ctx, entity, pixelSize) {
+  if (!entity.text || entity.height < pixelSize * 3) return;
+  const useAlignPoint = entity.hAlign !== 0 || entity.vAlign !== 0;
+  const px = useAlignPoint && entity.alignmentPoint ? entity.alignmentPoint.x : entity.insertionPoint.x;
+  const py = useAlignPoint && entity.alignmentPoint ? entity.alignmentPoint.y : entity.insertionPoint.y;
+  ctx.save();
+  ctx.translate(px, py);
+  ctx.scale(1, -1);
+  if (entity.rotation) {
+    ctx.rotate(-entity.rotation * Math.PI / 180);
+  }
+  if (entity.widthFactor !== 1) {
+    ctx.scale(entity.widthFactor, 1);
+  }
+  if (entity.obliqueAngle) {
+    const skew = Math.tan(entity.obliqueAngle * Math.PI / 180);
+    ctx.transform(1, 0, skew, 1, 0, 0);
+  }
+  const backward = (entity.generationFlags & 2) !== 0;
+  const upsideDown = (entity.generationFlags & 4) !== 0;
+  if (backward) ctx.scale(-1, 1);
+  if (upsideDown) ctx.scale(1, -1);
+  const fontName = mapCADFont(entity.style || "Standard");
+  ctx.font = `${entity.height}px ${fontName}`;
+  switch (entity.hAlign) {
+    case 0:
+      ctx.textAlign = "left";
+      break;
+    case 1:
+      ctx.textAlign = "center";
+      break;
+    case 2:
+      ctx.textAlign = "right";
+      break;
+    case 3:
+      ctx.textAlign = "left";
+      break;
+    // ALIGNED
+    case 4:
+      ctx.textAlign = "center";
+      break;
+    // MIDDLE
+    case 5:
+      ctx.textAlign = "left";
+      break;
+    // FIT
+    default:
+      ctx.textAlign = "left";
+  }
+  switch (entity.vAlign) {
+    case 0:
+      ctx.textBaseline = "alphabetic";
+      break;
+    case 1:
+      ctx.textBaseline = "bottom";
+      break;
+    case 2:
+      ctx.textBaseline = "middle";
+      break;
+    case 3:
+      ctx.textBaseline = "top";
+      break;
+    default:
+      ctx.textBaseline = "alphabetic";
+  }
+  ctx.fillText(entity.text, 0, 0);
+  ctx.restore();
+}
+function stripMTextFormatting(text) {
+  return text.replace(/\\P/g, "\n").replace(/\\[fFHWQTCAaLlOoKk][^;]*;/g, "").replace(/\\\\/g, "\\").replace(/\\~/g, "\xA0").replace(/\{/g, "").replace(/\}/g, "").replace(/\\S[^;]*;/g, "").trim();
+}
+function drawMText(ctx, entity, pixelSize) {
+  if (!entity.text || entity.height < pixelSize * 3) return;
+  ctx.save();
+  ctx.translate(entity.insertionPoint.x, entity.insertionPoint.y);
+  ctx.scale(1, -1);
+  const rotation = entity.textDirection ? Math.atan2(entity.textDirection.y, entity.textDirection.x) : (entity.rotation || 0) * Math.PI / 180;
+  if (rotation) ctx.rotate(-rotation);
+  const plainText = stripMTextFormatting(entity.text);
+  const lines = plainText.split("\n");
+  const lineHeight = entity.height * (entity.lineSpacingFactor || 1.4);
+  const fontName = mapCADFont(entity.style || "Standard");
+  ctx.font = `${entity.height}px ${fontName}`;
+  const col = (entity.attachmentPoint - 1) % 3;
+  const row = Math.floor((entity.attachmentPoint - 1) / 3);
+  const alignments = ["left", "center", "right"];
+  ctx.textAlign = alignments[col] ?? "left";
+  let startY = 0;
+  const totalHeight = lines.length * lineHeight;
+  switch (row) {
+    case 0:
+      startY = entity.height;
+      break;
+    // top: first line baseline
+    case 1:
+      startY = entity.height - totalHeight / 2;
+      break;
+    // middle
+    case 2:
+      startY = entity.height - totalHeight;
+      break;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    ctx.fillText(lines[i], 0, startY + i * lineHeight);
+  }
+  ctx.restore();
+}
+// src/renderer/entities/draw-insert.ts
+var MAX_INSERT_DEPTH = 100;
+function drawInsert(ctx, entity, doc, vt, theme, pixelSize, depth = 0) {
+  if (depth > MAX_INSERT_DEPTH) return;
+  const block = doc.blocks.get(entity.blockName);
+  if (!block) return;
+  const cols = Math.max(1, entity.columnCount);
+  const rows = Math.max(1, entity.rowCount);
+  for (let row = 0; row < rows; row++) {
+    for (let col = 0; col < cols; col++) {
+      ctx.save();
+      const ox = entity.insertionPoint.x + col * entity.columnSpacing;
+      const oy = entity.insertionPoint.y + row * entity.rowSpacing;
+      ctx.translate(ox, oy);
+      if (entity.rotation) {
+        ctx.rotate(entity.rotation * Math.PI / 180);
+      }
+      ctx.scale(entity.scaleX, entity.scaleY);
+      ctx.translate(-block.basePoint.x, -block.basePoint.y);
+      const scaleCompensation = Math.max(Math.abs(entity.scaleX), Math.abs(entity.scaleY));
+      const adjustedPixelSize = pixelSize / (scaleCompensation || 1);
+      for (const blockEntity of block.entities) {
+        const color = resolveEntityColor(blockEntity, doc.layers, theme);
+        ctx.strokeStyle = color;
+        ctx.fillStyle = color;
+        ctx.lineWidth = adjustedPixelSize;
+        if (blockEntity.type === "INSERT") {
+          drawInsert(ctx, blockEntity, doc, vt, theme, adjustedPixelSize, depth + 1);
+        } else {
+          drawEntity(ctx, blockEntity, doc, vt, theme, adjustedPixelSize);
+        }
+      }
+      ctx.restore();
+    }
+  }
+}
+// src/renderer/entities/draw-dimension.ts
+function drawDimension(ctx, entity, doc, vt, theme, pixelSize) {
+  if (entity.blockName) {
+    const block = doc.blocks.get(entity.blockName);
+    if (block) {
+      for (const blockEntity of block.entities) {
+        const color = resolveEntityColor(blockEntity, doc.layers, theme);
+        ctx.strokeStyle = color;
+        ctx.fillStyle = color;
+        ctx.lineWidth = pixelSize;
+        drawEntity(ctx, blockEntity, doc, vt, theme, pixelSize);
+      }
+      return;
+    }
+  }
+  if (entity.defPoint2 && entity.defPoint3) {
+    ctx.beginPath();
+    ctx.moveTo(entity.defPoint2.x, entity.defPoint2.y);
+    ctx.lineTo(entity.defPoint.x, entity.defPoint.y);
+    ctx.stroke();
+    ctx.beginPath();
+    ctx.moveTo(entity.defPoint3.x, entity.defPoint3.y);
+    ctx.lineTo(entity.defPoint.x, entity.defPoint.y);
+    ctx.stroke();
+  }
+}
+// src/renderer/entities/draw-hatch.ts
+function drawHatch(ctx, entity) {
+  if (entity.boundaryPaths.length === 0) return;
+  ctx.beginPath();
+  for (const path of entity.boundaryPaths) {
+    if (path.type === "polyline" && path.vertices && path.vertices.length > 0) {
+      const firstVert = path.vertices[0];
+      ctx.moveTo(firstVert.x, firstVert.y);
+      for (let i = 1; i < path.vertices.length; i++) {
+        const prev = path.vertices[i - 1];
+        const curr = path.vertices[i];
+        const bulge = path.bulges?.[i - 1] ?? 0;
+        if (Math.abs(bulge) < 1e-10) {
+          ctx.lineTo(curr.x, curr.y);
+        } else {
+          drawBulgeArc(ctx, prev.x, prev.y, curr.x, curr.y, bulge);
+        }
+      }
+      if (path.isClosed) ctx.closePath();
+    } else if (path.type === "edges" && path.edges) {
+      for (let i = 0; i < path.edges.length; i++) {
+        const edge = path.edges[i];
+        if (edge.type === "line") {
+          if (i === 0) ctx.moveTo(edge.start.x, edge.start.y);
+          ctx.lineTo(edge.end.x, edge.end.y);
+        } else if (edge.type === "arc") {
+          if (i === 0) {
+            const sx = edge.center.x + edge.radius * Math.cos(edge.startAngle * Math.PI / 180);
+            const sy = edge.center.y + edge.radius * Math.sin(edge.startAngle * Math.PI / 180);
+            ctx.moveTo(sx, sy);
+          }
+          ctx.arc(
+            edge.center.x,
+            edge.center.y,
+            edge.radius,
+            edge.startAngle * Math.PI / 180,
+            edge.endAngle * Math.PI / 180,
+            !edge.ccw
+          );
+        }
+      }
+    }
+  }
+  if (entity.solidFill) {
+    ctx.globalAlpha = 0.3;
+    ctx.fill("evenodd");
+    ctx.globalAlpha = 1;
+  }
+  ctx.stroke();
+}
+// src/renderer/entities/draw-point.ts
+function drawPoint(ctx, entity, pixelSize) {
+  const size = pixelSize * 3;
+  ctx.beginPath();
+  ctx.arc(entity.position.x, entity.position.y, size, 0, Math.PI * 2);
+  ctx.fill();
+}
+// src/renderer/entities/draw-entity.ts
+function drawEntity(ctx, entity, doc, vt, theme, pixelSize) {
+  switch (entity.type) {
+    case "LINE":
+      drawLine(ctx, entity);
+      break;
+    case "CIRCLE":
+      drawCircle(ctx, entity);
+      break;
+    case "ARC":
+      drawArc(ctx, entity);
+      break;
+    case "LWPOLYLINE":
+      drawLwPolyline(ctx, entity);
+      break;
+    case "POLYLINE":
+      drawPolyline(ctx, entity);
+      break;
+    case "ELLIPSE":
+      drawEllipse(ctx, entity);
+      break;
+    case "SPLINE":
+      drawSpline(ctx, entity, pixelSize);
+      break;
+    case "TEXT":
+      drawText(ctx, entity, pixelSize);
+      break;
+    case "MTEXT":
+      drawMText(ctx, entity, pixelSize);
+      break;
+    case "INSERT":
+      drawInsert(ctx, entity, doc, vt, theme, pixelSize);
+      break;
+    case "DIMENSION":
+      drawDimension(ctx, entity, doc, vt, theme, pixelSize);
+      break;
+    case "HATCH":
+      drawHatch(ctx, entity);
+      break;
+    case "POINT":
+      drawPoint(ctx, entity, pixelSize);
+      break;
+  }
+}
+// src/renderer/canvas-renderer.ts
+var CanvasRenderer = class {
+  constructor(canvas) {
+    this.canvas = canvas;
+    const ctx = canvas.getContext("2d", { alpha: false });
+    if (!ctx) {
+      throw new Error(
+        "Failed to get 2D rendering context. The canvas may already have a different context type, or canvas rendering is not available in this environment."
+      );
+    }
+    this.ctx = ctx;
+    this.updateSize();
+  }
+  ctx;
+  width = 0;
+  height = 0;
+  getContext() {
+    return this.ctx;
+  }
+  getWidth() {
+    return this.width;
+  }
+  getHeight() {
+    return this.height;
+  }
+  updateSize() {
+    const dpr = window.devicePixelRatio || 1;
+    const rect = this.canvas.getBoundingClientRect();
+    this.width = rect.width;
+    this.height = rect.height;
+    this.canvas.width = rect.width * dpr;
+    this.canvas.height = rect.height * dpr;
+  }
+  render(doc, vt, theme, visibleLayers, selectedEntityIndex) {
+    const ctx = this.ctx;
+    const dpr = window.devicePixelRatio || 1;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.fillStyle = THEMES[theme].backgroundColor;
+    ctx.fillRect(0, 0, this.width, this.height);
+    applyTransform(ctx, vt);
+    const pixelSize = 1 / vt.scale;
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    for (let i = 0; i < doc.entities.length; i++) {
+      const entity = doc.entities[i];
+      if (!entity.visible) continue;
+      if (!visibleLayers.has(entity.layer)) continue;
+      const color = resolveEntityColor(entity, doc.layers, theme);
+      ctx.strokeStyle = color;
+      ctx.fillStyle = color;
+      ctx.lineWidth = pixelSize;
+      drawEntity(ctx, entity, doc, vt, theme, pixelSize);
+    }
+    if (selectedEntityIndex >= 0 && selectedEntityIndex < doc.entities.length) {
+      const selEntity = doc.entities[selectedEntityIndex];
+      applyTransform(ctx, vt);
+      ctx.strokeStyle = THEMES[theme].selectionColor;
+      ctx.fillStyle = THEMES[theme].selectionColor;
+      ctx.lineWidth = pixelSize * 3;
+      drawEntity(ctx, selEntity, doc, vt, theme, pixelSize);
+    }
+  }
+  renderEmpty(theme) {
+    const ctx = this.ctx;
+    const dpr = window.devicePixelRatio || 1;
+    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+    ctx.fillStyle = THEMES[theme].backgroundColor;
+    ctx.fillRect(0, 0, this.width, this.height);
+  }
+  destroy() {
+  }
+};
+// src/viewer/layers.ts
+var LayerManager = class {
+  layers = /* @__PURE__ */ new Map();
+  visibility = /* @__PURE__ */ new Map();
+  colorOverrides = /* @__PURE__ */ new Map();
+  visibleCache = null;
+  setLayers(layers) {
+    this.layers = new Map(layers);
+    this.visibility.clear();
+    this.colorOverrides.clear();
+    this.visibleCache = null;
+    for (const [name, layer] of this.layers) {
+      this.visibility.set(name, !layer.isOff && !layer.isFrozen);
+    }
+  }
+  getAllLayers() {
+    return Array.from(this.layers.values());
+  }
+  setVisible(name, visible) {
+    this.visibility.set(name, visible);
+    this.visibleCache = null;
+  }
+  isVisible(name) {
+    return this.visibility.get(name) ?? true;
+  }
+  setColorOverride(name, color) {
+    this.colorOverrides.set(name, color);
+  }
+  getColorOverride(name) {
+    return this.colorOverrides.get(name);
+  }
+  getVisibleLayerNames() {
+    if (this.visibleCache) return this.visibleCache;
+    const visible = /* @__PURE__ */ new Set();
+    for (const [name, isVisible] of this.visibility) {
+      if (isVisible) visible.add(name);
+    }
+    this.visibleCache = visible;
+    return visible;
+  }
+  clear() {
+    this.layers.clear();
+    this.visibility.clear();
+    this.colorOverrides.clear();
+    this.visibleCache = null;
+  }
+};
+// src/viewer/events.ts
+var EventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+  }
+  off(event, callback) {
+    this.listeners.get(event)?.delete(callback);
+  }
+  emit(event, data) {
+    const callbacks = this.listeners.get(event);
+    if (callbacks) {
+      for (const cb of callbacks) {
+        cb(data);
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+// src/viewer/input-handler.ts
+var InputHandler = class {
+  constructor(canvas, viewer) {
+    this.canvas = canvas;
+    this.viewer = viewer;
+    this.onPointerDown = this.handlePointerDown.bind(this);
+    this.onPointerMove = this.handlePointerMove.bind(this);
+    this.onPointerUp = this.handlePointerUp.bind(this);
+    this.onWheel = this.handleWheel.bind(this);
+    this.onTouchStart = this.handleTouchStart.bind(this);
+    this.onTouchMove = this.handleTouchMove.bind(this);
+    this.onTouchEnd = this.handleTouchEnd.bind(this);
+    this.onContextMenu = (e) => e.preventDefault();
+    canvas.addEventListener("pointerdown", this.onPointerDown);
+    canvas.addEventListener("pointermove", this.onPointerMove);
+    canvas.addEventListener("pointerup", this.onPointerUp);
+    canvas.addEventListener("wheel", this.onWheel, { passive: false });
+    canvas.addEventListener("touchstart", this.onTouchStart, { passive: false });
+    canvas.addEventListener("touchmove", this.onTouchMove, { passive: false });
+    canvas.addEventListener("touchend", this.onTouchEnd);
+    canvas.addEventListener("contextmenu", this.onContextMenu);
+  }
+  isPanning = false;
+  lastX = 0;
+  lastY = 0;
+  touches = /* @__PURE__ */ new Map();
+  // Bound event handlers (for cleanup)
+  onPointerDown;
+  onPointerMove;
+  onPointerUp;
+  onWheel;
+  onTouchStart;
+  onTouchMove;
+  onTouchEnd;
+  onContextMenu;
+  destroy() {
+    this.canvas.removeEventListener("pointerdown", this.onPointerDown);
+    this.canvas.removeEventListener("pointermove", this.onPointerMove);
+    this.canvas.removeEventListener("pointerup", this.onPointerUp);
+    this.canvas.removeEventListener("wheel", this.onWheel);
+    this.canvas.removeEventListener("touchstart", this.onTouchStart);
+    this.canvas.removeEventListener("touchmove", this.onTouchMove);
+    this.canvas.removeEventListener("touchend", this.onTouchEnd);
+    this.canvas.removeEventListener("contextmenu", this.onContextMenu);
+  }
+  // --- Pointer Events (Mouse) ---
+  handlePointerDown(e) {
+    const tool = this.viewer.getTool();
+    const rect = this.canvas.getBoundingClientRect();
+    const x = e.clientX - rect.left;
+    const y = e.clientY - rect.top;
+    if (e.button === 0 && tool === "pan") {
+      this.startPan(e, x, y);
+    } else if (e.button === 1) {
+      this.startPan(e, x, y);
+    } else if (e.button === 0 && (tool === "select" || tool === "measure")) {
+      this.viewer.handleClick(x, y);
+    }
+  }
+  startPan(e, x, y) {
+    this.isPanning = true;
+    this.lastX = x;
+    this.lastY = y;
+    this.canvas.setPointerCapture(e.pointerId);
+    this.canvas.style.cursor = "grabbing";
+  }
+  handlePointerMove(e) {
+    const rect = this.canvas.getBoundingClientRect();
+    const x = e.clientX - rect.left;
+    const y = e.clientY - rect.top;
+    if (this.isPanning) {
+      const dx = x - this.lastX;
+      const dy = y - this.lastY;
+      this.lastX = x;
+      this.lastY = y;
+      this.viewer.handlePan(dx, dy);
+    } else {
+      this.viewer.handleMouseMove(x, y);
+    }
+  }
+  handlePointerUp(e) {
+    if (this.isPanning) {
+      this.isPanning = false;
+      this.canvas.releasePointerCapture(e.pointerId);
+      this.canvas.style.cursor = this.viewer.getTool() === "pan" ? "grab" : "crosshair";
+    }
+  }
+  // --- Wheel (Zoom) ---
+  handleWheel(e) {
+    e.preventDefault();
+    const rect = this.canvas.getBoundingClientRect();
+    const x = e.clientX - rect.left;
+    const y = e.clientY - rect.top;
+    const delta = -Math.sign(e.deltaY);
+    const speed = this.viewer.getZoomSpeed();
+    const factor = delta > 0 ? speed : 1 / speed;
+    this.viewer.handleZoom(x, y, factor);
+  }
+  // --- Touch Events (Pinch-to-Zoom) ---
+  handleTouchStart(e) {
+    e.preventDefault();
+    for (const t of Array.from(e.changedTouches)) {
+      this.touches.set(t.identifier, { x: t.clientX, y: t.clientY });
+    }
+  }
+  handleTouchMove(e) {
+    e.preventDefault();
+    if (this.touches.size === 2 && e.touches.length === 2) {
+      const t0 = e.touches[0];
+      const t1 = e.touches[1];
+      const prev = Array.from(this.touches.values());
+      const prevDist = Math.hypot(prev[0].x - prev[1].x, prev[0].y - prev[1].y);
+      const currDist = Math.hypot(t0.clientX - t1.clientX, t0.clientY - t1.clientY);
+      if (prevDist > 0) {
+        const zoomFactor = currDist / prevDist;
+        const rect = this.canvas.getBoundingClientRect();
+        const prevCenterX = (prev[0].x + prev[1].x) / 2 - rect.left;
+        const prevCenterY = (prev[0].y + prev[1].y) / 2 - rect.top;
+        const currCenterX = (t0.clientX + t1.clientX) / 2 - rect.left;
+        const currCenterY = (t0.clientY + t1.clientY) / 2 - rect.top;
+        this.viewer.handleZoom(prevCenterX, prevCenterY, zoomFactor);
+        this.viewer.handlePan(currCenterX - prevCenterX, currCenterY - prevCenterY);
+      }
+    } else if (this.touches.size === 1 && e.touches.length === 1) {
+      const t = e.touches[0];
+      const prev = this.touches.get(t.identifier);
+      if (prev) {
+        this.viewer.handlePan(
+          t.clientX - prev.x,
+          t.clientY - prev.y
+        );
+      }
+    }
+    for (const t of Array.from(e.changedTouches)) {
+      this.touches.set(t.identifier, { x: t.clientX, y: t.clientY });
+    }
+  }
+  handleTouchEnd(e) {
+    for (const t of Array.from(e.changedTouches)) {
+      this.touches.delete(t.identifier);
+    }
+  }
+};
+// src/utils/bbox.ts
+function computeEntitiesBounds(entities) {
+  let minX = Infinity, minY = Infinity;
+  let maxX = -Infinity, maxY = -Infinity;
+  let hasAny = false;
+  for (const entity of entities) {
+    const bbox = computeEntityBBox(entity);
+    if (!bbox) continue;
+    hasAny = true;
+    minX = Math.min(minX, bbox.minX);
+    minY = Math.min(minY, bbox.minY);
+    maxX = Math.max(maxX, bbox.maxX);
+    maxY = Math.max(maxY, bbox.maxY);
+  }
+  return hasAny ? { minX, minY, maxX, maxY } : null;
+}
+function computeEntityBBox(entity) {
+  switch (entity.type) {
+    case "LINE":
+      return {
+        minX: Math.min(entity.start.x, entity.end.x),
+        minY: Math.min(entity.start.y, entity.end.y),
+        maxX: Math.max(entity.start.x, entity.end.x),
+        maxY: Math.max(entity.start.y, entity.end.y)
+      };
+    case "CIRCLE":
+      return {
+        minX: entity.center.x - entity.radius,
+        minY: entity.center.y - entity.radius,
+        maxX: entity.center.x + entity.radius,
+        maxY: entity.center.y + entity.radius
+      };
+    case "ARC": {
+      return {
+        minX: entity.center.x - entity.radius,
+        minY: entity.center.y - entity.radius,
+        maxX: entity.center.x + entity.radius,
+        maxY: entity.center.y + entity.radius
+      };
+    }
+    case "LWPOLYLINE":
+    case "POLYLINE": {
+      if (entity.vertices.length === 0) return null;
+      let pMinX = Infinity, pMinY = Infinity, pMaxX = -Infinity, pMaxY = -Infinity;
+      for (const v of entity.vertices) {
+        pMinX = Math.min(pMinX, v.x);
+        pMinY = Math.min(pMinY, v.y);
+        pMaxX = Math.max(pMaxX, v.x);
+        pMaxY = Math.max(pMaxY, v.y);
+      }
+      return { minX: pMinX, minY: pMinY, maxX: pMaxX, maxY: pMaxY };
+    }
+    case "ELLIPSE": {
+      const majorLen = Math.sqrt(entity.majorAxis.x ** 2 + entity.majorAxis.y ** 2);
+      return {
+        minX: entity.center.x - majorLen,
+        minY: entity.center.y - majorLen,
+        maxX: entity.center.x + majorLen,
+        maxY: entity.center.y + majorLen
+      };
+    }
+    case "TEXT":
+      return {
+        minX: entity.insertionPoint.x,
+        minY: entity.insertionPoint.y,
+        maxX: entity.insertionPoint.x + entity.height * entity.text.length * 0.6,
+        maxY: entity.insertionPoint.y + entity.height
+      };
+    case "MTEXT":
+      return {
+        minX: entity.insertionPoint.x,
+        minY: entity.insertionPoint.y - entity.height,
+        maxX: entity.insertionPoint.x + (entity.width || entity.height * 10),
+        maxY: entity.insertionPoint.y + entity.height
+      };
+    case "SPLINE": {
+      if (entity.controlPoints.length === 0) return null;
+      let sMinX = Infinity, sMinY = Infinity, sMaxX = -Infinity, sMaxY = -Infinity;
+      for (const p of entity.controlPoints) {
+        sMinX = Math.min(sMinX, p.x);
+        sMinY = Math.min(sMinY, p.y);
+        sMaxX = Math.max(sMaxX, p.x);
+        sMaxY = Math.max(sMaxY, p.y);
+      }
+      return { minX: sMinX, minY: sMinY, maxX: sMaxX, maxY: sMaxY };
+    }
+    case "POINT":
+      return {
+        minX: entity.position.x,
+        minY: entity.position.y,
+        maxX: entity.position.x,
+        maxY: entity.position.y
+      };
+    case "INSERT":
+      return {
+        minX: entity.insertionPoint.x,
+        minY: entity.insertionPoint.y,
+        maxX: entity.insertionPoint.x,
+        maxY: entity.insertionPoint.y
+      };
+    case "DIMENSION":
+      if (entity.defPoint) {
+        return {
+          minX: Math.min(entity.defPoint.x, entity.defPoint2?.x ?? entity.defPoint.x, entity.defPoint3?.x ?? entity.defPoint.x),
+          minY: Math.min(entity.defPoint.y, entity.defPoint2?.y ?? entity.defPoint.y, entity.defPoint3?.y ?? entity.defPoint.y),
+          maxX: Math.max(entity.defPoint.x, entity.defPoint2?.x ?? entity.defPoint.x, entity.defPoint3?.x ?? entity.defPoint.x),
+          maxY: Math.max(entity.defPoint.y, entity.defPoint2?.y ?? entity.defPoint.y, entity.defPoint3?.y ?? entity.defPoint.y)
+        };
+      }
+      return null;
+    case "HATCH": {
+      let hMinX = Infinity, hMinY = Infinity, hMaxX = -Infinity, hMaxY = -Infinity;
+      let hasPoints = false;
+      for (const path of entity.boundaryPaths) {
+        if (path.vertices) {
+          for (const v of path.vertices) {
+            hasPoints = true;
+            hMinX = Math.min(hMinX, v.x);
+            hMinY = Math.min(hMinY, v.y);
+            hMaxX = Math.max(hMaxX, v.x);
+            hMaxY = Math.max(hMaxY, v.y);
+          }
+        }
+      }
+      return hasPoints ? { minX: hMinX, minY: hMinY, maxX: hMaxX, maxY: hMaxY } : null;
+    }
+    default:
+      return null;
+  }
+}
+// src/viewer/selection.ts
+var HIT_TOLERANCE_PX = 5;
+var SpatialIndex = class {
+  tree = new RBush__default.default();
+  items = [];
+  build(entities) {
+    this.items = [];
+    for (let i = 0; i < entities.length; i++) {
+      const entity = entities[i];
+      const bbox = computeEntityBBox(entity);
+      if (!bbox) continue;
+      this.items.push({
+        ...bbox,
+        entityIndex: i
+      });
+    }
+    this.tree.clear();
+    this.tree.load(this.items);
+  }
+  search(minX, minY, maxX, maxY) {
+    return this.tree.search({ minX, minY, maxX, maxY });
+  }
+  clear() {
+    this.tree.clear();
+    this.items = [];
+  }
+};
+function hitTest(wx, wy, entities, spatialIndex, visibleLayers, scale) {
+  const tolerance = HIT_TOLERANCE_PX / scale;
+  const candidates = spatialIndex.search(
+    wx - tolerance,
+    wy - tolerance,
+    wx + tolerance,
+    wy + tolerance
+  );
+  let bestDist = tolerance;
+  let bestIndex = -1;
+  for (let i = candidates.length - 1; i >= 0; i--) {
+    const item = candidates[i];
+    const entity = entities[item.entityIndex];
+    if (!entity) continue;
+    if (!visibleLayers.has(entity.layer)) continue;
+    if (!entity.visible) continue;
+    const dist = distanceToEntity(wx, wy, entity);
+    if (dist < bestDist) {
+      bestDist = dist;
+      bestIndex = item.entityIndex;
+    }
+  }
+  return bestIndex;
+}
+function distanceToEntity(wx, wy, entity) {
+  switch (entity.type) {
+    case "LINE":
+      return distPointToSegment(wx, wy, entity.start.x, entity.start.y, entity.end.x, entity.end.y);
+    case "CIRCLE":
+      return distPointToCircle(wx, wy, entity.center.x, entity.center.y, entity.radius);
+    case "ARC":
+      return distPointToArc(
+        wx,
+        wy,
+        entity.center.x,
+        entity.center.y,
+        entity.radius,
+        entity.startAngle * Math.PI / 180,
+        entity.endAngle * Math.PI / 180
+      );
+    case "LWPOLYLINE":
+    case "POLYLINE": {
+      let minDist = Infinity;
+      const verts = entity.vertices;
+      const count = entity.closed ? verts.length : verts.length - 1;
+      for (let i = 0; i < count; i++) {
+        const a = verts[i];
+        const b = verts[(i + 1) % verts.length];
+        const d = distPointToSegment(wx, wy, a.x, a.y, b.x, b.y);
+        minDist = Math.min(minDist, d);
+      }
+      return minDist;
+    }
+    case "ELLIPSE":
+      return distPointToEllipse(
+        wx,
+        wy,
+        entity.center.x,
+        entity.center.y,
+        entity.majorAxis,
+        entity.minorRatio
+      );
+    case "TEXT":
+    case "MTEXT": {
+      const bbox = computeEntityBBox(entity);
+      if (!bbox) return Infinity;
+      return distPointToRect(wx, wy, bbox.minX, bbox.minY, bbox.maxX, bbox.maxY);
+    }
+    case "POINT":
+      return Math.hypot(wx - entity.position.x, wy - entity.position.y);
+    case "SPLINE": {
+      let minDist = Infinity;
+      const pts = entity.controlPoints;
+      for (let i = 0; i < pts.length - 1; i++) {
+        const d = distPointToSegment(wx, wy, pts[i].x, pts[i].y, pts[i + 1].x, pts[i + 1].y);
+        minDist = Math.min(minDist, d);
+      }
+      return minDist;
+    }
+    default:
+      return Infinity;
+  }
+}
+function distPointToSegment(px, py, x1, y1, x2, y2) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) return Math.hypot(px - x1, py - y1);
+  let t = ((px - x1) * dx + (py - y1) * dy) / lenSq;
+  t = Math.max(0, Math.min(1, t));
+  const projX = x1 + t * dx;
+  const projY = y1 + t * dy;
+  return Math.hypot(px - projX, py - projY);
+}
+function distPointToCircle(px, py, cx, cy, radius) {
+  return Math.abs(Math.hypot(px - cx, py - cy) - radius);
+}
+function distPointToArc(px, py, cx, cy, radius, startAngle, endAngle) {
+  const angle = Math.atan2(py - cy, px - cx);
+  const normAngle = (angle % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+  const normStart = (startAngle % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+  const normEnd = (endAngle % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+  const inArc = normStart <= normEnd ? normAngle >= normStart && normAngle <= normEnd : normAngle >= normStart || normAngle <= normEnd;
+  if (inArc) {
+    return Math.abs(Math.hypot(px - cx, py - cy) - radius);
+  }
+  const d1 = Math.hypot(
+    px - (cx + radius * Math.cos(startAngle)),
+    py - (cy + radius * Math.sin(startAngle))
+  );
+  const d2 = Math.hypot(
+    px - (cx + radius * Math.cos(endAngle)),
+    py - (cy + radius * Math.sin(endAngle))
+  );
+  return Math.min(d1, d2);
+}
+function distPointToRect(px, py, minX, minY, maxX, maxY) {
+  if (px >= minX && px <= maxX && py >= minY && py <= maxY) return 0;
+  const dx = Math.max(minX - px, 0, px - maxX);
+  const dy = Math.max(minY - py, 0, py - maxY);
+  return Math.hypot(dx, dy);
+}
+function distPointToEllipse(px, py, cx, cy, majorAxis, minorRatio) {
+  const rotation = Math.atan2(majorAxis.y, majorAxis.x);
+  const cos = Math.cos(-rotation);
+  const sin = Math.sin(-rotation);
+  const localX = (px - cx) * cos - (py - cy) * sin;
+  const localY = (px - cx) * sin + (py - cy) * cos;
+  const a = Math.sqrt(majorAxis.x ** 2 + majorAxis.y ** 2);
+  const b = a * minorRatio;
+  if (a < 1e-10) return Math.hypot(px - cx, py - cy);
+  const scaledY = localY * (a / b);
+  const dist = Math.hypot(localX, scaledY);
+  if (dist < 1e-10) return a;
+  const onEllipseX = localX / dist * a;
+  const onEllipseY = localY / dist * b;
+  return Math.hypot(localX - onEllipseX, localY - onEllipseY);
+}
+// src/viewer/measure.ts
+var MeasureTool = class {
+  state = { phase: "idle" };
+  currentSnap = null;
+  activate() {
+    this.state = { phase: "first-point" };
+    this.currentSnap = null;
+  }
+  deactivate() {
+    this.state = { phase: "idle" };
+    this.currentSnap = null;
+  }
+  handleClick(wx, wy, snap) {
+    const point = snap ? snap.point : { x: wx, y: wy };
+    switch (this.state.phase) {
+      case "first-point":
+        this.state = {
+          phase: "second-point",
+          firstPoint: point,
+          firstSnap: snap ?? void 0
+        };
+        return null;
+      case "second-point": {
+        const p1 = this.state.firstPoint;
+        const p2 = point;
+        const dx = p2.x - p1.x;
+        const dy = p2.y - p1.y;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        const angle = Math.atan2(dy, dx) * 180 / Math.PI;
+        this.state = { phase: "done", firstPoint: p1, secondPoint: p2, distance, angle };
+        return {
+          distance,
+          angle,
+          deltaX: dx,
+          deltaY: dy,
+          points: [p1, p2]
+        };
+      }
+      case "done":
+        this.state = { phase: "second-point", firstPoint: point };
+        return null;
+      default:
+        return null;
+    }
+  }
+  handleMove(snap) {
+    this.currentSnap = snap;
+  }
+};
+function findSnaps(wx, wy, entities, spatialIndex, scale, snapTypes = /* @__PURE__ */ new Set(["endpoint", "midpoint", "center"])) {
+  const tolerance = 10 / scale;
+  const results = [];
+  const candidates = spatialIndex.search(
+    wx - tolerance,
+    wy - tolerance,
+    wx + tolerance,
+    wy + tolerance
+  );
+  for (const item of candidates) {
+    const entity = entities[item.entityIndex];
+    if (!entity) continue;
+    const idx = item.entityIndex;
+    switch (entity.type) {
+      case "LINE": {
+        if (snapTypes.has("endpoint")) {
+          addIfClose(results, entity.start.x, entity.start.y, "endpoint", idx, wx, wy, tolerance);
+          addIfClose(results, entity.end.x, entity.end.y, "endpoint", idx, wx, wy, tolerance);
+        }
+        if (snapTypes.has("midpoint")) {
+          const mx = (entity.start.x + entity.end.x) / 2;
+          const my = (entity.start.y + entity.end.y) / 2;
+          addIfClose(results, mx, my, "midpoint", idx, wx, wy, tolerance);
+        }
+        break;
+      }
+      case "CIRCLE": {
+        if (snapTypes.has("center")) {
+          addIfClose(results, entity.center.x, entity.center.y, "center", idx, wx, wy, tolerance);
+        }
+        if (snapTypes.has("endpoint")) {
+          for (const angle of [0, Math.PI / 2, Math.PI, 3 * Math.PI / 2]) {
+            const qx = entity.center.x + entity.radius * Math.cos(angle);
+            const qy = entity.center.y + entity.radius * Math.sin(angle);
+            addIfClose(results, qx, qy, "endpoint", idx, wx, wy, tolerance);
+          }
+        }
+        break;
+      }
+      case "ARC": {
+        if (snapTypes.has("center")) {
+          addIfClose(results, entity.center.x, entity.center.y, "center", idx, wx, wy, tolerance);
+        }
+        if (snapTypes.has("endpoint")) {
+          const startRad = entity.startAngle * Math.PI / 180;
+          const endRad = entity.endAngle * Math.PI / 180;
+          addIfClose(results, entity.center.x + entity.radius * Math.cos(startRad), entity.center.y + entity.radius * Math.sin(startRad), "endpoint", idx, wx, wy, tolerance);
+          addIfClose(results, entity.center.x + entity.radius * Math.cos(endRad), entity.center.y + entity.radius * Math.sin(endRad), "endpoint", idx, wx, wy, tolerance);
+        }
+        break;
+      }
+      case "LWPOLYLINE":
+      case "POLYLINE": {
+        if (snapTypes.has("endpoint")) {
+          for (const v of entity.vertices) {
+            addIfClose(results, v.x, v.y, "endpoint", idx, wx, wy, tolerance);
+          }
+        }
+        if (snapTypes.has("midpoint")) {
+          for (let i = 0; i < entity.vertices.length - 1; i++) {
+            const a = entity.vertices[i];
+            const b = entity.vertices[i + 1];
+            addIfClose(results, (a.x + b.x) / 2, (a.y + b.y) / 2, "midpoint", idx, wx, wy, tolerance);
+          }
+        }
+        break;
+      }
+      case "ELLIPSE": {
+        if (snapTypes.has("center")) {
+          addIfClose(results, entity.center.x, entity.center.y, "center", idx, wx, wy, tolerance);
+        }
+        break;
+      }
+      case "TEXT": {
+        if (snapTypes.has("endpoint")) {
+          addIfClose(results, entity.insertionPoint.x, entity.insertionPoint.y, "endpoint", idx, wx, wy, tolerance);
+        }
+        break;
+      }
+      case "MTEXT": {
+        if (snapTypes.has("endpoint")) {
+          addIfClose(results, entity.insertionPoint.x, entity.insertionPoint.y, "endpoint", idx, wx, wy, tolerance);
+        }
+        break;
+      }
+    }
+  }
+  results.sort(
+    (a, b) => Math.hypot(a.point.x - wx, a.point.y - wy) - Math.hypot(b.point.x - wx, b.point.y - wy)
+  );
+  return results;
+}
+function addIfClose(results, x, y, type, entityIndex, wx, wy, tolerance) {
+  if (Math.hypot(x - wx, y - wy) <= tolerance) {
+    results.push({ point: { x, y }, type, entityIndex });
+  }
+}
+function renderMeasureOverlay(ctx, vt, measureTool, mouseScreenX, mouseScreenY, theme) {
+  const config = THEMES[theme];
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  const state = measureTool.state;
+  if (measureTool.currentSnap) {
+    const [sx, sy] = worldToScreen(vt, measureTool.currentSnap.point.x, measureTool.currentSnap.point.y);
+    drawSnapIndicator(ctx, sx, sy, measureTool.currentSnap.type, config.measureColor);
+  }
+  if (state.phase === "second-point") {
+    const [sx1, sy1] = worldToScreen(vt, state.firstPoint.x, state.firstPoint.y);
+    let targetX;
+    let targetY;
+    if (measureTool.currentSnap) {
+      const [snapSx, snapSy] = worldToScreen(vt, measureTool.currentSnap.point.x, measureTool.currentSnap.point.y);
+      targetX = snapSx;
+      targetY = snapSy;
+    } else {
+      targetX = mouseScreenX;
+      targetY = mouseScreenY;
+    }
+    ctx.strokeStyle = config.measureColor;
+    ctx.lineWidth = 1.5;
+    ctx.setLineDash([6, 3]);
+    ctx.beginPath();
+    ctx.moveTo(sx1, sy1);
+    ctx.lineTo(targetX, targetY);
+    ctx.stroke();
+    ctx.setLineDash([]);
+    drawEndpointMarker(ctx, sx1, sy1, config.measureColor);
+    drawEndpointMarker(ctx, targetX, targetY, config.measureColor);
+    let twx;
+    let twy;
+    if (measureTool.currentSnap) {
+      twx = measureTool.currentSnap.point.x;
+      twy = measureTool.currentSnap.point.y;
+    } else {
+      [twx, twy] = screenToWorld(vt, mouseScreenX, mouseScreenY);
+    }
+    const dist = Math.hypot(twx - state.firstPoint.x, twy - state.firstPoint.y);
+    drawMeasureLabel(ctx, (sx1 + targetX) / 2, (sy1 + targetY) / 2, dist, theme);
+  }
+  if (state.phase === "done") {
+    const [sx1, sy1] = worldToScreen(vt, state.firstPoint.x, state.firstPoint.y);
+    const [sx2, sy2] = worldToScreen(vt, state.secondPoint.x, state.secondPoint.y);
+    ctx.strokeStyle = config.measureColor;
+    ctx.lineWidth = 2;
+    ctx.beginPath();
+    ctx.moveTo(sx1, sy1);
+    ctx.lineTo(sx2, sy2);
+    ctx.stroke();
+    drawEndpointMarker(ctx, sx1, sy1, config.measureColor);
+    drawEndpointMarker(ctx, sx2, sy2, config.measureColor);
+    drawMeasureLabel(ctx, (sx1 + sx2) / 2, (sy1 + sy2) / 2, state.distance, theme);
+  }
+}
+function drawSnapIndicator(ctx, x, y, type, color) {
+  ctx.strokeStyle = color;
+  ctx.lineWidth = 2;
+  const size = 8;
+  switch (type) {
+    case "endpoint":
+      ctx.strokeRect(x - size / 2, y - size / 2, size, size);
+      break;
+    case "midpoint":
+      ctx.beginPath();
+      ctx.moveTo(x, y - size / 2);
+      ctx.lineTo(x + size / 2, y + size / 2);
+      ctx.lineTo(x - size / 2, y + size / 2);
+      ctx.closePath();
+      ctx.stroke();
+      break;
+    case "center":
+      ctx.beginPath();
+      ctx.arc(x, y, size / 2, 0, Math.PI * 2);
+      ctx.stroke();
+      break;
+    case "nearest":
+      ctx.beginPath();
+      ctx.moveTo(x - size / 2, y - size / 2);
+      ctx.lineTo(x + size / 2, y + size / 2);
+      ctx.moveTo(x + size / 2, y - size / 2);
+      ctx.lineTo(x - size / 2, y + size / 2);
+      ctx.stroke();
+      break;
+  }
+}
+function drawEndpointMarker(ctx, x, y, color) {
+  ctx.fillStyle = color;
+  ctx.beginPath();
+  ctx.arc(x, y, 4, 0, Math.PI * 2);
+  ctx.fill();
+}
+function drawMeasureLabel(ctx, x, y, distance, theme) {
+  const label = distance.toFixed(4);
+  ctx.font = "13px monospace";
+  ctx.textAlign = "center";
+  ctx.textBaseline = "bottom";
+  const metrics = ctx.measureText(label);
+  const pad = 4;
+  const bgX = x - metrics.width / 2 - pad;
+  const bgY = y - 20;
+  const bgW = metrics.width + pad * 2;
+  const bgH = 18;
+  ctx.fillStyle = theme === "dark" ? "rgba(0,0,0,0.8)" : "rgba(255,255,255,0.9)";
+  ctx.fillRect(bgX, bgY, bgW, bgH);
+  ctx.fillStyle = THEMES[theme].measureColor;
+  ctx.fillText(label, x, y - 6);
+}
+// src/viewer/viewer.ts
+var CadViewer = class {
+  canvas;
+  renderer;
+  camera;
+  layerManager;
+  emitter;
+  spatialIndex;
+  measureTool;
+  doc = null;
+  options;
+  currentTool;
+  inputHandler;
+  resizeObserver;
+  selectedEntityIndex = -1;
+  renderPending = false;
+  destroyed = false;
+  mouseScreenX = 0;
+  mouseScreenY = 0;
+  constructor(canvas, options) {
+    this.canvas = canvas;
+    this.options = {
+      theme: options?.theme ?? "dark",
+      backgroundColor: options?.backgroundColor,
+      antialias: options?.antialias ?? true,
+      minZoom: options?.minZoom ?? 1e-4,
+      maxZoom: options?.maxZoom ?? 1e5,
+      zoomSpeed: options?.zoomSpeed ?? 1.1,
+      initialTool: options?.initialTool ?? "pan"
+    };
+    this.renderer = new CanvasRenderer(canvas);
+    this.camera = new Camera(this.options);
+    this.layerManager = new LayerManager();
+    this.emitter = new EventEmitter();
+    this.spatialIndex = new SpatialIndex();
+    this.measureTool = new MeasureTool();
+    this.currentTool = this.options.initialTool;
+    this.inputHandler = new InputHandler(canvas, this);
+    this.resizeObserver = new ResizeObserver(() => this.resize());
+    this.resizeObserver.observe(canvas);
+    canvas.style.cursor = this.getCursorForTool(this.currentTool);
+    this.requestRender();
+  }
+  // === Loading ===
+  async loadFile(file) {
+    const buffer = await file.arrayBuffer();
+    this.loadArrayBuffer(buffer);
+  }
+  loadString(dxf) {
+    this.doc = parseDxf(dxf);
+    this.onDocumentLoaded();
+  }
+  loadArrayBuffer(buffer) {
+    this.doc = parseDxf(buffer);
+    this.onDocumentLoaded();
+  }
+  /**
+   * Clear the current document and reset all state without destroying the viewer.
+   */
+  clearDocument() {
+    this.doc = null;
+    this.selectedEntityIndex = -1;
+    this.spatialIndex.clear();
+    this.layerManager.clear();
+    this.measureTool.deactivate();
+    this.requestRender();
+  }
+  onDocumentLoaded() {
+    if (!this.doc) return;
+    this.layerManager.setLayers(this.doc.layers);
+    this.spatialIndex.build(this.doc.entities);
+    this.selectedEntityIndex = -1;
+    this.measureTool.deactivate();
+    if (this.currentTool === "measure") {
+      this.measureTool.activate();
+    }
+    this.fitToView();
+  }
+  // === Camera Controls ===
+  fitToView() {
+    if (!this.doc) return;
+    const bounds = this.computeDocumentBounds();
+    if (!bounds) return;
+    const rect = this.canvas.getBoundingClientRect();
+    this.camera.setTransform(
+      fitToView(rect.width, rect.height, bounds.minX, bounds.minY, bounds.maxX, bounds.maxY)
+    );
+    this.requestRender();
+    this.emitter.emit("viewchange", this.camera.getTransform());
+  }
+  zoomTo(scale) {
+    const rect = this.canvas.getBoundingClientRect();
+    const centerX = rect.width / 2;
+    const centerY = rect.height / 2;
+    const factor = scale / this.camera.getTransform().scale;
+    this.camera.zoom(centerX, centerY, factor);
+    this.requestRender();
+    this.emitter.emit("viewchange", this.camera.getTransform());
+  }
+  panTo(worldX, worldY) {
+    const rect = this.canvas.getBoundingClientRect();
+    const vt = this.camera.getTransform();
+    const currentSX = worldX * vt.scale + vt.offsetX;
+    const currentSY = -worldY * vt.scale + vt.offsetY;
+    const dx = rect.width / 2 - currentSX;
+    const dy = rect.height / 2 - currentSY;
+    this.camera.pan(dx, dy);
+    this.requestRender();
+    this.emitter.emit("viewchange", this.camera.getTransform());
+  }
+  getViewTransform() {
+    return { ...this.camera.getTransform() };
+  }
+  /** @internal */
+  getZoomSpeed() {
+    return this.options.zoomSpeed;
+  }
+  // === Layers ===
+  getLayers() {
+    return this.layerManager.getAllLayers();
+  }
+  setLayerVisible(name, visible) {
+    this.layerManager.setVisible(name, visible);
+    this.requestRender();
+  }
+  setLayerColor(name, color) {
+    this.layerManager.setColorOverride(name, color);
+    this.requestRender();
+  }
+  // === Theme ===
+  setTheme(theme) {
+    this.options.theme = theme;
+    this.requestRender();
+  }
+  getTheme() {
+    return this.options.theme;
+  }
+  setBackgroundColor(color) {
+    this.options.backgroundColor = color;
+    this.requestRender();
+  }
+  // === Tools ===
+  setTool(tool) {
+    if (this.currentTool === "measure" && tool !== "measure") {
+      this.measureTool.deactivate();
+    }
+    this.currentTool = tool;
+    this.canvas.style.cursor = this.getCursorForTool(tool);
+    if (tool === "measure") {
+      this.measureTool.activate();
+    }
+    if (tool !== "select") {
+      this.selectedEntityIndex = -1;
+    }
+    this.requestRender();
+  }
+  getTool() {
+    return this.currentTool;
+  }
+  getCursorForTool(tool) {
+    switch (tool) {
+      case "pan":
+        return "grab";
+      case "select":
+        return "crosshair";
+      case "measure":
+        return "crosshair";
+    }
+  }
+  // === Events ===
+  on(event, callback) {
+    this.emitter.on(event, callback);
+  }
+  off(event, callback) {
+    this.emitter.off(event, callback);
+  }
+  // === Document Access ===
+  getDocument() {
+    return this.doc;
+  }
+  getEntities() {
+    return this.doc?.entities ?? [];
+  }
+  // === Lifecycle ===
+  resize() {
+    this.renderer.updateSize();
+    this.requestRender();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.inputHandler.destroy();
+    this.resizeObserver.disconnect();
+    this.renderer.destroy();
+    this.emitter.removeAllListeners();
+    this.spatialIndex.clear();
+    this.layerManager.clear();
+    this.doc = null;
+  }
+  // === Internal (called by InputHandler) ===
+  /** @internal */
+  requestRender() {
+    if (this.renderPending || this.destroyed) return;
+    this.renderPending = true;
+    requestAnimationFrame(() => {
+      this.renderPending = false;
+      if (this.destroyed) return;
+      this.doRender();
+    });
+  }
+  doRender() {
+    if (!this.doc) {
+      this.renderer.renderEmpty(this.options.theme);
+      return;
+    }
+    this.renderer.render(
+      this.doc,
+      this.camera.getTransform(),
+      this.options.theme,
+      this.layerManager.getVisibleLayerNames(),
+      this.selectedEntityIndex
+    );
+    if (this.currentTool === "measure" && this.measureTool.state.phase !== "idle") {
+      const ctx = this.renderer.getContext();
+      renderMeasureOverlay(
+        ctx,
+        this.camera.getTransform(),
+        this.measureTool,
+        this.mouseScreenX,
+        this.mouseScreenY,
+        this.options.theme
+      );
+    }
+  }
+  /** @internal */
+  handlePan(dx, dy) {
+    this.camera.pan(dx, dy);
+    this.requestRender();
+    this.emitter.emit("viewchange", this.camera.getTransform());
+  }
+  /** @internal */
+  handleZoom(screenX, screenY, factor) {
+    this.camera.zoom(screenX, screenY, factor);
+    this.requestRender();
+    this.emitter.emit("viewchange", this.camera.getTransform());
+  }
+  /** @internal */
+  handleClick(screenX, screenY) {
+    if (!this.doc) return;
+    const vt = this.camera.getTransform();
+    const [wx, wy] = screenToWorld(vt, screenX, screenY);
+    switch (this.currentTool) {
+      case "select":
+        this.handleSelect(wx, wy, screenX, screenY);
+        break;
+      case "measure": {
+        const snaps = findSnaps(wx, wy, this.doc.entities, this.spatialIndex, vt.scale);
+        const snap = snaps.length > 0 ? snaps[0] : null;
+        const result = this.measureTool.handleClick(wx, wy, snap);
+        this.requestRender();
+        if (result) {
+          this.emitter.emit("measure", result);
+        }
+        break;
+      }
+    }
+  }
+  /** @internal — called by InputHandler for mouse move */
+  handleMouseMove(screenX, screenY) {
+    this.mouseScreenX = screenX;
+    this.mouseScreenY = screenY;
+    if (this.currentTool === "measure" && this.doc) {
+      const vt = this.camera.getTransform();
+      const [wx, wy] = screenToWorld(vt, screenX, screenY);
+      const snaps = findSnaps(wx, wy, this.doc.entities, this.spatialIndex, vt.scale);
+      this.measureTool.handleMove(snaps[0] ?? null);
+      this.requestRender();
+    }
+  }
+  handleSelect(wx, wy, sx, sy) {
+    if (!this.doc) return;
+    const index = hitTest(
+      wx,
+      wy,
+      this.doc.entities,
+      this.spatialIndex,
+      this.layerManager.getVisibleLayerNames(),
+      this.camera.getTransform().scale
+    );
+    this.selectedEntityIndex = index;
+    this.requestRender();
+    if (index >= 0 && this.doc) {
+      const entity = this.doc.entities[index];
+      if (entity) {
+        this.emitter.emit("select", {
+          entity,
+          entityIndex: index,
+          worldPoint: { x: wx, y: wy },
+          screenPoint: { x: sx, y: sy }
+        });
+      }
+    }
+  }
+  computeDocumentBounds() {
+    if (!this.doc) return null;
+    if (this.doc.header.extMin && this.doc.header.extMax) {
+      return {
+        minX: this.doc.header.extMin.x,
+        minY: this.doc.header.extMin.y,
+        maxX: this.doc.header.extMax.x,
+        maxY: this.doc.header.extMax.y
+      };
+    }
+    return computeEntitiesBounds(this.doc.entities);
+  }
+};
+exports.CadViewer = CadViewer;
+exports.Camera = Camera;
+exports.CanvasRenderer = CanvasRenderer;
+exports.DxfParseError = DxfParseError;
+exports.EventEmitter = EventEmitter;
+exports.LayerManager = LayerManager;
+exports.MeasureTool = MeasureTool;
+exports.SpatialIndex = SpatialIndex;
+exports.THEMES = THEMES;
+exports.aciToDisplayColor = aciToDisplayColor;
+exports.aciToHex = aciToHex;
+exports.applyTransform = applyTransform;
+exports.computeEntitiesBounds = computeEntitiesBounds;
+exports.computeEntityBBox = computeEntityBBox;
+exports.drawEntity = drawEntity;
+exports.findSnaps = findSnaps;
+exports.fitToView = fitToView;
+exports.hitTest = hitTest;
+exports.parseDxf = parseDxf;
+exports.renderMeasureOverlay = renderMeasureOverlay;
+exports.resolveEntityColor = resolveEntityColor;
+exports.screenToWorld = screenToWorld;
+exports.trueColorToHex = trueColorToHex;
+exports.worldToScreen = worldToScreen;
+exports.zoomAtPoint = zoomAtPoint;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map