cubing 0.31.6 → 0.32.0

package/dist/esm/{chunk-TUETQPSZ.js → chunk-W6D5GKZQ.js}

@@ -1,10 +1,11 @@
 import {
   KPuzzle,
   KState
-} from "./chunk-LGJ4AXVG.js";
+} from "./chunk-AUF56UEH.js";
 import {
-  Alg
-} from "./chunk-23PDUZN6.js";
+  Alg,
+  Move
+} from "./chunk-IJP4IAGZ.js";
 
 // src/cubing/puzzles/stickerings/mask.ts
 function getFaceletStickeringMask(stickeringMask, orbitName, pieceIdx, faceletIdx, hint) {
@@ -194,6 +195,456 @@ var StickeringManager = class {
   }
 };
 
+// src/cubing/puzzles/stickerings/puzzle-stickerings.ts
+var experimentalStickerings = {
+  full: { groups: { "3x3x3": "Stickering" } },
+  OLL: { groups: { "3x3x3": "Last Layer" } },
+  PLL: { groups: { "3x3x3": "Last Layer" } },
+  LL: { groups: { "3x3x3": "Last Layer" } },
+  EOLL: { groups: { "3x3x3": "Last Layer" } },
+  COLL: { groups: { "3x3x3": "Last Layer" } },
+  OCLL: { groups: { "3x3x3": "Last Layer" } },
+  CLL: { groups: { "3x3x3": "Last Layer" } },
+  ELL: { groups: { "3x3x3": "Last Layer" } },
+  ZBLL: { groups: { "3x3x3": "Last Layer" } },
+  LS: { groups: { "3x3x3": "Last Slot" } },
+  ELS: { groups: { "3x3x3": "Last Slot" } },
+  CLS: { groups: { "3x3x3": "Last Slot" } },
+  ZBLS: { groups: { "3x3x3": "Last Slot" } },
+  VLS: { groups: { "3x3x3": "Last Slot" } },
+  WVLS: { groups: { "3x3x3": "Last Slot" } },
+  F2L: { groups: { "3x3x3": "CFOP (Fridrich)" } },
+  Daisy: { groups: { "3x3x3": "CFOP (Fridrich)" } },
+  Cross: { groups: { "3x3x3": "CFOP (Fridrich)" } },
+  EO: { groups: { "3x3x3": "ZZ" } },
+  EOline: { groups: { "3x3x3": "ZZ" } },
+  EOcross: { groups: { "3x3x3": "ZZ" } },
+  CMLL: { groups: { "3x3x3": "Roux" } },
+  L10P: { groups: { "3x3x3": "Roux" } },
+  L6E: { groups: { "3x3x3": "Roux" } },
+  L6EO: { groups: { "3x3x3": "Roux" } },
+  "2x2x2": { groups: { "3x3x3": "Petrus" } },
+  "2x2x3": { groups: { "3x3x3": "Petrus" } },
+  "Void Cube": { groups: { "3x3x3": "Miscellaneous" } },
+  invisible: { groups: { "3x3x3": "Miscellaneous" } },
+  picture: { groups: { "3x3x3": "Miscellaneous" } },
+  "centers-only": { groups: { "3x3x3": "Miscellaneous" } },
+  "experimental-centers-U": {},
+  "experimental-centers-U-D": {},
+  "experimental-centers-U-L-D": {},
+  "experimental-centers-U-L-B-D": {},
+  "experimental-centers": {},
+  "experimental-fto-fc": { groups: { fto: "Bencisco" } },
+  "experimental-fto-f2t": { groups: { fto: "Bencisco" } },
+  "experimental-fto-sc": { groups: { fto: "Bencisco" } },
+  "experimental-fto-l2c": { groups: { fto: "Bencisco" } },
+  "experimental-fto-lbt": { groups: { fto: "Bencisco" } },
+  "experimental-fto-l3t": { groups: { fto: "Bencisco" } }
+};
+
+// src/cubing/puzzles/stickerings/cube-like-stickerings.ts
+async function cubeLikeStickeringMask(puzzleLoader, stickering) {
+  const kpuzzle = await puzzleLoader.kpuzzle();
+  const puzzleStickering = new PuzzleStickering(kpuzzle);
+  const m = new StickeringManager(kpuzzle);
+  const LL = () => m.move("U");
+  const orUD = () => m.or(m.moves(["U", "D"]));
+  const orLR = () => m.or(m.moves(["L", "R"]));
+  const M = () => m.not(orLR());
+  const F2L = () => m.not(LL());
+  const CENTERS = () => m.orbitPrefix("CENTER");
+  const EDGES = () => m.orbitPrefix("EDGE");
+  const CORNERS = () => m.or([
+    m.orbitPrefix("CORNER"),
+    m.orbitPrefix("C4RNER"),
+    m.orbitPrefix("C5RNER")
+  ]);
+  const L6E = () => m.or([M(), m.and([LL(), EDGES()])]);
+  const centerLL = () => m.and([LL(), CENTERS()]);
+  const edgeFR = () => m.and([m.and(m.moves(["F", "R"])), EDGES()]);
+  const cornerDFR = () => m.and([m.and(m.moves(["F", "R"])), CORNERS(), m.not(LL())]);
+  const slotFR = () => m.or([cornerDFR(), edgeFR()]);
+  function dimF2L() {
+    puzzleStickering.set(F2L(), "Dim" /* Dim */);
+  }
+  function setPLL() {
+    puzzleStickering.set(LL(), "PermuteNonPrimary" /* PermuteNonPrimary */);
+    puzzleStickering.set(centerLL(), "Dim" /* Dim */);
+  }
+  function setOLL() {
+    puzzleStickering.set(LL(), "IgnoreNonPrimary" /* IgnoreNonPrimary */);
+    puzzleStickering.set(centerLL(), "Regular" /* Regular */);
+  }
+  function dimOLL() {
+    puzzleStickering.set(LL(), "Ignoriented" /* Ignoriented */);
+    puzzleStickering.set(centerLL(), "Dim" /* Dim */);
+  }
+  switch (stickering) {
+    case "full":
+      break;
+    case "PLL": {
+      dimF2L();
+      setPLL();
+      break;
+    }
+    case "CLS": {
+      dimF2L();
+      puzzleStickering.set(cornerDFR(), "Regular" /* Regular */);
+      puzzleStickering.set(LL(), "Ignoriented" /* Ignoriented */);
+      puzzleStickering.set(m.and([LL(), CENTERS()]), "Dim" /* Dim */);
+      puzzleStickering.set(
+        m.and([LL(), CORNERS()]),
+        "IgnoreNonPrimary" /* IgnoreNonPrimary */
+      );
+      break;
+    }
+    case "OLL": {
+      dimF2L();
+      setOLL();
+      break;
+    }
+    case "EOLL": {
+      dimF2L();
+      setOLL();
+      puzzleStickering.set(m.and([LL(), CORNERS()]), "Ignored" /* Ignored */);
+      break;
+    }
+    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": {
+      dimF2L();
+      dimOLL();
+      puzzleStickering.set(
+        m.and([LL(), CORNERS()]),
+        "IgnoreNonPrimary" /* IgnoreNonPrimary */
+      );
+      break;
+    }
+    case "CLL": {
+      dimF2L();
+      puzzleStickering.set(
+        m.not(m.and([CORNERS(), LL()])),
+        "Dim" /* Dim */
+      );
+      break;
+    }
+    case "ELL": {
+      dimF2L();
+      puzzleStickering.set(LL(), "Dim" /* Dim */);
+      puzzleStickering.set(m.and([LL(), EDGES()]), "Regular" /* Regular */);
+      break;
+    }
+    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": {
+      dimF2L();
+      break;
+    }
+    case "F2L": {
+      puzzleStickering.set(LL(), "Ignored" /* Ignored */);
+      break;
+    }
+    case "ZBLL": {
+      dimF2L();
+      puzzleStickering.set(LL(), "PermuteNonPrimary" /* PermuteNonPrimary */);
+      puzzleStickering.set(centerLL(), "Dim" /* Dim */);
+      puzzleStickering.set(m.and([LL(), CORNERS()]), "Regular" /* Regular */);
+      break;
+    }
+    case "ZBLS": {
+      dimF2L();
+      puzzleStickering.set(slotFR(), "Regular" /* Regular */);
+      setOLL();
+      puzzleStickering.set(m.and([LL(), CORNERS()]), "Ignored" /* Ignored */);
+      break;
+    }
+    case "VLS": {
+      dimF2L();
+      puzzleStickering.set(slotFR(), "Regular" /* Regular */);
+      setOLL();
+      break;
+    }
+    case "WVLS": {
+      dimF2L();
+      puzzleStickering.set(slotFR(), "Regular" /* Regular */);
+      puzzleStickering.set(m.and([LL(), EDGES()]), "Ignoriented" /* Ignoriented */);
+      puzzleStickering.set(m.and([LL(), CENTERS()]), "Dim" /* Dim */);
+      puzzleStickering.set(
+        m.and([LL(), CORNERS()]),
+        "IgnoreNonPrimary" /* IgnoreNonPrimary */
+      );
+      break;
+    }
+    case "LS": {
+      dimF2L();
+      puzzleStickering.set(slotFR(), "Regular" /* Regular */);
+      puzzleStickering.set(LL(), "Ignored" /* Ignored */);
+      puzzleStickering.set(centerLL(), "Dim" /* Dim */);
+      break;
+    }
+    case "EO": {
+      puzzleStickering.set(CORNERS(), "Ignored" /* Ignored */);
+      puzzleStickering.set(
+        EDGES(),
+        "OrientationWithoutPermutation" /* OrientationWithoutPermutation */
+      );
+      break;
+    }
+    case "EOline": {
+      puzzleStickering.set(CORNERS(), "Ignored" /* Ignored */);
+      puzzleStickering.set(
+        EDGES(),
+        "OrientationWithoutPermutation" /* OrientationWithoutPermutation */
+      );
+      puzzleStickering.set(m.and(m.moves(["D", "M"])), "Regular" /* Regular */);
+      break;
+    }
+    case "EOcross": {
+      puzzleStickering.set(
+        EDGES(),
+        "OrientationWithoutPermutation" /* OrientationWithoutPermutation */
+      );
+      puzzleStickering.set(m.move("D"), "Regular" /* Regular */);
+      puzzleStickering.set(CORNERS(), "Ignored" /* Ignored */);
+      break;
+    }
+    case "CMLL": {
+      puzzleStickering.set(F2L(), "Dim" /* Dim */);
+      puzzleStickering.set(L6E(), "Ignored" /* Ignored */);
+      puzzleStickering.set(m.and([LL(), CORNERS()]), "Regular" /* Regular */);
+      break;
+    }
+    case "L10P": {
+      puzzleStickering.set(m.not(L6E()), "Dim" /* Dim */);
+      puzzleStickering.set(m.and([CORNERS(), LL()]), "Regular" /* Regular */);
+      break;
+    }
+    case "L6E": {
+      puzzleStickering.set(m.not(L6E()), "Dim" /* Dim */);
+      break;
+    }
+    case "L6EO": {
+      puzzleStickering.set(m.not(L6E()), "Dim" /* Dim */);
+      puzzleStickering.set(
+        L6E(),
+        "OrientationWithoutPermutation" /* OrientationWithoutPermutation */
+      );
+      puzzleStickering.set(
+        m.and([CENTERS(), orUD()]),
+        "OrientationStickers" /* OrientationStickers */
+      );
+      break;
+    }
+    case "Daisy": {
+      puzzleStickering.set(m.all(), "Ignored" /* Ignored */);
+      puzzleStickering.set(CENTERS(), "Dim" /* Dim */);
+      puzzleStickering.set(
+        m.and([m.move("D"), CENTERS()]),
+        "Regular" /* Regular */
+      );
+      puzzleStickering.set(
+        m.and([m.move("U"), EDGES()]),
+        "IgnoreNonPrimary" /* IgnoreNonPrimary */
+      );
+      break;
+    }
+    case "Cross": {
+      puzzleStickering.set(m.all(), "Ignored" /* Ignored */);
+      puzzleStickering.set(CENTERS(), "Dim" /* Dim */);
+      puzzleStickering.set(
+        m.and([m.move("D"), CENTERS()]),
+        "Regular" /* Regular */
+      );
+      puzzleStickering.set(
+        m.and([m.move("D"), EDGES()]),
+        "Regular" /* Regular */
+      );
+      break;
+    }
+    case "2x2x2": {
+      puzzleStickering.set(
+        m.or(m.moves(["U", "F", "R"])),
+        "Ignored" /* Ignored */
+      );
+      puzzleStickering.set(
+        m.and([m.or(m.moves(["U", "F", "R"])), CENTERS()]),
+        "Dim" /* Dim */
+      );
+      break;
+    }
+    case "2x2x3": {
+      puzzleStickering.set(m.all(), "Dim" /* Dim */);
+      puzzleStickering.set(
+        m.or(m.moves(["U", "F", "R"])),
+        "Ignored" /* Ignored */
+      );
+      puzzleStickering.set(
+        m.and([m.or(m.moves(["U", "F", "R"])), CENTERS()]),
+        "Dim" /* Dim */
+      );
+      puzzleStickering.set(
+        m.and([m.move("F"), m.not(m.or(m.moves(["U", "R"])))]),
+        "Regular" /* Regular */
+      );
+      break;
+    }
+    case "Void Cube": {
+      puzzleStickering.set(CENTERS(), "Invisible" /* Invisible */);
+      break;
+    }
+    case "picture":
+    case "invisible": {
+      puzzleStickering.set(m.all(), "Invisible" /* Invisible */);
+      break;
+    }
+    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.`
+      );
+      puzzleStickering.set(m.and(m.moves([])), "Dim" /* Dim */);
+  }
+  return puzzleStickering.toStickeringMask();
+}
+async function cubeStickerings() {
+  const stickerings = [];
+  for (const [name, info] of Object.entries(experimentalStickerings)) {
+    if (info.groups && "3x3x3" in info.groups) {
+      stickerings.push(name);
+    }
+  }
+  return stickerings;
+}
+
+// src/cubing/puzzles/async/lazy-cached.ts
+function getCached(getValue) {
+  let cachedPromise = null;
+  return () => {
+    return cachedPromise ?? (cachedPromise = getValue());
+  };
+}
+
+// src/cubing/vendor/p-lazy/p-lazy.ts
+var PLazy = class extends Promise {
+  constructor(executor) {
+    super((resolve) => {
+      resolve();
+    });
+    this._executor = executor;
+  }
+  static from(function_) {
+    return new PLazy((resolve) => {
+      resolve(function_());
+    });
+  }
+  static resolve(value) {
+    return new PLazy((resolve) => {
+      resolve(value);
+    });
+  }
+  static reject(error) {
+    return new PLazy((_resolve, reject) => {
+      reject(error);
+    });
+  }
+  then(onFulfilled, onRejected) {
+    this._promise = this._promise || new Promise(this._executor);
+    return this._promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    this._promise = this._promise || new Promise(this._executor);
+    return this._promise.catch(onRejected);
+  }
+};
+function from(function_) {
+  return new PLazy((resolve) => {
+    resolve(function_());
+  });
+}
+
+// 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 asyncGetKPuzzle(pgPromise, puzzleName) {
+  const pg = await pgPromise;
+  const kpuzzleDefinition = pg.getKPuzzleDefinition(true);
+  kpuzzleDefinition.name = puzzleName;
+  const puzzleGeometry = await import("./puzzle-geometry/index.js");
+  const pgNotation = new puzzleGeometry.ExperimentalPGNotation(
+    pg,
+    pg.getOrbitsDef(true)
+  );
+  return new KPuzzle(kpuzzleDefinition, {
+    experimentalPGNotation: pgNotation
+  });
+}
+var PGPuzzleLoader = class {
+  constructor(info) {
+    this.puzzleSpecificSimplifyOptionsPromise = puzzleSpecificSimplifyOptionsPromise(
+      this.kpuzzle.bind(this)
+    );
+    this.pgId = info.pgID;
+    this.id = info.id;
+    this.fullName = info.fullName;
+    this.inventedBy = info.inventedBy;
+    this.inventionYear = info.inventionYear;
+  }
+  #cachedPG;
+  pg() {
+    return this.#cachedPG ?? (this.#cachedPG = asyncGetPuzzleGeometry(this.pgId ?? this.id));
+  }
+  #cachedKPuzzle;
+  kpuzzle() {
+    return this.#cachedKPuzzle ?? (this.#cachedKPuzzle = asyncGetKPuzzle(this.pg(), this.id));
+  }
+  #cachedSVG;
+  svg() {
+    return this.#cachedSVG ?? (this.#cachedSVG = (async () => (await this.pg()).generatesvg())());
+  }
+};
+var CubePGPuzzleLoader = class extends PGPuzzleLoader {
+  constructor() {
+    super(...arguments);
+    this.stickerings = cubeStickerings;
+  }
+  stickeringMask(stickering) {
+    return cubeLikeStickeringMask(this, stickering);
+  }
+};
+function puzzleSpecificSimplifyOptionsPromise(kpuzzlePromiseFn) {
+  return new PLazy(
+    async (resolve) => {
+      const kpuzzle = await kpuzzlePromiseFn();
+      console.log(kpuzzle);
+      resolve({
+        quantumMoveOrder: (m) => {
+          return kpuzzle.moveToTransformation(new Move(m)).repetitionOrder();
+        }
+      });
+    }
+  );
+}
+
 // src/cubing/puzzles/implementations/dynamic/3x3x3/3x3x3.kpuzzle.json.ts
 var cube3x3x3KPuzzleDefinition = {
   name: "3x3x3",
@@ -492,52 +943,14 @@ cube3x3x3KPuzzleDefinition.experimentalDerivedMoves = {
   "2D": "d D'"
 };
 
-// src/cubing/puzzles/stickerings/puzzle-stickerings.ts
-var experimentalStickerings = {
-  full: { groups: { "3x3x3": "Stickering" } },
-  OLL: { groups: { "3x3x3": "Last Layer" } },
-  PLL: { groups: { "3x3x3": "Last Layer" } },
-  LL: { groups: { "3x3x3": "Last Layer" } },
-  EOLL: { groups: { "3x3x3": "Last Layer" } },
-  COLL: { groups: { "3x3x3": "Last Layer" } },
-  OCLL: { groups: { "3x3x3": "Last Layer" } },
-  CLL: { groups: { "3x3x3": "Last Layer" } },
-  ELL: { groups: { "3x3x3": "Last Layer" } },
-  ZBLL: { groups: { "3x3x3": "Last Layer" } },
-  LS: { groups: { "3x3x3": "Last Slot" } },
-  ELS: { groups: { "3x3x3": "Last Slot" } },
-  CLS: { groups: { "3x3x3": "Last Slot" } },
-  ZBLS: { groups: { "3x3x3": "Last Slot" } },
-  VLS: { groups: { "3x3x3": "Last Slot" } },
-  WVLS: { groups: { "3x3x3": "Last Slot" } },
-  F2L: { groups: { "3x3x3": "CFOP (Fridrich)" } },
-  Daisy: { groups: { "3x3x3": "CFOP (Fridrich)" } },
-  Cross: { groups: { "3x3x3": "CFOP (Fridrich)" } },
-  EO: { groups: { "3x3x3": "ZZ" } },
-  EOline: { groups: { "3x3x3": "ZZ" } },
-  EOcross: { groups: { "3x3x3": "ZZ" } },
-  CMLL: { groups: { "3x3x3": "Roux" } },
-  L10P: { groups: { "3x3x3": "Roux" } },
-  L6E: { groups: { "3x3x3": "Roux" } },
-  L6EO: { groups: { "3x3x3": "Roux" } },
-  "2x2x2": { groups: { "3x3x3": "Petrus" } },
-  "2x2x3": { groups: { "3x3x3": "Petrus" } },
-  "Void Cube": { groups: { "3x3x3": "Miscellaneous" } },
-  invisible: { groups: { "3x3x3": "Miscellaneous" } },
-  picture: { groups: { "3x3x3": "Miscellaneous" } },
-  "centers-only": { groups: { "3x3x3": "Miscellaneous" } },
-  "experimental-centers-U": {},
-  "experimental-centers-U-D": {},
-  "experimental-centers-U-L-D": {},
-  "experimental-centers-U-L-B-D": {},
-  "experimental-centers": {},
-  "experimental-fto-fc": { groups: { fto: "Bencisco" } },
-  "experimental-fto-f2t": { groups: { fto: "Bencisco" } },
-  "experimental-fto-sc": { groups: { fto: "Bencisco" } },
-  "experimental-fto-l2c": { groups: { fto: "Bencisco" } },
-  "experimental-fto-lbt": { groups: { fto: "Bencisco" } },
-  "experimental-fto-l3t": { groups: { fto: "Bencisco" } }
-};
+// src/cubing/puzzles/PuzzleLoader.ts
+async function getPartialAppendOptionsForPuzzleSpecificSimplifyOptions(puzzleLoader) {
+  const puzzleSpecificSimplifyOptions = await (puzzleLoader.puzzleSpecificSimplifyOptions ?? puzzleLoader.puzzleSpecificSimplifyOptionsPromise);
+  if (!puzzleSpecificSimplifyOptions) {
+    return {};
+  }
+  return { puzzleLoader: { puzzleSpecificSimplifyOptions } };
+}
 
 // src/cubing/puzzles/customPGPuzzleLoader.ts
 async function descAsyncGetPuzzleGeometry(desc) {
@@ -548,7 +961,7 @@ async function descAsyncGetPuzzleGeometry(desc) {
     addRotations: true
   });
 }
-async function asyncGetKPuzzle(desc) {
+async function asyncGetKPuzzle2(desc) {
   const pg = await descAsyncGetPuzzleGeometry(desc);
   const kpuzzleDefinition = pg.getKPuzzleDefinition(true);
   kpuzzleDefinition.name = `description: ${desc}`;
@@ -565,19 +978,21 @@ var nextCustomID = 1;
 function customPGPuzzleLoader(desc, info) {
   const customID = nextCustomID++;
   let cachedKPuzzle = null;
+  const kpuzzlePromiseFn = async () => {
+    return cachedKPuzzle ?? (cachedKPuzzle = asyncGetKPuzzle2(desc));
+  };
   const puzzleLoader = {
     id: `custom-${customID}`,
     fullName: info?.fullName ?? `Custom Puzzle (instance #${customID})`,
-    kpuzzle: async () => {
-      return cachedKPuzzle ?? (cachedKPuzzle = asyncGetKPuzzle(desc));
-    },
+    kpuzzle: kpuzzlePromiseFn,
     svg: async () => {
       const pg = await descAsyncGetPuzzleGeometry(desc);
       return pg.generatesvg();
     },
     pg: async () => {
       return descAsyncGetPuzzleGeometry(desc);
-    }
+    },
+    puzzleSpecificSimplifyOptionsPromise: puzzleSpecificSimplifyOptionsPromise(kpuzzlePromiseFn)
   };
   if (info?.inventedBy) {
     puzzleLoader.inventedBy = info.inventedBy;
@@ -660,11 +1075,18 @@ export {
   getPieceStickeringMask,
   PuzzleStickering,
   StickeringManager,
-  experimentalStickerings,
+  cubeLikeStickeringMask,
+  cubeStickerings,
+  getCached,
+  from,
+  asyncGetPuzzleGeometry,
+  PGPuzzleLoader,
+  CubePGPuzzleLoader,
   puzzleOrientation3x3x3Idx,
   puzzleOrientation3x3x3Cache,
   normalize3x3x3Orientation,
+  getPartialAppendOptionsForPuzzleSpecificSimplifyOptions,
   customPGPuzzleLoader,
   experimental3x3x3KPuzzle
 };
-//# sourceMappingURL=chunk-TUETQPSZ.js.map
+//# sourceMappingURL=chunk-W6D5GKZQ.js.map