cubing 0.22.0 → 0.24.0-pre2

package/dist/esm/chunk-KCRFOAR4.js

@@ -0,0 +1,122 @@
+import {
+  parseSGS
+} from "./chunk-27KJGD3S.js";
+import {
+  PGNotation,
+  getPuzzleGeometryByName
+} from "./chunk-J2U2GRS4.js";
+import {
+  KPuzzle
+} from "./chunk-TNRZDNGH.js";
+
+// src/cubing/search/inside/solve/puzzles/skewb.sgs.json.ts
+async function skewbKPuzzleWithoutMO() {
+  const pg = getPuzzleGeometryByName("skewb", {
+    allMoves: true,
+    addRotations: true
+  });
+  return new KPuzzle(pg.getKPuzzleDefinition(true), {
+    experimentalPGNotation: new PGNotation(pg, pg.getOrbitsDef(true))
+  });
+}
+var defCache = null;
+async function skewbKPuzzleWithoutMOCached() {
+  return defCache ?? (defCache = skewbKPuzzleWithoutMO());
+}
+var cachedData = null;
+async function sgsDataSkewb() {
+  return cachedData ?? (cachedData = uncachedSGSDataSkewb());
+}
+async function sgsDataSkewbFixedCorner() {
+  return {
+    ordering: (await sgsDataSkewb()).ordering.slice(1)
+  };
+}
+async function uncachedSGSDataSkewb() {
+  return parseSGS(await skewbKPuzzleWithoutMOCached(), `SubgroupSizes 24 6 5 12 9 3 4 9 3 3
+
+Alg y
+Alg y2
+Alg y'
+Alg F
+Alg F'
+Alg y U
+Alg y U'
+Alg y L
+Alg y L'
+Alg y F
+Alg y F'
+Alg y2 U
+Alg y2 U'
+Alg y2 B
+Alg y2 B'
+Alg y' U
+Alg y' F'
+Alg y U L'
+Alg y U B
+Alg y2 U B
+Alg y2 U B'
+Alg y2 U' B
+Alg y2 U' B'
+
+Alg U
+Alg U'
+Alg U L
+Alg U L'
+Alg U' R'
+
+Alg R
+Alg R'
+Alg R B
+Alg R' L'
+
+Alg U B' U
+Alg U' L U
+Alg U' L' U
+Alg U' B U'
+Alg R L R'
+Alg R B' R
+Alg U B L U'
+Alg U B' U B'
+Alg U B' L' U
+Alg U' L B U'
+Alg R' B L' R'
+
+Alg L
+Alg L'
+Alg L B
+Alg L B'
+Alg L B L
+Alg L B L'
+Alg L B' L
+Alg L B' L'
+
+Alg B
+Alg B'
+
+Alg L' B L
+Alg L' B' L
+Alg R' L' B L R
+
+Alg B L' B L B'
+Alg B L' B' L B'
+Alg U L U B U' L' U'
+Alg R L R' B' R L' R'
+Alg U B' R L R' B' U B
+Alg U' B U L U' B' U L'
+Alg L U' B U L' U' B' U
+Alg R B' U R B L U' B
+
+Alg U L U' B' U L' U' B
+Alg U' B L U L B' U' L'
+
+Alg U R' U' L B R' B' R
+Alg R' U' R U B' U' B L`);
+}
+
+export {
+  skewbKPuzzleWithoutMOCached,
+  sgsDataSkewb,
+  sgsDataSkewbFixedCorner
+};
+//# sourceMappingURL=chunk-KCRFOAR4.js.map

package/dist/esm/chunk-KCRFOAR4.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/search/inside/solve/puzzles/skewb.sgs.json.ts"],
+  "sourcesContent": ["import { KPuzzle } from \"../../../../kpuzzle\";\nimport {\n  getPuzzleGeometryByName,\n  ExperimentalPGNotation,\n} from \"../../../../puzzle-geometry\";\nimport { parseSGS, SGSCachedData } from \"../parseSGS\";\n\nasync function skewbKPuzzleWithoutMO(): Promise<KPuzzle> {\n  const pg = getPuzzleGeometryByName(\"skewb\", {\n    allMoves: true,\n    addRotations: true,\n  });\n  return new KPuzzle(pg.getKPuzzleDefinition(true), {\n    experimentalPGNotation: new ExperimentalPGNotation(\n      pg,\n      pg.getOrbitsDef(true),\n    ),\n  });\n}\n\n// TODO: Implement a general lazy Promise/ Promise cache wrapper\nlet defCache: Promise<KPuzzle> | null = null;\nexport async function skewbKPuzzleWithoutMOCached(): Promise<KPuzzle> {\n  return (defCache ??= skewbKPuzzleWithoutMO());\n}\n\nlet cachedData: Promise<SGSCachedData> | null = null;\nexport async function sgsDataSkewb() {\n  return (cachedData ??= uncachedSGSDataSkewb());\n}\n\nexport async function sgsDataSkewbFixedCorner(): Promise<SGSCachedData> {\n  return {\n    ordering: (await sgsDataSkewb()).ordering.slice(1),\n  };\n}\n\n// TODO: Reduce info.\nasync function uncachedSGSDataSkewb(): Promise<SGSCachedData> {\n  return parseSGS(\n    await skewbKPuzzleWithoutMOCached(),\n    `SubgroupSizes 24 6 5 12 9 3 4 9 3 3\n\nAlg y\nAlg y2\nAlg y'\nAlg F\nAlg F'\nAlg y U\nAlg y U'\nAlg y L\nAlg y L'\nAlg y F\nAlg y F'\nAlg y2 U\nAlg y2 U'\nAlg y2 B\nAlg y2 B'\nAlg y' U\nAlg y' F'\nAlg y U L'\nAlg y U B\nAlg y2 U B\nAlg y2 U B'\nAlg y2 U' B\nAlg y2 U' B'\n\nAlg U\nAlg U'\nAlg U L\nAlg U L'\nAlg U' R'\n\nAlg R\nAlg R'\nAlg R B\nAlg R' L'\n\nAlg U B' U\nAlg U' L U\nAlg U' L' U\nAlg U' B U'\nAlg R L R'\nAlg R B' R\nAlg U B L U'\nAlg U B' U B'\nAlg U B' L' U\nAlg U' L B U'\nAlg R' B L' R'\n\nAlg L\nAlg L'\nAlg L B\nAlg L B'\nAlg L B L\nAlg L B L'\nAlg L B' L\nAlg L B' L'\n\nAlg B\nAlg B'\n\nAlg L' B L\nAlg L' B' L\nAlg R' L' B L R\n\nAlg B L' B L B'\nAlg B L' B' L B'\nAlg U L U B U' L' U'\nAlg R L R' B' R L' R'\nAlg U B' R L R' B' U B\nAlg U' B U L U' B' U L'\nAlg L U' B U L' U' B' U\nAlg R B' U R B L U' B\n\nAlg U L U' B' U L' U' B\nAlg U' B L U L B' U' L'\n\nAlg U R' U' L B R' B' R\nAlg R' U' R U B' U' B L`,\n  );\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAOA,uCAAyD;AACvD,QAAM,KAAK,wBAAwB,SAAS;AAAA,IAC1C,UAAU;AAAA,IACV,cAAc;AAAA;AAEhB,SAAO,IAAI,QAAQ,GAAG,qBAAqB,OAAO;AAAA,IAChD,wBAAwB,IAAI,WAC1B,IACA,GAAG,aAAa;AAAA;AAAA;AAMtB,IAAI,WAAoC;AACxC,6CAAsE;AACpE,SAAQ,wBAAa;AAAA;AAGvB,IAAI,aAA4C;AAChD,8BAAqC;AACnC,SAAQ,4BAAe;AAAA;AAGzB,yCAAwE;AACtE,SAAO;AAAA,IACL,UAAW,OAAM,gBAAgB,SAAS,MAAM;AAAA;AAAA;AAKpD,sCAA8D;AAC5D,SAAO,SACL,MAAM,+BACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/{src/cubing/search/inside/solve/puzzles/pyraminx.sgs.json.ts → dist/esm/chunk-NPK6Z4AU.js}

@@ -1,22 +1,22 @@
-import { puzzles } from "../../../../puzzles";
-import { parseSGS, SGSCachedData } from "../parseSGS";
-
-let cachedData: Promise<SGSCachedData> | null = null;
-export async function sgsDataPyraminx() {
-  return (cachedData ??= uncachedSGSDataPyraminx());
+import {
+  parseSGS
+} from "./chunk-27KJGD3S.js";
+import {
+  puzzles
+} from "./chunk-ZLIK3DZT.js";
+
+// src/cubing/search/inside/solve/puzzles/pyraminx.sgs.json.ts
+var cachedData = null;
+async function sgsDataPyraminx() {
+  return cachedData ?? (cachedData = uncachedSGSDataPyraminx());
 }
-
-export async function sgsDataPyraminxFixedOrientation(): Promise<SGSCachedData> {
+async function sgsDataPyraminxFixedOrientation() {
   return {
-    ordering: (await sgsDataPyraminx()).ordering.slice(2),
+    ordering: (await sgsDataPyraminx()).ordering.slice(2)
   };
 }
-
-// TODO: Reduce info.
-async function uncachedSGSDataPyraminx(): Promise<SGSCachedData> {
-  return parseSGS(
-    await puzzles.pyraminx.def(),
-    `SubgroupSizes 12 9 12 3 10 3 8 6 2 3 3 3 3
+async function uncachedSGSDataPyraminx() {
+  return parseSGS(await puzzles.pyraminx.kpuzzle(), `SubgroupSizes 12 9 12 3 10 3 8 6 2 3 3 3 3
 
 Alg B
 Alg B'
@@ -93,6 +93,11 @@ Alg r
 Alg r'
 
 Alg u
-Alg u'`,
-  );
+Alg u'`);
 }
+
+export {
+  sgsDataPyraminx,
+  sgsDataPyraminxFixedOrientation
+};
+//# sourceMappingURL=chunk-NPK6Z4AU.js.map

package/dist/esm/chunk-NPK6Z4AU.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/search/inside/solve/puzzles/pyraminx.sgs.json.ts"],
+  "sourcesContent": ["import { puzzles } from \"../../../../puzzles\";\nimport { parseSGS, SGSCachedData } from \"../parseSGS\";\n\nlet cachedData: Promise<SGSCachedData> | null = null;\nexport async function sgsDataPyraminx() {\n  return (cachedData ??= uncachedSGSDataPyraminx());\n}\n\nexport async function sgsDataPyraminxFixedOrientation(): Promise<SGSCachedData> {\n  return {\n    ordering: (await sgsDataPyraminx()).ordering.slice(2),\n  };\n}\n\n// TODO: Reduce info.\nasync function uncachedSGSDataPyraminx(): Promise<SGSCachedData> {\n  return parseSGS(\n    await puzzles.pyraminx.kpuzzle(),\n    `SubgroupSizes 12 9 12 3 10 3 8 6 2 3 3 3 3\n\nAlg B\nAlg B'\nAlg y\nAlg B y\nAlg B' y\nAlg y'\nAlg B y'\nAlg B' y'\nAlg BR'\nAlg B BR'\nAlg B' BR'\n\nAlg L\nAlg L'\nAlg L F\nAlg L' F\nAlg F\nAlg L F'\nAlg L' F'\nAlg F'\n\nAlg L B' U L' B\nAlg L U L'\nAlg L U' L'\nAlg L U L' U'\nAlg B' U B\nAlg B' U' B\nAlg B' U' B U\nAlg L U' L' R\nAlg L U' L' R'\nAlg L' R' L\nAlg L' R' L R\n\nAlg R\nAlg R'\n\nAlg R' U R\nAlg R' U' R\nAlg R' U R U'\nAlg B U B'\nAlg B U' B'\nAlg R B' R' B\nAlg L R L' R U' R\nAlg R L R' L'\nAlg L' R' U R L\n\nAlg U\nAlg U'\n\nAlg R U R' U'\nAlg U R U' R'\nAlg L' U' L U\nAlg U' L' U L\nAlg U L R' L' R U'\nAlg U' R' L R L' U\nAlg L' U' L U' R U' R'\n\nAlg R U' R' U\nAlg L' U L U'\nAlg U' R U R'\nAlg U L' U' L\nAlg L R' L' R L' U L U'\n\nAlg L' U L U' L R' L' R\n\nAlg b\nAlg b'\n\nAlg l\nAlg l'\n\nAlg r\nAlg r'\n\nAlg u\nAlg u'`,\n  );\n}\n"],
+  "mappings": ";;;;;;;;AAGA,IAAI,aAA4C;AAChD,iCAAwC;AACtC,SAAQ,4BAAe;AAAA;AAGzB,iDAAgF;AAC9E,SAAO;AAAA,IACL,UAAW,OAAM,mBAAmB,SAAS,MAAM;AAAA;AAAA;AAKvD,yCAAiE;AAC/D,SAAO,SACL,MAAM,QAAQ,SAAS,WACvB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/esm/chunk-NV5ESXTN.js

@@ -0,0 +1,505 @@
+import {
+  randomChoiceFactory
+} from "./chunk-37EHU3GZ.js";
+import {
+  puzzles
+} from "./chunk-ZLIK3DZT.js";
+import {
+  KState
+} from "./chunk-TNRZDNGH.js";
+import {
+  Alg,
+  AlgBuilder,
+  Move
+} from "./chunk-EWRBHQFX.js";
+
+// src/cubing/search/inside/inside-worker.ts
+var isInsideWorker = false;
+function setIsInsideWorker(inside) {
+  isInsideWorker = inside;
+}
+function mustBeInsideWorker() {
+  if (!isInsideWorker) {
+    throw new Error("Must be called from inside a worker, to avoid impact on page performance. Try importing from the top level of `cubing/solve`?");
+  }
+}
+
+// src/cubing/search/inside/solve/addOrientationSuffix.ts
+async function addOrientationSuffix(alg, suffixSpec) {
+  const algBuilder = new AlgBuilder();
+  algBuilder.experimentalPushAlg(alg);
+  for (const suffix of suffixSpec) {
+    const choice = (await randomChoiceFactory())(suffix);
+    if (choice !== null) {
+      algBuilder.push(Move.fromString(choice));
+    }
+  }
+  return algBuilder.toAlg();
+}
+
+// src/cubing/search/inside/solve/puzzles/3x3x3/convert.ts
+var reidEdgeOrder = "UF UR UB UL DF DR DB DL FR FL BR BL".split(" ");
+var reidCornerOrder = "UFR URB UBL ULF DRF DFL DLB DBR".split(" ");
+var centerOrder = "U L F R B D".split(" ");
+var map = [
+  [1, 2, 0],
+  [0, 2, 0],
+  [1, 1, 0],
+  [0, 3, 0],
+  [2, 0, 0],
+  [0, 1, 0],
+  [1, 3, 0],
+  [0, 0, 0],
+  [1, 0, 0],
+  [1, 0, 2],
+  [0, 1, 1],
+  [1, 1, 1],
+  [0, 8, 1],
+  [2, 3, 0],
+  [0, 10, 1],
+  [1, 4, 1],
+  [0, 5, 1],
+  [1, 7, 2],
+  [1, 3, 2],
+  [0, 0, 1],
+  [1, 0, 1],
+  [0, 9, 0],
+  [2, 2, 0],
+  [0, 8, 0],
+  [1, 5, 1],
+  [0, 4, 1],
+  [1, 4, 2],
+  [1, 5, 0],
+  [0, 4, 0],
+  [1, 4, 0],
+  [0, 7, 0],
+  [2, 5, 0],
+  [0, 5, 0],
+  [1, 6, 0],
+  [0, 6, 0],
+  [1, 7, 0],
+  [1, 2, 2],
+  [0, 3, 1],
+  [1, 3, 1],
+  [0, 11, 1],
+  [2, 1, 0],
+  [0, 9, 1],
+  [1, 6, 1],
+  [0, 7, 1],
+  [1, 5, 2],
+  [1, 1, 2],
+  [0, 2, 1],
+  [1, 2, 1],
+  [0, 10, 0],
+  [2, 4, 0],
+  [0, 11, 0],
+  [1, 7, 1],
+  [0, 6, 1],
+  [1, 6, 2]
+];
+function rotateLeft(s, i) {
+  return s.slice(i) + s.slice(0, i);
+}
+function toReid333Struct(state) {
+  const output = [[], []];
+  for (let i = 0; i < 6; i++) {
+    if (state.stateData["CENTERS"].pieces[i] !== i) {
+      throw new Error("non-oriented puzzles are not supported");
+    }
+  }
+  for (let i = 0; i < 12; i++) {
+    output[0].push(rotateLeft(reidEdgeOrder[state.stateData["EDGES"].pieces[i]], state.stateData["EDGES"].orientation[i]));
+  }
+  for (let i = 0; i < 8; i++) {
+    output[1].push(rotateLeft(reidCornerOrder[state.stateData["CORNERS"].pieces[i]], state.stateData["CORNERS"].orientation[i]));
+  }
+  output.push(centerOrder);
+  return output;
+}
+function toMin2PhaseState(state) {
+  const reid = toReid333Struct(state);
+  return map.map(([orbit, perm, ori]) => reid[orbit][perm][ori]).join("");
+}
+
+// src/cubing/search/inside/solve/puzzles/3x3x3/filter.ts
+function isEquivalentTranformationIgnoringCENTERS(t1, t2) {
+  const t1NoCenterOri = new KState(t1.kpuzzle, {
+    EDGES: t1.stateData.EDGES,
+    CORNERS: t1.stateData.CORNERS,
+    CENTERS: {
+      pieces: t1.stateData.CENTERS.pieces,
+      orientation: new Array(6).fill(0)
+    }
+  }).experimentalToTransformation();
+  const t2NoCenterOri = new KState(t2.kpuzzle, {
+    EDGES: t2.stateData.EDGES,
+    CORNERS: t2.stateData.CORNERS,
+    CENTERS: {
+      pieces: t2.stateData.CENTERS.pieces,
+      orientation: new Array(6).fill(0)
+    }
+  }).experimentalToTransformation();
+  return t1NoCenterOri.isIdentical(t2NoCenterOri);
+}
+function passesFilter(kpuzzle, state) {
+  if (isEquivalentTranformationIgnoringCENTERS(kpuzzle.startState(), state)) {
+    return false;
+  }
+  for (const face of "ULFRBD") {
+    for (let amount = 1; amount < 4; amount++) {
+      const transformation = kpuzzle.moveToTransformation(new Move(face, amount)).toKState();
+      if (isEquivalentTranformationIgnoringCENTERS(transformation, state)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/cubing/search/inside/solve/puzzles/3x3x3/legacy-sgs.ts
+var sgs3x3x3 = [
+  [
+    "R U'",
+    "R2 B",
+    "D2 B2",
+    "D' L B'",
+    "R' U'",
+    "B",
+    "D B2",
+    "R' B",
+    "L' U",
+    "L2 B'",
+    "B2",
+    "D L B'",
+    "L U",
+    "B'",
+    "U'",
+    "R B",
+    "D' B2",
+    "L B'",
+    "U2",
+    "U L' B'",
+    "",
+    "U' L' B'",
+    "U",
+    "L' B'"
+  ],
+  [
+    "F2 L2",
+    "F' L'",
+    "R' F L2",
+    "D' L2",
+    "F L2",
+    "F2 L'",
+    "R' F' L'",
+    "R2 F L2",
+    "R2 F2 L'",
+    "L2",
+    "F L'",
+    "D' L",
+    "D2 L2",
+    "R2 F' L'",
+    "D L",
+    "",
+    "L2 F L'",
+    "L F' L2",
+    "L F L'",
+    "F' L2",
+    "L'",
+    "D L2",
+    "D F L'",
+    "L"
+  ],
+  [
+    "R B U2 B'",
+    "R2 B U' B'",
+    "F2 B U B'",
+    "F B2 L' B2",
+    "B2 L B2",
+    "B U' B'",
+    "R2 B U2 B'",
+    "R' B U' B'",
+    "B2 L' B2",
+    "F B U B'",
+    "B2 U' B2",
+    "B' L B",
+    "L F' B D' B'",
+    "B' U' B2 D B'",
+    "B U2 B'",
+    "R B U' B'",
+    "B2 L2 B2",
+    "D' B' L B",
+    "B U B'",
+    "F' B2 L' B2",
+    "",
+    "B2 L' B' U' B'"
+  ],
+  [
+    "U F2 L2 U'",
+    "F' U L' U'",
+    "F2 U L' U'",
+    "U F L2 U'",
+    "U2 B2 U2",
+    "R' U' B U",
+    "D2 U L U'",
+    "D U2 B' U2",
+    "U L2 U'",
+    "F U L' U'",
+    "D U L U'",
+    "U2 B' U2",
+    "",
+    "U2 B' U' L' U'",
+    "U2 L' U2",
+    "U' B U",
+    "U L U'",
+    "D' U2 B' U2",
+    "U L' U'",
+    "U2 B U2"
+  ],
+  [
+    "R' D' F2",
+    "F'",
+    "F2",
+    "D R F'",
+    "R D' F2",
+    "R2 F'",
+    "D' F2",
+    "R F'",
+    "F2 R' D' F2",
+    "F",
+    "D2 F2",
+    "D' R F'",
+    "R2 D' F2",
+    "R' F'",
+    "D F2",
+    "D2 R F'",
+    "",
+    "F R' D' F2"
+  ],
+  [
+    "R' D2 F' D F",
+    "R F2 R2 F2",
+    "R2 F' D2 F",
+    "F' R2 D2 F",
+    "L D' L'",
+    "D F' D2 F",
+    "F2 R2 F2",
+    "R F' D2 F",
+    "F' R2 D' F",
+    "F' R' D2 F",
+    "F2 R' F2",
+    "L D L'",
+    "F' R D' F",
+    "F2 R F2",
+    "F' D2 F",
+    "",
+    "L D2 R D' L'",
+    "F' D2 F' R F2",
+    "D2 R2 F2 R2 F2",
+    "D F' D' F",
+    "F' D F"
+  ],
+  [
+    "U F2 U'",
+    "R U F' U'",
+    "D R U F2 U'",
+    "U F U'",
+    "R2 U F2 U'",
+    "R' U F' U'",
+    "R U F2 U'",
+    "R2 U F' U'",
+    "",
+    "U L D L' F U'",
+    "F2 D' R D F2",
+    "D2 U F U'",
+    "R' U F2 U'",
+    "U F' U'",
+    "F2 D2 R D2 F2",
+    "D U F U'"
+  ],
+  [
+    "R2",
+    "R' B' D B",
+    "D R'",
+    "F' R2 F",
+    "",
+    "R B' D B",
+    "R'",
+    "B' D B",
+    "D' R'",
+    "D2 F' R2 F",
+    "R",
+    "R2 B' D B",
+    "D2 R'",
+    "B' D' B"
+  ],
+  [
+    "R2 D' R2",
+    "F' R' F R",
+    "R D' R2 D R'",
+    "D2 R2 D2 R2",
+    "R' D' F' R F",
+    "U F D F' U'",
+    "",
+    "R2 D2 B R' B' R'",
+    "R' F D' F2 R F",
+    "R2 D R2",
+    "F2 U F U' F",
+    "R' D F' R F",
+    "D R2 D2 R2",
+    "U F D' F' U'",
+    "D R' D2 F' R F",
+    "R2 D2 R2",
+    "U F D2 F' U'",
+    "R' D2 F' R F"
+  ],
+  [
+    "B R B'",
+    "F D F' B R2 B'",
+    "D B R2 B'",
+    "D2 B R' B'",
+    "B R2 B'",
+    "D B R' B'",
+    "D' B R2 B'",
+    "B R' B'",
+    "",
+    "B R2 B' D B R' B'",
+    "D2 B R2 B'",
+    "D' B R' B'"
+  ],
+  [
+    "",
+    "R' D R F D2 F'",
+    "R' D R",
+    "D F D' F'",
+    "R F' R' F",
+    "F D' F'",
+    "R' D' R",
+    "F D2 F'",
+    "R' D2 R",
+    "F D F'"
+  ],
+  [
+    "",
+    "F2 D2 R F' R' D2 F' D2 F'",
+    "F2 D2 F' D' F D' F' D2 F'",
+    "F2 D F2 D F2 D2 F2",
+    "D2 F L D2 L' D2 F'",
+    "D F D2 L D2 L' F'",
+    "R' D B' D2 B D' R",
+    "R' D2 B' D2 B R",
+    "F D2 F' D F D F'",
+    "F D' L D2 L' D F'",
+    "B D' F D B' D' F'",
+    "F D2 L D2 L' F'",
+    "F D' L D L' D F'",
+    "F L D2 L' D2 F'",
+    "R' B' D2 B D2 R"
+  ],
+  [
+    "D'",
+    "F L D L' D' F'",
+    "D2",
+    "L B D B' D' L'",
+    "D",
+    "B' L' D' L D B",
+    "",
+    "D F L D L' D' F'"
+  ],
+  [
+    "F' D2 F D F' D F",
+    "F' D' R' D R F",
+    "F' R' D' R D F",
+    "B D R D' R' B'",
+    "",
+    "D B' D' L' D L B"
+  ],
+  [
+    "D F D F' D F D2 F'",
+    "F' U2 B' R' B U2 F' L F' L' F'",
+    "",
+    "D2 L D L2 F L F2 D F"
+  ],
+  [
+    "L B' L' F L B L' F'",
+    "F2 U F' D2 F U' F' D2 F'",
+    "D' F' D B D' F D B'",
+    "F L2 F R2 F' L2 F R2 F2",
+    "D B D' F' D B' D' F",
+    "R F L F' R' F L' F'",
+    "",
+    "D2 B L' U2 L B' D2 B L' U2 L B'",
+    "D2 F R' U2 R F' D2 F R' U2 R F'",
+    "R F L' F' R' F L F'",
+    "D F D' B' D F' D' B",
+    "L2 F2 L' B2 L F2 L' B2 L'"
+  ],
+  [
+    "L B R' B' L' B R B'",
+    "R' B R F' R' B' R F",
+    "L D2 L U L' D2 L U' L2",
+    "",
+    "D2 B' D2 F D' L2 F L2 F' D2 B D' F'",
+    "D2 F' R' F R2 B' D2 B D2 R' F D2 F'",
+    "L B L' F L B' L' F'",
+    "F' D2 F' U' F D2 F' U F2",
+    "D' B' D F D' B D F'"
+  ],
+  ["", "D2 F' L U2 L' F D2 F' L U2 L' F", "D2 B' R U2 R' B D2 B' R U2 R' B"]
+];
+
+// src/cubing/search/inside/solve/puzzles/3x3x3/index.ts
+async function random333State() {
+  const kpuzzle = await puzzles["3x3x3"].kpuzzle();
+  let state = kpuzzle.startState();
+  for (const piece of sgs3x3x3) {
+    state = state.applyAlg(Alg.fromString((await randomChoiceFactory())(piece)));
+  }
+  if (!passesFilter(kpuzzle, state)) {
+    return random333State();
+  }
+  return state;
+}
+var cachedImport = null;
+function dynamicMin2phaseGWT() {
+  return cachedImport ?? (cachedImport = import("./gwt-B7CBESZR.js"));
+}
+async function solve333(s) {
+  mustBeInsideWorker();
+  return Alg.fromString((await dynamicMin2phaseGWT()).solveState(toMin2PhaseState(s)));
+}
+async function random333Scramble() {
+  return solve333(await random333State());
+}
+async function initialize333() {
+  (await dynamicMin2phaseGWT()).initialize();
+}
+var randomSuffixes = [
+  [null, "Rw", "Rw2", "Rw'", "Fw", "Fw'"],
+  [null, "Dw", "Dw2", "Dw'"]
+];
+async function random333OrientedScramble() {
+  return addOrientationSuffix(await random333Scramble(), randomSuffixes);
+}
+var extraBit = new Alg("R' U' F");
+async function random333FewestMovesScramble() {
+  const algBuilder = new AlgBuilder();
+  const unorientedScramble = await random333Scramble();
+  algBuilder.experimentalPushAlg(extraBit);
+  algBuilder.experimentalPushAlg(unorientedScramble);
+  algBuilder.experimentalPushAlg(extraBit);
+  return algBuilder.toAlg();
+}
+
+export {
+  setIsInsideWorker,
+  mustBeInsideWorker,
+  addOrientationSuffix,
+  random333State,
+  solve333,
+  random333Scramble,
+  initialize333,
+  random333OrientedScramble,
+  random333FewestMovesScramble
+};
+//# sourceMappingURL=chunk-NV5ESXTN.js.map