@chanmeng666/archlang 0.4.0 → 0.6.0

package/dist/{chunk-DHNWMOP7.js → chunk-PABYLU6Z.js}

@@ -301,6 +301,67 @@ function levenshtein(a, b) {
   return dp[m];
 }
 
+// src/theme.ts
+var DEFAULT_THEME = {
+  bg: "#ffffff",
+  pocheBase: "#e9e4db",
+  pocheHatch: "#b9b1a4",
+  wallStroke: "#1b1b1b",
+  roomFill: "#fbfaf7",
+  roomLabel: "#222222",
+  areaLabel: "#7a7a7a",
+  furnitureStroke: "#a8a29a",
+  furnitureFill: "#f4f2ee",
+  furnitureLabel: "#9a948c",
+  opening: "#ffffff",
+  doorLeaf: "#555555",
+  windowPane: "#3a6ea5",
+  dim: "#0E5484",
+  annotation: "#333333",
+  annotationMuted: "#888888",
+  column: "#4a4a4a",
+  lineWeight: 1,
+  font: "Helvetica, Arial, sans-serif"
+};
+var ALIASES = {
+  background: "bg",
+  wall: "wallStroke",
+  wallFill: "pocheBase",
+  wallHatch: "pocheHatch",
+  room: "roomFill",
+  furniture: "furnitureFill",
+  door: "doorLeaf",
+  window: "windowPane"
+};
+function resolveThemeKey(key) {
+  if (key in DEFAULT_THEME) return key;
+  if (key in ALIASES) return ALIASES[key];
+  return null;
+}
+function isNumericThemeKey(key) {
+  return key === "lineWeight";
+}
+function mergeTheme(...layers) {
+  const out = { ...DEFAULT_THEME };
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const k of Object.keys(layer)) {
+      const v = layer[k];
+      if (v !== void 0) out[k] = v;
+    }
+  }
+  return out;
+}
+function sanitizeTheme(theme) {
+  const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  const out = { ...theme };
+  for (const k of Object.keys(out)) {
+    const v = out[k];
+    if (typeof v === "string") out[k] = esc(v);
+  }
+  return out;
+}
+
 // src/geometry.ts
 var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
 var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
@@ -366,30 +427,63 @@ function segmentsOfWall(w) {
   }
   return segs;
 }
-function hostSegmentForWalls(walls, at, ref) {
+function hostInfoForWalls(walls, at, ref) {
   const candidates = ref ? walls.filter((w) => w.id === ref || w.category === ref) : walls;
-  let best = null;
+  let host = null;
   let bestDist = Infinity;
+  let onWall = false;
   for (const w of candidates) {
+    const tol = w.thickness / 2 + Math.max(w.thickness, 1);
     for (const s of segmentsOfWall(w)) {
       const dist = distPointToSegment(at, s.a, s.b);
       if (dist < bestDist) {
         bestDist = dist;
-        best = s;
+        host = s;
       }
+      if (!onWall && dist <= tol) onWall = true;
     }
   }
-  return best;
+  return { host, onWall };
 }
-function isOnSomeWall(walls, at, ref) {
-  const candidates = ref ? walls.filter((w) => w.id === ref || w.category === ref) : walls;
-  for (const w of candidates) {
-    const tol = w.thickness / 2 + Math.max(w.thickness, 1);
-    for (const s of segmentsOfWall(w)) {
-      if (distPointToSegment(at, s.a, s.b) <= tol) return true;
-    }
-  }
-  return false;
+
+// src/hatches.ts
+var KNOWN_MATERIALS = ["poche", "concrete", "brick", "insulation", "tile", "none"];
+var DEFAULT_MATERIAL = "poche";
+function patternId(material) {
+  return material === "poche" ? "poche" : `hatch-${material}`;
+}
+var HATCHES = {
+  poche: (id, c) => `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" patternTransform="rotate(45)"><rect width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" fill="${c.base}"/><line x1="0" y1="0" x2="0" y2="${c.fmt(c.gap)}" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.7)}"/></pattern>`,
+  // Aggregate speckle.
+  concrete: (id, c) => {
+    const w = c.gap * 1.6;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><circle cx="${c.fmt(w * 0.25)}" cy="${c.fmt(w * 0.3)}" r="${c.fmt(c.thin * 0.9)}" fill="${c.line}"/><circle cx="${c.fmt(w * 0.7)}" cy="${c.fmt(w * 0.62)}" r="${c.fmt(c.thin * 0.6)}" fill="${c.line}"/><circle cx="${c.fmt(w * 0.45)}" cy="${c.fmt(w * 0.85)}" r="${c.fmt(c.thin * 0.75)}" fill="${c.line}"/></pattern>`;
+  },
+  // Running-bond brick courses.
+  brick: (id, c) => {
+    const w = c.gap * 3;
+    const h = c.gap * 1.4;
+    const sw = c.fmt(c.thin * 0.6);
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(h)}"><rect width="${c.fmt(w)}" height="${c.fmt(h)}" fill="${c.base}"/><line x1="0" y1="${c.fmt(h)}" x2="${c.fmt(w)}" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="0" y1="${c.fmt(h / 2)}" x2="${c.fmt(w)}" y2="${c.fmt(h / 2)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="${c.fmt(w / 2)}" y1="0" x2="${c.fmt(w / 2)}" y2="${c.fmt(h / 2)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="0" y1="${c.fmt(h / 2)}" x2="0" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/><line x1="${c.fmt(w)}" y1="${c.fmt(h / 2)}" x2="${c.fmt(w)}" y2="${c.fmt(h)}" stroke="${c.line}" stroke-width="${sw}"/></pattern>`;
+  },
+  // Cross-hatch batting.
+  insulation: (id, c) => {
+    const w = c.gap * 1.2;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><path d="M0,0 L${c.fmt(w)},${c.fmt(w)} M${c.fmt(w)},0 L0,${c.fmt(w)}" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.5)}" fill="none"/></pattern>`;
+  },
+  // Square tile grid.
+  tile: (id, c) => {
+    const w = c.gap * 1.8;
+    return `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(w)}" height="${c.fmt(w)}"><rect width="${c.fmt(w)}" height="${c.fmt(w)}" fill="${c.base}"/><rect x="0" y="0" width="${c.fmt(w)}" height="${c.fmt(w)}" fill="none" stroke="${c.line}" stroke-width="${c.fmt(c.thin * 0.6)}"/></pattern>`;
+  },
+  // Solid fill, no hatch.
+  none: (id, c) => `<pattern id="${id}" patternUnits="userSpaceOnUse" width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}"><rect width="${c.fmt(c.gap)}" height="${c.fmt(c.gap)}" fill="${c.base}"/></pattern>`
+};
+function isKnownMaterial(name) {
+  return KNOWN_MATERIALS.includes(name);
+}
+function hatchPattern(material, c) {
+  return HATCHES[material](patternId(material), c);
 }
 
 // src/elements/wall.ts
@@ -402,6 +496,11 @@ var wall = {
     const category = ctx.eatIdent().value;
     ctx.eatKeyword("thickness");
     const thickness = ctx.parseExpr();
+    let material;
+    if (ctx.isKeyword("material")) {
+      ctx.next();
+      material = ctx.eatIdent().value;
+    }
     ctx.eat("lcurly");
     const points = [];
     let closed = false;
@@ -419,7 +518,7 @@ var wall = {
     }
     ctx.eat("rcurly");
     if (points.length < 2) ctx.fail("A wall needs at least two points", kw);
-    return { kind: "wall", id, category, thickness, points, closed, line: kw.line };
+    return { kind: "wall", id, category, thickness, material, points, closed, line: kw.line };
   },
   idPrefix: (node) => node.category || "wall",
   resolve(node, ctx) {
@@ -431,7 +530,18 @@ var wall = {
     if (thickness <= 0) {
       ctx.diag({ severity: "error", message: `Wall "${id}" must have a positive thickness`, code: "E_WALL_THICKNESS", span: n.span });
     }
-    return { kind: "wall", id, category: n.category, thickness, points, closed: n.closed, span: n.span };
+    let material = DEFAULT_MATERIAL;
+    if (n.material !== void 0) {
+      if (isKnownMaterial(n.material)) material = n.material;
+      else
+        ctx.diag({
+          severity: "warning",
+          message: `Unknown wall material "${n.material}" (known: ${KNOWN_MATERIALS.join(", ")}); using the default hatch`,
+          code: "W_UNKNOWN_MATERIAL",
+          span: n.span
+        });
+    }
+    return { kind: "wall", id, category: n.category, thickness, material, points, closed: n.closed, span: n.span };
   },
   bounds(resolved) {
     const w = resolved;
@@ -873,7 +983,7 @@ register(dim);
 register(column);
 
 // src/parser.ts
-var SETTINGS = ["units", "grid", "scale", "north", "title", "let", "component"];
+var SETTINGS = ["units", "grid", "scale", "north", "title", "theme", "let", "component"];
 var STATEMENT_STARTS = /* @__PURE__ */ new Set([...SETTINGS, ...registry.keys()]);
 var ParseError = class extends Error {
   constructor(message, span) {
@@ -1036,6 +1146,10 @@ var Parser = class {
             plan.title = n;
             break;
           }
+          case "theme": {
+            plan.theme = { ...plan.theme, ...this.parseTheme() };
+            break;
+          }
           case "let": {
             const n = this.parseLet();
             n.span = this.spanFrom(start);
@@ -1145,6 +1259,35 @@ var Parser = class {
     this.eat("rcurly");
     return node;
   }
+  /** `theme { key: <value> … }` — colours (strings), `lineWeight` (number), `font` (string). */
+  parseTheme() {
+    this.eatKeyword("theme");
+    this.eat("lcurly");
+    const t = {};
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const keyTok = this.eatIdent();
+      if (this.isType("colon")) this.next();
+      const resolved = resolveThemeKey(keyTok.value);
+      if (!resolved) {
+        this.diagnostics.push({
+          severity: "warning",
+          message: `Unknown theme key "${keyTok.value}"`,
+          code: "W_UNKNOWN_THEME_KEY",
+          span: { start: keyTok.start, end: keyTok.end }
+        });
+        if (this.isType("string") || this.isType("number")) this.next();
+        else this.fail(`Expected a value for theme key "${keyTok.value}"`);
+        continue;
+      }
+      if (isNumericThemeKey(resolved)) {
+        t[resolved] = this.eatNumber();
+      } else {
+        t[resolved] = this.eatString();
+      }
+    }
+    this.eat("rcurly");
+    return t;
+  }
   parseLet() {
     const kw = this.eatKeyword("let");
     const name = this.eatIdent().value;
@@ -1286,6 +1429,15 @@ function resolve(ast) {
   let activeEnv = /* @__PURE__ */ new Map();
   const evalNum = (e) => evalExpr(e, activeEnv, (d) => diagnostics.push(d));
   const evalPt = (p) => ({ x: evalNum(p.x), y: evalNum(p.y) });
+  let hiKey = "";
+  let hiVal = null;
+  const hostInfo = (at, ref) => {
+    const key = `${at.x},${at.y},${ref ?? ""}`;
+    if (key === hiKey && hiVal) return hiVal;
+    hiKey = key;
+    hiVal = hostInfoForWalls(walls, at, ref);
+    return hiVal;
+  };
   const ctx = {
     grid: g,
     snap,
@@ -1294,8 +1446,8 @@ function resolve(ast) {
     evalPt,
     id: "",
     walls,
-    hostSegment: (at, ref) => hostSegmentForWalls(walls, at, ref),
-    isOnWall: (at, ref) => isOnSomeWall(walls, at, ref),
+    hostSegment: (at, ref) => hostInfo(at, ref).host,
+    isOnWall: (at, ref) => hostInfo(at, ref).onWall,
     diag: (d) => diagnostics.push(d)
   };
   for (const def of registryOrder) {
@@ -1343,6 +1495,7 @@ function resolve(ast) {
     scale: ast.scale,
     north: ast.north,
     title: ast.title,
+    theme: ast.theme,
     elements,
     walls
   };
@@ -1362,26 +1515,104 @@ var RENDER_PASSES = [
   "annotations"
 ];
 
+// src/geometry/union.ts
+function uniqSorted(values) {
+  const out = [...new Set(values)].sort((a, b) => a - b);
+  return out;
+}
+function rectUnionOutline(rects) {
+  if (rects.length === 0) return [];
+  const xs = uniqSorted(rects.flatMap((r) => [r.x0, r.x1]));
+  const ys = uniqSorted(rects.flatMap((r) => [r.y0, r.y1]));
+  const nx = xs.length - 1;
+  const ny = ys.length - 1;
+  const filled = (i, j) => {
+    if (i < 0 || j < 0 || i >= nx || j >= ny) return false;
+    const cx = (xs[i] + xs[i + 1]) / 2;
+    const cy = (ys[j] + ys[j + 1]) / 2;
+    return rects.some((r) => cx > r.x0 && cx < r.x1 && cy > r.y0 && cy < r.y1);
+  };
+  const key = (x, y) => `${x},${y}`;
+  const starts = /* @__PURE__ */ new Map();
+  const pushEdge = (ax, ay, bx, by) => {
+    const k = key(ax, ay);
+    const list = starts.get(k);
+    if (list) list.push({ x: bx, y: by });
+    else starts.set(k, [{ x: bx, y: by }]);
+  };
+  for (let i = 0; i < nx; i++) {
+    for (let j = 0; j < ny; j++) {
+      if (!filled(i, j)) continue;
+      const x0 = xs[i];
+      const x1 = xs[i + 1];
+      const y0 = ys[j];
+      const y1 = ys[j + 1];
+      if (!filled(i, j - 1)) pushEdge(x1, y0, x0, y0);
+      if (!filled(i - 1, j)) pushEdge(x0, y0, x0, y1);
+      if (!filled(i, j + 1)) pushEdge(x0, y1, x1, y1);
+      if (!filled(i + 1, j)) pushEdge(x1, y1, x1, y0);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  const edgeKey = (a, b) => `${a.x},${a.y}->${b.x},${b.y}`;
+  const loops = [];
+  const takeNext = (from, prevDir) => {
+    const list = starts.get(key(from.x, from.y));
+    if (!list) return null;
+    const candidates = list.filter((to) => !used.has(edgeKey(from, to)));
+    if (candidates.length === 0) return null;
+    if (candidates.length === 1 || !prevDir) return candidates[0];
+    let best = candidates[0];
+    let bestScore = -Infinity;
+    for (const c of candidates) {
+      const dir = { x: c.x - from.x, y: c.y - from.y };
+      const cross = prevDir.x * dir.y - prevDir.y * dir.x;
+      if (cross > bestScore) {
+        bestScore = cross;
+        best = c;
+      }
+    }
+    return best;
+  };
+  for (const [startKey, ends] of starts) {
+    for (const firstEnd of ends) {
+      const [sx, sy] = startKey.split(",").map(Number);
+      const start = { x: sx, y: sy };
+      if (used.has(edgeKey(start, firstEnd))) continue;
+      const loop = [start];
+      let cur = start;
+      let next = firstEnd;
+      let dir = null;
+      while (next) {
+        used.add(edgeKey(cur, next));
+        if (next.x === start.x && next.y === start.y) break;
+        loop.push(next);
+        dir = { x: next.x - cur.x, y: next.y - cur.y };
+        cur = next;
+        next = takeNext(cur, dir);
+      }
+      if (loop.length >= 4) loops.push(mergeCollinear(loop));
+    }
+  }
+  return loops;
+}
+function mergeCollinear(loop) {
+  const n = loop.length;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const prev = loop[(i - 1 + n) % n];
+    const cur = loop[i];
+    const next = loop[(i + 1) % n];
+    const d1x = cur.x - prev.x;
+    const d1y = cur.y - prev.y;
+    const d2x = next.x - cur.x;
+    const d2y = next.y - cur.y;
+    if (d1x * d2y - d1y * d2x !== 0) out.push(cur);
+  }
+  return out.length >= 3 ? out : loop;
+}
+
 // src/render.ts
-var THEME = {
-  bg: "#ffffff",
-  pocheBase: "#e9e4db",
-  pocheHatch: "#b9b1a4",
-  wallStroke: "#1b1b1b",
-  roomFill: "#fbfaf7",
-  roomLabel: "#222222",
-  areaLabel: "#7a7a7a",
-  furnitureStroke: "#a8a29a",
-  furnitureFill: "#f4f2ee",
-  furnitureLabel: "#9a948c",
-  opening: "#ffffff",
-  doorLeaf: "#555555",
-  windowPane: "#3a6ea5",
-  dim: "#0E5484",
-  annotation: "#333333",
-  annotationMuted: "#888888",
-  column: "#4a4a4a"
-};
 function fmt(v) {
   const r = Math.round(v * 100) / 100;
   return Object.is(r, -0) ? "0" : String(r);
@@ -1408,15 +1639,56 @@ function planBounds(ir) {
   }
   return b;
 }
+function allOrthogonal(walls) {
+  return walls.every((w) => segmentsOfWall(w).every((s) => s.a.x === s.b.x || s.a.y === s.b.y));
+}
+function loopsToPath(loops) {
+  return loops.map((loop) => "M " + loop.map(pt).join(" L ") + " Z").join(" ");
+}
+function materialsUsed(walls) {
+  return [...new Set(walls.map((w) => w.material))].sort();
+}
+function renderWalls(walls, ctx) {
+  if (walls.length === 0) return [];
+  const ops = [];
+  for (const mat of materialsUsed(walls)) {
+    const group = walls.filter((w) => w.material === mat);
+    if (!allOrthogonal(group)) {
+      const def = registry.get("wall");
+      ops.push(...group.flatMap((w) => def.render(w, ctx)));
+      continue;
+    }
+    const rects = [];
+    for (const w of group) {
+      for (const s of segmentsOfWall(w)) {
+        const corners = segmentRectangle(s.a, s.b, s.thickness);
+        const xsv = corners.map((c) => c.x);
+        const ysv = corners.map((c) => c.y);
+        rects.push({ x0: Math.min(...xsv), y0: Math.min(...ysv), x1: Math.max(...xsv), y1: Math.max(...ysv) });
+      }
+    }
+    const loops = rectUnionOutline(rects);
+    if (loops.length === 0) continue;
+    const d = loopsToPath(loops);
+    ops.push({ pass: "wallFill", svg: `<path d="${d}" fill="url(#${patternId(mat)})" fill-rule="nonzero"/>` });
+    ops.push({
+      pass: "wallFace",
+      svg: `<path d="${d}" fill="none" stroke="${ctx.theme.wallStroke}" stroke-width="${ctx.fmt(ctx.sizes.wallStroke)}" stroke-linejoin="miter"/>`
+    });
+  }
+  return ops;
+}
 function render(ir, opts = {}) {
+  const THEME = sanitizeTheme(mergeTheme(DEFAULT_THEME, ir.theme, opts.theme));
+  const lw = THEME.lineWeight;
   const b = planBounds(ir);
   const drawW = b.maxX - b.minX;
   const drawH = b.maxY - b.minY;
   const refDim = Math.max(drawW, drawH, 1);
   const sizes = {
     refDim,
-    wallStroke: refDim * 28e-4,
-    thin: refDim * 16e-4,
+    wallStroke: refDim * 28e-4 * lw,
+    thin: refDim * 16e-4 * lw,
     roomFont: refDim * 0.03,
     areaFont: refDim * 0.022,
     dimFont: refDim * 0.02,
@@ -1432,28 +1704,30 @@ function render(ir, opts = {}) {
   const out = [];
   const svgAttrs = opts.width ? `width="${fmt(opts.width)}" height="${fmt(opts.width * vbH / vbW)}"` : "";
   out.push(
-    `<svg xmlns="http://www.w3.org/2000/svg" ${svgAttrs} viewBox="${fmt(vbX)} ${fmt(vbY)} ${fmt(vbW)} ${fmt(vbH)}" font-family="Helvetica, Arial, sans-serif">`
-  );
-  out.push(
-    `<defs><pattern id="poche" patternUnits="userSpaceOnUse" width="${fmt(hatchGap)}" height="${fmt(hatchGap)}" patternTransform="rotate(45)"><rect width="${fmt(hatchGap)}" height="${fmt(hatchGap)}" fill="${THEME.pocheBase}"/><line x1="0" y1="0" x2="0" y2="${fmt(hatchGap)}" stroke="${THEME.pocheHatch}" stroke-width="${fmt(thin * 0.7)}"/></pattern></defs>`
+    `<svg xmlns="http://www.w3.org/2000/svg" ${svgAttrs} viewBox="${fmt(vbX)} ${fmt(vbY)} ${fmt(vbW)} ${fmt(vbH)}" font-family="${THEME.font}">`
   );
+  const hatchCtx = { fmt, gap: hatchGap, thin, base: THEME.pocheBase, line: THEME.pocheHatch };
+  const patterns = materialsUsed(ir.walls).map((m) => hatchPattern(m, hatchCtx)).join("");
+  out.push(`<defs>${patterns}</defs>`);
   out.push(`<rect x="${fmt(vbX)}" y="${fmt(vbY)}" width="${fmt(vbW)}" height="${fmt(vbH)}" fill="${THEME.bg}"/>`);
   const ctx = { fmt, pt, xml, theme: THEME, sizes, bounds: b };
   const ops = ir.elements.flatMap((el) => {
+    if (el.kind === "wall") return [];
     const def = registry.get(el.kind);
     return def ? def.render(el, ctx) : [];
   });
+  ops.push(...renderWalls(ir.walls, ctx));
   for (const pass of RENDER_PASSES) {
     for (const op of ops) if (op.pass === pass) out.push(op.svg);
   }
-  out.push(northArrow(ir, b, margin, refDim));
-  out.push(scaleBar(b, margin, refDim, thin));
-  const tb = titleBlock(ir, b, margin, refDim, thin);
+  out.push(northArrow(ir, b, margin, refDim, THEME));
+  out.push(scaleBar(b, margin, refDim, thin, THEME));
+  const tb = titleBlock(ir, b, margin, refDim, thin, THEME);
   if (tb) out.push(tb);
   out.push("</svg>");
   return out.join("\n");
 }
-function northArrow(ir, b, margin, refDim) {
+function northArrow(ir, b, margin, refDim, THEME) {
   const r = refDim * 0.045;
   const cx = b.maxX - r;
   const cy = b.minY - margin * 0.55;
@@ -1483,7 +1757,7 @@ function northArrow(ir, b, margin, refDim) {
   const ly = cy + ny * (r + fs * 0.8);
   return `<g><polygon points="${tri}" fill="${THEME.annotation}" transform="rotate(${fmt(deg)} ${fmt(cx)} ${fmt(cy)})"/><text x="${fmt(lx)}" y="${fmt(ly)}" font-size="${fmt(fs)}" fill="${THEME.annotation}" text-anchor="middle" dominant-baseline="central">N</text></g>`;
 }
-function scaleBar(b, margin, refDim, thin) {
+function scaleBar(b, margin, refDim, thin, THEME) {
   const barLen = niceBarLength(refDim * 0.3);
   const x0 = b.minX;
   const y0 = b.maxY + margin * 0.55;
@@ -1503,7 +1777,7 @@ function scaleBar(b, margin, refDim, thin) {
   );
   return `<g>${parts.join("")}</g>`;
 }
-function titleBlock(ir, b, margin, refDim, thin) {
+function titleBlock(ir, b, margin, refDim, thin, THEME) {
   const t = ir.title;
   if (!t && !ir.scale) return null;
   const boxW = refDim * 0.34;
@@ -1565,8 +1839,8 @@ function lineEnd(source, offset) {
 }
 function formatDiagnostic(source, d) {
   const codeTag = d.code ? `[${d.code}]` : "";
-  const header = `${d.severity}${codeTag}: ${d.message}`;
-  const lines = [header];
+  const header2 = `${d.severity}${codeTag}: ${d.message}`;
+  const lines = [header2];
   if (d.span) {
     const { line, col } = offsetToLineCol(source, d.span.start);
     const ls = lineStart(source, d.span.start);
@@ -1592,11 +1866,211 @@ function formatDiagnostic(source, d) {
   return lines.join("\n");
 }
 
+// src/export/dxf.ts
+function num(v) {
+  const r = Math.round(v * 1e4) / 1e4;
+  return Object.is(r, -0) ? "0" : String(r);
+}
+var DxfBuilder = class {
+  out = [];
+  /** group-code / value pair. */
+  pair(code, value) {
+    this.out.push(String(code), String(value));
+  }
+  line(layer, a, b) {
+    this.pair(0, "LINE");
+    this.pair(8, layer);
+    this.pair(10, num(a.x));
+    this.pair(20, num(-a.y));
+    this.pair(11, num(b.x));
+    this.pair(21, num(-b.y));
+  }
+  arc(layer, center, radius, startDeg, endDeg) {
+    this.pair(0, "ARC");
+    this.pair(8, layer);
+    this.pair(10, num(center.x));
+    this.pair(20, num(-center.y));
+    this.pair(40, num(radius));
+    this.pair(50, num(startDeg));
+    this.pair(51, num(endDeg));
+  }
+  text(layer, at, height, value) {
+    this.pair(0, "TEXT");
+    this.pair(8, layer);
+    this.pair(10, num(at.x));
+    this.pair(20, num(-at.y));
+    this.pair(40, num(height));
+    this.pair(1, value.replace(/\n/g, " "));
+  }
+  rect(layer, corners) {
+    for (let i = 0; i < corners.length; i++) {
+      this.line(layer, corners[i], corners[(i + 1) % corners.length]);
+    }
+  }
+  toString() {
+    return this.out.join("\n") + "\n";
+  }
+};
+var LAYERS = ["WALLS", "ROOMS", "DOORS", "WINDOWS", "FURNITURE", "COLUMNS", "DIMS", "LABELS"];
+function header() {
+  const h = [];
+  const p = (c, v) => h.push(String(c), String(v));
+  p(0, "SECTION");
+  p(2, "HEADER");
+  p(9, "$ACADVER");
+  p(1, "AC1009");
+  p(0, "ENDSEC");
+  p(0, "SECTION");
+  p(2, "TABLES");
+  p(0, "TABLE");
+  p(2, "LAYER");
+  p(70, LAYERS.length);
+  for (const name of LAYERS) {
+    p(0, "LAYER");
+    p(2, name);
+    p(70, 0);
+    p(62, 7);
+    p(6, "CONTINUOUS");
+  }
+  p(0, "ENDTAB");
+  p(0, "ENDSEC");
+  return h.join("\n") + "\n";
+}
+function emitDoor(b, dr) {
+  const seg = dr.host;
+  if (!seg) return;
+  const d = unit(sub(seg.b, seg.a));
+  const n = normal(d);
+  const hw = dr.width / 2;
+  const hinge = dr.hinge === "left" ? add(dr.at, mul(d, -hw)) : add(dr.at, mul(d, hw));
+  const farJamb = dr.hinge === "left" ? add(dr.at, mul(d, hw)) : add(dr.at, mul(d, -hw));
+  const leafDir = dr.swing === "in" ? n : mul(n, -1);
+  const leafEnd = add(hinge, mul(leafDir, dr.width));
+  b.line("DOORS", hinge, leafEnd);
+  const deg = (p) => Math.atan2(-(p.y - hinge.y), p.x - hinge.x) * 180 / Math.PI;
+  const a1 = deg(leafEnd);
+  const a2 = deg(farJamb);
+  const ccw = ((a2 - a1) % 360 + 360) % 360;
+  if (ccw <= 180) b.arc("DOORS", hinge, dr.width, a1, a2);
+  else b.arc("DOORS", hinge, dr.width, a2, a1);
+}
+function emitWindow(b, wn) {
+  const seg = wn.host;
+  if (!seg) return;
+  const d = unit(sub(seg.b, seg.a));
+  const n = normal(d);
+  const hw = wn.width / 2;
+  const h = seg.thickness / 2;
+  const jA = add(wn.at, mul(d, -hw));
+  const jB = add(wn.at, mul(d, hw));
+  b.line("WINDOWS", add(jA, mul(n, h)), add(jB, mul(n, h)));
+  b.line("WINDOWS", add(jA, mul(n, -h)), add(jB, mul(n, -h)));
+  b.line("WINDOWS", jA, jB);
+}
+function emitDim(b, dm) {
+  const dd = unit(sub(dm.to, dm.from));
+  const dn = normal(dd);
+  const p1 = add(dm.from, mul(dn, dm.offset));
+  const p2 = add(dm.to, mul(dn, dm.offset));
+  b.line("DIMS", p1, p2);
+  if (dm.text) {
+    const mid = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
+    b.text("DIMS", mid, 150, dm.text);
+  }
+}
+function toDxf(ir) {
+  const b = new DxfBuilder();
+  b.pair(0, "SECTION");
+  b.pair(2, "ENTITIES");
+  const labelAt = (at, w, h) => ({ x: at.x + w / 2, y: at.y + h / 2 });
+  for (const el of ir.elements) {
+    switch (el.kind) {
+      case "wall":
+        for (const s of segmentsOfWall(el)) {
+          const d = unit(sub(s.b, s.a));
+          const n = normal(d);
+          const off = s.thickness / 2;
+          b.line("WALLS", add(s.a, mul(n, off)), add(s.b, mul(n, off)));
+          b.line("WALLS", add(s.a, mul(n, -off)), add(s.b, mul(n, -off)));
+        }
+        break;
+      case "room":
+        b.rect("ROOMS", rectCorners(el.at.x, el.at.y, el.size.w, el.size.h));
+        if (el.label) b.text("LABELS", labelAt(el.at, el.size.w, el.size.h), 200, el.label);
+        break;
+      case "furniture":
+        b.rect("FURNITURE", rectCorners(el.at.x, el.at.y, el.size.w, el.size.h));
+        if (el.label) b.text("LABELS", labelAt(el.at, el.size.w, el.size.h), 150, el.label);
+        break;
+      case "column":
+        b.rect("COLUMNS", rectCorners(el.at.x, el.at.y, el.size.w, el.size.h));
+        break;
+      case "door":
+        emitDoor(b, el);
+        break;
+      case "window":
+        emitWindow(b, el);
+        break;
+      case "dim":
+        emitDim(b, el);
+        break;
+    }
+  }
+  b.pair(0, "ENDSEC");
+  const entities = b.toString();
+  return header() + entities + "0\nEOF\n";
+}
+
+// src/export/pdf.ts
+function svgSize(svg) {
+  const w = /<svg[^>]*\bwidth="([\d.]+)/.exec(svg);
+  const h = /<svg[^>]*\bheight="([\d.]+)/.exec(svg);
+  if (w && h) return { width: parseFloat(w[1]), height: parseFloat(h[1]) };
+  const vb = /<svg[^>]*\bviewBox="[\d.\-]+ [\d.\-]+ ([\d.]+) ([\d.]+)"/.exec(svg);
+  if (vb) return { width: parseFloat(vb[1]), height: parseFloat(vb[2]) };
+  return { width: 800, height: 600 };
+}
+async function toPdf(svg) {
+  let PDFDocument;
+  let SVGtoPDF;
+  try {
+    PDFDocument = (await import("pdfkit")).default;
+    SVGtoPDF = (await import("svg-to-pdfkit")).default;
+  } catch {
+    throw new Error(
+      "PDF export needs the optional dependencies 'pdfkit' and 'svg-to-pdfkit'. Install them: npm install pdfkit svg-to-pdfkit"
+    );
+  }
+  const { width, height } = svgSize(svg);
+  const doc = new PDFDocument({ size: [width, height], margin: 0 });
+  const chunks = [];
+  const done = new Promise((resolve2, reject) => {
+    doc.on("data", (c) => chunks.push(c));
+    doc.on("end", () => resolve2());
+    doc.on("error", (e) => reject(e));
+  });
+  SVGtoPDF(doc, svg, 0, 0, { width, height, assumePt: true });
+  doc.end();
+  await done;
+  return concat(chunks);
+}
+function concat(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+
 // src/index.ts
 var cache = /* @__PURE__ */ new Map();
 var CACHE_MAX = 64;
 function compile(source, opts = {}) {
-  const key = JSON.stringify([source, opts.width ?? null]);
+  const key = JSON.stringify([source, opts.width ?? null, opts.theme ?? null]);
   if (!opts.noCache) {
     const hit = cache.get(key);
     if (hit) return hit;
@@ -1631,9 +2105,12 @@ function clearCache() {
 }
 
 export {
+  resolve,
   offsetToLineCol,
   formatDiagnostic,
+  toDxf,
+  toPdf,
   compile,
   clearCache
 };
-//# sourceMappingURL=chunk-DHNWMOP7.js.map
+//# sourceMappingURL=chunk-PABYLU6Z.js.map