cubing 0.66.0 → 0.66.1

package/dist/lib/cubing/chunks/{puzzles-dynamic-unofficial-2CY6GVZ4.js → puzzles-dynamic-unofficial-6BF3EWTI.js}

@@ -899,4 +899,3 @@ export {
   rediCubeJSON,
   rediCubeSVG
 };
-//# sourceMappingURL=puzzles-dynamic-unofficial-2CY6GVZ4.js.map

package/dist/lib/cubing/chunks/{search-dynamic-sgs-side-events-KPAPKICT.js → search-dynamic-sgs-side-events-5GQDHSJR.js}

@@ -1,15 +1,15 @@
 import {
   parseSGS
-} from "./chunk-ZCZVKGKB.js";
+} from "./chunk-7LEVC3YR.js";
 import {
   cube2x2x2,
   puzzles
-} from "./chunk-XAOXLHYH.js";
-import "./chunk-JL5REGXZ.js";
+} from "./chunk-6R47S6MP.js";
+import "./chunk-IIJFVP3K.js";
 import {
   KPuzzle
-} from "./chunk-L6OQRJJX.js";
-import "./chunk-CFZLXDM6.js";
+} from "./chunk-LBER75W4.js";
+import "./chunk-QZK3M7IM.js";
 
 // src/cubing/search/inside/solve/puzzles/dynamic/sgs-side-events/2x2x2.sgs.ts
 var cachedData = null;
@@ -1888,4 +1888,3 @@ export {
   sgsDataSkewbFixedCorner,
   skewbKPuzzleWithoutMOCached
 };
-//# sourceMappingURL=search-dynamic-sgs-side-events-KPAPKICT.js.map

package/dist/lib/cubing/chunks/{search-dynamic-sgs-unofficial-WJZ2CWX5.js → search-dynamic-sgs-unofficial-YM23KVCN.js}

@@ -1,16 +1,16 @@
 import {
   parseSGS
-} from "./chunk-ZCZVKGKB.js";
+} from "./chunk-7LEVC3YR.js";
 import {
   puzzles
-} from "./chunk-XAOXLHYH.js";
-import "./chunk-JL5REGXZ.js";
-import "./chunk-L6OQRJJX.js";
+} from "./chunk-6R47S6MP.js";
+import "./chunk-IIJFVP3K.js";
+import "./chunk-LBER75W4.js";
 import {
   Alg
-} from "./chunk-CFZLXDM6.js";
+} from "./chunk-QZK3M7IM.js";
 
-// src/cubing/vendor/mpl/xyzzy/redi_cube.js
+// src/cubing/vendor/mpl/xyzzy/redi_cube.ts
 import { randomUIntBelow } from "random-uint-below";
 function factorial(n) {
   if (n < 2) {
@@ -42,10 +42,10 @@ function permutation_to_index(perm) {
   let ind = 0;
   while (n > 1) {
     n--;
-    let e = perm[0];
+    const e = perm[0];
     ind += e * f;
     for (let i = 0; i < n; i++) {
-      let x = perm[i + 1];
+      const x = perm[i + 1];
       perm[i] = x - (x > e);
     }
     f /= n;
@@ -53,7 +53,7 @@ function permutation_to_index(perm) {
   return ind;
 }
 function index_to_permutation(ind, n) {
-  let perm = [];
+  const perm = [];
   let f = factorial(n - 1);
   for (let i = 0; i < n; i++) {
     perm[i] = ind / f | 0;
@@ -68,7 +68,7 @@ function index_to_permutation(ind, n) {
   return perm;
 }
 function permutation_parity(A) {
-  let n = A.length;
+  const n = A.length;
   let parity = 0;
   for (let i = 0; i < n - 1; i++) {
     for (let j = i; j < n; j++) {
@@ -80,7 +80,7 @@ function permutation_parity(A) {
   return parity;
 }
 function index_to_evenpermutation(ind, n) {
-  let perm = [];
+  const perm = [];
   let f = factorial(n - 1) / 2;
   let parity = 0;
   for (let i = 0; i < n - 1; i++) {
@@ -132,8 +132,8 @@ function comb_to_index(l) {
 function index_to_comb(ind, ones, bits) {
   let zeros = bits - ones;
   let b = C(bits - 1, ones);
-  let l = [];
-  let n = bits - 1;
+  const l = [];
+  const n = bits - 1;
   for (let i = 0; i < n; i++) {
     bits--;
     if (ind < b) {
@@ -149,14 +149,14 @@ function index_to_comb(ind, ones, bits) {
   return l;
 }
 function compose(A, B) {
-  let C2 = [];
+  const C2 = [];
   for (let i = 0; i < B.length; i++) {
     C2[i] = A[B[i]];
   }
   return C2;
 }
 function permutation_from_cycle(cycle, n) {
-  let perm = [];
+  const perm = [];
   for (let i = 0; i < n; i++) {
     perm[i] = i;
   }
@@ -166,14 +166,14 @@ function permutation_from_cycle(cycle, n) {
   return perm;
 }
 function unsparsify_list(d, n) {
-  let l = Array(n).fill(0);
-  for (let k in d) {
+  const l = Array(n).fill(0);
+  for (const k in d) {
     l[k] = d[k];
   }
   return l;
 }
 function compose_state(state1, state2) {
-  let o = Array(8).fill(0);
+  const o = Array(8).fill(0);
   for (let i = 0; i < 8; i++) {
     o[i] = (state1[1][i] + state2[1][i]) % 3;
   }
@@ -212,20 +212,29 @@ var move_D = [
   unsparsify_list({ 7: 2 }, 8)
 ];
 var solved = [index_to_permutation(0, 12), Array(8).fill(0)];
-var moves = [move_UL, move_U, move_UR, move_F, move_L, move_B, move_R, move_D];
+var moves = [
+  move_UL,
+  move_U,
+  move_UR,
+  move_F,
+  move_L,
+  move_B,
+  move_R,
+  move_D
+];
 var move_names = ["UL", "U", "UR", "F", "L", "B", "R", "D"];
 var tetrad = [0, 1, 0, 1, 1, 0, 1, 0];
 function stringify_move_sequence(move_sequence) {
-  let suffixes = ["0", "", "'"];
-  let s = move_sequence.map(([m, r]) => move_names[m] + suffixes[r]);
+  const suffixes = ["0", "", "'"];
+  const s = move_sequence.map(([m, r]) => move_names[m] + suffixes[r]);
   return s.join(" ");
 }
 function generate_random_state() {
-  let p = index_to_evenpermutation(
+  const p = index_to_evenpermutation(
     Math.floor(randomUIntBelow(factorial(12)) / 2),
     12
   );
-  let o = Array(8);
+  const o = Array(8);
   for (let i = 0; i < 8; i++) {
     o[i] = randomUIntBelow(3);
   }
@@ -235,31 +244,35 @@ function generate_random_state_scramble() {
   return solve(generate_random_state());
 }
 function solve(state) {
-  let phase1_indices = index_phase1(state);
-  let phase1_mtables = [
+  const phase1_indices = index_phase1(state);
+  const phase1_mtables = [
     generate_phase1_edge_mtable(),
     generate_phase1_separate_mtable()
   ];
-  let phase1_ptables = [
+  const phase1_ptables = [
     generate_phase1_edge_ptable(),
     generate_phase1_separate_ptable()
   ];
-  let phase2_mtables = [
+  const phase2_mtables = [
     generate_phase2_edge_mtable(),
     generate_phase2_corner_mtable()
   ];
-  let phase2_ptables = [
+  const phase2_ptables = [
     generate_phase2_edge_ptable(),
     generate_phase1_corner_ptable()
   ];
-  let phase1gen = ida_solve_gen(phase1_indices, phase1_mtables, phase1_ptables);
-  let best = void 0;
-  let intermediate_states = /* @__PURE__ */ new Set();
-  let start_time = +/* @__PURE__ */ new Date();
+  const phase1gen = ida_solve_gen(
+    phase1_indices,
+    phase1_mtables,
+    phase1_ptables
+  );
+  let best;
+  const intermediate_states = /* @__PURE__ */ new Set();
+  const start_time = +/* @__PURE__ */ new Date();
   for (let i = 0; i < 25; i++) {
-    let { value: sol1, done } = phase1gen.next();
+    const { value: sol1, done } = phase1gen.next();
     let new_state = state;
-    for (let [m, r] of sol1) {
+    for (const [m, r] of sol1) {
       for (let i2 = 0; i2 < r; i2++) {
         new_state = compose_state(new_state, moves[m]);
       }
@@ -269,14 +282,14 @@ function solve(state) {
     } else {
       intermediate_states.add(new_state.toString());
     }
-    let edge_ind = evenpermutation_to_index(new_state[0].slice(0, 8));
+    const edge_ind = evenpermutation_to_index(new_state[0].slice(0, 8));
     let corner_ind = 0;
     for (let i2 = 0; i2 < 4; i2++) {
       corner_ind += new_state[1][i2] * 3 ** i2;
     }
-    let phase2_indices = [edge_ind, corner_ind];
-    let moves_left = best ? best.length - sol1.length - 1 : 999999;
-    let sol2 = ida_solve(
+    const phase2_indices = [edge_ind, corner_ind];
+    const moves_left = best ? best.length - sol1.length - 1 : 999999;
+    const sol2 = ida_solve(
       phase2_indices,
       phase2_mtables,
       phase2_ptables,
@@ -303,8 +316,8 @@ function index_phase1(state) {
   for (let i = 0; i < 4; i++) {
     corner_ind += state[1][i + 4] * 3 ** i;
   }
-  let filtered = state[0].map((x) => Math.max(-1, x - 8));
-  let separate_ind = comb_to_index(filtered.map((x) => +(x >= 0))) * 2 + permutation_parity(filtered.filter((x) => x >= 0));
+  const filtered = state[0].map((x) => Math.max(-1, x - 8));
+  const separate_ind = comb_to_index(filtered.map((x) => +(x >= 0))) * 2 + permutation_parity(filtered.filter((x) => x >= 0));
   return [edge_ind, corner_ind + 81 * separate_ind];
 }
 var tables = {};
@@ -312,10 +325,10 @@ function generate_phase1_corner_mtable() {
   if (tables.phase1cm) {
     return tables.phase1cm;
   }
-  let mtable = [];
+  const mtable = [];
   for (let i = 0; i < 81; i++) {
     mtable[i] = Array(8);
-    let o = [
+    const o = [
       i % 3,
       Math.floor(i / 3) % 3,
       Math.floor(i / 9) % 3,
@@ -334,9 +347,9 @@ function generate_phase1_corner_ptable() {
   if (tables.phase1cp) {
     return tables.phase1cp;
   }
-  let ptable = Array(81);
+  const ptable = Array(81);
   for (let i = 0; i < 81; i++) {
-    let o = [
+    const o = [
       i % 3,
       Math.floor(i / 3) % 3,
       Math.floor(i / 9) % 3,
@@ -350,14 +363,14 @@ function generate_phase1_edge_mtable() {
   if (tables.phase1em) {
     return tables.phase1em;
   }
-  let mtable_single = [];
+  const mtable_single = [];
   for (let i = 0; i < 12; i++) {
     mtable_single[i] = [];
     for (let m = 0; m < 8; m++) {
       mtable_single[i][m] = moves[m][0].indexOf(i);
     }
   }
-  let mtable = Array(12 ** 4);
+  const mtable = Array(12 ** 4);
   for (let i = 0; i < 12 ** 4; i++) {
     mtable[i] = Array(8);
     for (let m = 0; m < 8; m++) {
@@ -383,11 +396,11 @@ function generate_phase1_separate_mtable() {
     return tables.phase1sm;
   }
   const C12_4 = C(12, 4);
-  let mtable_c = [];
+  const mtable_c = [];
   for (let i = 0; i < C12_4; i++) {
     mtable_c[i] = [];
-    let comb = index_to_comb(i, 4, 12);
-    let perm = [];
+    const comb = index_to_comb(i, 4, 12);
+    const perm = [];
     for (let j = 0, k = 0; j < 12; j++) {
       if (comb[j] === 0) {
         perm[j] = -1;
@@ -396,18 +409,18 @@ function generate_phase1_separate_mtable() {
       }
     }
     for (let m = 0; m < 8; m++) {
-      let new_perm = compose(perm, moves[m][0]);
-      let new_comb = compose(comb, moves[m][0]);
-      let parity = permutation_parity(new_perm.filter((x) => x >= 0));
+      const new_perm = compose(perm, moves[m][0]);
+      const new_comb = compose(comb, moves[m][0]);
+      const parity = permutation_parity(new_perm.filter((x) => x >= 0));
       mtable_c[i][m] = comb_to_index(new_comb) * 2 + parity;
     }
   }
-  let mtable_co = generate_phase1_corner_mtable();
-  let mtable = [];
+  const mtable_co = generate_phase1_corner_mtable();
+  const mtable = [];
   for (let j = 0; j < C12_4; j++) {
     for (let i = 0; i < 81; i++) {
-      let m0 = mtable[i + 81 * (2 * j)] = [];
-      let m1 = mtable[i + 81 * (2 * j + 1)] = [];
+      const m0 = mtable[i + 81 * (2 * j)] = [];
+      const m1 = mtable[i + 81 * (2 * j + 1)] = [];
       for (let m = 0; m < 8; m++) {
         m0[m] = mtable_co[i][m] + 81 * mtable_c[j][m];
         m1[m] = mtable_co[i][m] + 81 * (mtable_c[j][m] ^ 1);
@@ -426,8 +439,8 @@ function generate_phase2_corner_mtable() {
   if (tables.phase2cm) {
     return tables.phase2cm;
   }
-  let phase1_mtable = generate_phase1_corner_mtable();
-  let mtable = Array(81);
+  const phase1_mtable = generate_phase1_corner_mtable();
+  const mtable = Array(81);
   for (let i = 0; i < 81; i++) {
     mtable[i] = phase1_mtable[i].slice(4, 8);
   }
@@ -439,12 +452,12 @@ function generate_phase2_edge_mtable() {
   }
   const n = 8;
   const HALFFACT8 = factorial(n) / 2;
-  let mtable = Array(HALFFACT8);
-  let perm = [0, 1, 2, 3, 4, 5, 6, 7];
+  const mtable = Array(HALFFACT8);
+  const perm = [0, 1, 2, 3, 4, 5, 6, 7];
   for (let i = 0; i < HALFFACT8; i++) {
     mtable[i] = Array(4);
     for (let m = 0; m < 4; m++) {
-      let new_perm = compose(perm, moves[m][0].slice(0, 8));
+      const new_perm = compose(perm, moves[m][0].slice(0, 8));
       mtable[i][m] = evenpermutation_to_index(new_perm);
     }
     if (i === HALFFACT8 - 1) {
@@ -483,15 +496,15 @@ function generate_phase2_edge_ptable() {
   return tables.phase2ep = bfs(generate_phase2_edge_mtable(), [0]);
 }
 function bfs(mtable, goal_states) {
-  let N = mtable.length;
-  let nmoves = mtable[0].length;
-  let ptable = Array(N).fill(-1);
+  const N = mtable.length;
+  const nmoves = mtable[0].length;
+  const ptable = Array(N).fill(-1);
   let queue = goal_states.slice();
   let new_queue = [];
   let depth = 0;
   while (queue.length > 0) {
     new_queue.length = 0;
-    for (let state of queue) {
+    for (const state of queue) {
       if (ptable[state] !== -1) {
         continue;
       }
@@ -511,13 +524,13 @@ function bfs(mtable, goal_states) {
 }
 function ida_solve(indices, mtables, ptables, max_bound) {
   max_bound = max_bound || 999999;
-  let ncoords = indices.length;
+  const ncoords = indices.length;
   let bound = 0;
   for (let i = 0; i < ncoords; i++) {
     bound = Math.max(bound, ptables[i][indices[i]]);
   }
   while (bound <= max_bound) {
-    let path = ida_search(indices, mtables, ptables, bound, -1);
+    const path = ida_search(indices, mtables, ptables, bound, -1);
     if (path !== void 0) {
       return path;
     }
@@ -525,8 +538,8 @@ function ida_solve(indices, mtables, ptables, max_bound) {
   }
 }
 function ida_search(indices, mtables, ptables, bound, last) {
-  let ncoords = indices.length;
-  let nmoves = mtables[0][0].length;
+  const ncoords = indices.length;
+  const nmoves = mtables[0][0].length;
   let heuristic = 0;
   for (let i = 0; i < ncoords; i++) {
     heuristic = Math.max(heuristic, ptables[i][indices[i]]);
@@ -547,13 +560,13 @@ function ida_search(indices, mtables, ptables, bound, last) {
     if (m < last && tetrad[m] === tetrad[last]) {
       continue;
     }
-    let new_indices = indices.slice();
+    const new_indices = indices.slice();
     for (let c = 0; c < ncoords; c++) {
       new_indices[c] = mtables[c][indices[c]][m];
     }
     let r = 1;
     while (indices.some((_, i) => indices[i] !== new_indices[i])) {
-      let subpath = ida_search(new_indices, mtables, ptables, bound - 1, m);
+      const subpath = ida_search(new_indices, mtables, ptables, bound - 1, m);
       if (subpath !== void 0) {
         return [[m, r]].concat(subpath);
       }
@@ -566,7 +579,7 @@ function ida_search(indices, mtables, ptables, bound, last) {
   return;
 }
 function* ida_solve_gen(indices, mtables, ptables) {
-  let ncoords = indices.length;
+  const ncoords = indices.length;
   let bound = 0;
   for (let i = 0; i < ncoords; i++) {
     bound = Math.max(bound, ptables[i][indices[i]]);
@@ -577,8 +590,8 @@ function* ida_solve_gen(indices, mtables, ptables) {
   }
 }
 function* ida_search_gen(indices, mtables, ptables, bound, last) {
-  let ncoords = indices.length;
-  let nmoves = mtables[0][0].length;
+  const ncoords = indices.length;
+  const nmoves = mtables[0][0].length;
   let heuristic = 0;
   for (let i = 0; i < ncoords; i++) {
     heuristic = Math.max(heuristic, ptables[i][indices[i]]);
@@ -600,13 +613,13 @@ function* ida_search_gen(indices, mtables, ptables, bound, last) {
     if (m < last && tetrad[m] === tetrad[last]) {
       continue;
     }
-    let new_indices = indices.slice();
+    const new_indices = indices.slice();
     for (let c = 0; c < ncoords; c++) {
       new_indices[c] = mtables[c][indices[c]][m];
     }
     let r = 1;
     while (indices.some((_, i) => indices[i] !== new_indices[i])) {
-      let subpath_gen = ida_search_gen(
+      const subpath_gen = ida_search_gen(
         new_indices,
         mtables,
         ptables,
@@ -614,7 +627,7 @@ function* ida_search_gen(indices, mtables, ptables, bound, last) {
         m
       );
       while (true) {
-        let { value: subpath, done } = subpath_gen.next();
+        const { value: subpath, done } = subpath_gen.next();
         if (done) {
           break;
         }
@@ -1265,4 +1278,3 @@ export {
   getRandomRediCubeScramble,
   sgsDataFTO
 };
-//# sourceMappingURL=search-dynamic-sgs-unofficial-WJZ2CWX5.js.map

package/dist/lib/cubing/chunks/{search-dynamic-solve-3x3x3-B2L4IN34.js → search-dynamic-solve-3x3x3-6UMZH4WB.js}

@@ -1,4 +1,4 @@
-// src/cubing/vendor/mit/cs0x7f/min2phase/3x3x3-min2phase.js
+// src/cubing/vendor/mit/cs0x7f/min2phase/3x3x3-min2phase.ts
 var $intern_3 = { 3: 1 };
 var $intern_9 = 4194303;
 var $intern_10 = 1048575;
@@ -2536,14 +2536,11 @@ var B_classLit = createForPrimitive("byte", "B");
 var J_classLit = createForPrimitive("long", "J");
 var C_classLit = createForPrimitive("char", "C");
 createForClass("com.google.gwt.user.client.rpc", "XsrfToken", null), createForInterface("java.util", "Map/Entry");
-var initialize = function() {
+var initialize = () => {
   init_0(false);
 };
-var solvePattern = function(s) {
-  return $solution(new Search(), s);
-};
+var solvePattern = (s) => $solution(new Search(), s);
 export {
   initialize,
   solvePattern
 };
-//# sourceMappingURL=search-dynamic-solve-3x3x3-B2L4IN34.js.map

package/dist/lib/cubing/chunks/{search-dynamic-solve-4x4x4-OLWUV6G6.js → search-dynamic-solve-4x4x4-KNSBAM7Q.js}

@@ -1,15 +1,18 @@
-import "./chunk-NAPITA3L.js";
-import "./chunk-ZV7PYR2S.js";
+import "./chunk-RDKH6CDA.js";
+import "./chunk-NJ66FRKF.js";
 import {
   random333Scramble
-} from "./chunk-CAQY24I5.js";
-import "./chunk-7GUL3OBQ.js";
-import "./chunk-XAOXLHYH.js";
-import "./chunk-JL5REGXZ.js";
-import "./chunk-L6OQRJJX.js";
+} from "./chunk-QOLD6GH2.js";
+import "./chunk-BHVTDDUY.js";
+import "./chunk-6R47S6MP.js";
+import "./chunk-IIJFVP3K.js";
+import "./chunk-LBER75W4.js";
 import {
   Alg
-} from "./chunk-CFZLXDM6.js";
+} from "./chunk-QZK3M7IM.js";
+
+// src/cubing/vendor/mit/cs0x7f/cstimer/src/js/scramble/444-solver.ts
+import { randomUIntBelow } from "random-uint-below";
 
 // src/cubing/vendor/mit/cs0x7f/cstimer/src/js/lib/mathlib.ts
 var Cnk = [];
@@ -64,7 +67,6 @@ function set8Perm(arr, idx, n, even) {
 }
 
 // src/cubing/vendor/mit/cs0x7f/cstimer/src/js/scramble/444-solver.ts
-import { randomUIntBelow } from "random-uint-below";
 function createArray(length1, length2) {
   const result = new Array(length1);
   if (length2 !== void 0) {
@@ -2308,9 +2310,7 @@ function $doSearch(this$static) {
       0
     )
   );
-  p1SolsArr.sort(function(a, b) {
-    return a.value - b.value;
-  });
+  p1SolsArr.sort((a, b) => a.value - b.value);
   MAX_LENGTH2 = 9;
   do {
     OUT: for (length12 = p1SolsArr[0].value; length12 < 100; ++length12) {
@@ -2338,9 +2338,7 @@ function $doSearch(this$static) {
     }
     ++MAX_LENGTH2;
   } while (length12 === 100);
-  this$static.arr2.sort(function(a, b) {
-    return a.value - b.value;
-  });
+  this$static.arr2.sort((a, b) => a.value - b.value);
   index = 0;
   MAX_LENGTH3 = 13;
   do {
@@ -2703,7 +2701,7 @@ function setClassLiteral(seedId, clazz) {
       if (seed) {
         proto = seed.prototype;
       } else {
-        seed = seedTable[seedId] = function() {
+        seed = seedTable[seedId] = () => {
         };
         seed.___clazz$ = clazz;
         return;
@@ -2920,4 +2918,3 @@ export {
   initialize,
   random444Scramble
 };
-//# sourceMappingURL=search-dynamic-solve-4x4x4-OLWUV6G6.js.map