@chanmeng666/archlang 0.1.0 → 0.3.0

package/dist/chunk-3YUQPQPZ.js

@@ -0,0 +1,1330 @@
+// src/lexer.ts
+var isDigit = (c) => c >= "0" && c <= "9";
+var isIdentStart = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+var isIdentPart = (c) => isIdentStart(c) || isDigit(c);
+function lex(src) {
+  const tokens = [];
+  const errors = [];
+  let i = 0;
+  let line = 1;
+  let col = 1;
+  const peek = (o = 0) => src[i + o] ?? "";
+  const advance = () => {
+    const c = src[i++];
+    if (c === "\n") {
+      line++;
+      col = 1;
+    } else {
+      col++;
+    }
+    return c;
+  };
+  const push = (type, value, startLine, startCol, startIdx, extra) => tokens.push({ type, value, line: startLine, col: startCol, ...extra, start: startIdx, end: i });
+  while (i < src.length) {
+    const c = peek();
+    const startLine = line;
+    const startCol = col;
+    const startIdx = i;
+    if (c === " " || c === "	" || c === "\r" || c === "\n") {
+      advance();
+      continue;
+    }
+    if (c === "#") {
+      while (i < src.length && peek() !== "\n") advance();
+      continue;
+    }
+    if (c === '"') {
+      advance();
+      let value = "";
+      let terminated = false;
+      while (i < src.length) {
+        const ch = peek();
+        if (ch === "\\") {
+          advance();
+          const esc = advance();
+          value += esc === "n" ? "\n" : esc;
+          continue;
+        }
+        if (ch === '"') {
+          advance();
+          terminated = true;
+          break;
+        }
+        if (ch === "\n") break;
+        value += advance();
+      }
+      if (!terminated) {
+        errors.push({ message: "Unterminated string literal", span: { start: startIdx, end: i } });
+      }
+      push("string", value, startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "(") {
+      advance();
+      push("lparen", "(", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === ")") {
+      advance();
+      push("rparen", ")", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "{") {
+      advance();
+      push("lcurly", "{", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "}") {
+      advance();
+      push("rcurly", "}", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === ",") {
+      advance();
+      push("comma", ",", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "=") {
+      advance();
+      push("equals", "=", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === ":") {
+      advance();
+      push("colon", ":", startLine, startCol, startIdx);
+      continue;
+    }
+    if (c === "-" && peek(1) === ">") {
+      advance();
+      advance();
+      push("arrow", "->", startLine, startCol, startIdx);
+      continue;
+    }
+    if (isDigit(c) || c === "-" && isDigit(peek(1)) || c === "." && isDigit(peek(1))) {
+      let raw = "";
+      if (c === "-") raw += advance();
+      while (isDigit(peek())) raw += advance();
+      if (peek() === ".") {
+        raw += advance();
+        while (isDigit(peek())) raw += advance();
+      }
+      const first = parseFloat(raw);
+      if (peek() === "x" && (isDigit(peek(1)) || peek(1) === "-" && isDigit(peek(2)) || peek(1) === "." && isDigit(peek(2)))) {
+        advance();
+        let raw2 = "";
+        if (peek() === "-") raw2 += advance();
+        while (isDigit(peek())) raw2 += advance();
+        if (peek() === ".") {
+          raw2 += advance();
+          while (isDigit(peek())) raw2 += advance();
+        }
+        const second = parseFloat(raw2);
+        push("dimension", `${raw}x${raw2}`, startLine, startCol, startIdx, { num: first, num2: second });
+        continue;
+      }
+      push("number", raw, startLine, startCol, startIdx, { num: first });
+      continue;
+    }
+    if (isIdentStart(c)) {
+      let value = "";
+      while (i < src.length && isIdentPart(peek())) value += advance();
+      push("ident", value, startLine, startCol, startIdx);
+      continue;
+    }
+    errors.push({ message: `Unexpected character ${JSON.stringify(c)}`, span: { start: startIdx, end: startIdx + 1 } });
+    advance();
+  }
+  push("eof", "", line, col, i);
+  return { tokens, errors };
+}
+
+// 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 });
+var mul = (v, s) => ({ x: v.x * s, y: v.y * s });
+var length = (v) => Math.hypot(v.x, v.y);
+function unit(v) {
+  const l = length(v);
+  return l === 0 ? { x: 0, y: 0 } : { x: v.x / l, y: v.y / l };
+}
+var normal = (v) => ({ x: -v.y, y: v.x });
+var emptyBounds = () => ({
+  minX: Infinity,
+  minY: Infinity,
+  maxX: -Infinity,
+  maxY: -Infinity
+});
+function extendBounds(b, x, y) {
+  if (x < b.minX) b.minX = x;
+  if (y < b.minY) b.minY = y;
+  if (x > b.maxX) b.maxX = x;
+  if (y > b.maxY) b.maxY = y;
+}
+function distPointToSegment(p, a, b) {
+  const abx = b.x - a.x;
+  const aby = b.y - a.y;
+  const apx = p.x - a.x;
+  const apy = p.y - a.y;
+  const len2 = abx * abx + aby * aby;
+  let t = len2 === 0 ? 0 : (apx * abx + apy * aby) / len2;
+  t = Math.max(0, Math.min(1, t));
+  const cx = a.x + t * abx;
+  const cy = a.y + t * aby;
+  return Math.hypot(p.x - cx, p.y - cy);
+}
+function rectCorners(x, y, w, h) {
+  return [
+    { x, y },
+    { x: x + w, y },
+    { x: x + w, y: y + h },
+    { x, y: y + h }
+  ];
+}
+function segmentRectangle(a, b, thickness) {
+  const d = unit(sub(b, a));
+  const n = normal(d);
+  const half = thickness / 2;
+  const a2 = add(a, mul(d, -half));
+  const b2 = add(b, mul(d, half));
+  return [
+    add(a2, mul(n, half)),
+    add(b2, mul(n, half)),
+    add(b2, mul(n, -half)),
+    add(a2, mul(n, -half))
+  ];
+}
+function segmentsOfWall(w) {
+  const segs = [];
+  for (let k = 0; k < w.points.length - 1; k++) {
+    segs.push({ a: w.points[k], b: w.points[k + 1], thickness: w.thickness, category: w.category });
+  }
+  if (w.closed && w.points.length > 2) {
+    segs.push({ a: w.points[w.points.length - 1], b: w.points[0], thickness: w.thickness, category: w.category });
+  }
+  return segs;
+}
+function hostSegmentForWalls(walls, at, ref) {
+  const candidates = ref ? walls.filter((w) => w.id === ref || w.category === ref) : walls;
+  let best = null;
+  let bestDist = Infinity;
+  for (const w of candidates) {
+    for (const s of segmentsOfWall(w)) {
+      const dist = distPointToSegment(at, s.a, s.b);
+      if (dist < bestDist) {
+        bestDist = dist;
+        best = s;
+      }
+    }
+  }
+  return best;
+}
+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/elements/wall.ts
+var wall = {
+  kind: "wall",
+  keyword: "wall",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("wall");
+    const id = ctx.parseIdOpt();
+    const category = ctx.eatIdent().value;
+    ctx.eatKeyword("thickness");
+    const thickness = ctx.eatNumber();
+    ctx.eat("lcurly");
+    const points = [];
+    let closed = false;
+    while (!ctx.isType("rcurly") && !ctx.isType("eof")) {
+      if (ctx.isKeyword("close")) {
+        ctx.next();
+        closed = true;
+        break;
+      }
+      if (ctx.isType("lparen")) {
+        points.push(ctx.parsePoint());
+        continue;
+      }
+      ctx.fail(`Expected a point "(x,y)" or "close" in wall body but found ${describe(ctx)}`);
+    }
+    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 };
+  },
+  idPrefix: (node) => node.category || "wall",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const points = n.points.map(ctx.snapPt);
+    const thickness = ctx.snap(n.thickness) || n.thickness;
+    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 };
+  },
+  bounds(resolved) {
+    const w = resolved;
+    return segmentsOfWall(w).flatMap((s) => segmentRectangle(s.a, s.b, s.thickness));
+  },
+  render(resolved, ctx) {
+    const w = resolved;
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const segs = segmentsOfWall(w);
+    const ops = [];
+    for (const s of segs) {
+      const poly = segmentRectangle(s.a, s.b, s.thickness);
+      ops.push({ pass: "wallFill", svg: `<polygon points="${poly.map(pt2).join(" ")}" fill="url(#poche)"/>` });
+    }
+    for (const s of segs) {
+      const d = unit(sub(s.b, s.a));
+      const n = normal(d);
+      const h = s.thickness / 2;
+      const fa1 = add(s.a, mul(n, h));
+      const fb1 = add(s.b, mul(n, h));
+      const fa2 = add(s.a, mul(n, -h));
+      const fb2 = add(s.b, mul(n, -h));
+      ops.push({
+        pass: "wallFace",
+        svg: `<line x1="${fmt2(fa1.x)}" y1="${fmt2(fa1.y)}" x2="${fmt2(fb1.x)}" y2="${fmt2(fb1.y)}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.wallStroke)}" stroke-linecap="square"/>`
+      });
+      ops.push({
+        pass: "wallFace",
+        svg: `<line x1="${fmt2(fa2.x)}" y1="${fmt2(fa2.y)}" x2="${fmt2(fb2.x)}" y2="${fmt2(fb2.y)}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.wallStroke)}" stroke-linecap="square"/>`
+      });
+    }
+    return ops;
+  }
+};
+function describe(ctx) {
+  const t = ctx.peek();
+  if (t.type === "eof") return "end of input";
+  if (t.type === "string") return `string ${JSON.stringify(t.value)}`;
+  return `"${t.value}"`;
+}
+
+// src/elements/room.ts
+var room = {
+  kind: "room",
+  keyword: "room",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("room");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("size");
+    const dim2 = ctx.eat("dimension");
+    const node = { kind: "room", id, at, size: { w: dim2.num, h: dim2.num2 }, line: kw.line };
+    if (ctx.isKeyword("label")) {
+      ctx.next();
+      node.label = ctx.eatString();
+    }
+    return node;
+  },
+  idPrefix: () => "room",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const size = { w: ctx.snap(n.size.w), h: ctx.snap(n.size.h) };
+    if (size.w <= 0 || size.h <= 0) {
+      ctx.diag({ severity: "error", message: `Room "${id}" must have a positive size`, code: "E_ROOM_SIZE", span: n.span });
+    }
+    return { kind: "room", id, at, size, label: n.label, span: n.span };
+  },
+  bounds(resolved) {
+    const r = resolved;
+    return rectCorners(r.at.x, r.at.y, r.size.w, r.size.h);
+  },
+  render(resolved, ctx) {
+    const r = resolved;
+    const { fmt: fmt2, pt: pt2, xml: xml2, theme, sizes } = ctx;
+    const ops = [];
+    const c = rectCorners(r.at.x, r.at.y, r.size.w, r.size.h);
+    ops.push({ pass: "floor", svg: `<polygon points="${c.map(pt2).join(" ")}" fill="${theme.roomFill}"/>` });
+    const cx = r.at.x + r.size.w / 2;
+    const cy = r.at.y + r.size.h / 2;
+    const areaM2 = (r.size.w / 1e3 * (r.size.h / 1e3)).toFixed(1);
+    if (r.label) {
+      ops.push({
+        pass: "labels",
+        svg: `<text x="${fmt2(cx)}" y="${fmt2(cy - sizes.roomFont * 0.2)}" font-size="${fmt2(sizes.roomFont)}" fill="${theme.roomLabel}" text-anchor="middle" dominant-baseline="central" font-weight="600">${xml2(r.label)}</text>`
+      });
+    }
+    ops.push({
+      pass: "labels",
+      svg: `<text x="${fmt2(cx)}" y="${fmt2(cy + (r.label ? sizes.roomFont * 0.9 : 0))}" font-size="${fmt2(sizes.areaFont)}" fill="${theme.areaLabel}" text-anchor="middle" dominant-baseline="central">${areaM2} m\xB2</text>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/door.ts
+var door = {
+  kind: "door",
+  keyword: "door",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("door");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("width");
+    const width = ctx.eatNumber();
+    const node = { kind: "door", id, at, width, hinge: "left", swing: "in", line: kw.line };
+    if (ctx.isKeyword("wall")) {
+      ctx.next();
+      node.wall = ctx.eatIdent().value;
+    }
+    if (ctx.isKeyword("hinge")) {
+      ctx.next();
+      const h = ctx.eatIdent().value;
+      if (h !== "left" && h !== "right") ctx.fail(`Expected hinge "left" or "right" but found "${h}"`);
+      node.hinge = h;
+    }
+    if (ctx.isKeyword("swing")) {
+      ctx.next();
+      const s = ctx.eatIdent().value;
+      if (s !== "in" && s !== "out") ctx.fail(`Expected swing "in" or "out" but found "${s}"`);
+      node.swing = s;
+    }
+    return node;
+  },
+  idPrefix: () => "door",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const width = ctx.snap(n.width) || n.width;
+    if (width <= 0) {
+      ctx.diag({ severity: "error", message: `Door "${id}" must have a positive width`, code: "E_DOOR_WIDTH", span: n.span });
+    }
+    if (ctx.walls.length > 0 && !ctx.isOnWall(at, n.wall)) {
+      ctx.diag({ severity: "warning", message: `Door "${id}" does not lie on any wall`, code: "W_DOOR_OFF_WALL", span: n.span });
+    }
+    return { kind: "door", id, at, width, hinge: n.hinge, swing: n.swing, host: ctx.hostSegment(at, n.wall), span: n.span };
+  },
+  bounds: () => [],
+  render(resolved, ctx) {
+    const dr = resolved;
+    const seg = dr.host;
+    if (!seg) return [];
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const d = unit(sub(seg.b, seg.a));
+    const n = normal(d);
+    const h = seg.thickness / 2 + sizes.wallStroke;
+    const hw = dr.width / 2;
+    const cover = [
+      add(add(dr.at, mul(d, -hw)), mul(n, h)),
+      add(add(dr.at, mul(d, hw)), mul(n, h)),
+      add(add(dr.at, mul(d, hw)), mul(n, -h)),
+      add(add(dr.at, mul(d, -hw)), mul(n, -h))
+    ];
+    const ops = [];
+    ops.push({ pass: "doors", svg: `<polygon points="${cover.map(pt2).join(" ")}" fill="${theme.opening}"/>` });
+    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));
+    const cross = (leafEnd.x - hinge.x) * (farJamb.y - hinge.y) - (leafEnd.y - hinge.y) * (farJamb.x - hinge.x);
+    const sweep = cross < 0 ? 1 : 0;
+    ops.push({
+      pass: "doors",
+      svg: `<line x1="${fmt2(hinge.x)}" y1="${fmt2(hinge.y)}" x2="${fmt2(leafEnd.x)}" y2="${fmt2(leafEnd.y)}" stroke="${theme.doorLeaf}" stroke-width="${fmt2(sizes.thin * 1.3)}"/>`
+    });
+    ops.push({
+      pass: "doors",
+      svg: `<path d="M ${pt2(leafEnd)} A ${fmt2(dr.width)} ${fmt2(dr.width)} 0 0 ${sweep} ${pt2(farJamb)}" fill="none" stroke="${theme.doorLeaf}" stroke-width="${fmt2(sizes.thin)}" stroke-dasharray="${fmt2(sizes.thin * 4)} ${fmt2(sizes.thin * 3)}"/>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/window.ts
+var windowEl = {
+  kind: "window",
+  keyword: "window",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("window");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("width");
+    const width = ctx.eatNumber();
+    const node = { kind: "window", id, at, width, line: kw.line };
+    if (ctx.isKeyword("wall")) {
+      ctx.next();
+      node.wall = ctx.eatIdent().value;
+    }
+    return node;
+  },
+  idPrefix: () => "window",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const width = ctx.snap(n.width) || n.width;
+    if (width <= 0) {
+      ctx.diag({ severity: "error", message: `Window "${id}" must have a positive width`, code: "E_WINDOW_WIDTH", span: n.span });
+    }
+    if (ctx.walls.length > 0 && !ctx.isOnWall(at, n.wall)) {
+      ctx.diag({ severity: "warning", message: `Window "${id}" does not lie on any wall`, code: "W_WINDOW_OFF_WALL", span: n.span });
+    }
+    return { kind: "window", id, at, width, host: ctx.hostSegment(at, n.wall), span: n.span };
+  },
+  bounds: () => [],
+  render(resolved, ctx) {
+    const wn = resolved;
+    const seg = wn.host;
+    if (!seg) return [];
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const d = unit(sub(seg.b, seg.a));
+    const n = normal(d);
+    const h = seg.thickness / 2;
+    const he = h + sizes.wallStroke;
+    const hw = wn.width / 2;
+    const cover = [
+      add(add(wn.at, mul(d, -hw)), mul(n, he)),
+      add(add(wn.at, mul(d, hw)), mul(n, he)),
+      add(add(wn.at, mul(d, hw)), mul(n, -he)),
+      add(add(wn.at, mul(d, -hw)), mul(n, -he))
+    ];
+    const ops = [];
+    ops.push({ pass: "windows", svg: `<polygon points="${cover.map(pt2).join(" ")}" fill="${theme.opening}"/>` });
+    const jA = add(wn.at, mul(d, -hw));
+    const jB = add(wn.at, mul(d, hw));
+    for (const off of [h, -h]) {
+      const a = add(jA, mul(n, off));
+      const bb = add(jB, mul(n, off));
+      ops.push({
+        pass: "windows",
+        svg: `<line x1="${fmt2(a.x)}" y1="${fmt2(a.y)}" x2="${fmt2(bb.x)}" y2="${fmt2(bb.y)}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.thin)}"/>`
+      });
+    }
+    ops.push({
+      pass: "windows",
+      svg: `<line x1="${fmt2(jA.x)}" y1="${fmt2(jA.y)}" x2="${fmt2(jB.x)}" y2="${fmt2(jB.y)}" stroke="${theme.windowPane}" stroke-width="${fmt2(sizes.thin)}"/>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/furniture.ts
+var furniture = {
+  kind: "furniture",
+  keyword: "furniture",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("furniture");
+    const id = ctx.parseIdOpt();
+    const category = ctx.eatIdent().value;
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("size");
+    const dim2 = ctx.eat("dimension");
+    const node = { kind: "furniture", id, category, at, size: { w: dim2.num, h: dim2.num2 }, line: kw.line };
+    if (ctx.isKeyword("label")) {
+      ctx.next();
+      node.label = ctx.eatString();
+    }
+    return node;
+  },
+  idPrefix: (node) => node.category || "furniture",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const size = { w: ctx.snap(n.size.w), h: ctx.snap(n.size.h) };
+    if (size.w <= 0 || size.h <= 0) {
+      ctx.diag({ severity: "error", message: `Furniture "${id}" must have a positive size`, code: "E_FURN_SIZE", span: n.span });
+    }
+    return { kind: "furniture", id, category: n.category, at, size, label: n.label, span: n.span };
+  },
+  bounds(resolved) {
+    const f = resolved;
+    return rectCorners(f.at.x, f.at.y, f.size.w, f.size.h);
+  },
+  render(resolved, ctx) {
+    const f = resolved;
+    const { fmt: fmt2, pt: pt2, xml: xml2, theme, sizes } = ctx;
+    const ops = [];
+    const c = rectCorners(f.at.x, f.at.y, f.size.w, f.size.h);
+    ops.push({
+      pass: "furniture",
+      svg: `<polygon points="${c.map(pt2).join(" ")}" fill="${theme.furnitureFill}" stroke="${theme.furnitureStroke}" stroke-width="${fmt2(sizes.thin)}"/>`
+    });
+    if (f.label) {
+      const cx = f.at.x + f.size.w / 2;
+      const cy = f.at.y + f.size.h / 2;
+      ops.push({
+        pass: "furniture",
+        svg: `<text x="${fmt2(cx)}" y="${fmt2(cy)}" font-size="${fmt2(sizes.furnFont)}" fill="${theme.furnitureLabel}" text-anchor="middle" dominant-baseline="central">${xml2(f.label)}</text>`
+      });
+    }
+    return ops;
+  }
+};
+
+// src/elements/dim.ts
+var dim = {
+  kind: "dim",
+  keyword: "dim",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("dim");
+    const from = ctx.parsePoint();
+    ctx.eat("arrow");
+    const to = ctx.parsePoint();
+    const node = { kind: "dim", id: "", from, to, offset: 300, line: kw.line };
+    if (ctx.isKeyword("offset")) {
+      ctx.next();
+      node.offset = ctx.eatNumber();
+    }
+    if (ctx.isKeyword("text")) {
+      ctx.next();
+      node.text = ctx.eatString();
+    }
+    return node;
+  },
+  idPrefix: () => "dim",
+  resolve(node, ctx) {
+    const n = node;
+    return {
+      kind: "dim",
+      id: ctx.idOf(n),
+      from: ctx.snapPt(n.from),
+      to: ctx.snapPt(n.to),
+      offset: n.offset,
+      text: n.text,
+      span: n.span
+    };
+  },
+  bounds(resolved) {
+    const dm = resolved;
+    return [dm.from, dm.to];
+  },
+  render(resolved, ctx) {
+    const dm = resolved;
+    const { fmt: fmt2, xml: xml2, theme, sizes } = ctx;
+    const dir = unit(sub(dm.to, dm.from));
+    const n = normal(dir);
+    const off = mul(n, dm.offset);
+    const p1 = add(dm.from, off);
+    const p2 = add(dm.to, off);
+    const tick = sizes.refDim * 0.012;
+    const ops = [];
+    ops.push({
+      pass: "dims",
+      svg: `<line x1="${fmt2(dm.from.x)}" y1="${fmt2(dm.from.y)}" x2="${fmt2(p1.x)}" y2="${fmt2(p1.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin * 0.7)}"/>`
+    });
+    ops.push({
+      pass: "dims",
+      svg: `<line x1="${fmt2(dm.to.x)}" y1="${fmt2(dm.to.y)}" x2="${fmt2(p2.x)}" y2="${fmt2(p2.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin * 0.7)}"/>`
+    });
+    ops.push({
+      pass: "dims",
+      svg: `<line x1="${fmt2(p1.x)}" y1="${fmt2(p1.y)}" x2="${fmt2(p2.x)}" y2="${fmt2(p2.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin)}"/>`
+    });
+    for (const p of [p1, p2]) {
+      const t1 = add(p, mul(unit({ x: dir.x + n.x, y: dir.y + n.y }), tick));
+      const t2 = add(p, mul(unit({ x: dir.x + n.x, y: dir.y + n.y }), -tick));
+      ops.push({
+        pass: "dims",
+        svg: `<line x1="${fmt2(t1.x)}" y1="${fmt2(t1.y)}" x2="${fmt2(t2.x)}" y2="${fmt2(t2.y)}" stroke="${theme.dim}" stroke-width="${fmt2(sizes.thin)}"/>`
+      });
+    }
+    const mid = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };
+    const tp = add(mid, mul(n, sizes.dimFont * 0.7));
+    let angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
+    if (angle > 90) angle -= 180;
+    if (angle < -90) angle += 180;
+    const label = dm.text ?? String(Math.round(length(sub(dm.to, dm.from))));
+    ops.push({
+      pass: "dims",
+      svg: `<text x="${fmt2(tp.x)}" y="${fmt2(tp.y)}" font-size="${fmt2(sizes.dimFont)}" fill="${theme.dim}" text-anchor="middle" dominant-baseline="central" transform="rotate(${fmt2(angle)} ${fmt2(tp.x)} ${fmt2(tp.y)})">${xml2(label)}</text>`
+    });
+    return ops;
+  }
+};
+
+// src/elements/column.ts
+var column = {
+  kind: "column",
+  keyword: "column",
+  parse(ctx) {
+    const kw = ctx.eatKeyword("column");
+    const id = ctx.parseIdOpt();
+    ctx.eatKeyword("at");
+    const at = ctx.parsePoint();
+    ctx.eatKeyword("size");
+    const dim2 = ctx.eat("dimension");
+    return { kind: "column", id, at, size: { w: dim2.num, h: dim2.num2 }, line: kw.line };
+  },
+  idPrefix: () => "column",
+  resolve(node, ctx) {
+    const n = node;
+    const id = ctx.idOf(n);
+    const at = ctx.snapPt(n.at);
+    const size = { w: ctx.snap(n.size.w), h: ctx.snap(n.size.h) };
+    if (size.w <= 0 || size.h <= 0) {
+      ctx.diag({ severity: "error", message: `Column "${id}" must have a positive size`, code: "E_COLUMN_SIZE", span: n.span });
+    }
+    return { kind: "column", id, at, size, span: n.span };
+  },
+  bounds(resolved) {
+    const c = resolved;
+    return rectCorners(c.at.x, c.at.y, c.size.w, c.size.h);
+  },
+  render(resolved, ctx) {
+    const c = resolved;
+    const { fmt: fmt2, pt: pt2, theme, sizes } = ctx;
+    const pts = rectCorners(c.at.x, c.at.y, c.size.w, c.size.h);
+    return [
+      {
+        pass: "furniture",
+        svg: `<polygon points="${pts.map(pt2).join(" ")}" fill="${theme.column}" stroke="${theme.wallStroke}" stroke-width="${fmt2(sizes.thin)}"/>`
+      }
+    ];
+  }
+};
+
+// src/elements/index.ts
+var registryOrder = [];
+var registry = /* @__PURE__ */ new Map();
+function register(def) {
+  registry.set(def.keyword, def);
+  registryOrder.push(def);
+}
+register(wall);
+register(room);
+register(door);
+register(windowEl);
+register(furniture);
+register(dim);
+register(column);
+
+// src/parser.ts
+var SETTINGS = ["units", "grid", "scale", "north", "title"];
+var STATEMENT_STARTS = /* @__PURE__ */ new Set([...SETTINGS, ...registry.keys()]);
+var ParseError = class extends Error {
+  constructor(message, span) {
+    super(message);
+    this.message = message;
+    this.span = span;
+  }
+  message;
+  span;
+};
+function parse(src) {
+  const { tokens, errors: lexErrors } = lex(src);
+  const lexDiags = lexErrors.map((e) => ({
+    severity: "error",
+    message: e.message,
+    span: e.span
+  }));
+  const p = new Parser(tokens);
+  let plan;
+  try {
+    plan = p.parsePlan();
+  } catch (e) {
+    if (e instanceof ParseError) {
+      p.diagnostics.push({ severity: "error", message: e.message, span: e.span });
+    } else {
+      throw e;
+    }
+  }
+  return { plan, diagnostics: [...lexDiags, ...p.diagnostics] };
+}
+var Parser = class {
+  constructor(toks) {
+    this.toks = toks;
+    this.ctx = {
+      peek: (o) => this.peek(o),
+      next: () => this.next(),
+      eat: (type) => this.eat(type),
+      eatKeyword: (kw) => this.eatKeyword(kw),
+      eatIdent: () => this.eatIdent(),
+      eatNumber: () => this.eatNumber(),
+      eatString: () => this.eatString(),
+      isKeyword: (kw, o) => this.isKeyword(kw, o),
+      isType: (type) => this.isType(type),
+      parsePoint: () => this.parsePoint(),
+      parseIdOpt: () => this.parseIdOpt(),
+      fail: (msg, t) => this.fail(msg, t)
+    };
+  }
+  toks;
+  pos = 0;
+  diagnostics = [];
+  /** Facade passed to element parse functions (see registry.ts). */
+  ctx;
+  peek(o = 0) {
+    return this.toks[Math.min(this.pos + o, this.toks.length - 1)];
+  }
+  next() {
+    return this.toks[Math.min(this.pos++, this.toks.length - 1)];
+  }
+  fail(msg, t = this.peek()) {
+    throw new ParseError(msg, { start: t.start, end: t.end });
+  }
+  /** Span from a start offset to the end of the last consumed token. */
+  spanFrom(start) {
+    const last = this.toks[Math.max(0, Math.min(this.pos - 1, this.toks.length - 1))];
+    return { start, end: last.end };
+  }
+  /** Recover after a statement error: skip to the next statement start or block end. */
+  synchronize() {
+    if (!this.isType("rcurly") && !this.isType("eof")) this.next();
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const t = this.peek();
+      if (t.type === "ident" && STATEMENT_STARTS.has(t.value)) return;
+      this.next();
+    }
+  }
+  isKeyword(kw, o = 0) {
+    const t = this.peek(o);
+    return t.type === "ident" && t.value === kw;
+  }
+  eatKeyword(kw) {
+    const t = this.peek();
+    if (t.type !== "ident" || t.value !== kw) this.fail(`Expected "${kw}" but found ${describe2(t)}`);
+    return this.next();
+  }
+  eat(type) {
+    const t = this.peek();
+    if (t.type !== type) this.fail(`Expected ${type} but found ${describe2(t)}`);
+    return this.next();
+  }
+  eatIdent() {
+    return this.eat("ident");
+  }
+  eatNumber() {
+    const t = this.eat("number");
+    return t.num;
+  }
+  eatString() {
+    return this.eat("string").value;
+  }
+  parsePlan() {
+    this.eatKeyword("plan");
+    const name = this.eatString();
+    this.eat("lcurly");
+    const plan = {
+      name,
+      units: "mm",
+      grid: 0,
+      north: "up",
+      elements: []
+    };
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const t = this.peek();
+      const start = t.start;
+      try {
+        if (t.type !== "ident") this.fail(`Expected a statement but found ${describe2(t)}`);
+        const def = registry.get(t.value);
+        if (def) {
+          const node = def.parse(this.ctx);
+          node.span = this.spanFrom(start);
+          plan.elements.push(node);
+          continue;
+        }
+        switch (t.value) {
+          case "units": {
+            this.next();
+            const u = this.eatIdent().value;
+            if (u !== "mm") this.fail(`Unsupported units "${u}" (only "mm" is supported)`, t);
+            plan.units = "mm";
+            break;
+          }
+          case "grid":
+            this.next();
+            plan.grid = this.eatNumber();
+            break;
+          case "scale": {
+            this.next();
+            const a = this.eatNumber();
+            this.eat("colon");
+            const b = this.eatNumber();
+            plan.scale = `${a}:${b}`;
+            break;
+          }
+          case "north":
+            this.next();
+            plan.north = this.parseNorth();
+            break;
+          case "title": {
+            const n = this.parseTitle();
+            n.span = this.spanFrom(start);
+            plan.title = n;
+            break;
+          }
+          default:
+            this.fail(`Unknown statement "${t.value}"`, t);
+        }
+      } catch (e) {
+        if (e instanceof ParseError) {
+          this.diagnostics.push({ severity: "error", message: e.message, span: e.span });
+          this.synchronize();
+        } else {
+          throw e;
+        }
+      }
+    }
+    try {
+      this.eat("rcurly");
+    } catch (e) {
+      if (e instanceof ParseError) {
+        this.diagnostics.push({ severity: "error", message: e.message, span: e.span });
+      } else {
+        throw e;
+      }
+    }
+    return plan;
+  }
+  isType(type) {
+    return this.peek().type === type;
+  }
+  /** Optional `id=<ident>` prefix; returns "" when absent. */
+  parseIdOpt() {
+    if (this.isKeyword("id")) {
+      this.next();
+      this.eat("equals");
+      return this.eatIdent().value;
+    }
+    return "";
+  }
+  parseNorth() {
+    const t = this.peek();
+    if (t.type === "number") {
+      this.next();
+      return { deg: t.num };
+    }
+    if (t.type === "ident" && ["up", "down", "left", "right"].includes(t.value)) {
+      this.next();
+      return t.value;
+    }
+    this.fail(`Expected a north direction (up|down|left|right|<degrees>) but found ${describe2(t)}`);
+  }
+  parsePoint() {
+    this.eat("lparen");
+    const x = this.eatNumber();
+    this.eat("comma");
+    const y = this.eatNumber();
+    this.eat("rparen");
+    return { x, y };
+  }
+  parseTitle() {
+    const kw = this.eatKeyword("title");
+    this.eat("lcurly");
+    const node = { line: kw.line };
+    while (!this.isType("rcurly") && !this.isType("eof")) {
+      const t = this.peek();
+      if (t.type !== "ident") this.fail(`Expected a title field but found ${describe2(t)}`);
+      switch (t.value) {
+        case "project":
+          this.next();
+          node.project = this.eatString();
+          break;
+        case "drawn_by":
+          this.next();
+          node.drawnBy = this.eatString();
+          break;
+        case "date":
+          this.next();
+          node.date = this.eatString();
+          break;
+        default:
+          this.fail(`Unknown title field "${t.value}"`, t);
+      }
+    }
+    this.eat("rcurly");
+    return node;
+  }
+};
+function describe2(t) {
+  if (t.type === "eof") return "end of input";
+  if (t.type === "string") return `string ${JSON.stringify(t.value)}`;
+  return `"${t.value}"`;
+}
+
+// src/ir.ts
+function resolve(ast) {
+  const diagnostics = [];
+  const g = ast.grid;
+  const snap = (v) => g > 0 ? Math.round(v / g) * g : v;
+  const snapPt = (p) => ({ x: snap(p.x), y: snap(p.y) });
+  const idMap = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const assignId = (provided, prefix, idx, span) => {
+    if (provided) {
+      if (seen.has(provided)) {
+        diagnostics.push({ severity: "error", message: `Duplicate id "${provided}"`, code: "E_DUP_ID", span });
+      }
+      seen.add(provided);
+      return provided;
+    }
+    let auto = `${prefix}_${idx}`;
+    while (seen.has(auto)) auto = `${auto}_`;
+    seen.add(auto);
+    return auto;
+  };
+  for (const def of registryOrder) {
+    let idx = 0;
+    for (const node of ast.elements) {
+      if (node.kind !== def.kind) continue;
+      idx++;
+      idMap.set(node, assignId(node.id, def.idPrefix(node), idx, node.span));
+    }
+  }
+  const walls = [];
+  const ctx = {
+    grid: g,
+    snap,
+    snapPt,
+    idOf: (node) => idMap.get(node) ?? node.id,
+    walls,
+    hostSegment: (at, ref) => hostSegmentForWalls(walls, at, ref),
+    isOnWall: (at, ref) => isOnSomeWall(walls, at, ref),
+    diag: (d) => diagnostics.push(d)
+  };
+  const rmap = /* @__PURE__ */ new Map();
+  for (const def of registryOrder) {
+    for (const node of ast.elements) {
+      if (node.kind !== def.kind) continue;
+      const r = def.resolve(node, ctx);
+      rmap.set(node, r);
+      if (r.kind === "wall") walls.push(r);
+    }
+  }
+  const elements = ast.elements.map((n) => rmap.get(n));
+  const drawable = elements.some(
+    (e) => e.kind === "wall" || e.kind === "room" || e.kind === "furniture" || e.kind === "column"
+  );
+  if (!drawable) {
+    diagnostics.push({
+      severity: "warning",
+      message: "Plan has no walls, rooms, or furniture \u2014 nothing to draw",
+      code: "W_EMPTY_PLAN"
+    });
+  }
+  const rooms = elements.filter((e) => e.kind === "room");
+  for (let a = 0; a < rooms.length; a++) {
+    for (let b = a + 1; b < rooms.length; b++) {
+      const r1 = rooms[a];
+      const r2 = rooms[b];
+      const ox = Math.max(0, Math.min(r1.at.x + r1.size.w, r2.at.x + r2.size.w) - Math.max(r1.at.x, r2.at.x));
+      const oy = Math.max(0, Math.min(r1.at.y + r1.size.h, r2.at.y + r2.size.h) - Math.max(r1.at.y, r2.at.y));
+      if (ox > 1 && oy > 1) {
+        diagnostics.push({
+          severity: "warning",
+          message: `Rooms "${r1.id}" and "${r2.id}" overlap`,
+          code: "W_ROOM_OVERLAP",
+          span: r2.span
+        });
+      }
+    }
+  }
+  const ir = {
+    name: ast.name,
+    units: ast.units,
+    grid: ast.grid,
+    scale: ast.scale,
+    north: ast.north,
+    title: ast.title,
+    elements,
+    walls
+  };
+  return { ir, diagnostics };
+}
+
+// src/registry.ts
+var RENDER_PASSES = [
+  "floor",
+  "furniture",
+  "wallFill",
+  "wallFace",
+  "doors",
+  "windows",
+  "labels",
+  "dims",
+  "annotations"
+];
+
+// 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);
+}
+var pt = (p) => `${fmt(p.x)},${fmt(p.y)}`;
+function xml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var NICE_LENGTHS = [500, 1e3, 2e3, 5e3, 1e4, 2e4, 5e4, 1e5];
+function niceBarLength(target) {
+  let best = NICE_LENGTHS[0];
+  for (const v of NICE_LENGTHS) if (v <= target) best = v;
+  return best;
+}
+function planBounds(ir) {
+  const b = emptyBounds();
+  for (const el of ir.elements) {
+    const def = registry.get(el.kind);
+    if (!def) continue;
+    for (const p of def.bounds(el)) extendBounds(b, p.x, p.y);
+  }
+  if (!isFinite(b.minX)) {
+    return { minX: 0, minY: 0, maxX: 1e3, maxY: 1e3 };
+  }
+  return b;
+}
+function render(ir, opts = {}) {
+  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,
+    roomFont: refDim * 0.03,
+    areaFont: refDim * 0.022,
+    dimFont: refDim * 0.02,
+    furnFont: refDim * 0.017,
+    margin: refDim * 0.17,
+    hatchGap: refDim * 0.013
+  };
+  const { thin, margin, hatchGap } = sizes;
+  const vbX = b.minX - margin;
+  const vbY = b.minY - margin;
+  const vbW = drawW + margin * 2;
+  const vbH = drawH + margin * 2;
+  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>`
+  );
+  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) => {
+    const def = registry.get(el.kind);
+    return def ? def.render(el, 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);
+  if (tb) out.push(tb);
+  out.push("</svg>");
+  return out.join("\n");
+}
+function northArrow(ir, b, margin, refDim) {
+  const r = refDim * 0.045;
+  const cx = b.maxX - r;
+  const cy = b.minY - margin * 0.55;
+  let deg;
+  switch (ir.north) {
+    case "up":
+      deg = 0;
+      break;
+    case "down":
+      deg = 180;
+      break;
+    case "left":
+      deg = 270;
+      break;
+    case "right":
+      deg = 90;
+      break;
+    default:
+      deg = typeof ir.north === "object" ? ir.north.deg : 0;
+  }
+  const fs = refDim * 0.026;
+  const tri = `${fmt(cx)},${fmt(cy - r)} ${fmt(cx - r * 0.5)},${fmt(cy + r * 0.6)} ${fmt(cx)},${fmt(cy + r * 0.25)} ${fmt(cx + r * 0.5)},${fmt(cy + r * 0.6)}`;
+  const rad = deg * Math.PI / 180;
+  const nx = Math.sin(rad);
+  const ny = -Math.cos(rad);
+  const lx = cx + nx * (r + fs * 0.8);
+  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) {
+  const barLen = niceBarLength(refDim * 0.3);
+  const x0 = b.minX;
+  const y0 = b.maxY + margin * 0.55;
+  const hgt = refDim * 0.014;
+  const fs = refDim * 0.02;
+  const parts = [];
+  const half = barLen / 2;
+  parts.push(`<rect x="${fmt(x0)}" y="${fmt(y0)}" width="${fmt(half)}" height="${fmt(hgt)}" fill="${THEME.annotation}"/>`);
+  parts.push(
+    `<rect x="${fmt(x0 + half)}" y="${fmt(y0)}" width="${fmt(half)}" height="${fmt(hgt)}" fill="none" stroke="${THEME.annotation}" stroke-width="${fmt(thin)}"/>`
+  );
+  parts.push(
+    `<text x="${fmt(x0)}" y="${fmt(y0 + hgt + fs)}" font-size="${fmt(fs)}" fill="${THEME.annotation}" text-anchor="start" dominant-baseline="central">0</text>`
+  );
+  parts.push(
+    `<text x="${fmt(x0 + barLen)}" y="${fmt(y0 + hgt + fs)}" font-size="${fmt(fs)}" fill="${THEME.annotation}" text-anchor="middle" dominant-baseline="central">${barLen / 1e3} m</text>`
+  );
+  return `<g>${parts.join("")}</g>`;
+}
+function titleBlock(ir, b, margin, refDim, thin) {
+  const t = ir.title;
+  if (!t && !ir.scale) return null;
+  const boxW = refDim * 0.34;
+  const boxH = margin * 0.82;
+  const x0 = b.maxX - boxW;
+  const y0 = b.maxY + margin * 0.15;
+  const fs = refDim * 0.019;
+  const pad = boxW * 0.05;
+  const lines = [];
+  if (t?.project) lines.push({ k: "PROJECT", v: t.project });
+  if (t?.drawnBy) lines.push({ k: "DRAWN BY", v: t.drawnBy });
+  if (t?.date) lines.push({ k: "DATE", v: t.date });
+  if (ir.scale) lines.push({ k: "SCALE", v: ir.scale });
+  const parts = [];
+  parts.push(
+    `<rect x="${fmt(x0)}" y="${fmt(y0)}" width="${fmt(boxW)}" height="${fmt(boxH)}" fill="none" stroke="${THEME.annotation}" stroke-width="${fmt(thin)}"/>`
+  );
+  const rowH = boxH / Math.max(lines.length, 1);
+  lines.forEach((ln, i) => {
+    const ly = y0 + rowH * (i + 0.5);
+    parts.push(
+      `<text x="${fmt(x0 + pad)}" y="${fmt(ly)}" font-size="${fmt(fs * 0.8)}" fill="${THEME.annotationMuted}" dominant-baseline="central">${xml(ln.k)}</text>`
+    );
+    parts.push(
+      `<text x="${fmt(x0 + boxW - pad)}" y="${fmt(ly)}" font-size="${fmt(fs)}" fill="${THEME.annotation}" text-anchor="end" dominant-baseline="central">${xml(ln.v)}</text>`
+    );
+    if (i > 0)
+      parts.push(
+        `<line x1="${fmt(x0)}" y1="${fmt(y0 + rowH * i)}" x2="${fmt(x0 + boxW)}" y2="${fmt(y0 + rowH * i)}" stroke="${THEME.annotation}" stroke-width="${fmt(thin * 0.5)}"/>`
+      );
+  });
+  return `<g>${parts.join("")}</g>`;
+}
+
+// src/diagnostics.ts
+function offsetToLineCol(source, offset) {
+  const o = Math.max(0, Math.min(offset, source.length));
+  let line = 1;
+  let col = 1;
+  for (let k = 0; k < o; k++) {
+    if (source[k] === "\n") {
+      line++;
+      col = 1;
+    } else {
+      col++;
+    }
+  }
+  return { line, col };
+}
+function lineStart(source, offset) {
+  let k = Math.max(0, Math.min(offset, source.length));
+  while (k > 0 && source[k - 1] !== "\n") k--;
+  return k;
+}
+function lineEnd(source, offset) {
+  let k = Math.max(0, Math.min(offset, source.length));
+  while (k < source.length && source[k] !== "\n") k++;
+  return k;
+}
+function formatDiagnostic(source, d) {
+  const codeTag = d.code ? `[${d.code}]` : "";
+  const header = `${d.severity}${codeTag}: ${d.message}`;
+  const lines = [header];
+  if (d.span) {
+    const { line, col } = offsetToLineCol(source, d.span.start);
+    const ls = lineStart(source, d.span.start);
+    const le = lineEnd(source, d.span.start);
+    const srcLine = source.slice(ls, le);
+    const caretStart = d.span.start - ls;
+    const caretEnd = Math.min(d.span.end, le) - ls;
+    const caretLen = Math.max(1, caretEnd - caretStart);
+    const gutter = String(line);
+    const pad = " ".repeat(gutter.length);
+    lines.push(`${pad} --> ${line}:${col}`);
+    lines.push(`${pad} |`);
+    lines.push(`${gutter} | ${srcLine}`);
+    lines.push(`${pad} | ${" ".repeat(caretStart)}${"^".repeat(caretLen)}`);
+    for (const hint of d.hints ?? []) {
+      lines.push(`${pad} = help: ${hint}`);
+    }
+  } else {
+    for (const hint of d.hints ?? []) {
+      lines.push(`  = help: ${hint}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/index.ts
+var cache = /* @__PURE__ */ new Map();
+var CACHE_MAX = 64;
+function compile(source, opts = {}) {
+  const key = JSON.stringify([source, opts.width ?? null]);
+  if (!opts.noCache) {
+    const hit = cache.get(key);
+    if (hit) return hit;
+  }
+  const result = compileUncached(source, opts);
+  if (!opts.noCache) {
+    if (cache.size >= CACHE_MAX) {
+      const oldest = cache.keys().next().value;
+      if (oldest !== void 0) cache.delete(oldest);
+    }
+    cache.set(key, result);
+  }
+  return result;
+}
+function toLegacy(source, d) {
+  if (!d.span) return { message: d.message };
+  const { line, col } = offsetToLineCol(source, d.span.start);
+  return { message: d.message, line, col };
+}
+function compileUncached(source, opts) {
+  const { plan, diagnostics: parseDiags } = parse(source);
+  const resolved = plan ? resolve(plan) : null;
+  const diagnostics = resolved ? [...parseDiags, ...resolved.diagnostics] : [...parseDiags];
+  const errs = diagnostics.filter((d) => d.severity === "error");
+  const errors = errs.map((d) => toLegacy(source, d));
+  const warnings = diagnostics.filter((d) => d.severity === "warning").map((d) => toLegacy(source, d));
+  const svg = resolved && errs.length === 0 ? render(resolved.ir, opts) : "";
+  return { svg, errors, warnings, diagnostics, ast: plan };
+}
+function clearCache() {
+  cache.clear();
+}
+
+export {
+  offsetToLineCol,
+  formatDiagnostic,
+  compile,
+  clearCache
+};
+//# sourceMappingURL=chunk-3YUQPQPZ.js.map