ldr 0.2.0 → 0.3.0

package/dist/cli.js

@@ -145,31 +145,67 @@ class Library {
 }
 function splitModel(text, fallbackName = "main.ldr") {
   const files = new Map;
+  const data = new Map;
+  let dataCur = null;
   let cur = null, buf = [], main = null;
+  let skip = false, sawBlock = false;
+  const flush = () => {
+    if (cur)
+      files.set(cur, buf.join(`
+`));
+    cur = null;
+    buf = [];
+  };
+  const firstBlock = () => {
+    if (sawBlock)
+      return;
+    sawBlock = true;
+    files.clear();
+    cur = null;
+    buf = [];
+    main = null;
+  };
   for (const line of text.split(/\r?\n/)) {
     const m = /^\s*0\s+FILE\s+(.+)$/i.exec(line);
     if (m) {
-      if (cur)
-        files.set(cur, buf.join(`
-`));
+      firstBlock();
+      flush();
+      skip = false;
+      dataCur = null;
       cur = norm(m[1]);
-      buf = [];
       if (!main)
         main = cur;
       continue;
     }
-    if (/^\s*0\s+NOFILE/i.test(line))
+    if (/^\s*0\s+(NOFILE|!DATA)(\s|$)/i.test(line)) {
+      dataCur = null;
+      if (/!DATA/i.test(line)) {
+        firstBlock();
+        const dn = norm(line.replace(/^\s*0\s+!DATA\s*/i, ""));
+        dataCur = dn;
+        data.set(dn, "");
+      }
+      flush();
+      skip = true;
       continue;
+    }
+    if (skip) {
+      const dc = dataCur;
+      if (dc) {
+        const d = /^\s*0\s+!:\s*(.*)$/.exec(line);
+        if (d)
+          data.set(dc, data.get(dc) + d[1].trim());
+      }
+      continue;
+    }
     if (!cur) {
       cur = norm(fallbackName);
       main = cur;
     }
     buf.push(line);
   }
-  if (cur)
-    files.set(cur, buf.join(`
-`));
-  return { files, main };
+  flush();
+  return { files, main, data };
 }
 function flatten(model, lib, onInstance) {
   const missing = new Map;
@@ -223,6 +259,438 @@ function collectDeps(lib, refs) {
 // src/node/compile.ts
 import fs2 from "node:fs";
 import path2 from "node:path";
+
+// src/spec.ts
+var norm2 = (s) => s.trim().toLowerCase().replace(/\\/g, "/").replace(/\/+/g, "/");
+function parseColor(tok) {
+  if (/^0x/i.test(tok))
+    return parseInt(tok, 16);
+  return +tok;
+}
+var MOVED_RE = /^~?\s*moved\s+to\s+(.+)$/i;
+function texNames(rest) {
+  const out = [];
+  let i = 0;
+  while (i < rest.length) {
+    while (rest[i] === " " || rest[i] === "\t")
+      i++;
+    if (i >= rest.length)
+      break;
+    if (rest[i] === '"') {
+      let v = "";
+      i++;
+      while (i < rest.length && rest[i] !== '"') {
+        if (rest[i] === "\\" && i + 1 < rest.length)
+          i++;
+        v += rest[i++];
+      }
+      i++;
+      out.push(v);
+    } else {
+      let j = i;
+      while (j < rest.length && rest[j] !== " " && rest[j] !== "\t")
+        j++;
+      out.push(rest.slice(i, j));
+      i = j;
+    }
+  }
+  return out;
+}
+function parseTexMap(tail, next = false) {
+  const m = /^\s*(\S+)\s+(.*)$/.exec(tail);
+  if (!m)
+    return null;
+  const method = m[1].toUpperCase();
+  const n = method === "PLANAR" ? 9 : method === "CYLINDRICAL" ? 10 : method === "SPHERICAL" ? 11 : 0;
+  if (!n)
+    return null;
+  const parts = m[2].trim().split(/\s+/);
+  if (parts.length < n + 1)
+    return null;
+  const v = parts.slice(0, n).map(Number);
+  if (!v.every(Number.isFinite))
+    return null;
+  let rest = m[2].trim();
+  for (let k = 0;k < n; k++)
+    rest = rest.replace(/^\S+\s*/, "");
+  const names = texNames(rest);
+  if (!names.length)
+    return null;
+  const t = { method, p1: v.slice(0, 3), p2: v.slice(3, 6), p3: v.slice(6, 9), texture: names[0] };
+  if (n >= 10)
+    t.a = v[9];
+  if (n === 11)
+    t.b = v[10];
+  const g = names.findIndex((x, i) => i > 0 && x.toUpperCase() === "GLOSSMAP");
+  if (g > 0 && names[g + 1])
+    t.glossmap = names[g + 1];
+  if (next)
+    t.next = true;
+  return t;
+}
+var b64 = (s) => {
+  const clean = s.replace(/[^A-Za-z0-9+/]/g, "");
+  const pad = clean + "=".repeat((4 - clean.length % 4) % 4);
+  const bin = atob(pad);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0;i < bin.length; i++)
+    out[i] = bin.charCodeAt(i);
+  return out;
+};
+function geomLine(tk) {
+  const t = +tk[0];
+  if (!(t >= 1 && t <= 5) || tk.length < 2)
+    return null;
+  const color = parseColor(tk[1]);
+  const nums = tk.slice(2).map(Number);
+  if (t === 1)
+    return { t: 1, color, m: nums.slice(0, 12), file: norm2(tk.slice(14).join(" ")) };
+  if (t === 2)
+    return { t: 2, color, p: nums.slice(0, 6) };
+  if (t === 3)
+    return { t: 3, color, p: nums.slice(0, 9) };
+  if (t === 4)
+    return { t: 4, color, p: nums.slice(0, 12) };
+  return { t: 5, color, p: nums.slice(0, 12) };
+}
+function parse(src, name = "main.ldr") {
+  const files = new Map;
+  let cur = null;
+  let main = "";
+  let data;
+  let dataCur = null;
+  let texStack = [];
+  let texNext = null;
+  const closeData = () => {
+    if (!dataCur)
+      return;
+    const bytes = b64(dataCur.chunks.join(""));
+    const png = bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71;
+    (data ??= new Map).set(norm2(dataCur.name), { name: dataCur.name, bytes, ...png ? { mime: "image/png" } : {} });
+    dataCur = null;
+  };
+  const start = (n) => {
+    closeData();
+    cur = { name: norm2(n), cmds: [] };
+    files.set(cur.name, cur);
+    if (!main)
+      main = cur.name;
+    texStack = [];
+    texNext = null;
+  };
+  let skip = false, sawBlock = false;
+  const firstBlock = () => {
+    if (sawBlock)
+      return;
+    sawBlock = true;
+    files.clear();
+    cur = null;
+    main = "";
+  };
+  const annotate = (c, fromColon) => {
+    if (texNext) {
+      c.tex = texNext;
+      texNext = null;
+      return;
+    }
+    const top = texStack[texStack.length - 1];
+    if (!top)
+      return;
+    if (top.fallback) {
+      if (!fromColon)
+        c.fallback = true;
+    } else
+      c.tex = top.map;
+  };
+  for (const raw of src.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    const tk = line.split(/\s+/);
+    const t = +tk[0];
+    if (t === 0) {
+      const text = line.slice(1).trim();
+      if (tk[1] === "FILE") {
+        firstBlock();
+        skip = false;
+        start(text.slice(5));
+        continue;
+      }
+      if (tk[1] === "NOFILE") {
+        closeData();
+        cur = null;
+        skip = true;
+        continue;
+      }
+      if (tk[1] === "!DATA") {
+        firstBlock();
+        closeData();
+        cur = null;
+        skip = false;
+        dataCur = { name: text.slice(5).trim(), chunks: [] };
+        continue;
+      }
+      if (skip)
+        continue;
+      if (dataCur) {
+        if (tk[1] === "!:")
+          dataCur.chunks.push(tk.slice(2).join(""));
+        continue;
+      }
+      if (!cur)
+        start(name);
+      const c = { t: 0, text };
+      if (tk[1] === "STEP") {
+        c.step = true;
+        texStack = [];
+        texNext = null;
+      } else if (tk[1] === "BFC")
+        c.bfc = tk.slice(2).join(" ");
+      else if (tk[1] === "ROTSTEP") {
+        c.meta = "ROTSTEP";
+        if ((tk[2] ?? "").toUpperCase() === "END")
+          c.rotstep = { x: 0, y: 0, z: 0, mode: "END" };
+        else {
+          const mode = (tk[5] ?? "REL").toUpperCase();
+          c.rotstep = { x: +tk[2] || 0, y: +tk[3] || 0, z: +tk[4] || 0, mode: ["REL", "ABS", "ADD"].includes(mode) ? mode : "REL" };
+        }
+      } else if (tk[1] === "BUFEXCHG") {
+        c.meta = "BUFEXCHG";
+        const op = (tk[2] ?? "").toUpperCase();
+        c.bufexchg = { op: op === "RETRIEVE" ? "RETRIEVE" : "STORE", buf: tk[3] ?? "A" };
+      } else if (tk[1]?.startsWith("!"))
+        c.meta = tk[1];
+      if (tk[1] === "!TEXMAP") {
+        const op = (tk[2] ?? "").toUpperCase();
+        texNext = null;
+        if (op === "START" || op === "NEXT") {
+          const map = parseTexMap(text.replace(/^!TEXMAP\s+\S+/i, ""), op === "NEXT");
+          c.texmap = { op, ...map ? { map } : {} };
+          if (map) {
+            (cur.texmaps ??= []).push(map);
+            if (op === "START")
+              texStack.push({ map, fallback: false });
+            else
+              texNext = map;
+          }
+        } else if (op === "FALLBACK") {
+          c.texmap = { op };
+          const top = texStack[texStack.length - 1];
+          if (top)
+            top.fallback = true;
+        } else if (op === "END") {
+          c.texmap = { op };
+          texStack.pop();
+        }
+      } else if (tk[1] === "!:") {
+        texNext = null;
+        const g = geomLine(tk.slice(2));
+        if (g) {
+          annotate(g, true);
+          c.geom = g;
+        }
+      } else
+        texNext = null;
+      const moved = text.match(MOVED_RE);
+      if (moved && !cur.movedTo) {
+        let target = moved[1].trim().replace(/\\/g, "/");
+        if (!/\.(dat|ldr|mpd)$/i.test(target))
+          target += ".dat";
+        cur.movedTo = norm2(target);
+      }
+      cur.cmds.push(c);
+      continue;
+    }
+    if (dataCur || skip)
+      continue;
+    if (!cur)
+      start(name);
+    const g = geomLine(tk);
+    if (!g)
+      continue;
+    annotate(g, false);
+    cur.cmds.push(g);
+  }
+  closeData();
+  return data ? { main, files, data } : { main, files };
+}
+function resolveTexture(doc, name) {
+  if (!doc.data)
+    return null;
+  const n = norm2(name);
+  return doc.data.get(n) ?? doc.data.get(n.replace(/^textures\//, "")) ?? doc.data.get("textures/" + n) ?? null;
+}
+var sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+var dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var cross3 = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+var unit3 = (a) => {
+  const l = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / l, a[1] / l, a[2] / l];
+};
+var DEG = Math.PI / 180;
+function texmapUV(map, p) {
+  const w = texmapTriangleUV(map, [p, p, p]);
+  const u = w[0], v = w[1];
+  return { u, v, inside: u >= -0.000001 && u <= 1 + 0.000001 && v >= -0.000001 && v <= 1 + 0.000001 };
+}
+var radial = (p, c, n) => {
+  const d = sub3(p, c);
+  const k = dot3(d, n);
+  const r = [d[0] - n[0] * k, d[1] - n[1] * k, d[2] - n[2] * k];
+  return Math.hypot(r[0], r[1], r[2]) < 0.00001 ? null : unit3(r);
+};
+function texmapTriangleUV(map, pts) {
+  const { p1, p2, p3 } = map;
+  const out = new Array(pts.length * 2).fill(0);
+  if (map.method === "PLANAR") {
+    const e1 = sub3(p2, p1), e2 = sub3(p3, p1);
+    const l1 = dot3(e1, e1) || 1, l2 = dot3(e2, e2) || 1;
+    pts.forEach((p, i) => {
+      const d = sub3(p, p1);
+      out[i * 2] = dot3(d, e1) / l1;
+      out[i * 2 + 1] = dot3(d, e2) / l2;
+    });
+    return out;
+  }
+  const cyl = map.method === "CYLINDRICAL";
+  const n = cyl ? unit3(sub3(p2, p1)) : unit3(cross3(sub3(p1, p2), sub3(p3, p2)).map((x) => -x));
+  const dir = cyl ? radial(p3, p1, n) : unit3(sub3(p2, p1));
+  const A = (map.a ?? 360) * DEG;
+  let base = null, baseAng = 0;
+  const sAng = (q) => {
+    if (!base) {
+      base = q;
+      baseAng = Math.atan2(dot3(cross3(dir, q), n), dot3(q, dir));
+      return baseAng;
+    }
+    return Math.atan2(dot3(cross3(base, q), n), dot3(q, base)) + baseAng;
+  };
+  const miss = [];
+  let uSum = 0;
+  const h = cyl ? Math.hypot(...sub3(p2, p1)) || 1 : 0, n2 = cyl ? null : unit3(cross3(n, sub3(p2, p1))), B = (map.b ?? 180) * DEG;
+  pts.forEach((p, i) => {
+    if (cyl) {
+      const q = dir ? radial(p, p1, n) : null;
+      if (q) {
+        const a = sAng(q);
+        out[i * 2] = 0.5 + a / A;
+        uSum += out[i * 2];
+      } else
+        miss.push(i);
+      out[i * 2 + 1] = dot3(n, sub3(p2, p)) / h;
+    } else {
+      const pd = unit3(sub3(p, p1));
+      const c = dot3(pd, n);
+      if (Math.abs(c) > 1 - 0.000000001) {
+        miss.push(i);
+        out[i * 2 + 1] = 0.5 + (c > 0 ? -Math.PI / 2 : Math.PI / 2) / B;
+        return;
+      }
+      const a = sAng(radial(p, p1, n));
+      uSum += a;
+      out[i * 2] = 0.5 + a / A;
+      const th = -a, ct = Math.cos(th), st = Math.sin(th), cr = cross3(n, pd), k = dot3(n, pd) * (1 - ct);
+      const r = unit3([pd[0] * ct + cr[0] * st + n[0] * k, pd[1] * ct + cr[1] * st + n[1] * k, pd[2] * ct + cr[2] * st + n[2] * k]);
+      out[i * 2 + 1] = 0.5 + Math.atan2(dot3(cross3(dir, r), n2), dot3(r, dir)) / B;
+    }
+  });
+  if (miss.length && miss.length < pts.length) {
+    const avg = cyl ? uSum / (pts.length - miss.length) : 0.5 + uSum / (pts.length - miss.length) / A;
+    for (const i of miss)
+      out[i * 2] = avg;
+  }
+  return out;
+}
+function transformTexMap(map, m) {
+  const x = (q) => [m[3] * q[0] + m[4] * q[1] + m[5] * q[2] + m[0], m[6] * q[0] + m[7] * q[1] + m[8] * q[2] + m[1], m[9] * q[0] + m[10] * q[1] + m[11] * q[2] + m[2]];
+  return { ...map, p1: x(map.p1), p2: x(map.p2), p3: x(map.p3) };
+}
+function mul(a, b) {
+  const [ax, ay, az, a0, a1, a2, a3, a4, a5, a6, a7, a8] = a, [bx, by, bz, b0, b1, b2, b3, b4, b5, b6, b7, b8] = b;
+  return [
+    a0 * bx + a1 * by + a2 * bz + ax,
+    a3 * bx + a4 * by + a5 * bz + ay,
+    a6 * bx + a7 * by + a8 * bz + az,
+    a0 * b0 + a1 * b3 + a2 * b6,
+    a0 * b1 + a1 * b4 + a2 * b7,
+    a0 * b2 + a1 * b5 + a2 * b8,
+    a3 * b0 + a4 * b3 + a5 * b6,
+    a3 * b1 + a4 * b4 + a5 * b7,
+    a3 * b2 + a4 * b5 + a5 * b8,
+    a6 * b0 + a7 * b3 + a8 * b6,
+    a6 * b1 + a7 * b4 + a8 * b7,
+    a6 * b2 + a7 * b5 + a8 * b8
+  ];
+}
+var I = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1];
+var isDirectColor = (c) => c > 16777215;
+function smoothNormals(pos, edges, cond, creaseDeg = 35) {
+  const q = (i, a) => `${a[i].toFixed(2)},${a[i + 1].toFixed(2)},${a[i + 2].toFixed(2)}`;
+  const ek = (a, b) => a < b ? a + "|" + b : b + "|" + a;
+  const hard = new Set, soft = new Set;
+  for (let i = 0;i < edges.length; i += 6)
+    hard.add(ek(q(i, edges), q(i + 3, edges)));
+  const stride = cond.length > 0 && cond.length % 12 === 0 ? 12 : 6;
+  for (let i = 0;i < cond.length; i += stride)
+    soft.add(ek(q(i, cond), q(i + 3, cond)));
+  const nT = pos.length / 9, fn = [], vk = [];
+  for (let t = 0;t < nT; t++) {
+    const a = t * 9;
+    const u = [pos[a + 3] - pos[a], pos[a + 4] - pos[a + 1], pos[a + 5] - pos[a + 2]], v = [pos[a + 6] - pos[a], pos[a + 7] - pos[a + 1], pos[a + 8] - pos[a + 2]];
+    const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+    const l = Math.hypot(...n) || 1;
+    fn.push(n.map((x) => x / l));
+    for (let k = 0;k < 3; k++)
+      vk.push(q(a + k * 3, pos));
+  }
+  const byV = new Map;
+  vk.forEach((k, i) => (byV.get(k) ?? byV.set(k, []).get(k)).push(i));
+  const edgeFaces = new Map;
+  for (let t = 0;t < nT; t++)
+    for (let k = 0;k < 3; k++) {
+      const e = ek(vk[t * 3 + k], vk[t * 3 + (k + 1) % 3]);
+      (edgeFaces.get(e) ?? edgeFaces.set(e, []).get(e)).push(t);
+    }
+  const cosC = Math.cos(creaseDeg * Math.PI / 180), out = new Float32Array(pos.length);
+  const joinable = (e, a, b) => {
+    if (hard.has(e))
+      return false;
+    const d = fn[a][0] * fn[b][0] + fn[a][1] * fn[b][1] + fn[a][2] * fn[b][2];
+    return soft.has(e) ? d > -0.2 : d > cosC;
+  };
+  for (const [key, corners] of byV) {
+    const faces = corners.map((c) => c / 3 | 0), par = faces.map((_, i) => i);
+    const f = (i) => par[i] === i ? i : par[i] = f(par[i]);
+    for (let i = 0;i < faces.length; i++)
+      for (let j = i + 1;j < faces.length; j++) {
+        const A = faces[i], B = faces[j];
+        const va = [0, 1, 2].map((k) => vk[A * 3 + k]), vb = new Set([0, 1, 2].map((k) => vk[B * 3 + k]));
+        for (const o of va)
+          if (o !== key && vb.has(o)) {
+            const e = ek(key, o);
+            if ((edgeFaces.get(e)?.length ?? 0) >= 2 && joinable(e, A, B))
+              par[f(i)] = f(j);
+          }
+      }
+    const acc = new Map;
+    faces.forEach((F, i) => {
+      const r = f(i), s = acc.get(r) ?? [0, 0, 0];
+      s[0] += fn[F][0];
+      s[1] += fn[F][1];
+      s[2] += fn[F][2];
+      acc.set(r, s);
+    });
+    corners.forEach((c, i) => {
+      const s = acc.get(f(i)), l = Math.hypot(...s) || 1;
+      out[c * 3] = s[0] / l;
+      out[c * 3 + 1] = s[1] / l;
+      out[c * 3 + 2] = s[2] / l;
+    });
+  }
+  return out;
+}
+
+// src/node/compile.ts
 function loadColors(root) {
   const map = new Map;
   for (const l of fs2.readFileSync(path2.join(root, "LDConfig.ldr"), "latin1").split(/\r?\n/)) {
@@ -270,7 +738,7 @@ class Compiler {
     const ck = key + (separateStuds ? "" : "#nostudsep");
     if (this.cache.has(ck))
       return this.cache.get(ck);
-    const out = { body: { pos: [], col: [] }, under: { pos: [], col: [] }, edges: [], condLines: 0, studs: [], bbox: [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity], fullBottom: false };
+    const out = { body: { pos: [], col: [] }, under: { pos: [], col: [] }, edges: [], condLines: 0, cond: this.opts.cond ? [] : undefined, condUnder: this.opts.cond ? [] : undefined, studs: [], bbox: [Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity], fullBottom: false };
     const colorOf = (code) => code === "16" ? [1, 1, 1, 0] : [...this.colors.get(code) || (code.startsWith("0x2") ? [parseInt(code.slice(3, 5), 16) / 255, parseInt(code.slice(5, 7), 16) / 255, parseInt(code.slice(7, 9), 16) / 255] : [1, 0, 1]), 1];
     const walk = (fk, M, color, invert, target, depth) => {
       if (depth > 40)
@@ -325,6 +793,13 @@ class Compiler {
         }
         if (c === "5") {
           out.condLines++;
+          const dst = target === "under" ? out.condUnder : out.cond;
+          if (dst) {
+            const v = t.split(/\s+/).slice(2, 14).map(Number);
+            if (v.length === 12 && v.every(Number.isFinite))
+              for (let i = 0;i < 12; i += 3)
+                dst.push(...xf(M, v.slice(i, i + 3)));
+          }
           continue;
         }
         if (c === "3" || c === "4") {
@@ -351,6 +826,8 @@ class Compiler {
         out.uncertified = true;
     };
     walk(key, IDENT, "16", false, "body", 0);
+    if (this.opts.tex && this.hasTex(key))
+      this.texPass(key, out, separateStuds, colorOf);
     const [x0, y0, z0, x1, y1, z1] = out.bbox;
     let ax0 = Infinity, ax1 = -Infinity, az0 = Infinity, az1 = -Infinity;
     for (const b of [out.body, out.under])
@@ -367,6 +844,169 @@ class Compiler {
     this.cache.set(ck, out);
     return out;
   }
+  texMemo = new Map;
+  hasTex(key) {
+    const m = this.texMemo.get(key);
+    if (m !== undefined)
+      return m;
+    this.texMemo.set(key, false);
+    const txt = this.lib.read(key);
+    let r = /^\s*0\s+!TEXMAP/im.test(txt);
+    if (!r)
+      for (const l of txt.split(/\r?\n/)) {
+        const t = l.trim();
+        const p = t.startsWith("0 !:") ? parseType1(t.slice(4)) : t[0] === "1" ? parseType1(t) : null;
+        if (p) {
+          const k = this.lib.resolve(p.name);
+          if (k && this.hasTex(k)) {
+            r = true;
+            break;
+          }
+        }
+      }
+    this.texMemo.set(key, r);
+    return r;
+  }
+  texture(name) {
+    const n = norm(name);
+    for (const pre of ["parts/textures/", "p/textures/", "models/textures/", "parts/", "p/", "models/"]) {
+      const k = pre + n;
+      if (this.lib.index.has(k))
+        return new Uint8Array(fs2.readFileSync(this.lib.index.get(k)));
+    }
+    return null;
+  }
+  texPass(key, out, separateStuds, colorOf) {
+    const tbody = { pos: [], col: [] }, texb = new Map;
+    const walk = (fk, M, color, invert, target, depth, texIn) => {
+      if (depth > 40)
+        return;
+      let ccw = true, invertNext = false;
+      let stack = [];
+      let next = null;
+      for (const raw of this.lib.read(fk).split(/\r?\n/)) {
+        let t = raw.trim();
+        if (!t)
+          continue;
+        let colon = false;
+        if (t[0] === "0") {
+          const m = /^0\s+(\S+)\s*(.*)$/.exec(t);
+          const kw = (m?.[1] ?? "").toUpperCase(), rest = m?.[2] ?? "";
+          if (kw === "!TEXMAP") {
+            const op = (rest.split(/\s+/)[0] || "").toUpperCase();
+            next = null;
+            if (op === "START" || op === "NEXT") {
+              const map = parseTexMap(rest.replace(/^\S+/, ""), op === "NEXT");
+              if (map) {
+                const pm = transformTexMap(map, M);
+                if (op === "START")
+                  stack.push({ map: pm, fallback: false });
+                else
+                  next = pm;
+              }
+            } else if (op === "FALLBACK") {
+              const top = stack[stack.length - 1];
+              if (top)
+                top.fallback = true;
+            } else if (op === "END")
+              stack.pop();
+            continue;
+          }
+          if (kw === "!:") {
+            next = null;
+            t = rest.trim();
+            colon = true;
+            if (!t || t[0] === "0")
+              continue;
+          } else {
+            if (kw === "BFC") {
+              if (/\bCW\b/.test(t))
+                ccw = false;
+              if (/\bCCW\b/.test(t))
+                ccw = true;
+              if (/INVERTNEXT/.test(t))
+                invertNext = true;
+            }
+            if (kw === "STEP")
+              stack = [];
+            next = null;
+            continue;
+          }
+        }
+        let tex = texIn;
+        if (next) {
+          tex = next;
+          next = null;
+        } else {
+          const top = stack[stack.length - 1];
+          if (top) {
+            if (top.fallback) {
+              if (!colon)
+                continue;
+            } else
+              tex = top.map;
+          }
+        }
+        const c = t[0];
+        if (c === "1") {
+          const r = parseType1(t);
+          if (!r)
+            continue;
+          const base = r.name.trim().replace(/\\/g, "/").split("/").pop().toLowerCase();
+          const isTop = TOP_STUD_RE.test(base), isUnder = UNDER_STUD_RE.test(base);
+          const ck2 = this.resolve(r.name, isTop);
+          if (!ck2) {
+            invertNext = false;
+            continue;
+          }
+          const inv = invert !== invertNext !== det3(r.m) < 0;
+          invertNext = false;
+          if (isTop && separateStuds)
+            continue;
+          walk(ck2, compose(M, r.m), r.color === "16" ? color : r.color, inv, isUnder ? "under" : target, depth + 1, tex);
+          continue;
+        }
+        if (c !== "3" && c !== "4")
+          continue;
+        const tok = t.split(/\s+/);
+        const code = tok[1] === "16" ? color : tok[1];
+        const n = c === "3" ? 3 : 4;
+        const v = tok.slice(2, 2 + n * 3).map(Number);
+        const pts = [];
+        for (let i = 0;i < n; i++)
+          pts.push(xf(M, v.slice(i * 3, i * 3 + 3)));
+        let order = n === 3 ? [0, 1, 2] : [0, 1, 2, 0, 2, 3];
+        if (!ccw !== invert)
+          order = n === 3 ? [0, 2, 1] : [0, 2, 1, 0, 3, 2];
+        const rgba = colorOf(code);
+        if (tex) {
+          let b = texb.get(tex.texture);
+          if (!b)
+            texb.set(tex.texture, b = { pos: [], col: [], uv: [] });
+          if (Math.abs(tex.a ?? 0) >= 360)
+            b.wrapU = true;
+          for (let k = 0;k < order.length; k += 3) {
+            const tri = [pts[order[k]], pts[order[k + 1]], pts[order[k + 2]]];
+            const w = texmapTriangleUV(tex, tri);
+            for (let j = 0;j < 3; j++) {
+              b.pos.push(...tri[j]);
+              b.col.push(...rgba);
+              b.uv.push(w[j * 2], w[j * 2 + 1]);
+            }
+          }
+        } else if (target === "body")
+          for (const i of order) {
+            tbody.pos.push(...pts[i]);
+            tbody.col.push(...rgba);
+          }
+      }
+    };
+    walk(key, IDENT, "16", false, "body", 0, null);
+    if (texb.size) {
+      out.tbody = tbody;
+      out.texb = texb;
+    }
+  }
 }
 function enclosureMask(c) {
   const [x0, , z0, x1, y1, z1] = c.bbox;
@@ -449,10 +1089,10 @@ function growBox(b, M, cb) {
       for (const z of [cb[2], cb[5]])
         grow(b, xf(M, [x, y, z]));
 }
-function writePack(file, parts, studKinds, weld, extra) {
-  fs2.writeFileSync(file, encodePack(parts, studKinds, weld, extra));
+function writePack(file, parts, studKinds, weld, extra, options) {
+  fs2.writeFileSync(file, encodePack(parts, studKinds, weld, extra, options));
 }
-function encodePack(parts, studKinds, weld, extra) {
+function encodePack(parts, studKinds, weld, extra, options = {}) {
   const chunks = [];
   let off = 0;
   const put = (a) => {
@@ -461,13 +1101,15 @@ function encodePack(parts, studKinds, weld, extra) {
       chunks.push(new Uint8Array(pad));
       off += pad;
     }
-    const r = [off, a.length, a instanceof Float32Array ? "f32" : a instanceof Uint16Array ? "u16" : "u32"];
+    const r = [off, a.length, a instanceof Float32Array ? "f32" : a instanceof Uint16Array ? "u16" : a instanceof Uint8Array ? "u8" : "u32"];
     chunks.push(a);
     off += a.byteLength;
     return r;
   };
+  let lastPos = [];
   const bucket = (b) => {
     const n = b.pos.length / 3;
+    lastPos = [];
     if (!n)
       return null;
     const nrm = new Float32Array(n * 3);
@@ -486,8 +1128,10 @@ function encodePack(parts, studKinds, weld, extra) {
         nrm[(i + k) * 3 + 2] = nz;
       }
     }
-    if (!weld)
+    if (!weld) {
+      lastPos = b.pos;
       return { pos: put(new Float32Array(b.pos)), nrm: put(nrm), col: put(new Float32Array(b.col)), tris: n / 3 };
+    }
     const map = new Map;
     const P = [], N = [], C = [], I = [];
     for (let i = 0;i < n; i++) {
@@ -503,184 +1147,118 @@ function encodePack(parts, studKinds, weld, extra) {
       I.push(j);
     }
     const vcount = P.length / 3;
+    lastPos = P;
     return { pos: put(new Float32Array(P)), nrm: put(new Float32Array(N)), col: put(new Float32Array(C)), idx: put(vcount < 65536 ? new Uint16Array(I) : new Uint32Array(I)), tris: n / 3 };
   };
-  const enc = (c) => ({ body: bucket(c.body), under: bucket(c.under), edges: c.edges.length ? put(new Float32Array(c.edges)) : null, cond: c.condLines, studs: c.studs.map((s) => [s.kind, s.color, ...s.m.map((x) => +x.toFixed(4))]), bbox: c.bbox, fullBottom: c.fullBottom, uncert: !!c.uncertified, mask: c.bottomMask ? [c.bottomMask.nx, c.bottomMask.nz, c.bottomMask.bits.join("")] : null });
-  const header = { version: 1, weld, parts: Object.fromEntries([...parts].map(([k, c]) => [k, enc(c)])), studKinds: Object.fromEntries([...studKinds].map(([k, c]) => [k, enc(c)])), ...extra };
-  const hj = new TextEncoder().encode(JSON.stringify(header));
-  const hpad = (4 - (4 + hj.length) % 4) % 4;
-  const head = new Uint8Array(4 + hj.length + hpad);
-  new DataView(head.buffer).setUint32(0, hj.length + hpad, true);
-  head.set(hj, 4);
-  head.fill(32, 4 + hj.length);
-  return Buffer.concat([head, ...chunks.map((c) => new Uint8Array(c.buffer, c.byteOffset, c.byteLength))]);
-}
-
-// src/spec.ts
-var norm2 = (s) => s.trim().toLowerCase().replace(/\\/g, "/").replace(/\/+/g, "/");
-function parseColor(tok) {
-  if (/^0x/i.test(tok))
-    return parseInt(tok, 16);
-  return +tok;
-}
-var MOVED_RE = /^~?\s*moved\s+to\s+(.+)$/i;
-function parse(src, name = "main.ldr") {
-  const files = new Map;
-  let cur = null;
-  let main = "";
-  const start = (n) => {
-    cur = { name: norm2(n), cmds: [] };
-    files.set(cur.name, cur);
-    if (!main)
-      main = cur.name;
-  };
-  for (const raw of src.split(/\r?\n/)) {
-    const line = raw.trim();
-    if (!line)
-      continue;
-    const tk = line.split(/\s+/);
-    const t = +tk[0];
-    if (t === 0) {
-      const text = line.slice(1).trim();
-      if (tk[1] === "FILE") {
-        start(text.slice(5));
-        continue;
-      }
-      if (tk[1] === "NOFILE") {
-        cur = null;
-        continue;
+  let anyCond = false;
+  const condl = (a, pools) => {
+    if (!a || !a.length)
+      return;
+    anyCond = true;
+    const key = (p, i) => Math.round(p[i] * 1000) + "," + Math.round(p[i + 1] * 1000) + "," + Math.round(p[i + 2] * 1000);
+    const need = new Map;
+    for (let i = 0;i < a.length; i += 3)
+      need.set(key(a, i), -1);
+    let base = 0;
+    for (const p of pools) {
+      for (let i = 0;i < p.length; i += 3) {
+        const k = key(p, i);
+        if (need.get(k) === -1)
+          need.set(k, base + i / 3);
       }
-      if (!cur)
-        start(name);
-      const c = { t: 0, text };
-      if (tk[1] === "STEP")
-        c.step = true;
-      else if (tk[1] === "BFC")
-        c.bfc = tk.slice(2).join(" ");
-      else if (tk[1] === "ROTSTEP") {
-        c.meta = "ROTSTEP";
-        if ((tk[2] ?? "").toUpperCase() === "END")
-          c.rotstep = { x: 0, y: 0, z: 0, mode: "END" };
-        else {
-          const mode = (tk[5] ?? "REL").toUpperCase();
-          c.rotstep = { x: +tk[2] || 0, y: +tk[3] || 0, z: +tk[4] || 0, mode: ["REL", "ABS", "ADD"].includes(mode) ? mode : "REL" };
-        }
-      } else if (tk[1] === "BUFEXCHG") {
-        c.meta = "BUFEXCHG";
-        const op = (tk[2] ?? "").toUpperCase();
-        c.bufexchg = { op: op === "RETRIEVE" ? "RETRIEVE" : "STORE", buf: tk[3] ?? "A" };
-      } else if (tk[1]?.startsWith("!"))
-        c.meta = tk[1];
-      const moved = text.match(MOVED_RE);
-      if (moved && !cur.movedTo) {
-        let target = moved[1].trim().replace(/\\/g, "/");
-        if (!/\.(dat|ldr|mpd)$/i.test(target))
-          target += ".dat";
-        cur.movedTo = norm2(target);
+      base += p.length / 3;
+    }
+    const X = [], I = new Array(a.length / 3);
+    for (let i = 0;i < a.length; i += 3) {
+      const k = key(a, i);
+      let j = need.get(k);
+      if (j === -1) {
+        j = base + X.length / 3;
+        need.set(k, j);
+        X.push(a[i], a[i + 1], a[i + 2]);
       }
-      cur.cmds.push(c);
-      continue;
+      I[i / 3] = j;
     }
-    if (!cur)
-      start(name);
-    const color = parseColor(tk[1]);
-    const nums = tk.slice(2).map(Number);
-    if (t === 1)
-      cur.cmds.push({ t: 1, color, m: nums.slice(0, 12), file: norm2(tk.slice(14).join(" ")) });
-    else if (t === 2)
-      cur.cmds.push({ t: 2, color, p: nums.slice(0, 6) });
-    else if (t === 3)
-      cur.cmds.push({ t: 3, color, p: nums.slice(0, 9) });
-    else if (t === 4)
-      cur.cmds.push({ t: 4, color, p: nums.slice(0, 12) });
-    else if (t === 5)
-      cur.cmds.push({ t: 5, color, p: nums.slice(0, 12) });
-  }
-  return { main, files };
-}
-function mul(a, b) {
-  const [ax, ay, az, a0, a1, a2, a3, a4, a5, a6, a7, a8] = a, [bx, by, bz, b0, b1, b2, b3, b4, b5, b6, b7, b8] = b;
-  return [
-    a0 * bx + a1 * by + a2 * bz + ax,
-    a3 * bx + a4 * by + a5 * bz + ay,
-    a6 * bx + a7 * by + a8 * bz + az,
-    a0 * b0 + a1 * b3 + a2 * b6,
-    a0 * b1 + a1 * b4 + a2 * b7,
-    a0 * b2 + a1 * b5 + a2 * b8,
-    a3 * b0 + a4 * b3 + a5 * b6,
-    a3 * b1 + a4 * b4 + a5 * b7,
-    a3 * b2 + a4 * b5 + a5 * b8,
-    a6 * b0 + a7 * b3 + a8 * b6,
-    a6 * b1 + a7 * b4 + a8 * b7,
-    a6 * b2 + a7 * b5 + a8 * b8
-  ];
-}
-var I = [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1];
-var isDirectColor = (c) => c > 16777215;
-function smoothNormals(pos, edges, cond, creaseDeg = 35) {
-  const q = (i, a) => `${a[i].toFixed(2)},${a[i + 1].toFixed(2)},${a[i + 2].toFixed(2)}`;
-  const ek = (a, b) => a < b ? a + "|" + b : b + "|" + a;
-  const hard = new Set, soft = new Set;
-  for (let i = 0;i < edges.length; i += 6)
-    hard.add(ek(q(i, edges), q(i + 3, edges)));
-  const stride = cond.length > 0 && cond.length % 12 === 0 ? 12 : 6;
-  for (let i = 0;i < cond.length; i += stride)
-    soft.add(ek(q(i, cond), q(i + 3, cond)));
-  const nT = pos.length / 9, fn = [], vk = [];
-  for (let t = 0;t < nT; t++) {
-    const a = t * 9;
-    const u = [pos[a + 3] - pos[a], pos[a + 4] - pos[a + 1], pos[a + 5] - pos[a + 2]], v = [pos[a + 6] - pos[a], pos[a + 7] - pos[a + 1], pos[a + 8] - pos[a + 2]];
-    const n = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
-    const l = Math.hypot(...n) || 1;
-    fn.push(n.map((x) => x / l));
-    for (let k = 0;k < 3; k++)
-      vk.push(q(a + k * 3, pos));
-  }
-  const byV = new Map;
-  vk.forEach((k, i) => (byV.get(k) ?? byV.set(k, []).get(k)).push(i));
-  const edgeFaces = new Map;
-  for (let t = 0;t < nT; t++)
-    for (let k = 0;k < 3; k++) {
-      const e = ek(vk[t * 3 + k], vk[t * 3 + (k + 1) % 3]);
-      (edgeFaces.get(e) ?? edgeFaces.set(e, []).get(e)).push(t);
+    let prev = 0, max = 0;
+    for (let i = 0;i < I.length; i++) {
+      const d = I[i] - prev;
+      prev = I[i];
+      const z = d >= 0 ? d * 2 : -d * 2 - 1;
+      I[i] = z;
+      if (z > max)
+        max = z;
     }
-  const cosC = Math.cos(creaseDeg * Math.PI / 180), out = new Float32Array(pos.length);
-  const joinable = (e, a, b) => {
-    if (hard.has(e))
-      return false;
-    const d = fn[a][0] * fn[b][0] + fn[a][1] * fn[b][1] + fn[a][2] * fn[b][2];
-    return soft.has(e) ? d > -0.2 : d > cosC;
+    return { idx: put(max < 65536 ? new Uint16Array(I) : new Uint32Array(I)), ...X.length ? { x: put(new Float32Array(X)) } : {} };
   };
-  for (const [key, corners] of byV) {
-    const faces = corners.map((c) => c / 3 | 0), par = faces.map((_, i) => i);
-    const f = (i) => par[i] === i ? i : par[i] = f(par[i]);
-    for (let i = 0;i < faces.length; i++)
-      for (let j = i + 1;j < faces.length; j++) {
-        const A = faces[i], B = faces[j];
-        const va = [0, 1, 2].map((k) => vk[A * 3 + k]), vb = new Set([0, 1, 2].map((k) => vk[B * 3 + k]));
-        for (const o of va)
-          if (o !== key && vb.has(o)) {
-            const e = ek(key, o);
-            if ((edgeFaces.get(e)?.length ?? 0) >= 2 && joinable(e, A, B))
-              par[f(i)] = f(j);
-          }
+  const texNames = [];
+  const texBucket = (b) => {
+    const n = b.pos.length / 3;
+    if (!n)
+      return null;
+    const nrm = new Float32Array(n * 3);
+    for (let i = 0;i < n; i += 3) {
+      const p = b.pos;
+      const a = i * 3;
+      const ux = p[a + 3] - p[a], uy = p[a + 4] - p[a + 1], uz = p[a + 5] - p[a + 2], vx = p[a + 6] - p[a], vy = p[a + 7] - p[a + 1], vz = p[a + 8] - p[a + 2];
+      let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
+      const l = Math.hypot(nx, ny, nz) || 1;
+      nx /= l;
+      ny /= l;
+      nz /= l;
+      for (let k = 0;k < 3; k++) {
+        nrm[(i + k) * 3] = nx;
+        nrm[(i + k) * 3 + 1] = ny;
+        nrm[(i + k) * 3 + 2] = nz;
       }
-    const acc = new Map;
-    faces.forEach((F, i) => {
-      const r = f(i), s = acc.get(r) ?? [0, 0, 0];
-      s[0] += fn[F][0];
-      s[1] += fn[F][1];
-      s[2] += fn[F][2];
-      acc.set(r, s);
-    });
-    corners.forEach((c, i) => {
-      const s = acc.get(f(i)), l = Math.hypot(...s) || 1;
-      out[c * 3] = s[0] / l;
-      out[c * 3 + 1] = s[1] / l;
-      out[c * 3 + 2] = s[2] / l;
+    }
+    const map = new Map;
+    const P = [], N = [], C = [], U = [], I = [];
+    for (let i = 0;i < n; i++) {
+      const k = weld ? `${b.pos.slice(i * 3, i * 3 + 3).map((x) => x.toFixed(3))},${[...nrm.subarray(i * 3, i * 3 + 3)].map((x) => x.toFixed(3))},${b.col.slice(i * 4, i * 4 + 4).join()},${b.uv[i * 2].toFixed(5)},${b.uv[i * 2 + 1].toFixed(5)}` : String(i);
+      let j = map.get(k);
+      if (j === undefined) {
+        j = P.length / 3;
+        map.set(k, j);
+        P.push(b.pos[i * 3], b.pos[i * 3 + 1], b.pos[i * 3 + 2]);
+        N.push(nrm[i * 3], nrm[i * 3 + 1], nrm[i * 3 + 2]);
+        C.push(...b.col.slice(i * 4, i * 4 + 4));
+        U.push(b.uv[i * 2], b.uv[i * 2 + 1]);
+      }
+      I.push(j);
+    }
+    return { pos: put(new Float32Array(P)), nrm: put(new Float32Array(N)), col: put(new Float32Array(C)), uv: put(new Float32Array(U)), idx: put(P.length / 3 < 65536 ? new Uint16Array(I) : new Uint32Array(I)), tris: n / 3 };
+  };
+  const encTex = (c) => {
+    if (!c.texb)
+      return {};
+    const tex = [...c.texb].map(([name, b]) => {
+      let t = texNames.indexOf(name);
+      if (t < 0)
+        t = texNames.push(name) - 1;
+      return { t, ...b.wrapU ? { wrapU: true } : {}, ...texBucket(b) };
     });
-  }
-  return out;
+    return { tbody: bucket(c.tbody), tex };
+  };
+  const enc = (c) => {
+    const body = bucket(c.body), bodyP = lastPos, under = bucket(c.under), underP = lastPos;
+    const edges = c.edges.length ? put(new Float32Array(c.edges)) : null;
+    const condlB = condl(c.cond, [bodyP, underP, c.edges]), condlU = condl(c.condUnder, [bodyP, underP, c.edges]);
+    return { body, under, edges, cond: c.condLines, condl: condlB, condlu: condlU, studs: c.studs.map((s) => [s.kind, s.color, ...s.m.map((x) => +x.toFixed(4))]), bbox: c.bbox, fullBottom: c.fullBottom, uncert: !!c.uncertified, mask: c.bottomMask ? [c.bottomMask.nx, c.bottomMask.nz, c.bottomMask.bits.join("")] : null, ...encTex(c) };
+  };
+  const encParts = Object.fromEntries([...parts].map(([k, c]) => [k, enc(c)])), encKinds = Object.fromEntries([...studKinds].map(([k, c]) => [k, enc(c)]));
+  const textures = texNames.map((name) => {
+    const b = options.texture?.(name);
+    return b ? { name, mime: "image/png", data: put(b) } : { name, missing: true };
+  });
+  const features = [...anyCond ? ["cond"] : [], ...texNames.length ? ["tex"] : []];
+  const header = { version: features.length ? 2 : 1, ...features.length ? { features } : {}, weld, parts: encParts, studKinds: encKinds, ...texNames.length ? { textures } : {}, ...extra };
+  const hj = new TextEncoder().encode(JSON.stringify(header));
+  const hpad = (4 - (4 + hj.length) % 4) % 4;
+  const head = new Uint8Array(4 + hj.length + hpad);
+  new DataView(head.buffer).setUint32(0, hj.length + hpad, true);
+  head.set(hj, 4);
+  head.fill(32, 4 + hj.length);
+  return Buffer.concat([head, ...chunks.map((c) => new Uint8Array(c.buffer, c.byteOffset, c.byteLength))]);
 }
 
 // src/model.ts
@@ -739,9 +1317,14 @@ function buildPack(o) {
   const lib = new Library(o.ldrawRoot);
   const refs = new Map;
   const missing = new Set;
+  const data = new Map;
   for (const m of o.models ?? []) {
     const { name, text } = typeof m === "string" ? { name: path3.basename(m), text: fs3.readFileSync(m, "latin1") } : m;
-    const r = flatten(splitModel(text, name), lib, (i) => refs.set(i.ref, i.part));
+    const sm = splitModel(text, name);
+    for (const [k, v] of sm.data)
+      if (!data.has(k))
+        data.set(k, v);
+    const r = flatten(sm, lib, (i) => refs.set(i.ref, i.part));
     for (const k of r.missing.keys())
       missing.add(k);
   }
@@ -757,7 +1340,7 @@ function buildPack(o) {
       if (lib.isPart(k) && /\.dat$/.test(k))
         refs.set(k.slice(6), k);
   }
-  const comp = new Compiler(lib, { studs: o.studs ?? "low", prims: o.primitives ?? "full", weld: o.weld ?? true, separateStuds: true });
+  const comp = new Compiler(lib, { studs: o.studs ?? "low", prims: o.primitives ?? "full", weld: o.weld ?? true, separateStuds: true, cond: !!o.cond, tex: !!o.textures });
   const parts = new Map, kinds = new Map;
   let n = 0;
   for (const [ref, key] of refs) {
@@ -778,7 +1361,11 @@ function buildPack(o) {
     if (fs3.existsSync(cfg))
       extra = { colors: Object.fromEntries([...parseLDConfig(fs3.readFileSync(cfg, "latin1"))].map(([k, v]) => [k, v.hex])) };
   }
-  return { data: encodePack(parts, kinds, comp.opts.weld, extra), parts: parts.size, studKinds: kinds.size, missing: [...missing] };
+  const texture = (n) => {
+    const k = norm(n), b = data.get(k) ?? data.get(k.replace(/^textures\//, "")) ?? data.get("textures/" + k);
+    return b ? new Uint8Array(Buffer.from(b, "base64")) : comp.texture(n);
+  };
+  return { data: encodePack(parts, kinds, comp.opts.weld, extra, { texture }), parts: parts.size, studKinds: kinds.size, missing: [...missing] };
 }
 
 // src/cli.ts
@@ -795,6 +1382,9 @@ Options:
   --studs low|full    Stud detail (default low)
   --prims full|low    Other primitive detail (default full)
   --no-weld           Don't index/weld vertices
+  --cond              Keep conditional (type-5) lines for curved-surface outlines (pack v2, ~+8-14% zstd)
+  --textures          Keep printed/sticker parts' !TEXMAP geometry + UVs and embed their PNGs (pack v2; packs without
+                      textured parts are unchanged). Textures come from model !DATA blocks, then <ldraw>/parts/textures
   --no-colors         Don't embed the LDConfig colour table
 `;
 var argv = process.argv.slice(2);
@@ -812,6 +1402,8 @@ var prims = "full";
 var weld = true;
 var colors = true;
 var all = false;
+var cond = false;
+var textures = false;
 for (let i = 0;i < a.length; i++) {
   const k = a[i];
   const v = () => {
@@ -836,6 +1428,10 @@ for (let i = 0;i < a.length; i++) {
     weld = false;
   else if (k === "--no-colors")
     colors = false;
+  else if (k === "--cond")
+    cond = true;
+  else if (k === "--textures")
+    textures = true;
   else if (k === "--all-parts")
     all = true;
   else if (k.startsWith("-")) {
@@ -855,7 +1451,7 @@ if (!fs4.existsSync(ldraw + "/LDConfig.ldr")) {
   process.exit(1);
 }
 var t0 = performance.now();
-var r = buildPack({ ldrawRoot: ldraw, models, parts, allParts: all, studs, primitives: prims, weld, colors });
+var r = buildPack({ ldrawRoot: ldraw, models, parts, allParts: all, studs, primitives: prims, weld, colors, cond, textures });
 var data = r.data;
 if (out.endsWith(".gz"))
   data = zlib.gzipSync(data, { level: 9 });