cubing 0.20.2 → 0.21.0-pre12

package/dist/esm/{chunk-CWVB5RRW.js → chunk-YV3RT5PX.js}

@@ -1,515 +1,237 @@
 import {
   Alg,
-  Move,
-  experimentalIs
-} from "./chunk-YNB7QLBF.js";
+  Move
+} from "./chunk-BU5PUJK3.js";
 
-// src/cubing/puzzles/implementations/3x3x3/3x3x3.kpuzzle.json_.ts
-var cube3x3x3KPuzzle = {
-  name: "3x3x3",
-  orbits: {
-    EDGES: { numPieces: 12, orientations: 2 },
-    CORNERS: { numPieces: 8, orientations: 3 },
-    CENTERS: { numPieces: 6, orientations: 4 }
-  },
-  startPieces: {
-    EDGES: {
-      permutation: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
-      orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-    },
-    CORNERS: {
-      permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-      orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-    },
-    CENTERS: {
-      permutation: [0, 1, 2, 3, 4, 5],
-      orientation: [0, 0, 0, 0, 0, 0]
-    }
-  },
-  moves: {
-    U: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [1, 0, 0, 0, 0, 0]
+// src/cubing/protocol/binary/orbit-indexing.ts
+function identityPermutation(numElems) {
+  const arr = new Array(numElems);
+  for (let i = 0; i < numElems; i++) {
+    arr[i] = i;
+  }
+  return arr;
+}
+function orientationsToMask(radix, orientations) {
+  let val = 0;
+  for (const orientation of orientations) {
+    val *= radix;
+    val += orientation;
+  }
+  return val;
+}
+function maskToOrientations(radix, numElems, mask) {
+  const arr = [];
+  while (mask > 0) {
+    arr.push(mask % radix);
+    mask = Math.floor(mask / radix);
+  }
+  return new Array(numElems - arr.length).fill(0).concat(arr.reverse());
+}
+function permutationToLex(permutation) {
+  const n = permutation.length;
+  let lexicographicIdx = 0;
+  for (let i = 0; i < n - 1; i++) {
+    lexicographicIdx = lexicographicIdx * (n - i);
+    for (let j = i + 1; j < n; j++) {
+      if (permutation[i] > permutation[j]) {
+        lexicographicIdx += 1;
       }
-    },
-    y: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 5, 6, 7, 4, 10, 8, 11, 9],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 7, 4, 5, 6],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 2, 3, 4, 1, 5],
-        orientation: [1, 0, 0, 0, 0, 3]
+    }
+  }
+  return lexicographicIdx;
+}
+function lexToPermutation(numPieces, lexicographicIdx) {
+  const permutation = new Array(numPieces);
+  permutation[numPieces - 1] = 0;
+  for (let i = numPieces - 2; i >= 0; i--) {
+    permutation[i] = lexicographicIdx % (numPieces - i);
+    lexicographicIdx = Math.floor(lexicographicIdx / (numPieces - i));
+    for (let j = i + 1; j < numPieces; j++) {
+      if (permutation[j] >= permutation[i]) {
+        permutation[j] = permutation[j] + 1;
       }
-    },
-    x: {
-      EDGES: {
-        permutation: [4, 8, 0, 9, 6, 10, 2, 11, 5, 7, 1, 3],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [4, 0, 3, 5, 7, 6, 2, 1],
-        orientation: [2, 1, 2, 1, 1, 2, 1, 2]
-      },
-      CENTERS: {
-        permutation: [2, 1, 5, 3, 0, 4],
-        orientation: [0, 3, 0, 1, 2, 2]
+    }
+  }
+  return permutation;
+}
+
+// src/cubing/kpuzzle/transformations.ts
+var lasto;
+function isIdentity(omod, o) {
+  if (o === lasto) {
+    return true;
+  }
+  const perm = o.permutation;
+  const n = perm.length;
+  for (let idx = 0; idx < n; idx++) {
+    if (perm[idx] !== idx) {
+      return false;
+    }
+  }
+  if (omod > 1) {
+    const ori = o.orientation;
+    for (let idx = 0; idx < n; idx++) {
+      if (ori[idx] !== 0) {
+        return false;
       }
-    },
-    L: {
-      EDGES: {
-        permutation: [0, 1, 2, 11, 4, 5, 6, 9, 8, 3, 10, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
-        orientation: [0, 0, 2, 1, 0, 2, 1, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 1, 0, 0, 0, 0]
+    }
+  }
+  lasto = o;
+  return true;
+}
+function combineTransformations(def, t1, t2) {
+  const newTrans = {};
+  for (const orbitName in def.orbits) {
+    const oDef = def.orbits[orbitName];
+    const o1 = t1[orbitName];
+    const o2 = t2[orbitName];
+    if (isIdentity(oDef.orientations, o2)) {
+      newTrans[orbitName] = o1;
+    } else if (isIdentity(oDef.orientations, o1)) {
+      newTrans[orbitName] = o2;
+    } else {
+      const newPerm = new Array(oDef.numPieces);
+      if (oDef.orientations === 1) {
+        for (let idx = 0; idx < oDef.numPieces; idx++) {
+          newPerm[idx] = o1.permutation[o2.permutation[idx]];
+        }
+        newTrans[orbitName] = {
+          permutation: newPerm,
+          orientation: o1.orientation
+        };
+      } else {
+        const newOri = new Array(oDef.numPieces);
+        for (let idx = 0; idx < oDef.numPieces; idx++) {
+          newOri[idx] = (o1.orientation[o2.permutation[idx]] + o2.orientation[idx]) % oDef.orientations;
+          newPerm[idx] = o1.permutation[o2.permutation[idx]];
+        }
+        newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
       }
-    },
-    F: {
-      EDGES: {
-        permutation: [9, 1, 2, 3, 8, 5, 6, 7, 0, 4, 10, 11],
-        orientation: [1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0]
-      },
-      CORNERS: {
-        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 1, 0, 0, 0]
+    }
+  }
+  return newTrans;
+}
+function multiplyTransformations(def, t, amount) {
+  if (amount < 0) {
+    return multiplyTransformations(def, invertTransformation(def, t), -amount);
+  }
+  if (amount === 0) {
+    return identityTransformation(def);
+  }
+  if (amount === 1) {
+    return t;
+  }
+  let halfish = t;
+  if (amount !== 2) {
+    halfish = multiplyTransformations(def, t, Math.floor(amount / 2));
+  }
+  const twiceHalfish = combineTransformations(def, halfish, halfish);
+  if (amount % 2 === 0) {
+    return twiceHalfish;
+  } else {
+    return combineTransformations(def, t, twiceHalfish);
+  }
+}
+function identityTransformation(definition) {
+  const transformation = {};
+  for (const orbitName in definition.orbits) {
+    const orbitDefinition = definition.orbits[orbitName];
+    if (!lasto || lasto.permutation.length !== orbitDefinition.numPieces) {
+      const newPermutation = new Array(orbitDefinition.numPieces);
+      const newOrientation = new Array(orbitDefinition.numPieces);
+      for (let i = 0; i < orbitDefinition.numPieces; i++) {
+        newPermutation[i] = i;
+        newOrientation[i] = 0;
       }
-    },
-    R: {
-      EDGES: {
-        permutation: [0, 8, 2, 3, 4, 10, 6, 7, 5, 9, 1, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
-        orientation: [2, 1, 0, 0, 1, 0, 0, 2]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 1, 0, 0]
+      const orbitTransformation = {
+        permutation: newPermutation,
+        orientation: newOrientation
+      };
+      lasto = orbitTransformation;
+    }
+    transformation[orbitName] = lasto;
+  }
+  return transformation;
+}
+function invertTransformation(def, t) {
+  const newTrans = {};
+  for (const orbitName in def.orbits) {
+    const oDef = def.orbits[orbitName];
+    const o = t[orbitName];
+    if (isIdentity(oDef.orientations, o)) {
+      newTrans[orbitName] = o;
+    } else if (oDef.orientations === 1) {
+      const newPerm = new Array(oDef.numPieces);
+      for (let idx = 0; idx < oDef.numPieces; idx++) {
+        newPerm[o.permutation[idx]] = idx;
       }
-    },
-    B: {
-      EDGES: {
-        permutation: [0, 1, 10, 3, 4, 5, 11, 7, 8, 9, 6, 2],
-        orientation: [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1]
-      },
-      CORNERS: {
-        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
-        orientation: [0, 2, 1, 0, 0, 0, 2, 1]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 0, 1, 0]
-      }
-    },
-    D: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 8, 9, 10, 11],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 1, 2, 3, 4, 5],
-        orientation: [0, 0, 0, 0, 0, 1]
-      }
-    },
-    z: {
-      EDGES: {
-        permutation: [9, 3, 11, 7, 8, 1, 10, 5, 0, 4, 2, 6],
-        orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [3, 2, 6, 5, 0, 4, 7, 1],
-        orientation: [1, 2, 1, 2, 2, 1, 2, 1]
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 1, 1, 3, 1]
-      }
-    },
-    M: {
-      EDGES: {
-        permutation: [2, 1, 6, 3, 0, 5, 4, 7, 8, 9, 10, 11],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [4, 1, 0, 3, 5, 2],
-        orientation: [2, 0, 0, 0, 2, 0]
-      }
-    },
-    E: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 8, 10],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 4, 1, 2, 3, 5],
-        orientation: [0, 0, 0, 0, 0, 0]
-      }
-    },
-    S: {
-      EDGES: {
-        permutation: [0, 3, 2, 7, 4, 1, 6, 5, 8, 9, 10, 11],
-        orientation: [0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 0, 1, 0, 1]
-      }
-    },
-    u: {
-      EDGES: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 10, 8, 11, 9],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 2, 3, 4, 1, 5],
-        orientation: [1, 0, 0, 0, 0, 0]
-      }
-    },
-    l: {
-      EDGES: {
-        permutation: [2, 1, 6, 11, 0, 5, 4, 9, 8, 3, 10, 7],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
-        orientation: [0, 0, 2, 1, 0, 2, 1, 0]
-      },
-      CENTERS: {
-        permutation: [4, 1, 0, 3, 5, 2],
-        orientation: [2, 1, 0, 0, 2, 0]
-      }
-    },
-    f: {
-      EDGES: {
-        permutation: [9, 3, 2, 7, 8, 1, 6, 5, 0, 4, 10, 11],
-        orientation: [1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0]
-      },
-      CORNERS: {
-        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0]
-      },
-      CENTERS: {
-        permutation: [1, 5, 2, 0, 4, 3],
-        orientation: [1, 1, 1, 1, 0, 1]
-      }
-    },
-    r: {
-      EDGES: {
-        permutation: [4, 8, 0, 3, 6, 10, 2, 7, 5, 9, 1, 11],
-        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-      },
-      CORNERS: {
-        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
-        orientation: [2, 1, 0, 0, 1, 0, 0, 2]
-      },
-      CENTERS: {
-        permutation: [2, 1, 5, 3, 0, 4],
-        orientation: [0, 0, 0, 1, 2, 2]
-      }
-    },
-    b: {
-      EDGES: {
-        permutation: [8, 5, 2, 1, 9, 7, 6, 3, 4, 0, 10, 11],
-        orientation: [1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0]
-      },
-      CORNERS: {
-        permutation: [4, 1, 2, 0, 5, 3, 6, 7],
-        orientation: [1, 0, 0, 2, 2, 1, 0, 0]
-      },
-      CENTERS: {
-        permutation: [3, 0, 2, 5, 4, 1],
-        orientation: [3, 3, 3, 3, 0, 3]
-      }
-    },
-    d: {
-      EDGES: {
-        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 9, 11, 8, 10],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-      },
-      CORNERS: {
-        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
-        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-      },
-      CENTERS: {
-        permutation: [0, 4, 1, 2, 3, 5],
-        orientation: [0, 0, 0, 0, 0, 1]
+      newTrans[orbitName] = {
+        permutation: newPerm,
+        orientation: o.orientation
+      };
+    } else {
+      const newPerm = new Array(oDef.numPieces);
+      const newOri = new Array(oDef.numPieces);
+      for (let idx = 0; idx < oDef.numPieces; idx++) {
+        const fromIdx = o.permutation[idx];
+        newPerm[fromIdx] = idx;
+        newOri[fromIdx] = (oDef.orientations - o.orientation[idx] + oDef.orientations) % oDef.orientations;
       }
+      newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
     }
   }
-};
-cube3x3x3KPuzzle.moves["Uw"] = cube3x3x3KPuzzle.moves["u"];
-cube3x3x3KPuzzle.moves["Lw"] = cube3x3x3KPuzzle.moves["l"];
-cube3x3x3KPuzzle.moves["Fw"] = cube3x3x3KPuzzle.moves["f"];
-cube3x3x3KPuzzle.moves["Rw"] = cube3x3x3KPuzzle.moves["r"];
-cube3x3x3KPuzzle.moves["Bw"] = cube3x3x3KPuzzle.moves["b"];
-cube3x3x3KPuzzle.moves["Dw"] = cube3x3x3KPuzzle.moves["d"];
-cube3x3x3KPuzzle.moves["Rv"] = cube3x3x3KPuzzle.moves["x"];
-cube3x3x3KPuzzle.moves["Uv"] = cube3x3x3KPuzzle.moves["y"];
-cube3x3x3KPuzzle.moves["Fv"] = cube3x3x3KPuzzle.moves["z"];
-cube3x3x3KPuzzle.moves["Lv"] = {
-  EDGES: {
-    permutation: [2, 10, 6, 11, 0, 8, 4, 9, 1, 3, 5, 7],
-    orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
-  },
-  CORNERS: {
-    permutation: [1, 7, 6, 2, 0, 3, 5, 4],
-    orientation: [2, 1, 2, 1, 1, 2, 1, 2]
-  },
-  CENTERS: {
-    permutation: [4, 1, 0, 3, 5, 2],
-    orientation: [2, 1, 0, 3, 2, 0]
-  }
-};
-cube3x3x3KPuzzle.moves["Dv"] = {
-  EDGES: {
-    permutation: [3, 0, 1, 2, 7, 4, 5, 6, 9, 11, 8, 10],
-    orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
-  },
-  CORNERS: {
-    permutation: [3, 0, 1, 2, 5, 6, 7, 4],
-    orientation: [0, 0, 0, 0, 0, 0, 0, 0]
-  },
-  CENTERS: {
-    permutation: [0, 4, 1, 2, 3, 5],
-    orientation: [3, 0, 0, 0, 0, 1]
-  }
-};
-cube3x3x3KPuzzle.moves["Bv"] = {
-  EDGES: {
-    permutation: [8, 5, 10, 1, 9, 7, 11, 3, 4, 0, 6, 2],
-    orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-  },
-  CORNERS: {
-    permutation: [4, 7, 1, 0, 5, 3, 2, 6],
-    orientation: [1, 2, 1, 2, 2, 1, 2, 1]
-  },
-  CENTERS: {
-    permutation: [3, 0, 2, 5, 4, 1],
-    orientation: [3, 3, 3, 3, 1, 3]
+  return newTrans;
+}
+function gcd(a, b) {
+  if (b) {
+    return gcd(b, a % b);
   }
-};
-
-// src/cubing/kpuzzle/transformations.ts
-var lasto;
-function isIdentity(omod, o2) {
-  if (o2 === lasto) {
-    return true;
+  return a;
+}
+function transformationOrder(def, t) {
+  let r = 1;
+  for (const orbitName in def.orbits) {
+    const oDef = def.orbits[orbitName];
+    const o = t[orbitName];
+    const d = new Array(oDef.numPieces);
+    for (let idx = 0; idx < oDef.numPieces; idx++) {
+      if (!d[idx]) {
+        let w = idx;
+        let om = 0;
+        let pm = 0;
+        for (; ; ) {
+          d[w] = true;
+          om = om + o.orientation[w];
+          pm = pm + 1;
+          w = o.permutation[w];
+          if (w === idx) {
+            break;
+          }
+        }
+        if (om !== 0) {
+          pm = pm * oDef.orientations / gcd(oDef.orientations, om);
+        }
+        r = r * pm / gcd(r, pm);
+      }
+    }
   }
-  const perm = o2.permutation;
-  const n = perm.length;
-  for (let idx = 0; idx < n; idx++) {
-    if (perm[idx] !== idx) {
+  return r;
+}
+function areOrbitTransformationsEquivalent(def, orbitName, t1, t2, options = {}) {
+  const oDef = def.orbits[orbitName];
+  const o1 = t1[orbitName];
+  const o2 = t2[orbitName];
+  for (let idx = 0; idx < oDef.numPieces; idx++) {
+    if (!options?.ignoreOrientation && o1.orientation[idx] !== o2.orientation[idx]) {
       return false;
     }
-  }
-  if (omod > 1) {
-    const ori = o2.orientation;
-    for (let idx = 0; idx < n; idx++) {
-      if (ori[idx] !== 0) {
-        return false;
-      }
+    if (!options?.ignorePermutation && o1.permutation[idx] !== o2.permutation[idx]) {
+      return false;
     }
   }
-  lasto = o2;
   return true;
 }
-function combineTransformations(def, t1, t2) {
-  const newTrans = {};
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o1 = t1[orbitName];
-    const o2 = t2[orbitName];
-    if (isIdentity(oDef.orientations, o2)) {
-      newTrans[orbitName] = o1;
-    } else if (isIdentity(oDef.orientations, o1)) {
-      newTrans[orbitName] = o2;
-    } else {
-      const newPerm = new Array(oDef.numPieces);
-      if (oDef.orientations === 1) {
-        for (let idx = 0; idx < oDef.numPieces; idx++) {
-          newPerm[idx] = o1.permutation[o2.permutation[idx]];
-        }
-        newTrans[orbitName] = {
-          permutation: newPerm,
-          orientation: o1.orientation
-        };
-      } else {
-        const newOri = new Array(oDef.numPieces);
-        for (let idx = 0; idx < oDef.numPieces; idx++) {
-          newOri[idx] = (o1.orientation[o2.permutation[idx]] + o2.orientation[idx]) % oDef.orientations;
-          newPerm[idx] = o1.permutation[o2.permutation[idx]];
-        }
-        newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
-      }
-    }
-  }
-  return newTrans;
-}
-function multiplyTransformations(def, t, amount) {
-  if (amount < 0) {
-    return multiplyTransformations(def, invertTransformation(def, t), -amount);
-  }
-  if (amount === 0) {
-    return identityTransformation(def);
-  }
-  if (amount === 1) {
-    return t;
-  }
-  let halfish = t;
-  if (amount !== 2) {
-    halfish = multiplyTransformations(def, t, Math.floor(amount / 2));
-  }
-  const twiceHalfish = combineTransformations(def, halfish, halfish);
-  if (amount % 2 === 0) {
-    return twiceHalfish;
-  } else {
-    return combineTransformations(def, t, twiceHalfish);
-  }
-}
-function identityTransformation(definition) {
-  const transformation = {};
-  for (const orbitName in definition.orbits) {
-    const orbitDefinition = definition.orbits[orbitName];
-    if (!lasto || lasto.permutation.length !== orbitDefinition.numPieces) {
-      const newPermutation = new Array(orbitDefinition.numPieces);
-      const newOrientation = new Array(orbitDefinition.numPieces);
-      for (let i2 = 0; i2 < orbitDefinition.numPieces; i2++) {
-        newPermutation[i2] = i2;
-        newOrientation[i2] = 0;
-      }
-      const orbitTransformation = {
-        permutation: newPermutation,
-        orientation: newOrientation
-      };
-      lasto = orbitTransformation;
-    }
-    transformation[orbitName] = lasto;
-  }
-  return transformation;
-}
-function invertTransformation(def, t) {
-  const newTrans = {};
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o2 = t[orbitName];
-    if (isIdentity(oDef.orientations, o2)) {
-      newTrans[orbitName] = o2;
-    } else if (oDef.orientations === 1) {
-      const newPerm = new Array(oDef.numPieces);
-      for (let idx = 0; idx < oDef.numPieces; idx++) {
-        newPerm[o2.permutation[idx]] = idx;
-      }
-      newTrans[orbitName] = {
-        permutation: newPerm,
-        orientation: o2.orientation
-      };
-    } else {
-      const newPerm = new Array(oDef.numPieces);
-      const newOri = new Array(oDef.numPieces);
-      for (let idx = 0; idx < oDef.numPieces; idx++) {
-        const fromIdx = o2.permutation[idx];
-        newPerm[fromIdx] = idx;
-        newOri[fromIdx] = (oDef.orientations - o2.orientation[idx] + oDef.orientations) % oDef.orientations;
-      }
-      newTrans[orbitName] = { permutation: newPerm, orientation: newOri };
-    }
-  }
-  return newTrans;
-}
-function gcd(a, b) {
-  if (b) {
-    return gcd(b, a % b);
-  }
-  return a;
-}
-function transformationOrder(def, t) {
-  let r2 = 1;
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o2 = t[orbitName];
-    const d2 = new Array(oDef.numPieces);
-    for (let idx = 0; idx < oDef.numPieces; idx++) {
-      if (!d2[idx]) {
-        let w = idx;
-        let om = 0;
-        let pm = 0;
-        for (; ; ) {
-          d2[w] = true;
-          om = om + o2.orientation[w];
-          pm = pm + 1;
-          w = o2.permutation[w];
-          if (w === idx) {
-            break;
-          }
-        }
-        if (om !== 0) {
-          pm = pm * oDef.orientations / gcd(oDef.orientations, om);
-        }
-        r2 = r2 * pm / gcd(r2, pm);
-      }
-    }
-  }
-  return r2;
-}
-function areOrbitTransformationsEquivalent(def, orbitName, t1, t2, options = {}) {
-  const oDef = def.orbits[orbitName];
-  const o1 = t1[orbitName];
-  const o2 = t2[orbitName];
-  for (let idx = 0; idx < oDef.numPieces; idx++) {
-    if (!options?.ignoreOrientation && o1.orientation[idx] !== o2.orientation[idx]) {
-      return false;
-    }
-    if (!options?.ignorePermutation && o1.permutation[idx] !== o2.permutation[idx]) {
-      return false;
-    }
-  }
-  return true;
-}
-function areTransformationsEquivalent(def, t1, t2) {
+function areTransformationsEquivalent(def, t1, t2) {
   for (const orbitName in def.orbits) {
     if (!areOrbitTransformationsEquivalent(def, orbitName, t1, t2)) {
       return false;
@@ -549,28 +271,28 @@ var KPuzzleMoveNotation = class {
   }
   lookupMove(move) {
     const key = move.toString();
-    let r2 = this.cache[key];
-    if (r2) {
-      return r2;
+    let r = this.cache[key];
+    if (r) {
+      return r;
     }
     const quantumKey = move.quantum.toString();
-    r2 = this.def.moves[quantumKey];
-    if (r2) {
-      r2 = multiplyTransformations(this.def, r2, move.amount);
-      this.cache[key] = r2;
+    r = this.def.moves[quantumKey];
+    if (r) {
+      r = multiplyTransformations(this.def, r, move.amount);
+      this.cache[key] = r;
     } else {
-      r2 = this.def.moves[move.toString()];
-      if (r2) {
-        this.cache[key] = r2;
+      r = this.def.moves[move.toString()];
+      if (r) {
+        this.cache[key] = r;
       } else {
-        r2 = this.def.moves[move.invert().toString()];
-        if (r2) {
-          r2 = multiplyTransformations(this.def, r2, -1);
-          this.cache[key] = r2;
+        r = this.def.moves[move.invert().toString()];
+        if (r) {
+          r = multiplyTransformations(this.def, r, -1);
+          this.cache[key] = r;
         }
       }
     }
-    return r2;
+    return r;
   }
 };
 var KPuzzle = class {
@@ -649,26 +371,26 @@ var Canonicalizer = class {
       this.transforms.push([id, basemoves[mv1]]);
     }
     this.baseMoveCount = this.movenames.length;
-    for (let i2 = 0; i2 < this.baseMoveCount; i2++) {
+    for (let i = 0; i < this.baseMoveCount; i++) {
       this.commutes.push([]);
-      const t1 = this.transforms[i2][1];
+      const t1 = this.transforms[i][1];
       for (let j = 0; j < this.baseMoveCount; j++) {
         const t2 = this.transforms[j][1];
         const ab = combineTransformations(def, t1, t2);
         const ba = combineTransformations(def, t2, t1);
-        this.commutes[i2][j] = areTransformationsEquivalent(def, ab, ba);
+        this.commutes[i][j] = areTransformationsEquivalent(def, ab, ba);
       }
     }
-    for (let i2 = 0; i2 < this.baseMoveCount; i2++) {
-      const t1 = this.transforms[i2][1];
+    for (let i = 0; i < this.baseMoveCount; i++) {
+      const t1 = this.transforms[i][1];
       let ct = t1;
       let order = 1;
       for (let mult = 2; !areTransformationsEquivalent(def, id, ct); mult++) {
         order++;
         ct = combineTransformations(def, ct, t1);
-        this.transforms[i2].push(ct);
+        this.transforms[i].push(ct);
       }
-      this.moveorder[i2] = order;
+      this.moveorder[i] = order;
     }
   }
   blockMoveToInternalMove(move) {
@@ -710,14 +432,14 @@ var SearchSequence = class {
     }
   }
   clone() {
-    const r2 = new SearchSequence(this.canon, this.trans);
-    r2.moveseq = [...this.moveseq];
-    return r2;
+    const r = new SearchSequence(this.canon, this.trans);
+    r.moveseq = [...this.moveseq];
+    return r;
   }
   mergeOneMove(mv) {
-    const r2 = this.onlyMergeOneMove(mv);
+    const r = this.onlyMergeOneMove(mv);
     this.trans = combineTransformations(this.canon.def, this.trans, mv.getTransformation(this.canon));
-    return r2;
+    return r;
   }
   appendOneMove(mv) {
     this.moveseq.push(mv);
@@ -764,21 +486,21 @@ var SearchSequence = class {
     return 1;
   }
   mergeSequence(seq) {
-    let r2 = this.moveseq.length;
-    for (let i2 = 0; i2 < seq.moveseq.length; i2++) {
-      const mv = seq.moveseq[i2];
-      const d2 = this.onlyMergeOneMove(mv);
-      r2 += d2;
+    let r = this.moveseq.length;
+    for (let i = 0; i < seq.moveseq.length; i++) {
+      const mv = seq.moveseq[i];
+      const d = this.onlyMergeOneMove(mv);
+      r += d;
     }
     this.trans = combineTransformations(this.canon.def, this.trans, seq.trans);
-    return r2;
+    return r;
   }
   getSequenceAsString() {
-    const r2 = [];
+    const r = [];
     for (const mv of this.moveseq) {
-      r2.push(mv.asString(this.canon));
+      r.push(mv.asString(this.canon));
     }
-    return r2.join(" ");
+    return r.join(" ");
   }
 };
 var CanonicalSequenceIterator = class {
@@ -820,13 +542,13 @@ var CanonicalSequenceIterator = class {
     return null;
   }
   *generator() {
-    for (let d2 = 0; ; d2++) {
-      yield* this.genSequence(d2, []);
+    for (let d = 0; ; d++) {
+      yield* this.genSequence(d, []);
     }
   }
   *genSequenceTree(canonstate) {
-    const r2 = yield this.ss;
-    if (r2 > 0) {
+    const r = yield this.ss;
+    if (r > 0) {
       return null;
     }
     for (let base = 0; base < this.canon.baseMoveCount; base++) {
@@ -906,12 +628,12 @@ peg$SyntaxError.buildMessage = function(expected, found) {
   }
   function describeExpected(expected2) {
     var descriptions = expected2.map(describeExpectation);
-    var i2, j;
+    var i, j;
     descriptions.sort();
     if (descriptions.length > 0) {
-      for (i2 = 1, j = 1; i2 < descriptions.length; i2++) {
-        if (descriptions[i2 - 1] !== descriptions[i2]) {
-          descriptions[j] = descriptions[i2];
+      for (i = 1, j = 1; i < descriptions.length; i++) {
+        if (descriptions[i - 1] !== descriptions[i]) {
+          descriptions[j] = descriptions[i];
           j++;
         }
       }
@@ -1861,8 +1583,8 @@ function peg$parse(input, options) {
         const oldOrientation = moveOrbit.orientation;
         const perm = moveOrbit.permutation;
         const newOrientation = new Array(oldOrientation.length);
-        for (let i2 = 0; i2 < perm.length; i2++) {
-          newOrientation[i2] = oldOrientation[perm[i2]];
+        for (let i = 0; i < perm.length; i++) {
+          newOrientation[i] = oldOrientation[perm[i]];
         }
         moveOrbit.orientation = newOrientation;
       }
@@ -2032,85 +1754,372 @@ var KPuzzleSVGWrapper = class {
       }
     }
   }
-  newGradient(id, originalColor) {
-    const grad = document.createElementNS(xmlns, "radialGradient");
-    grad.setAttribute("id", `grad-${this.svgID}-${id}`);
-    grad.setAttribute("r", `70.7107%`);
-    const stopDefs = [
-      { offset: 0, color: originalColor },
-      { offset: 0, color: originalColor },
-      { offset: 0, color: "black" },
-      { offset: 0, color: "black" },
-      { offset: 0, color: originalColor },
-      { offset: 100, color: originalColor }
-    ];
-    for (const stopDef of stopDefs) {
-      const stop = document.createElementNS(xmlns, "stop");
-      stop.setAttribute("offset", `${stopDef.offset}%`);
-      stop.setAttribute("stop-color", stopDef.color);
-      stop.setAttribute("stop-opacity", "1");
-      grad.appendChild(stop);
-    }
-    return grad;
+  newGradient(id, originalColor) {
+    const grad = document.createElementNS(xmlns, "radialGradient");
+    grad.setAttribute("id", `grad-${this.svgID}-${id}`);
+    grad.setAttribute("r", `70.7107%`);
+    const stopDefs = [
+      { offset: 0, color: originalColor },
+      { offset: 0, color: originalColor },
+      { offset: 0, color: "black" },
+      { offset: 0, color: "black" },
+      { offset: 0, color: originalColor },
+      { offset: 100, color: originalColor }
+    ];
+    for (const stopDef of stopDefs) {
+      const stop = document.createElementNS(xmlns, "stop");
+      stop.setAttribute("offset", `${stopDef.offset}%`);
+      stop.setAttribute("stop-color", stopDef.color);
+      stop.setAttribute("stop-opacity", "1");
+      grad.appendChild(stop);
+    }
+    return grad;
+  }
+  elementID(orbitName, idx, orientation) {
+    return orbitName + "-l" + idx + "-o" + orientation;
+  }
+  elementByID(id) {
+    return this.element.querySelector("#" + id);
+  }
+};
+
+// src/cubing/kpuzzle/3x3x3/3x3x3.kpuzzle.json.ts
+var cube3x3x3KPuzzle = {
+  name: "3x3x3",
+  orbits: {
+    EDGES: { numPieces: 12, orientations: 2 },
+    CORNERS: { numPieces: 8, orientations: 3 },
+    CENTERS: { numPieces: 6, orientations: 4 }
+  },
+  startPieces: {
+    EDGES: {
+      permutation: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+      orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    CORNERS: {
+      permutation: [0, 1, 2, 3, 4, 5, 6, 7],
+      orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+    },
+    CENTERS: {
+      permutation: [0, 1, 2, 3, 4, 5],
+      orientation: [0, 0, 0, 0, 0, 0]
+    }
+  },
+  moves: {
+    U: {
+      EDGES: {
+        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 8, 9, 10, 11],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [0, 1, 2, 3, 4, 5],
+        orientation: [1, 0, 0, 0, 0, 0]
+      }
+    },
+    y: {
+      EDGES: {
+        permutation: [1, 2, 3, 0, 5, 6, 7, 4, 10, 8, 11, 9],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
+      },
+      CORNERS: {
+        permutation: [1, 2, 3, 0, 7, 4, 5, 6],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [0, 2, 3, 4, 1, 5],
+        orientation: [1, 0, 0, 0, 0, 3]
+      }
+    },
+    x: {
+      EDGES: {
+        permutation: [4, 8, 0, 9, 6, 10, 2, 11, 5, 7, 1, 3],
+        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [4, 0, 3, 5, 7, 6, 2, 1],
+        orientation: [2, 1, 2, 1, 1, 2, 1, 2]
+      },
+      CENTERS: {
+        permutation: [2, 1, 5, 3, 0, 4],
+        orientation: [0, 3, 0, 1, 2, 2]
+      }
+    },
+    L: {
+      EDGES: {
+        permutation: [0, 1, 2, 11, 4, 5, 6, 9, 8, 3, 10, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
+        orientation: [0, 0, 2, 1, 0, 2, 1, 0]
+      },
+      CENTERS: {
+        permutation: [0, 1, 2, 3, 4, 5],
+        orientation: [0, 1, 0, 0, 0, 0]
+      }
+    },
+    F: {
+      EDGES: {
+        permutation: [9, 1, 2, 3, 8, 5, 6, 7, 0, 4, 10, 11],
+        orientation: [1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0]
+      },
+      CORNERS: {
+        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
+        orientation: [1, 0, 0, 2, 2, 1, 0, 0]
+      },
+      CENTERS: {
+        permutation: [0, 1, 2, 3, 4, 5],
+        orientation: [0, 0, 1, 0, 0, 0]
+      }
+    },
+    R: {
+      EDGES: {
+        permutation: [0, 8, 2, 3, 4, 10, 6, 7, 5, 9, 1, 11],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
+        orientation: [2, 1, 0, 0, 1, 0, 0, 2]
+      },
+      CENTERS: {
+        permutation: [0, 1, 2, 3, 4, 5],
+        orientation: [0, 0, 0, 1, 0, 0]
+      }
+    },
+    B: {
+      EDGES: {
+        permutation: [0, 1, 10, 3, 4, 5, 11, 7, 8, 9, 6, 2],
+        orientation: [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1]
+      },
+      CORNERS: {
+        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
+        orientation: [0, 2, 1, 0, 0, 0, 2, 1]
+      },
+      CENTERS: {
+        permutation: [0, 1, 2, 3, 4, 5],
+        orientation: [0, 0, 0, 0, 1, 0]
+      }
+    },
+    D: {
+      EDGES: {
+        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 8, 9, 10, 11],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [0, 1, 2, 3, 4, 5],
+        orientation: [0, 0, 0, 0, 0, 1]
+      }
+    },
+    z: {
+      EDGES: {
+        permutation: [9, 3, 11, 7, 8, 1, 10, 5, 0, 4, 2, 6],
+        orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+      },
+      CORNERS: {
+        permutation: [3, 2, 6, 5, 0, 4, 7, 1],
+        orientation: [1, 2, 1, 2, 2, 1, 2, 1]
+      },
+      CENTERS: {
+        permutation: [1, 5, 2, 0, 4, 3],
+        orientation: [1, 1, 1, 1, 3, 1]
+      }
+    },
+    M: {
+      EDGES: {
+        permutation: [2, 1, 6, 3, 0, 5, 4, 7, 8, 9, 10, 11],
+        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [4, 1, 0, 3, 5, 2],
+        orientation: [2, 0, 0, 0, 2, 0]
+      }
+    },
+    E: {
+      EDGES: {
+        permutation: [0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 8, 10],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
+      },
+      CORNERS: {
+        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [0, 4, 1, 2, 3, 5],
+        orientation: [0, 0, 0, 0, 0, 0]
+      }
+    },
+    S: {
+      EDGES: {
+        permutation: [0, 3, 2, 7, 4, 1, 6, 5, 8, 9, 10, 11],
+        orientation: [0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [0, 1, 2, 3, 4, 5, 6, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [1, 5, 2, 0, 4, 3],
+        orientation: [1, 1, 0, 1, 0, 1]
+      }
+    },
+    u: {
+      EDGES: {
+        permutation: [1, 2, 3, 0, 4, 5, 6, 7, 10, 8, 11, 9],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
+      },
+      CORNERS: {
+        permutation: [1, 2, 3, 0, 4, 5, 6, 7],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [0, 2, 3, 4, 1, 5],
+        orientation: [1, 0, 0, 0, 0, 0]
+      }
+    },
+    l: {
+      EDGES: {
+        permutation: [2, 1, 6, 11, 0, 5, 4, 9, 8, 3, 10, 7],
+        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [0, 1, 6, 2, 4, 3, 5, 7],
+        orientation: [0, 0, 2, 1, 0, 2, 1, 0]
+      },
+      CENTERS: {
+        permutation: [4, 1, 0, 3, 5, 2],
+        orientation: [2, 1, 0, 0, 2, 0]
+      }
+    },
+    f: {
+      EDGES: {
+        permutation: [9, 3, 2, 7, 8, 1, 6, 5, 0, 4, 10, 11],
+        orientation: [1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0]
+      },
+      CORNERS: {
+        permutation: [3, 1, 2, 5, 0, 4, 6, 7],
+        orientation: [1, 0, 0, 2, 2, 1, 0, 0]
+      },
+      CENTERS: {
+        permutation: [1, 5, 2, 0, 4, 3],
+        orientation: [1, 1, 1, 1, 0, 1]
+      }
+    },
+    r: {
+      EDGES: {
+        permutation: [4, 8, 0, 3, 6, 10, 2, 7, 5, 9, 1, 11],
+        orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
+      },
+      CORNERS: {
+        permutation: [4, 0, 2, 3, 7, 5, 6, 1],
+        orientation: [2, 1, 0, 0, 1, 0, 0, 2]
+      },
+      CENTERS: {
+        permutation: [2, 1, 5, 3, 0, 4],
+        orientation: [0, 0, 0, 1, 2, 2]
+      }
+    },
+    b: {
+      EDGES: {
+        permutation: [0, 5, 10, 1, 4, 7, 11, 3, 8, 9, 6, 2],
+        orientation: [0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1]
+      },
+      CORNERS: {
+        permutation: [0, 7, 1, 3, 4, 5, 2, 6],
+        orientation: [0, 2, 1, 0, 0, 0, 2, 1]
+      },
+      CENTERS: {
+        permutation: [3, 0, 2, 5, 4, 1],
+        orientation: [3, 3, 0, 3, 1, 3]
+      }
+    },
+    d: {
+      EDGES: {
+        permutation: [0, 1, 2, 3, 7, 4, 5, 6, 9, 11, 8, 10],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
+      },
+      CORNERS: {
+        permutation: [0, 1, 2, 3, 5, 6, 7, 4],
+        orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+      },
+      CENTERS: {
+        permutation: [0, 4, 1, 2, 3, 5],
+        orientation: [0, 0, 0, 0, 0, 1]
+      }
+    }
+  }
+};
+cube3x3x3KPuzzle.moves["Uw"] = cube3x3x3KPuzzle.moves["u"];
+cube3x3x3KPuzzle.moves["Lw"] = cube3x3x3KPuzzle.moves["l"];
+cube3x3x3KPuzzle.moves["Fw"] = cube3x3x3KPuzzle.moves["f"];
+cube3x3x3KPuzzle.moves["Rw"] = cube3x3x3KPuzzle.moves["r"];
+cube3x3x3KPuzzle.moves["Bw"] = cube3x3x3KPuzzle.moves["b"];
+cube3x3x3KPuzzle.moves["Dw"] = cube3x3x3KPuzzle.moves["d"];
+cube3x3x3KPuzzle.moves["Rv"] = cube3x3x3KPuzzle.moves["x"];
+cube3x3x3KPuzzle.moves["Uv"] = cube3x3x3KPuzzle.moves["y"];
+cube3x3x3KPuzzle.moves["Fv"] = cube3x3x3KPuzzle.moves["z"];
+cube3x3x3KPuzzle.moves["Lv"] = {
+  EDGES: {
+    permutation: [2, 10, 6, 11, 0, 8, 4, 9, 1, 3, 5, 7],
+    orientation: [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0]
+  },
+  CORNERS: {
+    permutation: [1, 7, 6, 2, 0, 3, 5, 4],
+    orientation: [2, 1, 2, 1, 1, 2, 1, 2]
+  },
+  CENTERS: {
+    permutation: [4, 1, 0, 3, 5, 2],
+    orientation: [2, 1, 0, 3, 2, 0]
   }
-  elementID(orbitName, idx, orientation) {
-    return orbitName + "-l" + idx + "-o" + orientation;
+};
+cube3x3x3KPuzzle.moves["Dv"] = {
+  EDGES: {
+    permutation: [3, 0, 1, 2, 7, 4, 5, 6, 9, 11, 8, 10],
+    orientation: [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1]
+  },
+  CORNERS: {
+    permutation: [3, 0, 1, 2, 5, 6, 7, 4],
+    orientation: [0, 0, 0, 0, 0, 0, 0, 0]
+  },
+  CENTERS: {
+    permutation: [0, 4, 1, 2, 3, 5],
+    orientation: [3, 0, 0, 0, 0, 1]
   }
-  elementByID(id) {
-    return this.element.querySelector("#" + id);
+};
+cube3x3x3KPuzzle.moves["Bv"] = {
+  EDGES: {
+    permutation: [8, 5, 10, 1, 9, 7, 11, 3, 4, 0, 6, 2],
+    orientation: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+  },
+  CORNERS: {
+    permutation: [4, 7, 1, 0, 5, 3, 2, 6],
+    orientation: [1, 2, 1, 2, 2, 1, 2, 1]
+  },
+  CENTERS: {
+    permutation: [3, 0, 2, 5, 4, 1],
+    orientation: [3, 3, 3, 3, 1, 3]
   }
 };
 
-// src/cubing/protocol/binary/orbit-indexing.ts
-function identityPermutation(numElems) {
-  const arr = new Array(numElems);
-  for (let i2 = 0; i2 < numElems; i2++) {
-    arr[i2] = i2;
-  }
-  return arr;
-}
-function orientationsToMask(radix, orientations) {
-  let val = 0;
-  for (const orientation of orientations) {
-    val *= radix;
-    val += orientation;
-  }
-  return val;
-}
-function maskToOrientations(radix, numElems, mask) {
-  const arr = [];
-  while (mask > 0) {
-    arr.push(mask % radix);
-    mask = Math.floor(mask / radix);
-  }
-  return new Array(numElems - arr.length).fill(0).concat(arr.reverse());
-}
-function permutationToLex(permutation) {
-  const n = permutation.length;
-  let lexicographicIdx = 0;
-  for (let i2 = 0; i2 < n - 1; i2++) {
-    lexicographicIdx = lexicographicIdx * (n - i2);
-    for (let j = i2 + 1; j < n; j++) {
-      if (permutation[i2] > permutation[j]) {
-        lexicographicIdx += 1;
-      }
-    }
-  }
-  return lexicographicIdx;
-}
-function lexToPermutation(numPieces, lexicographicIdx) {
-  const permutation = new Array(numPieces);
-  permutation[numPieces - 1] = 0;
-  for (let i2 = numPieces - 2; i2 >= 0; i2--) {
-    permutation[i2] = lexicographicIdx % (numPieces - i2);
-    lexicographicIdx = Math.floor(lexicographicIdx / (numPieces - i2));
-    for (let j = i2 + 1; j < numPieces; j++) {
-      if (permutation[j] >= permutation[i2]) {
-        permutation[j] = permutation[j] + 1;
-      }
-    }
+// src/cubing/kpuzzle/puzzle-orientation.ts
+function experimentalIs3x3x3Solved(transformation, options) {
+  const normalized = normalizePuzzleOrientation(transformation);
+  if (options.ignoreCenterOrientation) {
+    return areOrbitTransformationsEquivalent(cube3x3x3KPuzzle, "EDGES", normalized, cube3x3x3KPuzzle.startPieces) && areOrbitTransformationsEquivalent(cube3x3x3KPuzzle, "CORNERS", normalized, cube3x3x3KPuzzle.startPieces);
+  } else {
+    return areTransformationsEquivalent(cube3x3x3KPuzzle, normalized, cube3x3x3KPuzzle.startPieces);
   }
-  return permutation;
 }
 
 // src/cubing/protocol/binary/puzzle-orientation.ts
@@ -2137,7 +2146,7 @@ var puzzleOrientationCache = new Array(6).fill(0).map(() => {
   for (const uAlg of uAlgs) {
     orientationKpuzzle.reset();
     orientationKpuzzle.applyAlg(uAlg);
-    for (let i2 = 0; i2 < 4; i2++) {
+    for (let i = 0; i < 4; i++) {
       orientationKpuzzle.applyAlg(yAlg);
       const [idxU, idxL] = puzzleOrientationIdx(orientationKpuzzle.state);
       puzzleOrientationCache[idxU][idxL] = invertTransformation(cube3x3x3KPuzzle, orientationKpuzzle.state);
@@ -2184,9 +2193,9 @@ function concatBinary(bitLengths, values) {
   let at = 0;
   let bits = 0;
   let accum = 0;
-  for (let i2 = 0; i2 < bitLengths.length; i2++) {
-    accum = accum << bitLengths[i2] | values[i2];
-    bits += bitLengths[i2];
+  for (let i = 0; i < bitLengths.length; i++) {
+    accum = accum << bitLengths[i] | values[i];
+    bits += bitLengths[i];
     while (bits >= 8) {
       buffy[at++] = accum >> bits - 8;
       bits -= 8;
@@ -2320,667 +2329,6 @@ function spacedHexToBuffer(hex) {
   return new Uint8Array(hex.split(" ").map((c) => parseInt(c, 16)));
 }
 
-// src/cubing/kpuzzle/puzzle-orientation.ts
-function experimentalIs3x3x3Solved(transformation, options) {
-  const normalized = normalizePuzzleOrientation(transformation);
-  if (options.ignoreCenterOrientation) {
-    return areOrbitTransformationsEquivalent(cube3x3x3KPuzzle, "EDGES", normalized, cube3x3x3KPuzzle.startPieces) && areOrbitTransformationsEquivalent(cube3x3x3KPuzzle, "CORNERS", normalized, cube3x3x3KPuzzle.startPieces);
-  } else {
-    return areTransformationsEquivalent(cube3x3x3KPuzzle, normalized, cube3x3x3KPuzzle.startPieces);
-  }
-}
-
-// src/cubing/puzzles/stickerings/appearance.ts
-function getFaceletAppearance(appearance, orbitName, pieceIdx, faceletIdx, hint) {
-  const orbitAppearance = appearance.orbits[orbitName];
-  const pieceAppearance = orbitAppearance.pieces[pieceIdx];
-  if (pieceAppearance === null) {
-    return regular;
-  }
-  const faceletAppearance = pieceAppearance.facelets[faceletIdx];
-  if (faceletAppearance === null) {
-    return regular;
-  }
-  if (typeof faceletAppearance === "string") {
-    return faceletAppearance;
-  }
-  if (hint) {
-    return faceletAppearance.hintAppearance ?? faceletAppearance.appearance;
-  }
-  return faceletAppearance.appearance;
-}
-var PieceStickering;
-(function(PieceStickering2) {
-  PieceStickering2[PieceStickering2["Regular"] = 0] = "Regular";
-  PieceStickering2[PieceStickering2["Dim"] = 1] = "Dim";
-  PieceStickering2[PieceStickering2["Ignored"] = 2] = "Ignored";
-  PieceStickering2[PieceStickering2["OrientationStickers"] = 3] = "OrientationStickers";
-  PieceStickering2[PieceStickering2["Invisible"] = 4] = "Invisible";
-  PieceStickering2[PieceStickering2["Ignoriented"] = 5] = "Ignoriented";
-  PieceStickering2[PieceStickering2["IgnoreNonPrimary"] = 6] = "IgnoreNonPrimary";
-  PieceStickering2[PieceStickering2["PermuteNonPrimary"] = 7] = "PermuteNonPrimary";
-  PieceStickering2[PieceStickering2["OrientationWithoutPermutation"] = 8] = "OrientationWithoutPermutation";
-})(PieceStickering || (PieceStickering = {}));
-var PieceAnnotation = class {
-  constructor(def, defaultValue) {
-    this.stickerings = new Map();
-    for (const [orbitName, orbitDef] of Object.entries(def.orbits)) {
-      this.stickerings.set(orbitName, new Array(orbitDef.numPieces).fill(defaultValue));
-    }
-  }
-};
-var regular = "regular";
-var ignored = "ignored";
-var oriented = "oriented";
-var invisible = "invisible";
-var dim = "dim";
-var r = {
-  facelets: [regular, regular, regular, regular, regular]
-};
-var i = {
-  facelets: [ignored, ignored, ignored, ignored, ignored]
-};
-var o = {
-  facelets: [oriented, oriented, oriented, oriented, oriented]
-};
-var invisiblePiece = {
-  facelets: [invisible, invisible, invisible, invisible]
-};
-var riiii = {
-  facelets: [regular, ignored, ignored, ignored, ignored]
-};
-var drrrr = {
-  facelets: [dim, regular, regular, regular, regular]
-};
-var d = {
-  facelets: [dim, dim, dim, dim, dim]
-};
-var diiii = {
-  facelets: [dim, ignored, ignored, ignored, ignored]
-};
-var oiiii = {
-  facelets: [oriented, ignored, ignored, ignored, ignored]
-};
-function getPieceAppearance(pieceStickering) {
-  switch (pieceStickering) {
-    case 0:
-      return r;
-    case 1:
-      return d;
-    case 2:
-      return i;
-    case 3:
-      return o;
-    case 4:
-      return invisiblePiece;
-    case 6:
-      return riiii;
-    case 7:
-      return drrrr;
-    case 5:
-      return diiii;
-    case 8:
-      return oiiii;
-  }
-}
-var PuzzleStickering = class extends PieceAnnotation {
-  constructor(def) {
-    super(def, 0);
-  }
-  set(pieceSet, pieceStickering) {
-    for (const [orbitName, pieces] of this.stickerings.entries()) {
-      for (let i2 = 0; i2 < pieces.length; i2++) {
-        if (pieceSet.stickerings.get(orbitName)[i2]) {
-          pieces[i2] = pieceStickering;
-        }
-      }
-    }
-    return this;
-  }
-  toAppearance() {
-    const appearance = { orbits: {} };
-    for (const [orbitName, pieceStickerings] of this.stickerings.entries()) {
-      const pieces = [];
-      const orbitAppearance = {
-        pieces
-      };
-      appearance.orbits[orbitName] = orbitAppearance;
-      for (const pieceStickering of pieceStickerings) {
-        pieces.push(getPieceAppearance(pieceStickering));
-      }
-    }
-    return appearance;
-  }
-};
-var StickeringManager = class {
-  constructor(def) {
-    this.def = def;
-  }
-  and(pieceSets) {
-    const newPieceSet = new PieceAnnotation(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      pieceLoop:
-        for (let i2 = 0; i2 < orbitDef.numPieces; i2++) {
-          newPieceSet.stickerings.get(orbitName)[i2] = true;
-          for (const pieceSet of pieceSets) {
-            if (!pieceSet.stickerings.get(orbitName)[i2]) {
-              newPieceSet.stickerings.get(orbitName)[i2] = false;
-              continue pieceLoop;
-            }
-          }
-        }
-    }
-    return newPieceSet;
-  }
-  or(pieceSets) {
-    const newPieceSet = new PieceAnnotation(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      pieceLoop:
-        for (let i2 = 0; i2 < orbitDef.numPieces; i2++) {
-          newPieceSet.stickerings.get(orbitName)[i2] = false;
-          for (const pieceSet of pieceSets) {
-            if (pieceSet.stickerings.get(orbitName)[i2]) {
-              newPieceSet.stickerings.get(orbitName)[i2] = true;
-              continue pieceLoop;
-            }
-          }
-        }
-    }
-    return newPieceSet;
-  }
-  not(pieceSet) {
-    const newPieceSet = new PieceAnnotation(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      for (let i2 = 0; i2 < orbitDef.numPieces; i2++) {
-        newPieceSet.stickerings.get(orbitName)[i2] = !pieceSet.stickerings.get(orbitName)[i2];
-      }
-    }
-    return newPieceSet;
-  }
-  all() {
-    return this.and(this.moves([]));
-  }
-  move(moveSource) {
-    const transformation = transformationForMove(this.def, experimentalIs(moveSource, Move) ? moveSource : Move.fromString(moveSource));
-    const newPieceSet = new PieceAnnotation(this.def, false);
-    for (const [orbitName, orbitDef] of Object.entries(this.def.orbits)) {
-      for (let i2 = 0; i2 < orbitDef.numPieces; i2++) {
-        if (transformation[orbitName].permutation[i2] !== i2 || transformation[orbitName].orientation[i2] !== 0) {
-          newPieceSet.stickerings.get(orbitName)[i2] = true;
-        }
-      }
-    }
-    return newPieceSet;
-  }
-  moves(moveSources) {
-    return moveSources.map((moveSource) => this.move(moveSource));
-  }
-};
-
-// src/cubing/puzzles/stickerings/cube-stickerings.ts
-async function cubeAppearance(puzzleLoader, stickering) {
-  const def = await puzzleLoader.def();
-  const puzzleStickering = new PuzzleStickering(def);
-  const m = new StickeringManager(def);
-  const LL = () => m.move("U");
-  const orUD = () => m.or(m.moves(["U", "D"]));
-  const E = () => m.not(orUD());
-  const orLR = () => m.or(m.moves(["L", "R"]));
-  const M = () => m.not(orLR());
-  const orFB = () => m.or(m.moves(["F", "B"]));
-  const S = () => m.not(orFB());
-  const F2L = () => m.not(LL());
-  const centerU = () => m.and([LL(), M(), S()]);
-  const edgeFR = () => m.and([m.and(m.moves(["F", "R"])), m.not(orUD())]);
-  const cornerDFR = () => m.and(m.moves(["D", "R", "F"]));
-  const slotFR = () => m.or([cornerDFR(), edgeFR()]);
-  const CENTERS = () => m.or([m.and([M(), E()]), m.and([M(), S()]), m.and([E(), S()])]);
-  const EDGES = () => m.or([
-    m.and([M(), orUD(), orFB()]),
-    m.and([E(), orLR(), orFB()]),
-    m.and([S(), orUD(), orLR()])
-  ]);
-  const CORNERS = () => m.not(m.or([CENTERS(), EDGES()]));
-  const L6E = () => m.or([M(), m.and([LL(), EDGES()])]);
-  function dimF2L() {
-    puzzleStickering.set(F2L(), PieceStickering.Dim);
-  }
-  function setPLL() {
-    puzzleStickering.set(LL(), PieceStickering.PermuteNonPrimary);
-    puzzleStickering.set(centerU(), PieceStickering.Dim);
-  }
-  function setOLL() {
-    puzzleStickering.set(LL(), PieceStickering.IgnoreNonPrimary);
-    puzzleStickering.set(centerU(), PieceStickering.Regular);
-  }
-  function dimOLL() {
-    puzzleStickering.set(LL(), PieceStickering.Ignoriented);
-    puzzleStickering.set(centerU(), PieceStickering.Dim);
-  }
-  switch (stickering) {
-    case "full":
-      break;
-    case "PLL":
-      dimF2L();
-      setPLL();
-      break;
-    case "CLS":
-      dimF2L();
-      puzzleStickering.set(m.and(m.moves(["D", "R", "F"])), PieceStickering.Regular);
-      puzzleStickering.set(LL(), PieceStickering.Ignoriented);
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.IgnoreNonPrimary);
-      break;
-    case "OLL":
-      dimF2L();
-      setOLL();
-      break;
-    case "COLL":
-      dimF2L();
-      setPLL();
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Regular);
-      break;
-    case "OCLL":
-      dimF2L();
-      dimOLL();
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.IgnoreNonPrimary);
-      break;
-    case "CLL":
-      dimF2L();
-      puzzleStickering.set(m.not(m.and([CORNERS(), LL()])), PieceStickering.Dim);
-      break;
-    case "ELL":
-      dimF2L();
-      puzzleStickering.set(LL(), PieceStickering.Dim);
-      puzzleStickering.set(m.and([LL(), EDGES()]), PieceStickering.Regular);
-      break;
-    case "ELS":
-      dimF2L();
-      setOLL();
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Ignored);
-      puzzleStickering.set(edgeFR(), PieceStickering.Regular);
-      puzzleStickering.set(cornerDFR(), PieceStickering.Ignored);
-      break;
-    case "LL":
-      dimF2L();
-      break;
-    case "F2L":
-      puzzleStickering.set(LL(), PieceStickering.Ignored);
-      break;
-    case "ZBLL":
-      dimF2L();
-      puzzleStickering.set(LL(), PieceStickering.PermuteNonPrimary);
-      puzzleStickering.set(centerU(), PieceStickering.Dim);
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Regular);
-      break;
-    case "ZBLS":
-      dimF2L();
-      puzzleStickering.set(slotFR(), PieceStickering.Regular);
-      setOLL();
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Ignored);
-      break;
-    case "WVLS":
-    case "VLS":
-      dimF2L();
-      puzzleStickering.set(slotFR(), PieceStickering.Regular);
-      setOLL();
-      break;
-    case "LS":
-      dimF2L();
-      puzzleStickering.set(slotFR(), PieceStickering.Regular);
-      puzzleStickering.set(LL(), PieceStickering.Ignored);
-      puzzleStickering.set(centerU(), PieceStickering.Dim);
-      break;
-    case "EO":
-      puzzleStickering.set(CORNERS(), PieceStickering.Ignored);
-      puzzleStickering.set(EDGES(), PieceStickering.OrientationWithoutPermutation);
-      break;
-    case "CMLL":
-      puzzleStickering.set(F2L(), PieceStickering.Dim);
-      puzzleStickering.set(L6E(), PieceStickering.Ignored);
-      puzzleStickering.set(m.and([LL(), CORNERS()]), PieceStickering.Regular);
-      break;
-    case "L6E":
-      puzzleStickering.set(m.not(L6E()), PieceStickering.Dim);
-      break;
-    case "L6EO":
-      puzzleStickering.set(m.not(L6E()), PieceStickering.Dim);
-      puzzleStickering.set(L6E(), PieceStickering.OrientationWithoutPermutation);
-      puzzleStickering.set(m.and([CENTERS(), orUD()]), PieceStickering.OrientationStickers);
-      break;
-    case "Daisy":
-      puzzleStickering.set(m.all(), PieceStickering.Ignored);
-      puzzleStickering.set(CENTERS(), PieceStickering.Dim);
-      puzzleStickering.set(m.and([m.move("D"), CENTERS()]), PieceStickering.Regular);
-      puzzleStickering.set(m.and([m.move("U"), EDGES()]), PieceStickering.IgnoreNonPrimary);
-      break;
-    case "Cross":
-      puzzleStickering.set(m.all(), PieceStickering.Ignored);
-      puzzleStickering.set(CENTERS(), PieceStickering.Dim);
-      puzzleStickering.set(m.and([m.move("D"), CENTERS()]), PieceStickering.Regular);
-      puzzleStickering.set(m.and([m.move("D"), EDGES()]), PieceStickering.Regular);
-      break;
-    case "2x2x2":
-      puzzleStickering.set(m.or(m.moves(["U", "F", "R"])), PieceStickering.Ignored);
-      puzzleStickering.set(m.and([m.or(m.moves(["U", "F", "R"])), CENTERS()]), PieceStickering.Dim);
-      break;
-    case "2x2x3":
-      puzzleStickering.set(m.all(), PieceStickering.Dim);
-      puzzleStickering.set(m.or(m.moves(["U", "F", "R"])), PieceStickering.Ignored);
-      puzzleStickering.set(m.and([m.or(m.moves(["U", "F", "R"])), CENTERS()]), PieceStickering.Dim);
-      puzzleStickering.set(m.and([m.move("F"), m.not(m.or(m.moves(["U", "R"])))]), PieceStickering.Regular);
-      break;
-    case "Void Cube":
-      puzzleStickering.set(CENTERS(), PieceStickering.Invisible);
-      break;
-    case "picture":
-    case "invisible":
-      puzzleStickering.set(m.all(), PieceStickering.Invisible);
-      break;
-    case "centers-only":
-      puzzleStickering.set(m.not(CENTERS()), PieceStickering.Ignored);
-      break;
-    default:
-      console.warn(`Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`);
-      puzzleStickering.set(m.and(m.moves([])), PieceStickering.Dim);
-  }
-  return puzzleStickering.toAppearance();
-}
-async function cubeStickerings() {
-  return [
-    "full",
-    "PLL",
-    "CLS",
-    "OLL",
-    "COLL",
-    "OCLL",
-    "ELL",
-    "ELS",
-    "LL",
-    "F2L",
-    "ZBLL",
-    "ZBLS",
-    "WVLS",
-    "VLS",
-    "LS",
-    "EO",
-    "CMLL",
-    "L6E",
-    "L6EO",
-    "Daisy",
-    "Cross",
-    "2x2x2",
-    "2x2x3",
-    "Void Cube",
-    "picture",
-    "invisible",
-    "centers-only"
-  ];
-}
-
-// src/cubing/puzzles/async/async-pg3d.ts
-async function asyncGetPuzzleGeometry(puzzleName) {
-  const puzzleGeometry = await import("./puzzle-geometry/index.js");
-  return puzzleGeometry.getPuzzleGeometryByName(puzzleName, [
-    "allmoves",
-    "true",
-    "orientcenters",
-    "true",
-    "rotations",
-    "true"
-  ]);
-}
-async function asyncGetDef(puzzleName) {
-  return (await asyncGetPuzzleGeometry(puzzleName)).writekpuzzle(true);
-}
-function genericPGPuzzleLoader(id, fullName, info) {
-  const puzzleLoader = {
-    id,
-    fullName,
-    def: async () => {
-      return asyncGetDef(id);
-    },
-    svg: async () => {
-      const pg = await asyncGetPuzzleGeometry(id);
-      return pg.generatesvg();
-    },
-    pg: async () => {
-      return asyncGetPuzzleGeometry(id);
-    }
-  };
-  if (info?.inventedBy) {
-    puzzleLoader.inventedBy = info.inventedBy;
-  }
-  if (info?.inventionYear) {
-    puzzleLoader.inventionYear = info.inventionYear;
-  }
-  return puzzleLoader;
-}
-function cubePGPuzzleLoader(id, fullName, info) {
-  const puzzleLoader = genericPGPuzzleLoader(id, fullName, info);
-  puzzleLoader.appearance = cubeAppearance.bind(cubeAppearance, puzzleLoader);
-  puzzleLoader.stickerings = cubeStickerings;
-  return puzzleLoader;
-}
-
-// src/cubing/puzzles/implementations/2x2x2/index.ts
-var cube2x2x2 = {
-  id: "2x2x2",
-  fullName: "2\xD72\xD72 Cube",
-  def: async () => {
-    return (await import("./2x2x2.kpuzzle.json_-ZLJSYD5K.js")).cube2x2x2KPuzzle;
-  },
-  svg: async () => {
-    return (await import("./2x2x2.kpuzzle.svg-BNXPAM3A.js")).default;
-  },
-  pg: async () => {
-    return asyncGetPuzzleGeometry("2x2x2");
-  },
-  appearance: (stickering) => cubeAppearance(cube2x2x2, stickering),
-  stickerings: cubeStickerings
-};
-
-// src/cubing/puzzles/implementations/3x3x3/index.ts
-var cube3x3x3 = {
-  id: "3x3x3",
-  fullName: "3\xD73\xD73 Cube",
-  inventedBy: ["Ern\u0151 Rubik"],
-  inventionYear: 1974,
-  def: async () => {
-    return cube3x3x3KPuzzle;
-  },
-  svg: async () => {
-    return (await import("./3x3x3.kpuzzle.svg-DUKG2WHC.js")).default;
-  },
-  llSVG: async () => {
-    return (await import("./3x3x3-ll.kpuzzle.svg-EC42JHOH.js")).default;
-  },
-  pg: async () => {
-    return asyncGetPuzzleGeometry("3x3x3");
-  },
-  appearance: (stickering) => cubeAppearance(cube3x3x3, stickering),
-  stickerings: cubeStickerings
-};
-
-// src/cubing/puzzles/implementations/clock/index.ts
-var clock = {
-  id: "clock",
-  fullName: "Clock",
-  inventedBy: ["Christopher C. Wiggs", "Christopher J. Taylor"],
-  inventionYear: 1988,
-  def: async () => {
-    return (await import("./clock.kpuzzle.json_-PXORG6YF.js")).clockKPuzzle;
-  },
-  svg: async () => {
-    return (await import("./clock.kpuzzle.svg-E52B5OQV.js")).default;
-  }
-};
-
-// src/cubing/puzzles/stickerings/fto-stickerings.ts
-async function ftoStickering(puzzleLoader, stickering) {
-  const def = await puzzleLoader.def();
-  const puzzleStickering = new PuzzleStickering(def);
-  const m = new StickeringManager(def);
-  const experimentalFTO_FC = () => m.and([m.move("U"), m.not(m.or(m.moves(["F", "BL", "BR"])))]);
-  const experimentalFTO_F2T = () => m.and([m.move("U"), m.not(m.move("F"))]);
-  const experimentalFTO_SC = () => m.or([
-    experimentalFTO_F2T(),
-    m.and([m.move("F"), m.not(m.or(m.moves(["U", "BL", "BR"])))])
-  ]);
-  const experimentalFTO_L2C = () => m.not(m.or([
-    m.and([m.move("U"), m.move("F")]),
-    m.and([m.move("F"), m.move("BL")]),
-    m.and([m.move("F"), m.move("BR")]),
-    m.and([m.move("BL"), m.move("BR")])
-  ]));
-  const experimentalFTO_LBT = () => m.not(m.or([
-    m.and([m.move("F"), m.move("BL")]),
-    m.and([m.move("F"), m.move("BR")])
-  ]));
-  switch (stickering) {
-    case "full":
-      break;
-    case "experimental-fto-fc":
-      puzzleStickering.set(m.not(experimentalFTO_FC()), PieceStickering.Ignored);
-      break;
-    case "experimental-fto-f2t":
-      puzzleStickering.set(m.not(experimentalFTO_F2T()), PieceStickering.Ignored);
-      break;
-    case "experimental-fto-sc":
-      puzzleStickering.set(m.not(experimentalFTO_SC()), PieceStickering.Ignored);
-      break;
-    case "experimental-fto-l2c":
-      puzzleStickering.set(m.not(experimentalFTO_L2C()), PieceStickering.Ignored);
-      break;
-    case "experimental-fto-lbt":
-      puzzleStickering.set(m.not(experimentalFTO_LBT()), PieceStickering.Ignored);
-      break;
-    default:
-      console.warn(`Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`);
-      puzzleStickering.set(m.and(m.moves([])), PieceStickering.Dim);
-  }
-  return puzzleStickering.toAppearance();
-}
-async function ftoStickerings() {
-  return [
-    "full",
-    "experimental-fto-fc",
-    "experimental-fto-f2t",
-    "experimental-fto-sc",
-    "experimental-fto-l2c",
-    "experimental-fto-lbt"
-  ];
-}
-
-// src/cubing/puzzles/implementations/fto/index.ts
-var fto = genericPGPuzzleLoader("FTO", "Face-Turning Octahedron", {
-  inventedBy: ["Karl Rohrbach", "David Pitcher"],
-  inventionYear: 1983
-});
-fto.appearance = (stickering) => ftoStickering(fto, stickering);
-fto.stickerings = ftoStickerings;
-
-// src/cubing/puzzles/stickerings/megaminx-stickerings.ts
-async function megaminxAppearance(puzzleLoader, stickering) {
-  switch (stickering) {
-    case "full":
-    case "F2L":
-    case "LL":
-      return cubeAppearance(puzzleLoader, stickering);
-    default:
-      console.warn(`Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`);
-  }
-  return cubeAppearance(puzzleLoader, "full");
-}
-async function megaminxStickerings() {
-  return ["full", "F2L", "LL"];
-}
-
-// src/cubing/puzzles/implementations/megaminx/index.ts
-var megaminx = genericPGPuzzleLoader("megaminx", "Megaminx", {
-  inventionYear: 1981
-});
-megaminx.appearance = (stickering) => megaminxAppearance(megaminx, stickering);
-megaminx.stickerings = megaminxStickerings;
-
-// src/cubing/puzzles/implementations/pyraminx/index.ts
-var pyraminx = {
-  id: "pyraminx",
-  fullName: "Pyraminx",
-  inventedBy: ["Uwe Meffert"],
-  inventionYear: 1970,
-  def: async () => {
-    return asyncGetDef("pyraminx");
-  },
-  svg: async () => {
-    return (await import("./pyraminx.kpuzzle.svg-QKUJX37T.js")).default;
-  },
-  pg: async () => {
-    return asyncGetPuzzleGeometry("pyraminx");
-  }
-};
-
-// src/cubing/puzzles/implementations/square1/index.ts
-var square1 = {
-  id: "square1",
-  fullName: "Square-1",
-  inventedBy: ["Karel Hr\u0161el", "Vojtech Kopsk\xFD"],
-  inventionYear: 1990,
-  def: async () => {
-    return (await import("./sq1-hyperorbit.kpuzzle.json_-7KW5LSXC.js")).sq1HyperOrbitKPuzzle;
-  },
-  svg: async () => {
-    return (await import("./sq1-hyperorbit.kpuzzle.svg-7Y7N37NN.js")).default;
-  }
-};
-
-// src/cubing/puzzles/index.ts
-var puzzles = {
-  "3x3x3": cube3x3x3,
-  "2x2x2": cube2x2x2,
-  "4x4x4": cubePGPuzzleLoader("4x4x4", "4\xD74\xD74 Cube"),
-  "5x5x5": cubePGPuzzleLoader("5x5x5", "5\xD75\xD75 Cube"),
-  "6x6x6": cubePGPuzzleLoader("6x6x6", "6\xD76\xD76 Cube"),
-  "7x7x7": cubePGPuzzleLoader("7x7x7", "7\xD77\xD77 Cube"),
-  "40x40x40": cubePGPuzzleLoader("40x40x40", "40\xD740\xD740 Cube"),
-  clock,
-  "megaminx": megaminx,
-  pyraminx,
-  "skewb": genericPGPuzzleLoader("skewb", "Skewb", {
-    inventedBy: ["Tony Durham"]
-  }),
-  square1,
-  "fto": fto,
-  "gigaminx": genericPGPuzzleLoader("gigaminx", "Gigaminx", {
-    inventedBy: ["Tyler Fox"],
-    inventionYear: 2006
-  }),
-  "master_tetraminx": genericPGPuzzleLoader("master tetraminx", "Master Tetraminx", {
-    inventedBy: ["Katsuhiko Okamoto"],
-    inventionYear: 2002
-  })
-};
-var wcaEvents = {
-  "333": "3x3x3",
-  "222": "2x2x2",
-  "444": "4x4x4",
-  "555": "5x5x5",
-  "666": "6x6x6",
-  "777": "7x7x7",
-  "333bf": "3x3x3",
-  "333fm": "3x3x3",
-  "333oh": "3x3x3",
-  "clock": "clock",
-  "minx": "megaminx",
-  "pyram": "pyraminx",
-  "skewb": "skewb",
-  "sq1": "square1",
-  "444bf": "4x4x4",
-  "555bf": "5x5x5"
-};
-function puzzleIDForWCAEvent(event) {
-  return wcaEvents[event] ?? null;
-}
-
 export {
   combineTransformations,
   multiplyTransformations,
@@ -2999,11 +2347,6 @@ export {
   pegParseKPuzzleDefinition,
   KPuzzleSVGWrapper,
   cube3x3x3KPuzzle,
-  getFaceletAppearance,
-  cube2x2x2,
-  cube3x3x3,
-  puzzles,
-  puzzleIDForWCAEvent,
   normalizePuzzleOrientation,
   reid3x3x3ToTwizzleBinary,
   twizzleBinaryToBinaryComponents,
@@ -3013,4 +2356,4 @@ export {
   spacedHexToBuffer,
   experimentalIs3x3x3Solved
 };
-//# sourceMappingURL=chunk-CWVB5RRW.js.map
+//# sourceMappingURL=chunk-YV3RT5PX.js.map