cubing 0.20.2 → 0.21.0-pre12

package/dist/esm/chunk-CQS6JZ7G.js

@@ -0,0 +1,762 @@
+import {
+  cube3x3x3KPuzzle,
+  transformationForMove
+} from "./chunk-YV3RT5PX.js";
+import {
+  Move,
+  experimentalIs
+} from "./chunk-BU5PUJK3.js";
+
+// src/cubing/puzzles/customPGPuzzleLoader.ts
+async function descAsyncGetPuzzleGeometry(desc) {
+  const puzzleGeometry = await import("./puzzle-geometry/index.js");
+  return puzzleGeometry.getPuzzleGeometryByDesc(desc, {
+    allMoves: true,
+    orientCenters: true,
+    addRotations: true
+  });
+}
+async function dsecAsyncGetDef(desc) {
+  return (await descAsyncGetPuzzleGeometry(desc)).writekpuzzle(true);
+}
+var nextCustomID = 1;
+function customPGPuzzleLoader(desc, info) {
+  const customID = nextCustomID++;
+  const puzzleLoader = {
+    id: `custom-${customID}`,
+    fullName: info?.fullName ?? `Custom Puzzle (instance #${customID})`,
+    def: async () => {
+      return dsecAsyncGetDef(desc);
+    },
+    svg: async () => {
+      const pg = await descAsyncGetPuzzleGeometry(desc);
+      return pg.generatesvg();
+    },
+    pg: async () => {
+      return descAsyncGetPuzzleGeometry(desc);
+    }
+  };
+  if (info?.inventedBy) {
+    puzzleLoader.inventedBy = info.inventedBy;
+  }
+  if (info?.inventionYear) {
+    puzzleLoader.inventionYear = info.inventionYear;
+  }
+  return puzzleLoader;
+}
+
+// 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["Regular"] = "Regular";
+  PieceStickering2["Dim"] = "Dim";
+  PieceStickering2["Ignored"] = "Ignored";
+  PieceStickering2["OrientationStickers"] = "OrientationStickers";
+  PieceStickering2["Invisible"] = "Invisible";
+  PieceStickering2["Ignoriented"] = "Ignoriented";
+  PieceStickering2["IgnoreNonPrimary"] = "IgnoreNonPrimary";
+  PieceStickering2["PermuteNonPrimary"] = "PermuteNonPrimary";
+  PieceStickering2["OrientationWithoutPermutation"] = "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 PieceStickering.Regular:
+      return r;
+    case PieceStickering.Dim:
+      return d;
+    case PieceStickering.Ignored:
+      return i;
+    case PieceStickering.OrientationStickers:
+      return o;
+    case PieceStickering.Invisible:
+      return invisiblePiece;
+    case PieceStickering.IgnoreNonPrimary:
+      return riiii;
+    case PieceStickering.PermuteNonPrimary:
+      return drrrr;
+    case PieceStickering.Ignoriented:
+      return diiii;
+    case PieceStickering.OrientationWithoutPermutation:
+      return oiiii;
+  }
+}
+var PuzzleStickering = class extends PieceAnnotation {
+  constructor(def) {
+    super(def, PieceStickering.Regular);
+  }
+  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/global-custom-stickering-hack.ts
+var globalCustomStickerer = () => {
+};
+function setGlobalCustomStickerer(stickerer) {
+  (async () => {
+    globalCustomStickerer = stickerer;
+    const players = Array.from(document.body.querySelectorAll("twisty-player"));
+    console.log(`Setting the custom stickering for ${players.length} players!`);
+    const successPromises = [];
+    for (const player of players) {
+      successPromises.push((async () => {
+        const stickering = await player.experimentalModel.stickeringProp.get();
+        player.experimentalStickering = stickering === "experimental-global-custom-1" ? "experimental-global-custom-2" : "experimental-global-custom-1";
+      })());
+    }
+    await Promise.all(successPromises);
+    console.log("Success!");
+  })();
+}
+function useGlobalCustomStickerer(puzzleStickering, m) {
+  globalCustomStickerer(puzzleStickering, m);
+}
+if (typeof location !== "undefined" && new URL(location.href).searchParams.get("global-custom-stickerer") === "true") {
+  window.setGlobalCustomStickerer = setGlobalCustomStickerer;
+  window.PieceStickering = PieceStickering;
+  console.log("Global custom stickerer enabled! (using: global-custom-stickerer=true)");
+  console.log("Look here for inspiration:", "https://github.com/cubing/cubing.js/blob/81b5cab3e27d8defb39dd1e0a10bc9e8ba894d26/src/cubing/puzzles/stickerings/cube-stickerings.ts#L67");
+}
+
+// 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;
+    case "experimental-global-custom-1":
+    case "experimental-global-custom-2":
+      useGlobalCustomStickerer(puzzleStickering, m);
+      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",
+    "experimental-global-custom-1",
+    "experimental-global-custom-2"
+  ];
+}
+
+// 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,
+    addRotations: 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-JOGUSQ4N.js")).cube2x2x2KPuzzle;
+  },
+  svg: async () => {
+    return (await import("./2x2x2.kpuzzle.svg-CQF2FTV7.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-ERSSH66P.js")).default;
+  },
+  llSVG: async () => {
+    return (await import("./3x3x3-ll.kpuzzle.svg-53CBPG5O.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-EKWRMHJM.js")).clockKPuzzle;
+  },
+  svg: async () => {
+    return (await import("./clock.kpuzzle.svg-B7TMN3SY.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")]),
+    m.and([m.move("BL"), 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);
+      puzzleStickering.set(experimentalFTO_FC(), PieceStickering.Dim);
+      break;
+    case "experimental-fto-sc":
+      puzzleStickering.set(m.not(experimentalFTO_SC()), PieceStickering.Ignored);
+      puzzleStickering.set(experimentalFTO_F2T(), PieceStickering.Dim);
+      break;
+    case "experimental-fto-l2c":
+      puzzleStickering.set(m.not(experimentalFTO_L2C()), PieceStickering.Ignored);
+      puzzleStickering.set(experimentalFTO_SC(), PieceStickering.Dim);
+      break;
+    case "experimental-fto-lbt":
+      puzzleStickering.set(m.not(experimentalFTO_LBT()), PieceStickering.Ignored);
+      puzzleStickering.set(experimentalFTO_L2C(), PieceStickering.Dim);
+      break;
+    case "experimental-fto-l3t":
+      puzzleStickering.set(experimentalFTO_LBT(), PieceStickering.Dim);
+      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",
+    "experimental-fto-l3t"
+  ];
+}
+
+// src/cubing/puzzles/implementations/fto/index.ts
+var fto = {
+  id: "fto",
+  fullName: "Face-Turning Octahedron",
+  inventedBy: ["Karl Rohrbach", "David Pitcher"],
+  inventionYear: 1983,
+  def: async () => {
+    return asyncGetDef("FTO");
+  },
+  svg: async () => {
+    const pg = await asyncGetPuzzleGeometry("FTO");
+    return pg.generatesvg();
+  },
+  pg: async () => {
+    return asyncGetPuzzleGeometry("FTO");
+  },
+  appearance: (stickering) => ftoStickering(fto, stickering),
+  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-QBBMZVDY.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-N3FGCPML.js")).sq1HyperOrbitKPuzzle;
+  },
+  svg: async () => {
+    return (await import("./sq1-hyperorbit.kpuzzle.svg-ID57EER7.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": { puzzleID: "3x3x3", eventName: "3x3x3 Cube" },
+  "222": { puzzleID: "2x2x2", eventName: "2x2x2 Cube" },
+  "444": { puzzleID: "4x4x4", eventName: "4x4x4 Cube" },
+  "555": { puzzleID: "5x5x5", eventName: "5x5x5 Cube" },
+  "666": { puzzleID: "6x6x6", eventName: "6x6x6 Cube" },
+  "777": { puzzleID: "7x7x7", eventName: "7x7x7 Cube" },
+  "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" },
+  "444bf": { puzzleID: "4x4x4", eventName: "4x4x4 Blindfolded" },
+  "555bf": { puzzleID: "5x5x5", eventName: "5x5x5 Blindfolded" },
+  "333mb": { puzzleID: "3x3x3", eventName: " 3x3x3 Multi-Blind" }
+};
+function puzzleIDForWCAEvent(event) {
+  return wcaEvents[event]?.puzzleID ?? null;
+}
+
+export {
+  customPGPuzzleLoader,
+  getFaceletAppearance,
+  cubeAppearance,
+  cube2x2x2,
+  cube3x3x3,
+  puzzles,
+  puzzleIDForWCAEvent
+};
+//# sourceMappingURL=chunk-CQS6JZ7G.js.map