cubing 0.65.2 → 0.66.1

package/dist/lib/cubing/chunks/{search-dynamic-solve-kilominx-UKFT6I42.js → search-dynamic-solve-kilominx-EHAUQJXS.js}

@@ -1,8 +1,8 @@
 import {
   Alg
-} from "./chunk-UP5VP7GL.js";
+} from "./chunk-QZK3M7IM.js";
 
-// src/cubing/vendor/mpl/xyzzy/kilosolver.js
+// src/cubing/vendor/mpl/xyzzy/kilosolver.ts
 import { randomUIntBelow } from "random-uint-below";
 var PHASE4_THRESHOLD = 7;
 function factorial(n) {
@@ -35,10 +35,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;
@@ -46,7 +46,7 @@ function permutation_to_index(perm) {
   return ind;
 }
 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++) {
@@ -61,8 +61,8 @@ function evenpermutation_to_index(perm) {
   return permutation_to_index(perm) >> 1;
 }
 var [evenpermutation10_to_index, index_to_evenpermutation10] = (() => {
-  let index_in_set_bits = new Int8Array(1024 * 10);
-  let look_up_set_bits = new Int8Array(1024 * 10);
+  const index_in_set_bits = new Int8Array(1024 * 10);
+  const look_up_set_bits = new Int8Array(1024 * 10);
   for (let i = 0; i < 1024; i++) {
     for (let j = 0, counter = 0; j < 10; j++) {
       if ((i >>> j & 1) === 0) {
@@ -78,7 +78,7 @@ var [evenpermutation10_to_index, index_to_evenpermutation10] = (() => {
     let f = 181440;
     let ind = 0;
     for (let i = 0; i < 8; i++) {
-      let v = perm[i];
+      const v = perm[i];
       ind += index_in_set_bits[unused | v << 10] * f;
       unused &= ~(1 << v);
       f /= 9 - i;
@@ -90,10 +90,10 @@ var [evenpermutation10_to_index, index_to_evenpermutation10] = (() => {
     let f = 181440;
     let parity = 0;
     for (let i = 0; i < 8; i++) {
-      let a = ind / f | 0;
+      const a = ind / f | 0;
       ind -= a * f;
       parity ^= a & 1;
-      let v = look_up_set_bits[unused | a << 10];
+      const v = look_up_set_bits[unused | a << 10];
       perm[i] = v;
       unused &= ~(1 << v);
       f /= 9 - i;
@@ -130,8 +130,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) {
@@ -147,23 +147,23 @@ 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 compose_o(A, B) {
-  let p = compose(A[0], B[0]);
-  let o = [];
-  let n = B[0].length;
+  const p = compose(A[0], B[0]);
+  const o = [];
+  const n = B[0].length;
   for (let i = 0; i < n; i++) {
     o[i] = (A[1][B[0][i]] + B[1][i]) % 3;
   }
   return [p, o];
 }
 function permutation_from_cycle(cycle, n) {
-  let perm = [];
+  const perm = [];
   for (let i = 0; i < n; i++) {
     perm[i] = i;
   }
@@ -173,8 +173,8 @@ 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;
@@ -222,16 +222,16 @@ for (let i = 0; i < moves.length; i++) {
   }
 }
 function random_state() {
-  let p = [0];
+  const p = [0];
   for (let i = 1; i < 20; i++) {
-    let r = randomUIntBelow(i + 1);
+    const r = randomUIntBelow(i + 1);
     p[i] = p[r];
     p[r] = i;
   }
   if (permutation_parity(p) === 1) {
     [p[0], p[1]] = [p[1], p[0]];
   }
-  let o = Array(20).fill(0);
+  const o = Array(20).fill(0);
   for (let i = 0; i < 19; i++) {
     o[i] = randomUIntBelow(3);
     o[19] += 3 - o[i];
@@ -240,12 +240,12 @@ function random_state() {
   return [p, o];
 }
 function stringify_move_sequence(move_sequence) {
-  let suffixes = ["0", "", "2", "2'", "'"];
-  let s = move_sequence.map(([m, r]) => move_names[m] + suffixes[r]);
+  const suffixes = ["0", "", "2", "2'", "'"];
+  const s = move_sequence.map(([m, r]) => move_names[m] + suffixes[r]);
   return s.join(" ");
 }
 function apply_move_sequence(state, move_sequence) {
-  for (let [m, r] of move_sequence) {
+  for (const [m, r] of move_sequence) {
     for (let i = 0; i < r; i++) {
       state = compose_o(state, moves[m]);
     }
@@ -256,14 +256,14 @@ function generate_random_state_scramble() {
   return solve(random_state());
 }
 function solve_phase1(state) {
-  let p = state[0];
+  const p = state[0];
   if (p.slice(15, 20).every((x) => x < 15)) {
     return [];
   }
   if (p.slice(0, 5).every((x) => x < 15)) {
     return [[6, 1]];
   }
-  let flags = p.map((x) => x >= 15);
+  const flags = p.map((x) => x >= 15);
   let depth = 0;
   let sol;
   while (sol === void 0) {
@@ -285,8 +285,8 @@ function search_phase1(flags, depth, last) {
       continue;
     }
     for (let r = 1; r < 5; r++) {
-      let new_flags = compose(flags, moves_full[move_index][r][0]);
-      let sol = search_phase1(new_flags, depth - 1, move_index);
+      const new_flags = compose(flags, moves_full[move_index][r][0]);
+      const sol = search_phase1(new_flags, depth - 1, move_index);
       if (sol !== void 0) {
         return [[move_index, r]].concat(sol);
       }
@@ -295,73 +295,73 @@ function search_phase1(flags, depth, last) {
   return;
 }
 function index_phase2(state) {
-  let p = state[0].slice(0, 15);
-  let o = state[1];
-  let index_c = comb_to_index(p.map((x) => +(x >= 15)));
+  const p = state[0].slice(0, 15);
+  const o = state[1];
+  const index_c = comb_to_index(p.map((x) => +(x >= 15)));
   let index_o = 243 * index_c;
   for (let i = 0, j = 0; i < 15; i++) {
     if (p[i] < 15) {
       continue;
     }
-    index_o += o[i] * Math.pow(3, j);
+    index_o += o[i] * 3 ** j;
     j++;
   }
   let index_p = 0;
   for (let i = 0; i < 5; i++) {
-    index_p += p.indexOf(15 + i) * Math.pow(15, i);
+    index_p += p.indexOf(15 + i) * 15 ** i;
   }
   return [index_o, index_p];
 }
 function solve_phase2(state) {
-  let mtables = [
+  const mtables = [
     generate_phase23_orientation_mtable(),
     generate_phase23_permutation_mtable()
   ];
-  let ptables = [
+  const ptables = [
     generate_phase2_orientation_ptable(),
     generate_phase2_permutation_ptable()
   ];
   return ida_solve(index_phase2(state), mtables, ptables).concat([[6, 1]]);
 }
 function index_phase3(state) {
-  let pieces = [5, 6, 7, 8, 14];
-  let p = state[0].slice(0, 15);
-  let o = state[1];
-  let index_c = comb_to_index(p.map((x) => +(pieces.indexOf(x) !== -1)));
+  const pieces = [5, 6, 7, 8, 14];
+  const p = state[0].slice(0, 15);
+  const o = state[1];
+  const index_c = comb_to_index(p.map((x) => +(pieces.indexOf(x) !== -1)));
   let index_o = 243 * index_c;
   for (let i = 0, j = 0; i < 15; i++) {
     if (pieces.indexOf(p[i]) === -1) {
       continue;
     }
-    index_o += o[i] * Math.pow(3, j);
+    index_o += o[i] * 3 ** j;
     j++;
   }
   let index_p = 0;
   for (let i = 0; i < 5; i++) {
-    index_p += p.indexOf(pieces[i]) * Math.pow(15, i);
+    index_p += p.indexOf(pieces[i]) * 15 ** i;
   }
   return [index_o, index_p];
 }
 function solve_phase3(state) {
-  let mtables = [
+  const mtables = [
     generate_phase23_orientation_mtable(),
     generate_phase23_permutation_mtable()
   ];
-  let ptables = [
+  const ptables = [
     generate_phase3_orientation_ptable(),
     generate_phase3_permutation_ptable()
   ];
   return ida_solve(index_phase3(state), mtables, ptables);
 }
 function index_phase4(state) {
-  let p = state[0].slice(0, 14);
-  let o = state[1];
+  const p = state[0].slice(0, 14);
+  const o = state[1];
   let index_o = 0;
-  let perm = [];
+  const perm = [];
   let j = 0;
-  for (let i of [0, 1, 2, 3, 4, 9, 10, 11, 12, 13]) {
+  for (const i of [0, 1, 2, 3, 4, 9, 10, 11, 12, 13]) {
     if (i !== 13) {
-      index_o += o[i] * Math.pow(3, j);
+      index_o += o[i] * 3 ** j;
     }
     perm[j] = p[i] < 5 ? p[i] : p[i] - 4;
     j++;
@@ -373,13 +373,13 @@ function solve_phase4_fast(state) {
 }
 function solve(state) {
   let sol = [];
-  for (let solver of [
+  for (const solver of [
     solve_phase1,
     solve_phase2,
     solve_phase3,
     solve_phase4_fast
   ]) {
-    let phase_sol = solver(state);
+    const phase_sol = solver(state);
     state = apply_move_sequence(state, phase_sol);
     sol = sol.concat(phase_sol);
   }
@@ -392,18 +392,18 @@ function generate_phase23_orientation_mtable() {
   }
   const C15_5 = C(15, 5);
   const THREE = [1, 3, 9, 27, 81, 243];
-  let phase23om = Array(C(15, 5) * THREE[5]);
+  const phase23om = Array(C(15, 5) * THREE[5]);
   tables.phase23om = phase23om;
   for (let i = 0; i < C15_5; i++) {
-    let comb = index_to_comb(i, 5, 15).concat(Array(5).fill(0));
-    let new_comb_indices = [];
+    const comb = index_to_comb(i, 5, 15).concat(Array(5).fill(0));
+    const new_comb_indices = [];
     for (let move_index = 0; move_index < 6; move_index++) {
-      let new_comb = compose(comb, moves[move_index][0]).slice(0, 15);
+      const new_comb = compose(comb, moves[move_index][0]).slice(0, 15);
       new_comb_indices[move_index] = comb_to_index(new_comb);
     }
     for (let j = 0; j < THREE[5]; j++) {
       phase23om[j + 243 * i] = [];
-      let orient_full = [];
+      const orient_full = [];
       for (let k = 0, l = 0; k < 20; k++) {
         if (comb[k] === 1) {
           orient_full[k] = (j / THREE[l] | 0) % 3;
@@ -413,12 +413,12 @@ function generate_phase23_orientation_mtable() {
         }
       }
       for (let move_index = 0; move_index < 6; move_index++) {
-        let move = moves[move_index];
-        let new_orient_full = [];
+        const move = moves[move_index];
+        const new_orient_full = [];
         for (let k = 0; k < 15; k++) {
           new_orient_full[k] = orient_full[move[0][k]] + move[1][k];
         }
-        let new_orient = new_orient_full.filter((x) => x < 10);
+        const new_orient = new_orient_full.filter((x) => x < 10);
         let J = 0;
         for (let k = 0; k < 5; k++) {
           J += new_orient[k] % 3 * THREE[k];
@@ -433,37 +433,30 @@ function generate_phase2_orientation_ptable() {
   if (tables.phase2op) {
     return tables.phase2op;
   }
-  let mtable = generate_phase23_orientation_mtable();
+  const mtable = generate_phase23_orientation_mtable();
   return tables.phase2op = bfs(mtable, [243 * 3002]);
 }
 function generate_phase3_orientation_ptable() {
   if (tables.phase3op) {
     return tables.phase3op;
   }
-  let mtable = generate_phase23_orientation_mtable();
+  const mtable = generate_phase23_orientation_mtable();
   return tables.phase3op = bfs(mtable, [243 * 246]);
 }
 function generate_phase23_permutation_mtable() {
   if (tables.phase23pm) {
     return tables.phase23pm;
   }
-  const FIFTEEN = [
-    1,
-    15,
-    225,
-    Math.pow(15, 3),
-    Math.pow(15, 4),
-    Math.pow(15, 5)
-  ];
-  let phase23pm = Array(FIFTEEN[5]);
-  let single = Array(15);
+  const FIFTEEN = [1, 15, 225, 15 ** 3, 15 ** 4, 15 ** 5];
+  const phase23pm = Array(FIFTEEN[5]);
+  const single = Array(15);
   for (let i = 0; i < 15; i++) {
     single[i] = Array(6);
     for (let move_index = 0; move_index < 6; move_index++) {
       single[i][move_index] = moves[move_index][0].indexOf(i);
     }
   }
-  let locations = [0, 0, 0, 0, 0];
+  const locations = [0, 0, 0, 0, 0];
   for (let ind = 0; ind < FIFTEEN[5]; ind++) {
     phase23pm[ind] = Array(6);
     for (let move_index = 0; move_index < 6; move_index++) {
@@ -487,14 +480,14 @@ function generate_phase2_permutation_ptable() {
   if (tables.phase2pp) {
     return tables.phase2pp;
   }
-  let mtable = generate_phase23_permutation_mtable();
+  const mtable = generate_phase23_permutation_mtable();
   return tables.phase2pp = bfs(mtable, [213090]);
 }
 function generate_phase3_permutation_ptable() {
   if (tables.phase3pp) {
     return tables.phase3pp;
   }
-  let mtable = generate_phase23_permutation_mtable();
+  const mtable = generate_phase23_permutation_mtable();
   return tables.phase3pp = bfs(mtable, [737420]);
 }
 function generate_phase4_orientation_mtable() {
@@ -502,19 +495,19 @@ function generate_phase4_orientation_mtable() {
     return tables.phase4om;
   }
   const THREE = [1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049];
-  let mtable = Array(THREE[9]);
+  const mtable = Array(THREE[9]);
   for (let i = 0; i < THREE[9]; i++) {
-    let o = Array(14).fill(0);
+    const o = Array(14).fill(0);
     for (let j = 0; j < 9; j++) {
-      let J = j < 5 ? j : j + 4;
+      const J = j < 5 ? j : j + 4;
       o[J] = (i / THREE[j] | 0) % 3;
       o[13] -= o[J];
     }
     o[13] = (o[13] + 999) % 3;
     mtable[i] = [];
     for (let move_index = 0; move_index < 3; move_index++) {
-      let move = moves[move_index];
-      let new_o = [0, 1, 2, 3, 4, 9, 10, 11, 12, 13].map(
+      const move = moves[move_index];
+      const new_o = [0, 1, 2, 3, 4, 9, 10, 11, 12, 13].map(
         (i2) => o[move[0][i2]] + move[1][i2]
       );
       let new_i = 0;
@@ -532,20 +525,20 @@ function generate_phase4_permutation_mtable() {
   }
   const HALFFACT10 = factorial(10) / 2;
   const n = 10;
-  let pre = [0, 1, 2, 3, 4, -1, -1, -1, -1, 5, 6, 7, 8, 9];
-  let post = [0, 1, 2, 3, 4, 9, 10, 11, 12, 13];
-  let move_permutations = [
+  const pre = [0, 1, 2, 3, 4, -1, -1, -1, -1, 5, 6, 7, 8, 9];
+  const post = [0, 1, 2, 3, 4, 9, 10, 11, 12, 13];
+  const move_permutations = [
     compose(pre, compose(move_U[0], post)),
     compose(pre, compose(move_R[0], post)),
     compose(pre, compose(move_F[0], post))
   ];
-  let mtable = Array(HALFFACT10);
-  let perm = Array(10);
+  const mtable = Array(HALFFACT10);
+  const perm = Array(10);
   for (let i = 0; i < HALFFACT10; i++) {
     index_to_evenpermutation10(i, perm);
     mtable[i] = [];
     for (let move_index = 0; move_index < 3; move_index++) {
-      let new_perm = compose(perm, move_permutations[move_index]);
+      const new_perm = compose(perm, move_permutations[move_index]);
       mtable[i][move_index] = evenpermutation10_to_index(new_perm);
     }
   }
@@ -555,33 +548,33 @@ function generate_phase4_orientation_ptable() {
   if (tables.phase4op) {
     return tables.phase4op;
   }
-  let mtable = generate_phase4_orientation_mtable();
+  const mtable = generate_phase4_orientation_mtable();
   return tables.phase4op = bfs(mtable, [0]);
 }
 function generate_phase4_permutation_ptable() {
   if (tables.phase4pp) {
     return tables.phase4pp;
   }
-  let mtable = generate_phase4_permutation_mtable();
+  const mtable = generate_phase4_permutation_mtable();
   return tables.phase4pp = bfs(mtable, [0]);
 }
 function generate_phase4_near_ptable_list(threshold) {
   if (tables.phase4np_list && tables.phase4np_list.threshold === threshold) {
     return tables.phase4np_list;
   }
-  let mtables = [
+  const mtables = [
     generate_phase4_orientation_mtable(),
     generate_phase4_permutation_mtable()
   ];
-  let base = Math.pow(3, 9);
-  let states = [0];
+  const base = 3 ** 9;
+  const states = [0];
   populate(threshold, [0, 0], -1);
   function populate(depth, state, last2) {
     states.push(state[0] + base * state[1]);
     if (depth === 0) {
       return;
     }
-    let new_state = [];
+    const new_state = [];
     for (let move_index = 0; move_index < 3; move_index++) {
       if (move_index === last2) {
         continue;
@@ -597,9 +590,9 @@ function generate_phase4_near_ptable_list(threshold) {
     return;
   }
   states.sort((x, y) => x - y);
-  let unique_states = [];
+  const unique_states = [];
   let last = -1;
-  for (let state of states) {
+  for (const state of states) {
     if (state !== last) {
       unique_states.push(last = state);
     }
@@ -611,7 +604,7 @@ function binary_search(A, x) {
   let lo = 0;
   let hi = A.length - 1;
   while (hi - lo > 1) {
-    let mid = lo + hi >> 1;
+    const mid = lo + hi >> 1;
     if (x > A[mid]) {
       lo = mid + 1;
     } else {
@@ -621,10 +614,10 @@ function binary_search(A, x) {
   return x === A[lo] || x === A[hi];
 }
 function bfs(mtable, goal_states) {
-  let N = mtable.length;
-  let nmoves = mtable[0].length;
-  let ptable = Array(N).fill(-1);
-  for (let state of goal_states) {
+  const N = mtable.length;
+  const nmoves = mtable[0].length;
+  const ptable = Array(N).fill(-1);
+  for (const state of goal_states) {
     ptable[state] = 0;
   }
   let depth = 0;
@@ -651,13 +644,13 @@ function bfs(mtable, goal_states) {
   return ptable;
 }
 function ida_solve(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]]);
   }
   while (true) {
-    let path = ida_search(indices, mtables, ptables, bound, -1);
+    const path = ida_search(indices, mtables, ptables, bound, -1);
     if (path !== void 0) {
       return path;
     }
@@ -665,8 +658,8 @@ function ida_solve(indices, mtables, ptables) {
   }
 }
 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]]);
@@ -681,13 +674,13 @@ function ida_search(indices, mtables, ptables, bound, last) {
     if (m === 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);
       }
@@ -700,14 +693,14 @@ function ida_search(indices, mtables, ptables, bound, last) {
   return;
 }
 function phase4_ida_solve(indices) {
-  let mtable_o = generate_phase4_orientation_mtable();
-  let mtable_p = generate_phase4_permutation_mtable();
-  let ptable_o = generate_phase4_orientation_ptable();
-  let ptable_p = generate_phase4_permutation_ptable();
-  let ptable_n = generate_phase4_near_ptable_list(PHASE4_THRESHOLD);
+  const mtable_o = generate_phase4_orientation_mtable();
+  const mtable_p = generate_phase4_permutation_mtable();
+  const ptable_o = generate_phase4_orientation_ptable();
+  const ptable_p = generate_phase4_permutation_ptable();
+  const ptable_n = generate_phase4_near_ptable_list(PHASE4_THRESHOLD);
   let bound = Math.max(ptable_o[indices[0]], ptable_p[indices[1]]);
   while (true) {
-    let path = phase4_ida_search(
+    const path = phase4_ida_search(
       indices,
       bound,
       -1,
@@ -741,11 +734,11 @@ function phase4_ida_search(indices, bound, last, mtable_o, mtable_p, ptable_o, p
     if (m === last) {
       continue;
     }
-    let new_indices = indices.slice();
+    const new_indices = indices.slice();
     for (let r = 1; r < 5; r++) {
       new_indices[0] = mtable_o[new_indices[0]][m];
       new_indices[1] = mtable_p[new_indices[1]][m];
-      let subpath = phase4_ida_search(
+      const subpath = phase4_ida_search(
         new_indices,
         bound - 1,
         m,
@@ -768,4 +761,3 @@ function getRandomKilominxScramble() {
 export {
   getRandomKilominxScramble
 };
-//# sourceMappingURL=search-dynamic-solve-kilominx-UKFT6I42.js.map