cubing 0.29.1 → 0.30.0

package/dist/esm/{chunk-XRZBPKES.js → chunk-35OK6TQ4.js}

@@ -3,10 +3,14 @@ import {
   StickeringManager,
   experimental3x3x3KPuzzle,
   experimentalStickerings
-} from "./chunk-U2ONHTIX.js";
+} from "./chunk-6FB2XWAK.js";
 import {
   KPuzzle
-} from "./chunk-XU5ILFX5.js";
+} from "./chunk-GQBRF4EM.js";
+import {
+  Move,
+  QuantumMove
+} from "./chunk-ZQT3QSWD.js";
 
 // src/cubing/puzzles/events.ts
 var wcaEvents = {
@@ -19,11 +23,11 @@ var wcaEvents = {
   "333bf": { puzzleID: "3x3x3", eventName: "3x3x3 Blindfolded" },
   "333fm": { puzzleID: "3x3x3", eventName: "3x3x3 Fewest Moves" },
   "333oh": { puzzleID: "3x3x3", eventName: "3x3x3 One-Handed" },
-  "clock": { puzzleID: "clock", eventName: "Clock" },
-  "minx": { puzzleID: "megaminx", eventName: "Megaminx" },
-  "pyram": { puzzleID: "pyraminx", eventName: "Pyraminx" },
-  "skewb": { puzzleID: "skewb", eventName: "Skewb" },
-  "sq1": { puzzleID: "square1", eventName: "Square-1" },
+  clock: { puzzleID: "clock", eventName: "Clock" },
+  minx: { puzzleID: "megaminx", eventName: "Megaminx" },
+  pyram: { puzzleID: "pyraminx", eventName: "Pyraminx" },
+  skewb: { puzzleID: "skewb", eventName: "Skewb" },
+  sq1: { puzzleID: "square1", eventName: "Square-1" },
   "444bf": { puzzleID: "4x4x4", eventName: "4x4x4 Blindfolded" },
   "555bf": { puzzleID: "5x5x5", eventName: "5x5x5 Blindfolded" },
   "333mb": { puzzleID: "3x3x3", eventName: "3x3x3 Multi-Blind" }
@@ -31,7 +35,7 @@ var wcaEvents = {
 function wcaEventInfo(event) {
   return wcaEvents[event] ?? null;
 }
-var events = {
+var twizzleEvents = {
   ...wcaEvents,
   fto: { puzzleID: "fto", eventName: "Face-Turning Octahedron" },
   master_tetraminx: {
@@ -48,7 +52,7 @@ var events = {
   }
 };
 function eventInfo(event) {
-  return events[event] ?? null;
+  return twizzleEvents[event] ?? null;
 }
 
 // src/cubing/puzzles/stickerings/cube-stickerings.ts
@@ -91,11 +95,12 @@ async function cubeAppearance(puzzleLoader, stickering) {
   switch (stickering) {
     case "full":
       break;
-    case "PLL":
+    case "PLL": {
       dimF2L();
       setPLL();
       break;
-    case "CLS":
+    }
+    case "CLS": {
       dimF2L();
       puzzleStickering.set(cornerDFR(), "Regular" /* Regular */);
       puzzleStickering.set(LL(), "Ignoriented" /* Ignoriented */);
@@ -105,17 +110,20 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "IgnoreNonPrimary" /* IgnoreNonPrimary */
       );
       break;
-    case "OLL":
+    }
+    case "OLL": {
       dimF2L();
       setOLL();
       break;
-    case "COLL":
+    }
+    case "COLL": {
       dimF2L();
       puzzleStickering.set(m.and([LL(), EDGES()]), "Ignoriented" /* Ignoriented */);
       puzzleStickering.set(m.and([LL(), CENTERS()]), "Dim" /* Dim */);
       puzzleStickering.set(m.and([LL(), CORNERS()]), "Regular" /* Regular */);
       break;
-    case "OCLL":
+    }
+    case "OCLL": {
       dimF2L();
       dimOLL();
       puzzleStickering.set(
@@ -123,49 +131,58 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "IgnoreNonPrimary" /* IgnoreNonPrimary */
       );
       break;
-    case "CLL":
+    }
+    case "CLL": {
       dimF2L();
       puzzleStickering.set(
         m.not(m.and([CORNERS(), LL()])),
         "Dim" /* Dim */
       );
       break;
-    case "ELL":
+    }
+    case "ELL": {
       dimF2L();
       puzzleStickering.set(LL(), "Dim" /* Dim */);
       puzzleStickering.set(m.and([LL(), EDGES()]), "Regular" /* Regular */);
       break;
-    case "ELS":
+    }
+    case "ELS": {
       dimF2L();
       setOLL();
       puzzleStickering.set(m.and([LL(), CORNERS()]), "Ignored" /* Ignored */);
       puzzleStickering.set(edgeFR(), "Regular" /* Regular */);
       puzzleStickering.set(cornerDFR(), "Ignored" /* Ignored */);
       break;
-    case "LL":
+    }
+    case "LL": {
       dimF2L();
       break;
-    case "F2L":
+    }
+    case "F2L": {
       puzzleStickering.set(LL(), "Ignored" /* Ignored */);
       break;
-    case "ZBLL":
+    }
+    case "ZBLL": {
       dimF2L();
       puzzleStickering.set(LL(), "PermuteNonPrimary" /* PermuteNonPrimary */);
       puzzleStickering.set(centerLL(), "Dim" /* Dim */);
       puzzleStickering.set(m.and([LL(), CORNERS()]), "Regular" /* Regular */);
       break;
-    case "ZBLS":
+    }
+    case "ZBLS": {
       dimF2L();
       puzzleStickering.set(slotFR(), "Regular" /* Regular */);
       setOLL();
       puzzleStickering.set(m.and([LL(), CORNERS()]), "Ignored" /* Ignored */);
       break;
-    case "VLS":
+    }
+    case "VLS": {
       dimF2L();
       puzzleStickering.set(slotFR(), "Regular" /* Regular */);
       setOLL();
       break;
-    case "WVLS":
+    }
+    case "WVLS": {
       dimF2L();
       puzzleStickering.set(slotFR(), "Regular" /* Regular */);
       puzzleStickering.set(m.and([LL(), EDGES()]), "Ignoriented" /* Ignoriented */);
@@ -175,20 +192,23 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "IgnoreNonPrimary" /* IgnoreNonPrimary */
       );
       break;
-    case "LS":
+    }
+    case "LS": {
       dimF2L();
       puzzleStickering.set(slotFR(), "Regular" /* Regular */);
       puzzleStickering.set(LL(), "Ignored" /* Ignored */);
       puzzleStickering.set(centerLL(), "Dim" /* Dim */);
       break;
-    case "EO":
+    }
+    case "EO": {
       puzzleStickering.set(CORNERS(), "Ignored" /* Ignored */);
       puzzleStickering.set(
         EDGES(),
         "OrientationWithoutPermutation" /* OrientationWithoutPermutation */
       );
       break;
-    case "EOline":
+    }
+    case "EOline": {
       puzzleStickering.set(CORNERS(), "Ignored" /* Ignored */);
       puzzleStickering.set(
         EDGES(),
@@ -196,7 +216,8 @@ async function cubeAppearance(puzzleLoader, stickering) {
       );
       puzzleStickering.set(m.and(m.moves(["D", "M"])), "Regular" /* Regular */);
       break;
-    case "EOcross":
+    }
+    case "EOcross": {
       puzzleStickering.set(
         EDGES(),
         "OrientationWithoutPermutation" /* OrientationWithoutPermutation */
@@ -204,19 +225,23 @@ async function cubeAppearance(puzzleLoader, stickering) {
       puzzleStickering.set(m.move("D"), "Regular" /* Regular */);
       puzzleStickering.set(CORNERS(), "Ignored" /* Ignored */);
       break;
-    case "CMLL":
+    }
+    case "CMLL": {
       puzzleStickering.set(F2L(), "Dim" /* Dim */);
       puzzleStickering.set(L6E(), "Ignored" /* Ignored */);
       puzzleStickering.set(m.and([LL(), CORNERS()]), "Regular" /* Regular */);
       break;
-    case "L10P":
+    }
+    case "L10P": {
       puzzleStickering.set(m.not(L6E()), "Dim" /* Dim */);
       puzzleStickering.set(m.and([CORNERS(), LL()]), "Regular" /* Regular */);
       break;
-    case "L6E":
+    }
+    case "L6E": {
       puzzleStickering.set(m.not(L6E()), "Dim" /* Dim */);
       break;
-    case "L6EO":
+    }
+    case "L6EO": {
       puzzleStickering.set(m.not(L6E()), "Dim" /* Dim */);
       puzzleStickering.set(
         L6E(),
@@ -227,7 +252,8 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "OrientationStickers" /* OrientationStickers */
       );
       break;
-    case "Daisy":
+    }
+    case "Daisy": {
       puzzleStickering.set(m.all(), "Ignored" /* Ignored */);
       puzzleStickering.set(CENTERS(), "Dim" /* Dim */);
       puzzleStickering.set(
@@ -239,7 +265,8 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "IgnoreNonPrimary" /* IgnoreNonPrimary */
       );
       break;
-    case "Cross":
+    }
+    case "Cross": {
       puzzleStickering.set(m.all(), "Ignored" /* Ignored */);
       puzzleStickering.set(CENTERS(), "Dim" /* Dim */);
       puzzleStickering.set(
@@ -251,7 +278,8 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "Regular" /* Regular */
       );
       break;
-    case "2x2x2":
+    }
+    case "2x2x2": {
       puzzleStickering.set(
         m.or(m.moves(["U", "F", "R"])),
         "Ignored" /* Ignored */
@@ -261,7 +289,8 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "Dim" /* Dim */
       );
       break;
-    case "2x2x3":
+    }
+    case "2x2x3": {
       puzzleStickering.set(m.all(), "Dim" /* Dim */);
       puzzleStickering.set(
         m.or(m.moves(["U", "F", "R"])),
@@ -276,16 +305,20 @@ async function cubeAppearance(puzzleLoader, stickering) {
         "Regular" /* Regular */
       );
       break;
-    case "Void Cube":
+    }
+    case "Void Cube": {
       puzzleStickering.set(CENTERS(), "Invisible" /* Invisible */);
       break;
+    }
     case "picture":
-    case "invisible":
+    case "invisible": {
       puzzleStickering.set(m.all(), "Invisible" /* Invisible */);
       break;
-    case "centers-only":
+    }
+    case "centers-only": {
       puzzleStickering.set(m.not(CENTERS()), "Ignored" /* Ignored */);
       break;
+    }
     default:
       console.warn(
         `Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`
@@ -371,11 +404,11 @@ var cube2x2x2 = {
   fullName: "2\xD72\xD72 Cube",
   kpuzzle: getCached(
     async () => new KPuzzle(
-      (await import("./puzzles-dynamic-side-events-5C7LMBWX.js")).cube2x2x2JSON
+      (await import("./puzzles-dynamic-side-events-HMUBMHA5.js")).cube2x2x2JSON
     )
   ),
   svg: async () => {
-    return (await import("./puzzles-dynamic-side-events-5C7LMBWX.js")).cube2x2x2SVG;
+    return (await import("./puzzles-dynamic-side-events-HMUBMHA5.js")).cube2x2x2SVG;
   },
   pg: getCached(async () => {
     return asyncGetPuzzleGeometry("2x2x2");
@@ -384,6 +417,226 @@ var cube2x2x2 = {
   stickerings: cubeStickerings
 };
 
+// src/cubing/puzzles/implementations/3x3x3/puzzle-specific-simplifications.ts
+function makeSourceInfo(moveStrings, type, from, to) {
+  const output = [];
+  for (const moveString of moveStrings) {
+    const move = Move.fromString(moveString);
+    const { family, amount: direction } = move;
+    if (![-1, 1].includes(direction)) {
+      throw new Error("Invalid config move");
+    }
+    output.push({ family, direction, type, from, to });
+  }
+  return output;
+}
+var axisInfos = {
+  ["x axis" /* X */]: {
+    sliceDiameter: 3,
+    extendsThroughEntirePuzzle: true,
+    moveSourceInfos: [
+      ...makeSourceInfo(["R"], 0 /* INDEXABLE_SLICE_NEAR */, 0, 3),
+      ...makeSourceInfo(["L'"], 1 /* INDEXABLE_SLICE_FAR */, 0, 3),
+      ...makeSourceInfo(["r", "Rw"], 2 /* INDEXABLE_WIDE_NEAR */, 0, 2),
+      ...makeSourceInfo(["l'", "Lw'"], 3 /* INDEXABLE_WIDE_FAR */, 0, 2),
+      ...makeSourceInfo(["M'"], 4 /* SPECIFIC_SLICE */, 1, 2),
+      ...makeSourceInfo(["x", "Uv", "Dv'"], 5 /* ROTATION */, 0, 3)
+    ]
+  },
+  ["y axis" /* Y */]: {
+    sliceDiameter: 3,
+    extendsThroughEntirePuzzle: true,
+    moveSourceInfos: [
+      ...makeSourceInfo(["U"], 0 /* INDEXABLE_SLICE_NEAR */, 0, 3),
+      ...makeSourceInfo(["D'"], 1 /* INDEXABLE_SLICE_FAR */, 0, 3),
+      ...makeSourceInfo(["u", "Uw"], 2 /* INDEXABLE_WIDE_NEAR */, 0, 2),
+      ...makeSourceInfo(["d'", "Dw'"], 3 /* INDEXABLE_WIDE_FAR */, 0, 2),
+      ...makeSourceInfo(["E'"], 4 /* SPECIFIC_SLICE */, 1, 2),
+      ...makeSourceInfo(["y", "Uv", "Dv'"], 5 /* ROTATION */, 0, 3)
+    ]
+  },
+  ["z axis" /* Z */]: {
+    sliceDiameter: 3,
+    extendsThroughEntirePuzzle: true,
+    moveSourceInfos: [
+      ...makeSourceInfo(["F"], 0 /* INDEXABLE_SLICE_NEAR */, 0, 3),
+      ...makeSourceInfo(["B'"], 1 /* INDEXABLE_SLICE_FAR */, 0, 3),
+      ...makeSourceInfo(["f", "Fw"], 2 /* INDEXABLE_WIDE_NEAR */, 0, 3),
+      ...makeSourceInfo(["b'", "Bw'"], 3 /* INDEXABLE_WIDE_FAR */, 0, 3),
+      ...makeSourceInfo(["S"], 4 /* SPECIFIC_SLICE */, 1, 2),
+      ...makeSourceInfo(["z", "Fv", "Bv'"], 5 /* ROTATION */, 0, 3)
+    ]
+  }
+};
+var byFamily = {};
+for (const [axis, info] of Object.entries(axisInfos)) {
+  for (const moveSourceInfo of info.moveSourceInfos) {
+    byFamily[moveSourceInfo.family] = { axis, moveSourceInfo };
+  }
+}
+var byAxisThenType = {};
+var _a;
+for (const axis of Object.keys(axisInfos)) {
+  const entry = {};
+  byAxisThenType[axis] = entry;
+  for (const moveSourceInfo of axisInfos[axis].moveSourceInfos) {
+    (entry[_a = moveSourceInfo.type] ?? (entry[_a] = [])).push(moveSourceInfo);
+  }
+}
+var byAxisThenSpecificSlices = {};
+for (const axis of Object.keys(axisInfos)) {
+  const entry = /* @__PURE__ */ new Map();
+  byAxisThenSpecificSlices[axis] = entry;
+  for (const moveSourceInfo of axisInfos[axis].moveSourceInfos) {
+    if (!entry.get(moveSourceInfo.from)) {
+      entry.set(moveSourceInfo.from, moveSourceInfo);
+    }
+  }
+}
+function firstOfType(axis, moveSourceType) {
+  const entry = byAxisThenType[axis][moveSourceType]?.[0];
+  if (!entry) {
+    throw new Error(
+      `Could not find a reference move (axis: ${axis}, move source type: ${moveSourceType})`
+    );
+  }
+  return entry;
+}
+var areQuantumMovesSameAxis = (quantumMove1, quantumMove2) => {
+  return byFamily[quantumMove1.family].axis === byFamily[quantumMove2.family].axis;
+};
+function simplestMove(axis, from, to, directedAmount) {
+  if (from + 1 === to) {
+    const sliceSpecificInfo = byAxisThenSpecificSlices[axis].get(from);
+    if (sliceSpecificInfo) {
+      return new Move(
+        new QuantumMove(sliceSpecificInfo.family),
+        directedAmount * sliceSpecificInfo.direction
+      );
+    }
+  }
+  const axisInfo = axisInfos[axis];
+  const { sliceDiameter } = axisInfo;
+  if (from === 0 && to === sliceDiameter) {
+    const moveSourceInfo2 = firstOfType(axis, 5 /* ROTATION */);
+    return new Move(
+      new QuantumMove(moveSourceInfo2.family),
+      directedAmount * moveSourceInfo2.direction
+    );
+  }
+  const far = from + to > sliceDiameter;
+  if (far) {
+    [from, to] = [sliceDiameter - to, sliceDiameter - from];
+  }
+  let outerLayer = from + 1;
+  let innerLayer = to;
+  const slice = outerLayer === innerLayer;
+  if (slice) {
+    innerLayer = null;
+  }
+  if (outerLayer === 1) {
+    outerLayer = null;
+  }
+  if (slice && outerLayer === 1) {
+    innerLayer = null;
+  }
+  if (!slice && innerLayer === 2) {
+    innerLayer = null;
+  }
+  const moveSourceType = slice ? far ? 1 /* INDEXABLE_SLICE_FAR */ : 0 /* INDEXABLE_SLICE_NEAR */ : far ? 3 /* INDEXABLE_WIDE_FAR */ : 2 /* INDEXABLE_WIDE_NEAR */;
+  const moveSourceInfo = firstOfType(axis, moveSourceType);
+  return new Move(
+    new QuantumMove(moveSourceInfo.family, innerLayer, outerLayer),
+    directedAmount * moveSourceInfo.direction
+  );
+}
+function simplifySameAxisMoves(moves, quantumMod = true) {
+  if (moves.length === 0) {
+    return [];
+  }
+  const axis = byFamily[moves[0].family].axis;
+  const axisInfo = axisInfos[axis];
+  const { sliceDiameter } = axisInfo;
+  const sliceDeltas = /* @__PURE__ */ new Map();
+  let lastCandidateRange = null;
+  function adjustValue(idx, relativeDelta) {
+    let newDelta = (sliceDeltas.get(idx) ?? 0) + relativeDelta;
+    if (quantumMod) {
+      newDelta = newDelta % 4 + 5 % 4 - 1;
+    }
+    if (newDelta === 0) {
+      sliceDeltas.delete(idx);
+    } else {
+      sliceDeltas.set(idx, newDelta);
+    }
+  }
+  let suffixLength = 0;
+  for (const move of Array.from(moves).reverse()) {
+    suffixLength++;
+    const { moveSourceInfo } = byFamily[move.family];
+    const directedAmount2 = move.amount * moveSourceInfo.direction;
+    switch (moveSourceInfo.type) {
+      case 0 /* INDEXABLE_SLICE_NEAR */: {
+        const idx = (move.innerLayer ?? 1) - 1;
+        adjustValue(idx, directedAmount2);
+        adjustValue(idx + 1, -directedAmount2);
+        break;
+      }
+      case 1 /* INDEXABLE_SLICE_FAR */: {
+        const idx = sliceDiameter - (move.innerLayer ?? 1);
+        adjustValue(idx, directedAmount2);
+        adjustValue(idx + 1, -directedAmount2);
+        break;
+      }
+      case 2 /* INDEXABLE_WIDE_NEAR */: {
+        adjustValue((move.outerLayer ?? 1) - 1, directedAmount2);
+        adjustValue(move.innerLayer ?? 2, -directedAmount2);
+        break;
+      }
+      case 3 /* INDEXABLE_WIDE_FAR */: {
+        adjustValue(sliceDiameter - (move.innerLayer ?? 2), directedAmount2);
+        adjustValue(
+          sliceDiameter - ((move.outerLayer ?? 1) - 1),
+          -directedAmount2
+        );
+        break;
+      }
+      case 4 /* SPECIFIC_SLICE */: {
+        adjustValue(moveSourceInfo.from, directedAmount2);
+        adjustValue(moveSourceInfo.to, -directedAmount2);
+        break;
+      }
+      case 5 /* ROTATION */: {
+        adjustValue(0, directedAmount2);
+        adjustValue(sliceDiameter, -directedAmount2);
+        break;
+      }
+    }
+    if ([0, 2].includes(sliceDeltas.size)) {
+      lastCandidateRange = { suffixLength, sliceDeltas: new Map(sliceDeltas) };
+    }
+  }
+  if (sliceDeltas.size === 0) {
+    return [];
+  }
+  if (!lastCandidateRange) {
+    return moves;
+  }
+  let [from, to] = lastCandidateRange.sliceDeltas.keys();
+  if (from > to) {
+    [from, to] = [to, from];
+  }
+  const directedAmount = lastCandidateRange.sliceDeltas.get(from);
+  return [
+    ...moves.slice(0, -lastCandidateRange.suffixLength),
+    ...directedAmount !== 0 ? [simplestMove(axis, from, to, directedAmount)] : []
+  ];
+}
+var puzzleSpecificSimplifyOptions333 = {
+  quantumMoveOrder: () => 4,
+  axis: { areQuantumMovesSameAxis, simplifySameAxisMoves }
+};
+
 // src/cubing/puzzles/implementations/3x3x3/index.ts
 var cube3x3x3 = {
   id: "3x3x3",
@@ -394,16 +647,17 @@ var cube3x3x3 = {
     return experimental3x3x3KPuzzle;
   }),
   svg: getCached(async () => {
-    return (await import("./puzzles-dynamic-3x3x3-KIG5A6QR.js")).cube3x3x3SVG;
+    return (await import("./puzzles-dynamic-3x3x3-ZKMODX2P.js")).cube3x3x3SVG;
   }),
   llSVG: getCached(async () => {
-    return (await import("./puzzles-dynamic-3x3x3-KIG5A6QR.js")).cube3x3x3LLSVG;
+    return (await import("./puzzles-dynamic-3x3x3-ZKMODX2P.js")).cube3x3x3LLSVG;
   }),
   pg: getCached(async () => {
     return asyncGetPuzzleGeometry("3x3x3");
   }),
   appearance: (stickering) => cubeAppearance(cube3x3x3, stickering),
-  stickerings: cubeStickerings
+  stickerings: cubeStickerings,
+  puzzleSpecificSimplifyOptions: puzzleSpecificSimplifyOptions333
 };
 
 // src/cubing/puzzles/implementations/clock/index.ts
@@ -414,11 +668,11 @@ var clock = {
   inventionYear: 1988,
   kpuzzle: getCached(
     async () => new KPuzzle(
-      (await import("./puzzles-dynamic-side-events-5C7LMBWX.js")).clockJSON
+      (await import("./puzzles-dynamic-side-events-HMUBMHA5.js")).clockJSON
     )
   ),
   svg: getCached(async () => {
-    return (await import("./puzzles-dynamic-side-events-5C7LMBWX.js")).clockSVG;
+    return (await import("./puzzles-dynamic-side-events-HMUBMHA5.js")).clockSVG;
   })
 };
 
@@ -451,43 +705,49 @@ async function ftoStickering(puzzleLoader, stickering) {
   switch (stickering) {
     case "full":
       break;
-    case "experimental-fto-fc":
+    case "experimental-fto-fc": {
       puzzleStickering.set(
         m.not(experimentalFTO_FC()),
         "Ignored" /* Ignored */
       );
       break;
-    case "experimental-fto-f2t":
+    }
+    case "experimental-fto-f2t": {
       puzzleStickering.set(
         m.not(experimentalFTO_F2T()),
         "Ignored" /* Ignored */
       );
       puzzleStickering.set(experimentalFTO_FC(), "Dim" /* Dim */);
       break;
-    case "experimental-fto-sc":
+    }
+    case "experimental-fto-sc": {
       puzzleStickering.set(
         m.not(experimentalFTO_SC()),
         "Ignored" /* Ignored */
       );
       puzzleStickering.set(experimentalFTO_F2T(), "Dim" /* Dim */);
       break;
-    case "experimental-fto-l2c":
+    }
+    case "experimental-fto-l2c": {
       puzzleStickering.set(
         m.not(experimentalFTO_L2C()),
         "Ignored" /* Ignored */
       );
       puzzleStickering.set(experimentalFTO_SC(), "Dim" /* Dim */);
       break;
-    case "experimental-fto-lbt":
+    }
+    case "experimental-fto-lbt": {
       puzzleStickering.set(
         m.not(experimentalFTO_LBT()),
         "Ignored" /* Ignored */
       );
       puzzleStickering.set(experimentalFTO_L2C(), "Dim" /* Dim */);
       break;
-    case "experimental-fto-l3t":
+    }
+    case "experimental-fto-l3t": {
       puzzleStickering.set(experimentalFTO_LBT(), "Dim" /* Dim */);
       break;
+    }
     default:
       console.warn(
         `Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`
@@ -520,7 +780,7 @@ var FTOPuzzleLoader = class extends PGPuzzleLoader {
     });
     this.stickerings = ftoStickerings;
     this.svg = getCached(async () => {
-      return (await import("./puzzles-dynamic-unofficial-WWJ4NJMX.js")).ftoSVG;
+      return (await import("./puzzles-dynamic-unofficial-QXSDLTK5.js")).ftoSVG;
     });
   }
   appearance(stickering) {
@@ -576,7 +836,7 @@ var PyraminxPuzzleLoader = class extends PGPuzzleLoader {
       inventedBy: ["Uwe Meffert"]
     });
     this.svg = getCached(async () => {
-      return (await import("./puzzles-dynamic-side-events-5C7LMBWX.js")).pyraminxSVG;
+      return (await import("./puzzles-dynamic-side-events-HMUBMHA5.js")).pyraminxSVG;
     });
   }
 };
@@ -590,11 +850,11 @@ var square1 = {
   inventionYear: 1990,
   kpuzzle: getCached(
     async () => new KPuzzle(
-      (await import("./puzzles-dynamic-side-events-5C7LMBWX.js")).sq1HyperOrbitJSON
+      (await import("./puzzles-dynamic-side-events-HMUBMHA5.js")).sq1HyperOrbitJSON
     )
   ),
   svg: getCached(async () => {
-    return (await import("./puzzles-dynamic-side-events-5C7LMBWX.js")).sq1HyperOrbitSVG;
+    return (await import("./puzzles-dynamic-side-events-HMUBMHA5.js")).sq1HyperOrbitSVG;
   })
 };
 
@@ -637,7 +897,7 @@ var kilominx = {
     return kpuzzle;
   }),
   svg: getCached(async () => {
-    return (await import("./puzzles-dynamic-unofficial-WWJ4NJMX.js")).kilominxSVG;
+    return (await import("./puzzles-dynamic-unofficial-QXSDLTK5.js")).kilominxSVG;
   })
 };
 
@@ -649,11 +909,11 @@ var rediCube = {
   inventionYear: 2009,
   kpuzzle: getCached(
     async () => new KPuzzle(
-      (await import("./puzzles-dynamic-unofficial-WWJ4NJMX.js")).rediCubeJSON
+      (await import("./puzzles-dynamic-unofficial-QXSDLTK5.js")).rediCubeJSON
     )
   ),
   svg: async () => {
-    return (await import("./puzzles-dynamic-unofficial-WWJ4NJMX.js")).rediCubeSVG;
+    return (await import("./puzzles-dynamic-unofficial-QXSDLTK5.js")).rediCubeSVG;
   }
 };
 
@@ -663,7 +923,7 @@ var cube4x4x4 = new CubePGPuzzleLoader({
   fullName: "4\xD74\xD74 Cube"
 });
 cube4x4x4.llSVG = getCached(async () => {
-  return (await import("./puzzles-dynamic-4x4x4-PEDAPUZK.js")).cube4x4x4LLSVG;
+  return (await import("./puzzles-dynamic-4x4x4-DT42HVIY.js")).cube4x4x4LLSVG;
 });
 
 // src/cubing/puzzles/index.ts
@@ -679,22 +939,22 @@ var puzzles = {
     fullName: "40\xD740\xD740 Cube"
   }),
   clock,
-  "megaminx": megaminx,
+  megaminx,
   pyraminx,
-  "skewb": new PGPuzzleLoader({
+  skewb: new PGPuzzleLoader({
     id: "skewb",
     fullName: "Skewb",
     inventedBy: ["Tony Durham"]
   }),
   square1,
-  "fto": fto,
-  "gigaminx": new PGPuzzleLoader({
+  fto,
+  gigaminx: new PGPuzzleLoader({
     id: "gigaminx",
     fullName: "Gigaminx",
     inventedBy: ["Tyler Fox"],
     inventionYear: 2006
   }),
-  "master_tetraminx": new PGPuzzleLoader({
+  master_tetraminx: new PGPuzzleLoader({
     pgID: "master tetraminx",
     id: "master_tetraminx",
     fullName: "Master Tetraminx",
@@ -702,14 +962,16 @@ var puzzles = {
     inventionYear: 2002
   }),
   kilominx,
-  "redi_cube": rediCube
+  redi_cube: rediCube
 };
 
 export {
+  wcaEvents,
   wcaEventInfo,
+  twizzleEvents,
   eventInfo,
   cube2x2x2,
   cube3x3x3,
   puzzles
 };
-//# sourceMappingURL=chunk-XRZBPKES.js.map
+//# sourceMappingURL=chunk-35OK6TQ4.js.map