doubletwelve 0.1.0

package/dist/index.js

@@ -0,0 +1,1481 @@
+import { jsx as b, Fragment as re, jsxs as T } from "react/jsx-runtime";
+import { useMemo as Se, useState as Y, useEffect as ye } from "react";
+const me = {
+  "3x3": { rows: [20, 50, 80], cols: [20, 50, 80], size: "18%" },
+  "3x4": { rows: [24, 50, 76], cols: [22, 40, 60, 78], size: "12%" },
+  "4x3": { rows: [15, 38, 62, 85], cols: [20, 50, 80], size: "14%" }
+};
+function ze(e) {
+  const o = me[e.gridSize];
+  return {
+    top: e.top ?? `${o.rows[e.row]}%`,
+    left: e.left ?? `${o.cols[e.col]}%`,
+    width: o.size,
+    height: o.size
+  };
+}
+const $e = ({
+  row: e,
+  col: o,
+  gridSize: t,
+  color: n,
+  hollow: r,
+  top: l,
+  left: i
+}) => {
+  const s = ze({ row: e, col: o, gridSize: t, top: l, left: i });
+  return /* @__PURE__ */ b(
+    "div",
+    {
+      "data-testid": "pip",
+      "data-row": e,
+      "data-col": o,
+      "data-grid": t,
+      style: {
+        position: "absolute",
+        backgroundColor: r ? "transparent" : n,
+        border: r ? "2px solid #888" : void 0,
+        borderRadius: "50%",
+        transform: "translate(-50%, -50%)",
+        boxShadow: r ? void 0 : "1px 2px 3px rgba(0,0,0,0.3)",
+        ...s
+      }
+    }
+  );
+}, Me = {
+  0: [],
+  1: [{ row: 1, col: 1, gridSize: "3x3" }],
+  2: [
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" }
+  ],
+  3: [
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 1, col: 1, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" }
+  ],
+  4: [
+    { row: 0, col: 0, gridSize: "3x3" },
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" },
+    { row: 2, col: 2, gridSize: "3x3" }
+  ],
+  5: [
+    { row: 0, col: 0, gridSize: "3x3" },
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 1, col: 1, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" },
+    { row: 2, col: 2, gridSize: "3x3" }
+  ],
+  6: [
+    { row: 0, col: 0, gridSize: "3x3" },
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 1, col: 0, gridSize: "3x3" },
+    { row: 1, col: 2, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" },
+    { row: 2, col: 2, gridSize: "3x3" }
+  ],
+  7: [
+    { row: 0, col: 0, gridSize: "3x3" },
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 1, col: 0, gridSize: "3x3" },
+    { row: 1, col: 1, gridSize: "3x3" },
+    { row: 1, col: 2, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" },
+    { row: 2, col: 2, gridSize: "3x3" }
+  ],
+  8: [
+    { row: 0, col: 0, gridSize: "3x3" },
+    { row: 0, col: 1, gridSize: "3x3" },
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 1, col: 0, gridSize: "3x3" },
+    { row: 1, col: 2, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" },
+    { row: 2, col: 1, gridSize: "3x3" },
+    { row: 2, col: 2, gridSize: "3x3" }
+  ],
+  9: [
+    { row: 0, col: 0, gridSize: "3x3" },
+    { row: 0, col: 1, gridSize: "3x3" },
+    { row: 0, col: 2, gridSize: "3x3" },
+    { row: 1, col: 0, gridSize: "3x3" },
+    { row: 1, col: 1, gridSize: "3x3" },
+    { row: 1, col: 2, gridSize: "3x3" },
+    { row: 2, col: 0, gridSize: "3x3" },
+    { row: 2, col: 1, gridSize: "3x3" },
+    { row: 2, col: 2, gridSize: "3x3" }
+  ],
+  10: [
+    { row: 0, col: 0, gridSize: "3x4" },
+    { row: 0, col: 1, gridSize: "3x4" },
+    { row: 0, col: 2, gridSize: "3x4" },
+    { row: 0, col: 3, gridSize: "3x4" },
+    { row: 1, col: 0, gridSize: "3x4" },
+    { row: 1, col: 3, gridSize: "3x4" },
+    { row: 2, col: 0, gridSize: "3x4" },
+    { row: 2, col: 1, gridSize: "3x4" },
+    { row: 2, col: 2, gridSize: "3x4" },
+    { row: 2, col: 3, gridSize: "3x4" }
+  ],
+  11: [
+    { row: 0, col: 0, gridSize: "4x3" },
+    { row: 1, col: 0, gridSize: "4x3" },
+    { row: 2, col: 0, gridSize: "4x3" },
+    { row: 3, col: 0, gridSize: "4x3" },
+    { row: 0, col: 1, gridSize: "4x3" },
+    { row: 2, col: 1, gridSize: "4x3", top: "50%" },
+    { row: 3, col: 1, gridSize: "4x3" },
+    { row: 0, col: 2, gridSize: "4x3" },
+    { row: 1, col: 2, gridSize: "4x3" },
+    { row: 2, col: 2, gridSize: "4x3" },
+    { row: 3, col: 2, gridSize: "4x3" }
+  ],
+  12: [
+    { row: 0, col: 0, gridSize: "4x3" },
+    { row: 1, col: 0, gridSize: "4x3" },
+    { row: 2, col: 0, gridSize: "4x3" },
+    { row: 3, col: 0, gridSize: "4x3" },
+    { row: 0, col: 1, gridSize: "4x3" },
+    { row: 1, col: 1, gridSize: "4x3" },
+    { row: 2, col: 1, gridSize: "4x3" },
+    { row: 3, col: 1, gridSize: "4x3" },
+    { row: 0, col: 2, gridSize: "4x3" },
+    { row: 1, col: 2, gridSize: "4x3" },
+    { row: 2, col: 2, gridSize: "4x3" },
+    { row: 3, col: 2, gridSize: "4x3" }
+  ]
+};
+function Ce(e) {
+  return Me[e] ?? [];
+}
+const X = {
+  0: { color: "transparent" },
+  1: { color: "#1a1a1a" },
+  2: { color: "#8B1A1A" },
+  3: { color: "#E6B800" },
+  4: { color: "#e8e8e8", hollow: !0 },
+  5: { color: "#2E8B57" },
+  6: { color: "#2563EB" },
+  7: { color: "#E8A87C" },
+  8: { color: "#DC2626" },
+  9: { color: "#1E3A8A" },
+  10: { color: "#EA580C" },
+  11: { color: "#166534" },
+  12: { color: "#DC2626" }
+}, no = X;
+function ro(e) {
+  return { ...X, ...e };
+}
+function le(e, o) {
+  if (o !== void 0)
+    return o[e] ?? X[e] ?? { color: "#1a1a1a" };
+}
+function lo(e) {
+  return le(e, X);
+}
+const ke = (e, o, t) => {
+  const n = le(e, t);
+  return n ? { color: n.color, hollow: n.hollow } : { color: o };
+}, De = ({
+  value: e,
+  pipColor: o,
+  pipColors: t
+}) => {
+  const { color: n, hollow: r } = ke(e, o, t), l = Ce(e);
+  return /* @__PURE__ */ b(re, { children: l.map((i, s) => /* @__PURE__ */ b(
+    $e,
+    {
+      row: i.row,
+      col: i.col,
+      gridSize: i.gridSize,
+      color: n,
+      hollow: r,
+      top: i.top,
+      left: i.left
+    },
+    s
+  )) });
+}, ee = ({
+  value: e,
+  pipColor: o,
+  pipColors: t
+}) => /* @__PURE__ */ b(
+  "div",
+  {
+    style: {
+      width: "100%",
+      height: "100%",
+      position: "relative",
+      padding: "0",
+      overflow: "hidden"
+    },
+    children: /* @__PURE__ */ b(De, { value: e, pipColor: o, pipColors: t })
+  }
+), ie = ({
+  value1: e = 0,
+  value2: o = 0,
+  width: t = 100,
+  height: n = 200,
+  backgroundColor: r = "white",
+  pipColor: l = "black",
+  pipColors: i,
+  borderColor: s = "black",
+  rotation: a = 0
+}) => {
+  const u = Math.min(Math.max(e, 0), 12), f = Math.min(Math.max(o, 0), 12);
+  return /* @__PURE__ */ T(
+    "div",
+    {
+      style: {
+        width: `${t}px`,
+        height: `${n}px`,
+        backgroundColor: r,
+        borderColor: s,
+        borderWidth: "1px",
+        borderStyle: "solid",
+        borderRadius: "10px",
+        transform: `rotate(${a}deg)`,
+        transformOrigin: "center center",
+        boxShadow: "0 1px 2px rgba(0,0,0,0.2)",
+        display: "flex",
+        flexDirection: "column",
+        overflow: "hidden"
+      },
+      children: [
+        /* @__PURE__ */ b(
+          "div",
+          {
+            style: {
+              flex: 1,
+              position: "relative",
+              borderBottomWidth: "1px",
+              borderBottomStyle: "solid",
+              borderBottomColor: s
+            },
+            children: /* @__PURE__ */ b(ee, { value: u, pipColor: l, pipColors: i })
+          }
+        ),
+        /* @__PURE__ */ b(
+          "div",
+          {
+            style: {
+              flex: 1,
+              position: "relative"
+            },
+            children: /* @__PURE__ */ b(ee, { value: f, pipColor: l, pipColors: i })
+          }
+        )
+      ]
+    }
+  );
+}, D = 60, I = 120, Ie = [-45, 45];
+function oe(e, o = D, t = I) {
+  return e ? o / 2 : t / 2;
+}
+function k(e, o, t = D, n = I) {
+  return oe(e, t, n) + oe(o, t, n);
+}
+function _(e) {
+  const o = e * Math.PI / 180;
+  return {
+    dirX: Math.cos(o),
+    dirY: Math.sin(o)
+  };
+}
+function N(e) {
+  const { dirX: o, dirY: t } = _(e);
+  return { perpX: -t, perpY: o };
+}
+function Te(e, o) {
+  const t = e.map((n) => ({ ...n }));
+  for (let n = 1; n < t.length; n++) {
+    const r = t[n], i = t[n - 1].value2, s = r.value1 === r.value2;
+    if (o === "linear" && !s) {
+      t[n] = { value1: r.value2, value2: r.value1 };
+      continue;
+    }
+    o === "offset" && !s && r.value1 !== i && r.value2 === i && (t[n] = { value1: r.value2, value2: r.value1 });
+  }
+  return t;
+}
+function j(e) {
+  const { dirX: o, dirY: t } = _(e);
+  return Math.abs(o) >= Math.abs(t) ? o >= 0 ? 1 : -1 : t >= 0 ? 1 : -1;
+}
+function se(e, o) {
+  return e === 0 ? o : e === o ? -o : o;
+}
+function Oe({
+  startX: e,
+  startY: o,
+  angle: t,
+  dominoes: n,
+  layoutStyle: r,
+  dominoWidth: l = D,
+  dominoHeight: i = I,
+  leadGap: s = i * 0.3,
+  outwardSign: a,
+  hubIndex: u
+}) {
+  const f = [], { dirX: c, dirY: d } = _(t), { perpX: v, perpY: y } = N(t), x = Te([...n], r), w = a ?? j(t), z = r === "offset" && u != null, $ = [];
+  let m = e + c * s, p = o + d * s, h = 0, M = 0;
+  const O = l / 2, A = (g) => {
+    const S = (g - h) * O;
+    m += v * S, p += y * S, h = g;
+  };
+  for (let g = 0; g < x.length; g++) {
+    const S = x[g], E = S.value1 === S.value2, C = g > 0 && x[g - 1].value1 === x[g - 1].value2;
+    r === "linear" ? g > 0 && (E ? (m += c * k(C, !0, l, i), p += d * k(C, !0, l, i)) : C ? (m += c * k(!0, !1, l, i), p += d * k(!0, !1, l, i)) : (m += c * i, p += d * i)) : E ? g > 0 && (m += c * k(C, !0, l, i), p += d * k(C, !0, l, i)) : (g === 0 ? M = w : C ? (m += c * k(!0, !1, l, i), p += d * k(!0, !1, l, i)) : (m += c * (i / 2), p += d * (i / 2), M = se(M, w)), A(M)), $.push(h), f.push({
+      x: m,
+      y: p,
+      rotation: E ? t + 180 : t - 90,
+      isDouble: E,
+      value1: S.value1,
+      value2: S.value2
+    });
+  }
+  if (z && u != null) {
+    const g = -$[u] * O;
+    if (g !== 0)
+      for (let S = 0; S < f.length; S++)
+        f[S] = {
+          ...f[S],
+          x: f[S].x + v * g,
+          y: f[S].y + y * g
+        };
+  }
+  return f;
+}
+function te(e, o = D, t = I) {
+  const n = e.rotation * Math.PI / 180, r = Math.cos(n), l = Math.sin(n), i = o / 2, s = t / 2;
+  return [
+    [-i, -s],
+    [i, -s],
+    [i, s],
+    [-i, s]
+  ].map(([a, u]) => ({
+    x: e.x + a * r - u * l,
+    y: e.y + a * l + u * r
+  }));
+}
+function Pe(e, o, t) {
+  let n = 1 / 0, r = -1 / 0, l = 1 / 0, i = -1 / 0;
+  for (const s of e) {
+    const a = s.x * t.x + s.y * t.y;
+    n = Math.min(n, a), r = Math.max(r, a);
+  }
+  for (const s of o) {
+    const a = s.x * t.x + s.y * t.y;
+    l = Math.min(l, a), i = Math.max(i, a);
+  }
+  return Math.min(r, i) - Math.max(n, l);
+}
+function ae(e, o, t = 1, n = D, r = I) {
+  const l = te(e, n, r), i = te(o, n, r);
+  for (const s of [l, i])
+    for (let a = 0; a < 4; a++) {
+      const u = s[a], f = s[(a + 1) % 4], c = f.x - u.x, d = f.y - u.y, v = Math.hypot(c, d) || 1, y = { x: -d / v, y: c / v };
+      if (Pe(l, i, y) <= t)
+        return !1;
+    }
+  return !0;
+}
+function Ee(e, o, t, n) {
+  return o.some(
+    (r) => ae(e, r, 1, t, n)
+  );
+}
+const P = D / 4, ne = 24;
+function ue({
+  startX: e,
+  startY: o,
+  angle: t,
+  branch: n,
+  layoutStyle: r,
+  dominoWidth: l = D,
+  dominoHeight: i = I,
+  leadGap: s,
+  depth: a = 0,
+  anchor: u,
+  outwardSign: f,
+  placed: c = [],
+  pushAxis: d,
+  minPushSteps: v = 0
+}) {
+  const y = f ?? j(t), x = n.feet ? Object.keys(n.feet).map(Number).filter((p) => {
+    const h = n.dominoes[p];
+    return h && h.value1 === h.value2;
+  }).sort((p, h) => p - h)[0] : void 0, w = (p, h) => Oe({
+    startX: p,
+    startY: h,
+    angle: t,
+    dominoes: n.dominoes,
+    layoutStyle: r,
+    dominoWidth: l,
+    dominoHeight: i,
+    leadGap: s,
+    outwardSign: y,
+    hubIndex: x
+  });
+  let z = w(
+    e + (d?.x ?? 0) * P * v,
+    o + (d?.y ?? 0) * P * v
+  ), $ = u && d ? {
+    x: u.x + d.x * P * v,
+    y: u.y + d.y * P * v
+  } : u;
+  if (d && c.length > 0)
+    for (let p = v; p <= ne; p++) {
+      const h = e + d.x * P * p, M = o + d.y * P * p, O = w(h, M);
+      if (!O.some(
+        (g) => Ee(g, c, l, i)
+      ) || p === ne) {
+        z = O, $ = u && {
+          x: u.x + d.x * P * p,
+          y: u.y + d.y * P * p
+        };
+        break;
+      }
+    }
+  c.push(...z);
+  const m = [
+    {
+      angle: t,
+      depth: a,
+      layoutStyle: r,
+      outwardSign: y,
+      dominoes: n.dominoes,
+      layout: z,
+      anchor: $
+    }
+  ];
+  if (n.feet) {
+    const { dirX: p, dirY: h } = _(t), { perpX: M, perpY: O } = N(t), A = l / 2, g = i / 2;
+    for (const S of Object.keys(n.feet)) {
+      const E = Number(S), C = z[E], q = n.feet[E];
+      if (!(!C || !C.isDouble || !q))
+        for (let L = 0; L < q.length; L++) {
+          const he = q[L], J = Ie[L] ?? 0, R = Math.sign(J), Q = t + J, Z = N(Q), V = -R, be = C.x + p * (l / 2) + M * (i / 2) * R, we = C.y + h * (l / 2) + O * (i / 2) * R, H = be - Z.perpX * V * A, W = we - Z.perpY * V * A;
+          m.push(
+            ...ue({
+              startX: H,
+              startY: W,
+              angle: Q,
+              branch: he,
+              // Toes inherit the main style so they zigzag in offset mode.
+              layoutStyle: r,
+              dominoWidth: l,
+              dominoHeight: i,
+              leadGap: g,
+              outwardSign: V,
+              depth: a + 1,
+              anchor: { x: H, y: W },
+              placed: c,
+              // If the snug spot is still blocked (the offset center toe leans into
+              // one side), slide this toe along the double's open edge, away from
+              // center, until it clears. This keeps it butted against the double
+              // while stepping past the obstacle — independent per toe, so a foot
+              // ends up snug and only as asymmetric as the obstruction requires.
+              pushAxis: { x: M * R, y: O * R }
+            })
+          );
+        }
+    }
+  }
+  return m;
+}
+function Fe(e) {
+  return e.flatMap((o) => o.layout);
+}
+function io(e, o = 24, t = D, n = I) {
+  const r = Math.hypot(t, n) / 2;
+  if (e.length === 0)
+    return {
+      width: o * 2 + t,
+      height: o * 2 + n,
+      offsetX: o,
+      offsetY: o
+    };
+  let l = 1 / 0, i = 1 / 0, s = -1 / 0, a = -1 / 0;
+  for (const u of e)
+    l = Math.min(l, u.x - r), i = Math.min(i, u.y - r), s = Math.max(s, u.x + r), a = Math.max(a, u.y + r);
+  return {
+    width: Math.ceil(s - l + o * 2),
+    height: Math.ceil(a - i + o * 2),
+    offsetX: o - l,
+    offsetY: o - i
+  };
+}
+const Ae = ({
+  startX: e,
+  startY: o,
+  angle: t,
+  trainData: n,
+  layoutStyle: r,
+  tableWidth: l,
+  tableHeight: i,
+  centerX: s,
+  centerY: a,
+  pipColors: u
+}) => {
+  const f = Se(
+    () => Fe(
+      ue({
+        startX: e,
+        startY: o,
+        angle: t,
+        branch: { dominoes: n.dominoes, feet: n.feet },
+        layoutStyle: r
+      })
+    ),
+    [
+      e,
+      o,
+      t,
+      n.dominoes,
+      n.feet,
+      r,
+      l,
+      i
+    ]
+  );
+  return /* @__PURE__ */ b(re, { children: f.map((c, d) => {
+    const v = n.isPublic;
+    return /* @__PURE__ */ b(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          left: `${c.x - D / 2}px`,
+          top: `${c.y - I / 2}px`,
+          zIndex: 5
+        },
+        children: /* @__PURE__ */ b(
+          ie,
+          {
+            value1: c.value1,
+            value2: c.value2,
+            width: D,
+            height: I,
+            backgroundColor: "white",
+            pipColor: "black",
+            pipColors: u,
+            borderColor: v ? "red" : "black",
+            rotation: c.rotation
+          }
+        )
+      },
+      `main-train-${n.playerId}-${d}`
+    );
+  }) });
+}, Re = ({
+  playerCount: e,
+  centerX: o,
+  centerY: t,
+  radius: n,
+  engineValue: r,
+  trains: l,
+  layoutStyle: i,
+  tableWidth: s,
+  tableHeight: a,
+  pipColors: u
+}) => {
+  const f = Math.max(8, e), c = 120;
+  return /* @__PURE__ */ T("div", { style: { position: "relative", width: "100%", height: "100%" }, children: [
+    /* @__PURE__ */ b(
+      "div",
+      {
+        style: {
+          position: "absolute",
+          width: `${c}px`,
+          height: `${c}px`,
+          left: `${o - c / 2}px`,
+          top: `${t - c / 2}px`,
+          backgroundColor: "#d1d5db",
+          borderWidth: "3px",
+          borderStyle: "solid",
+          borderColor: "#6b7280",
+          borderRadius: "50%",
+          boxShadow: "0 4px 6px rgba(0,0,0,0.1)",
+          zIndex: 10,
+          display: "flex",
+          justifyContent: "center",
+          alignItems: "center"
+        },
+        children: /* @__PURE__ */ b("div", { style: { transform: "rotate(0deg)" }, children: /* @__PURE__ */ b(
+          ie,
+          {
+            value1: r,
+            value2: r,
+            width: 60,
+            height: 120,
+            backgroundColor: "white",
+            pipColor: "black",
+            pipColors: u,
+            borderColor: "#333"
+          }
+        ) })
+      }
+    ),
+    Array.from({ length: f }).map((y, x) => {
+      const w = x * 360 / f, z = w * Math.PI / 180, $ = o + (n + 20) * Math.cos(z), m = t + (n + 20) * Math.sin(z), p = l.find((h) => h.playerId === x) || {
+        dominoes: [],
+        playerId: x,
+        isPublic: !1
+      };
+      return /* @__PURE__ */ b(
+        Ae,
+        {
+          startX: $,
+          startY: m,
+          angle: w,
+          trainData: p,
+          layoutStyle: i,
+          tableWidth: s,
+          tableHeight: a,
+          centerX: o,
+          centerY: t,
+          pipColors: u
+        },
+        x
+      );
+    })
+  ] });
+};
+function F(e, o) {
+  return e <= o ? `${e}:${o}` : `${o}:${e}`;
+}
+function ce(e) {
+  return F(e.value1, e.value2);
+}
+function de(e) {
+  return e.value1 === e.value2;
+}
+function so(e, o) {
+  return e.value1 === o || e.value2 === o;
+}
+function ao(e, o) {
+  return e.value1 === o ? e.value2 : e.value2 === o ? e.value1 : null;
+}
+function fe(e, o) {
+  return e.value1 === o ? { value1: e.value1, value2: e.value2 } : e.value2 === o ? { value1: e.value2, value2: e.value1 } : null;
+}
+function uo(e) {
+  const o = [];
+  for (let t = 0; t <= e; t++)
+    for (let n = t; n <= e; n++)
+      o.push({ value1: t, value2: n });
+  return o;
+}
+function co(e) {
+  const o = e + 1;
+  return o * (o + 1) / 2;
+}
+function Xe(e, o = 12, t = {}) {
+  const n = /* @__PURE__ */ new Set([F(o, o)]), r = [];
+  for (let l = 0; l < e; l++) {
+    const i = 4 + Math.floor(Math.random() * 7), s = [];
+    let a = o, u = !1;
+    for (let c = 0; c < i; c++) {
+      const d = Ne(
+        a,
+        u,
+        c === 0,
+        o,
+        n
+      );
+      if (d === null)
+        break;
+      const v = d === a;
+      n.add(F(a, d)), s.push({ value1: a, value2: d }), u = v, a = d;
+    }
+    const f = t.chickenFeet ? _e(s, n) : void 0;
+    r.push({
+      playerId: l,
+      dominoes: s,
+      isPublic: Math.random() > 0.7,
+      ...f ? { feet: f } : {}
+    });
+  }
+  return r;
+}
+function _e(e, o) {
+  const t = {};
+  for (let n = 0; n < e.length; n++) {
+    if (e[n].value1 !== e[n].value2)
+      continue;
+    const r = e[n].value1, l = [];
+    for (let i = 0; i < 2; i++) {
+      const s = Le(r, o);
+      s && l.push(s);
+    }
+    l.length && (t[n] = l);
+  }
+  return Object.keys(t).length ? t : void 0;
+}
+function Le(e, o) {
+  const t = 1 + Math.floor(Math.random() * 2), n = [];
+  let r = e;
+  for (let l = 0; l < t; l++) {
+    const i = Ye(r, o);
+    if (i === null)
+      break;
+    o.add(F(r, i)), n.push({ value1: r, value2: i }), r = i;
+  }
+  return n.length ? { dominoes: n } : null;
+}
+function Ye(e, o) {
+  const t = [];
+  for (let n = 0; n < 13; n++)
+    n !== e && (o.has(F(e, n)) || t.push(n));
+  return t.length === 0 ? null : t[Math.floor(Math.random() * t.length)];
+}
+function Ne(e, o, t, n, r) {
+  const l = Array.from({ length: 13 }, (i, s) => s).filter(
+    (i) => je(
+      e,
+      i,
+      o,
+      t,
+      n,
+      r
+    )
+  );
+  return l.length === 0 ? null : l[Math.floor(Math.random() * l.length)];
+}
+function je(e, o, t, n, r, l) {
+  const i = o === e;
+  return !(n && i && e === r || i && t || l.has(F(e, o)));
+}
+const Be = {
+  playerCount: 8,
+  trains: [],
+  engineValue: 12
+}, fo = ({
+  initialState: e = Be,
+  width: o = 1200,
+  height: t = 800,
+  pipColors: n,
+  onPipColorsChange: r
+}) => {
+  const [l, i] = Y(e), [s, a] = Y("offset"), [u, f] = Y(!1), [c, d] = Y(void 0), v = n ?? c, y = r ?? d, x = v !== void 0, w = o / 2, z = t / 2, $ = (p = u) => {
+    const h = Xe(
+      l.playerCount,
+      l.engineValue,
+      { chickenFeet: p }
+    );
+    i((M) => ({
+      ...M,
+      trains: h
+    }));
+  };
+  ye(() => {
+    $();
+  }, []);
+  const m = () => {
+    const p = !u;
+    f(p), $(p);
+  };
+  return /* @__PURE__ */ T(
+    "div",
+    {
+      style: {
+        width: `${o}px`,
+        height: `${t}px`,
+        position: "relative",
+        backgroundColor: "#1f8a55",
+        // Classic green felt background
+        borderRadius: "8px",
+        boxShadow: "0 4px 12px rgba(0,0,0,0.2)",
+        overflow: "hidden"
+      },
+      children: [
+        /* @__PURE__ */ T(
+          "div",
+          {
+            style: { position: "absolute", top: "10px", left: "10px", zIndex: 100 },
+            children: [
+              /* @__PURE__ */ b(
+                "button",
+                {
+                  onClick: () => $(),
+                  style: {
+                    padding: "8px 12px",
+                    backgroundColor: "#fff",
+                    border: "1px solid #ccc",
+                    borderRadius: "4px",
+                    marginRight: "10px",
+                    cursor: "pointer"
+                  },
+                  children: "New trains"
+                }
+              ),
+              /* @__PURE__ */ T(
+                "button",
+                {
+                  onClick: () => a(s === "offset" ? "linear" : "offset"),
+                  style: {
+                    padding: "8px 12px",
+                    backgroundColor: "#fff",
+                    border: "1px solid #ccc",
+                    borderRadius: "4px",
+                    marginRight: "10px",
+                    cursor: "pointer"
+                  },
+                  children: [
+                    "Layout: ",
+                    s === "offset" ? "Offset" : "Linear"
+                  ]
+                }
+              ),
+              /* @__PURE__ */ T(
+                "button",
+                {
+                  onClick: m,
+                  style: {
+                    padding: "8px 12px",
+                    backgroundColor: u ? "#fef3c7" : "#fff",
+                    border: `1px solid ${u ? "#f59e0b" : "#ccc"}`,
+                    borderRadius: "4px",
+                    marginRight: "10px",
+                    cursor: "pointer"
+                  },
+                  children: [
+                    "Chicken Feet: ",
+                    u ? "On" : "Off"
+                  ]
+                }
+              ),
+              /* @__PURE__ */ T(
+                "button",
+                {
+                  onClick: () => y(x ? void 0 : X),
+                  style: {
+                    padding: "8px 12px",
+                    backgroundColor: x ? "#fef3c7" : "#fff",
+                    border: `1px solid ${x ? "#f59e0b" : "#ccc"}`,
+                    borderRadius: "4px",
+                    cursor: "pointer"
+                  },
+                  children: [
+                    "Pip Colors: ",
+                    x ? "On" : "Off"
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ T(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: "10px",
+              right: "10px",
+              zIndex: 100,
+              backgroundColor: "rgba(255,255,255,0.8)",
+              padding: "8px",
+              borderRadius: "4px",
+              fontSize: "14px"
+            },
+            children: [
+              /* @__PURE__ */ T("div", { children: [
+                "Engine: Double-",
+                l.engineValue
+              ] }),
+              /* @__PURE__ */ T("div", { children: [
+                "Players: ",
+                l.playerCount
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ b(
+          Re,
+          {
+            playerCount: l.playerCount,
+            centerX: w,
+            centerY: z,
+            radius: 80,
+            engineValue: l.engineValue,
+            trains: l.trains,
+            layoutStyle: s,
+            tableWidth: o,
+            tableHeight: t,
+            pipColors: v
+          }
+        )
+      ]
+    }
+  );
+}, B = 1;
+function pe(e, o, t) {
+  const { dirX: n, dirY: r } = _(t);
+  return e * n + o * r;
+}
+function Ue(e, o, t) {
+  const { perpX: n, perpY: r } = N(t);
+  return e * n + o * r;
+}
+function K(e) {
+  const o = [];
+  for (let t = 1; t < e.length; t++)
+    e[t].value1 !== e[t - 1].value2 && o.push({
+      code: "chain-break",
+      message: `Domino ${t} does not connect to domino ${t - 1}`,
+      index: t
+    });
+  for (let t = 1; t < e.length; t++) {
+    const n = e[t - 1].value1 === e[t - 1].value2, r = e[t].value1 === e[t].value2;
+    n && r && o.push({
+      code: "consecutive-doubles",
+      message: `Consecutive doubles at index ${t - 1} and ${t}`,
+      index: t
+    });
+  }
+  return { valid: o.length === 0, issues: o };
+}
+function ve(e, o, t, n = D, r = I) {
+  const l = n / 2, i = e.map((c) => c.isDouble), s = [];
+  let a = 0, u = 0, f = 0;
+  for (let c = 0; c < e.length; c++) {
+    const d = i[c], v = c > 0 && i[c - 1];
+    o === "linear" ? (c > 0 && (a += k(v, d, n, r)), u = 0) : d ? c > 0 && (a += k(v, !0, n, r)) : c === 0 ? (f = t, u = f * l) : v ? a += k(!0, !1, n, r) : (a += r / 2, f = se(f, t), u = f * l), s.push({ along: a, perp: u });
+  }
+  return s;
+}
+function qe(e, o, t, n = B, r) {
+  const l = [], i = r ?? j(o), s = ve(e, t, i);
+  for (let a = 1; a < e.length; a++) {
+    const u = e[a - 1], f = e[a], c = f.x - u.x, d = f.y - u.y, v = pe(c, d, o), y = Ue(c, d, o), x = s[a].along - s[a - 1].along, w = s[a].perp - s[a - 1].perp;
+    Math.abs(v - x) > n && l.push({
+      code: "spacing-along-train",
+      message: `Along-train spacing between domino ${a - 1} and ${a} is ${v.toFixed(2)}px (expected ${x}px)`,
+      index: a
+    }), Math.abs(y - w) > n && l.push({
+      code: "spacing-perpendicular",
+      message: `Perpendicular spacing between domino ${a - 1} and ${a} is ${y.toFixed(2)}px (expected ${w}px)`,
+      index: a
+    });
+  }
+  return { valid: l.length === 0, issues: l };
+}
+function Ve(e, o, t, n = B, r) {
+  const l = [], i = r ?? j(o), s = ve(e, t, i);
+  for (let a = 1; a < e.length; a++) {
+    const u = e[a - 1], f = e[a], c = f.x - u.x, d = f.y - u.y, v = Math.hypot(c, d), y = s[a].along - s[a - 1].along, x = s[a].perp - s[a - 1].perp, w = Math.hypot(y, x) * 0.9;
+    v + n < w && l.push({
+      code: "overlap",
+      message: `Domino ${a - 1} and ${a} centers are ${v.toFixed(2)}px apart (minimum ${w.toFixed(2)}px)`,
+      index: a
+    });
+  }
+  return { valid: l.length === 0, issues: l };
+}
+function po(e, o, t, n, r = B, l) {
+  const i = [
+    ...K(o).issues,
+    ...qe(
+      e,
+      t,
+      n,
+      r,
+      l
+    ).issues,
+    ...Ve(
+      e,
+      t,
+      n,
+      r,
+      l
+    ).issues
+  ];
+  return e.length !== o.length && i.push({
+    code: "layout-length",
+    message: `Layout length ${e.length} does not match domino count ${o.length}`
+  }), { valid: i.length === 0, issues: i };
+}
+function vo(e) {
+  const o = [], t = (n, r) => {
+    if (o.push(
+      ...K(n.dominoes).issues.map((l) => ({
+        ...l,
+        message: `[${r}] ${l.message}`
+      }))
+    ), !!n.feet)
+      for (const l of Object.keys(n.feet)) {
+        const i = Number(l), s = n.dominoes[i], a = n.feet[i] ?? [];
+        if (!s) {
+          o.push({
+            code: "foot-host-missing",
+            message: `[${r}] Foot references missing tile ${i}`
+          });
+          continue;
+        }
+        s.value1 !== s.value2 && o.push({
+          code: "foot-host-not-double",
+          message: `[${r}] Foot host tile ${i} is not a double`
+        }), a.length > 2 && o.push({
+          code: "foot-too-many-toes",
+          message: `[${r}] Double ${i} has ${a.length} side toes (max 2; the center toe is the main line)`
+        }), a.forEach((u, f) => {
+          const c = u.dominoes[0];
+          c && c.value1 !== s.value1 && o.push({
+            code: "foot-connection",
+            message: `[${r}] Toe ${f} on double ${i} starts with ${c.value1} but the double is ${s.value1}`
+          }), t(u, `${r}.${i}.${f}`);
+        });
+      }
+  };
+  return t(e, "main"), { valid: o.length === 0, issues: o };
+}
+function xo(e, o = B) {
+  const t = [];
+  e.forEach((r, l) => {
+    if (t.push(
+      ...K(r.dominoes).issues.map((i) => ({
+        ...i,
+        message: `[segment ${l} @${r.angle}°] ${i.message}`
+      }))
+    ), r.layout.length !== r.dominoes.length && t.push({
+      code: "layout-length",
+      message: `[segment ${l}] Layout length ${r.layout.length} does not match domino count ${r.dominoes.length}`
+    }), r.anchor && r.layout.length > 0) {
+      const i = r.layout[0], s = pe(
+        i.x - r.anchor.x,
+        i.y - r.anchor.y,
+        r.angle
+      ), a = I / 2;
+      Math.abs(s - a) > o && t.push({
+        code: "foot-anchor",
+        message: `[segment ${l}] First toe tile sits ${s.toFixed(2)}px from the double along the toe (expected ${a}px)`,
+        index: 0
+      });
+    }
+  });
+  const n = e.flatMap((r) => r.layout);
+  for (let r = 0; r < n.length; r++)
+    for (let l = r + 1; l < n.length; l++)
+      ae(n[r], n[l]) && t.push({
+        code: "tile-overlap",
+        message: `Tiles ${r} and ${l} overlap`,
+        index: l
+      });
+  return { valid: t.length === 0, issues: t };
+}
+const go = [
+  {
+    id: "regular-after-double",
+    name: "Regular after double",
+    description: "Double followed by a two-tile offset run",
+    angle: 0,
+    dominoes: [
+      { value1: 12, value2: 6 },
+      { value1: 6, value2: 6 },
+      { value1: 6, value2: 3 },
+      { value1: 3, value2: 1 }
+    ],
+    layoutStyles: ["linear", "offset"]
+  },
+  {
+    id: "double-after-regular",
+    name: "Double after regular",
+    description: "Offset run, a double, then another offset run",
+    angle: 0,
+    dominoes: [
+      { value1: 12, value2: 9 },
+      { value1: 9, value2: 4 },
+      { value1: 4, value2: 4 },
+      { value1: 4, value2: 2 },
+      { value1: 2, value2: 7 }
+    ],
+    layoutStyles: ["linear", "offset"]
+  },
+  {
+    id: "double-after-double",
+    name: "Double after double",
+    description: "Offset runs at the head, middle, and tail around two doubles",
+    angle: 90,
+    dominoes: [
+      { value1: 12, value2: 7 },
+      { value1: 7, value2: 8 },
+      { value1: 8, value2: 8 },
+      { value1: 8, value2: 3 },
+      { value1: 3, value2: 5 },
+      { value1: 5, value2: 5 },
+      { value1: 5, value2: 2 },
+      { value1: 2, value2: 1 }
+    ],
+    layoutStyles: ["linear", "offset"]
+  },
+  {
+    id: "offset-zigzag",
+    name: "Offset zigzag",
+    description: "Alternating perpendicular tiles without doubles",
+    angle: 0,
+    dominoes: [
+      { value1: 12, value2: 5 },
+      { value1: 5, value2: 9 },
+      { value1: 9, value2: 2 },
+      { value1: 2, value2: 7 },
+      { value1: 7, value2: 1 }
+    ],
+    layoutStyles: ["offset"]
+  },
+  {
+    id: "horizontal-open",
+    name: "Horizontal train",
+    description: "Rightward train: offset head, double, offset tail",
+    angle: 0,
+    dominoes: [
+      { value1: 5, value2: 12 },
+      { value1: 12, value2: 11 },
+      { value1: 11, value2: 11 },
+      { value1: 11, value2: 6 },
+      { value1: 6, value2: 2 }
+    ],
+    layoutStyles: ["linear", "offset"]
+  },
+  {
+    id: "vertical-open",
+    name: "Vertical train",
+    description: "Downward train: offset head, double, offset tail",
+    angle: 90,
+    dominoes: [
+      { value1: 3, value2: 12 },
+      { value1: 12, value2: 10 },
+      { value1: 10, value2: 10 },
+      { value1: 10, value2: 4 },
+      { value1: 4, value2: 1 }
+    ],
+    layoutStyles: ["linear", "offset"]
+  }
+], ho = [
+  {
+    id: "single-foot",
+    name: "Single foot",
+    description: "A double fans two angled toes (±45°) while the main line continues straight as the center toe",
+    angle: 0,
+    branch: {
+      dominoes: [
+        { value1: 12, value2: 6 },
+        { value1: 6, value2: 6 },
+        { value1: 6, value2: 3 },
+        { value1: 3, value2: 1 }
+      ],
+      feet: {
+        1: [
+          {
+            dominoes: [
+              { value1: 6, value2: 2 },
+              { value1: 2, value2: 5 }
+            ]
+          },
+          {
+            dominoes: [
+              { value1: 6, value2: 4 },
+              { value1: 4, value2: 0 }
+            ]
+          }
+        ]
+      }
+    },
+    layoutStyles: ["linear", "offset"]
+  },
+  {
+    id: "foot-no-center",
+    name: "Foot at the tail",
+    description: "Double ends the main line, so both side toes are present with no straight continuation",
+    angle: 0,
+    branch: {
+      dominoes: [
+        { value1: 9, value2: 7 },
+        { value1: 7, value2: 7 }
+      ],
+      feet: {
+        1: [
+          {
+            dominoes: [
+              { value1: 7, value2: 3 },
+              { value1: 3, value2: 8 }
+            ]
+          },
+          {
+            dominoes: [
+              { value1: 7, value2: 5 },
+              { value1: 5, value2: 0 }
+            ]
+          }
+        ]
+      }
+    },
+    layoutStyles: ["linear", "offset"]
+  },
+  {
+    id: "nested-foot",
+    name: "Nested foot",
+    description: "A side toe contains its own double, which sprouts a second-level foot",
+    angle: 90,
+    branch: {
+      dominoes: [
+        { value1: 12, value2: 8 },
+        { value1: 8, value2: 8 },
+        { value1: 8, value2: 3 }
+      ],
+      feet: {
+        1: [
+          {
+            dominoes: [
+              { value1: 8, value2: 5 },
+              { value1: 5, value2: 5 },
+              { value1: 5, value2: 2 }
+            ],
+            feet: {
+              1: [
+                {
+                  dominoes: [
+                    { value1: 5, value2: 9 },
+                    { value1: 9, value2: 1 }
+                  ]
+                },
+                {
+                  dominoes: [
+                    { value1: 5, value2: 4 },
+                    { value1: 4, value2: 6 }
+                  ]
+                }
+              ]
+            }
+          },
+          {
+            dominoes: [
+              { value1: 8, value2: 1 },
+              { value1: 1, value2: 7 }
+            ]
+          }
+        ]
+      }
+    },
+    layoutStyles: ["linear", "offset"]
+  }
+], G = {
+  maxPips: 12,
+  engineValue: 12,
+  allowConsecutiveDoubles: !1,
+  requireUniqueTiles: !0,
+  requireSequential: !0,
+  doubleObligation: "cover",
+  chickenFoot: {
+    toeCount: 3,
+    sideToeAngles: [-45, 45]
+  }
+};
+function Ge(e) {
+  switch (e.doubleObligation) {
+    case "chicken-foot":
+      return Math.max(1, e.chickenFoot.toeCount);
+    case "cover":
+      return 1;
+    default:
+      return 0;
+  }
+}
+function Ke(e) {
+  return e.doubleObligation === "chicken-foot" ? Math.max(0, e.chickenFoot.toeCount - 1) : 0;
+}
+function bo(e = {}) {
+  const o = e.maxPips ?? G.maxPips;
+  return {
+    ...G,
+    ...e,
+    maxPips: o,
+    engineValue: e.engineValue ?? o,
+    chickenFoot: {
+      ...G.chickenFoot,
+      ...e.chickenFoot ?? {}
+    }
+  };
+}
+function Je(e, o) {
+  let t = e;
+  for (const n of o)
+    if (t = t?.feet?.[n.doubleIndex]?.[n.toeIndex], !t) return;
+  return t;
+}
+function U(e, o, t) {
+  if (t(e, o), !!e.feet)
+    for (const n of Object.keys(e.feet)) {
+      const r = Number(n);
+      e.feet[r].forEach((l, i) => {
+        U(l, [...o, { doubleIndex: r, toeIndex: i }], t);
+      });
+    }
+}
+function Qe(e) {
+  const o = [];
+  return U(e, [], (t, n) => {
+    t.dominoes.forEach((r, l) => {
+      if (r.value1 !== r.value2) return;
+      const i = l < t.dominoes.length - 1, s = t.feet?.[l]?.length ?? 0;
+      o.push({
+        path: n,
+        doubleIndex: l,
+        value: r.value1,
+        hasCenter: i,
+        sideToes: s,
+        answers: (i ? 1 : 0) + s
+      });
+    });
+  }), o;
+}
+function Ze(e, o) {
+  const t = Ge(o);
+  return t <= 0 ? [] : Qe(e).filter((n) => n.answers < t);
+}
+function He(e) {
+  const o = /* @__PURE__ */ new Set();
+  return U(e, [], (t) => {
+    for (const n of t.dominoes)
+      o.add(ce(n));
+  }), o;
+}
+function We(e, o, t) {
+  if (e.dominoes.length === 0)
+    return [
+      {
+        path: [],
+        attach: "run-tail",
+        value: o,
+        attachToDouble: !0,
+        // a train starts off the engine double
+        obligation: !1
+      }
+    ];
+  const n = Ze(e, t);
+  if (t.doubleObligation !== "none" && n.length > 0) {
+    const l = Ke(t), i = [];
+    for (const s of n) {
+      const a = Je(e, s.path);
+      a && (!s.hasCenter && s.doubleIndex === a.dominoes.length - 1 && i.push({
+        path: s.path,
+        attach: "run-tail",
+        value: s.value,
+        attachToDouble: !0,
+        obligation: !0
+      }), s.sideToes < l && i.push({
+        path: s.path,
+        attach: "side-toe",
+        value: s.value,
+        doubleIndex: s.doubleIndex,
+        toeSlot: s.sideToes,
+        attachToDouble: !0,
+        obligation: !0
+      }));
+    }
+    return i;
+  }
+  const r = [];
+  return U(e, [], (l, i) => {
+    const s = l.dominoes[l.dominoes.length - 1];
+    s && r.push({
+      path: i,
+      attach: "run-tail",
+      value: s.value2,
+      attachToDouble: de(s),
+      obligation: !1
+    });
+  }), r;
+}
+function xe(e, o, t, n) {
+  const r = [], l = fe(e, o.value);
+  return n.requireSequential && !l && r.push("value-mismatch"), n.requireUniqueTiles && t.has(ce(e)) && r.push("duplicate-tile"), !n.allowConsecutiveDoubles && o.attachToDouble && de(e) && r.push("consecutive-doubles"), { legal: r.length === 0, violations: r };
+}
+function wo(e, o, t, n, r) {
+  const l = We(e, o, r), i = [];
+  for (const s of l)
+    for (const a of t)
+      xe(a, s, n, r).legal && i.push({ end: s, tile: a });
+  return i;
+}
+function ge(e, o, t) {
+  if (o.length === 0)
+    return t(e);
+  const [n, ...r] = o, i = (e.feet?.[n.doubleIndex] ?? []).map(
+    (s, a) => a === n.toeIndex ? ge(s, r, t) : s
+  );
+  return {
+    ...e,
+    feet: { ...e.feet, [n.doubleIndex]: i }
+  };
+}
+function eo(e, o, t) {
+  const n = fe(o.tile, o.end.value) ?? { ...o.tile };
+  return ge(e, o.end.path, (r) => {
+    if (o.end.attach === "run-tail")
+      return { ...r, dominoes: [...r.dominoes, n] };
+    const l = o.end.doubleIndex ?? 0, i = o.end.toeSlot ?? r.feet?.[l]?.length ?? 0, s = r.feet?.[l] ? [...r.feet[l]] : [];
+    return s[i] = { dominoes: [n] }, {
+      ...r,
+      feet: { ...r.feet, [l]: s }
+    };
+  });
+}
+function So(e, o, t) {
+  const n = xe(
+    o.tile,
+    o.end,
+    He(e),
+    t
+  );
+  return n.legal ? { ok: !0, board: eo(e, o), violations: [] } : { ok: !1, board: e, violations: n.violations };
+}
+export {
+  ho as CHICKEN_FOOT_FIXTURES,
+  Ie as CHICKEN_FOOT_TOE_ANGLES,
+  X as DEFAULT_PIP_COLORS,
+  G as DEFAULT_RULES,
+  Re as DominoHub,
+  Ae as DominoTrain,
+  ie as DoubleTwelve,
+  fo as MexicanTrainGame,
+  no as PIP_COLORS,
+  Me as PIP_LAYOUTS,
+  go as TRAIN_FIXTURES,
+  eo as applyMove,
+  He as collectPlayedKeys,
+  Oe as computeTrainLayout,
+  ue as computeTrainTree,
+  ce as dominoKey,
+  co as dominoSetSize,
+  xe as evaluatePlacement,
+  Fe as flattenSegments,
+  uo as generateDominoSet,
+  Je as getBranchAt,
+  wo as getLegalMoves,
+  We as getOpenEnds,
+  Ce as getPipLayout,
+  lo as getPipStyle,
+  io as getTrainLayoutBounds,
+  Ze as getUnsatisfiedDoubles,
+  de as isDouble,
+  ro as mergePipColors,
+  fe as orientForConnection,
+  ao as otherEnd,
+  j as outwardPerpSign,
+  So as playMove,
+  Ge as requiredDoubleAnswers,
+  ze as resolvePipPosition,
+  le as resolvePipStyle,
+  bo as resolveRules,
+  Ke as sideToeSlots,
+  k as stepAlongTrain,
+  te as tileCorners,
+  so as tileHasValue,
+  F as tileKey,
+  ae as tilesOverlap,
+  vo as validateChickenFootChain,
+  po as validateTrainLayout,
+  xo as validateTrainTree
+};
+//# sourceMappingURL=index.js.map