cubing 0.29.1 → 0.30.0

package/dist/esm/{search-dynamic-solve-kilominx-3HEVQ4MC.js → search-dynamic-solve-kilominx-HB2QFUGF.js}

@@ -1,26 +1,29 @@
 import {
   randomUIntBelowFactory
-} from "./chunk-WXCNEGW3.js";
+} from "./chunk-HR5D6SD4.js";
 import {
   Alg
-} from "./chunk-NI7U4XAZ.js";
-import "./chunk-SBZRVSPK.js";
+} from "./chunk-ZQT3QSWD.js";
 
 // src/cubing/vendor/xyzzy/kilosolver.js
 var PHASE4_THRESHOLD = 7;
 function factorial(n) {
-  if (n < 2)
+  if (n < 2) {
     return n;
+  }
   let f = 1;
-  for (let i = 2; i <= n; i++)
+  for (let i = 2; i <= n; i++) {
     f *= i;
+  }
   return f;
 }
 function C(n, k) {
-  if (k < 0 || k > n)
+  if (k < 0 || k > n) {
     return 0;
-  if (k === 0 || k === n)
+  }
+  if (k === 0 || k === n) {
     return 1;
+  }
   let c = 1;
   for (let i = 0; i < k; i++) {
     c = c * (n - i) / (i + 1) | 0;
@@ -49,8 +52,9 @@ function permutation_parity(A) {
   let parity = 0;
   for (let i = 0; i < n - 1; i++) {
     for (let j = i; j < n; j++) {
-      if (A[i] > A[j])
+      if (A[i] > A[j]) {
         parity ^= 1;
+      }
     }
   }
   return parity;
@@ -105,11 +109,13 @@ var [evenpermutation10_to_index, index_to_evenpermutation10] = (() => {
 function comb_to_index(l) {
   let bits = l.length;
   let ones = 0;
-  for (let i = 0; i < bits; i++)
+  for (let i = 0; i < bits; i++) {
     ones += +(l[i] === 1);
+  }
   let zeros = bits - ones;
-  if (zeros === 0 || ones === 0 || bits === 1)
+  if (zeros === 0 || ones === 0 || bits === 1) {
     return 0;
+  }
   let b = C(bits - 1, ones);
   let ind = 0;
   for (let i = 0; zeros > 0 && ones > 0 && bits > 1; i++) {
@@ -144,8 +150,9 @@ function index_to_comb(ind, ones, bits) {
 }
 function compose(A, B) {
   let C2 = [];
-  for (let i = 0; i < B.length; i++)
+  for (let i = 0; i < B.length; i++) {
     C2[i] = A[B[i]];
+  }
   return C2;
 }
 function compose_o(A, B) {
@@ -159,8 +166,9 @@ function compose_o(A, B) {
 }
 function permutation_from_cycle(cycle, n) {
   let perm = [];
-  for (let i = 0; i < n; i++)
+  for (let i = 0; i < n; i++) {
     perm[i] = i;
+  }
   for (let i = 0; i < cycle.length; i++) {
     perm[cycle[i]] = cycle[(i + 1) % cycle.length];
   }
@@ -168,8 +176,9 @@ function permutation_from_cycle(cycle, n) {
 }
 function unsparsify_list(d, n) {
   let l = Array(n).fill(0);
-  for (let k in d)
+  for (let k in d) {
     l[k] = d[k];
+  }
   return l;
 }
 var move_U = [
@@ -210,8 +219,9 @@ var id = compose_o(move_x2, move_x2);
 var moves_full = [];
 for (let i = 0; i < moves.length; i++) {
   moves_full[i] = [id];
-  for (let j = 1; j < 5; j++)
+  for (let j = 1; j < 5; j++) {
     moves_full[i][j] = compose_o(moves_full[i][j - 1], moves[i]);
+  }
 }
 function random_state(randomUintBelow2) {
   let p = [0];
@@ -220,8 +230,9 @@ function random_state(randomUintBelow2) {
     p[i] = p[r];
     p[r] = i;
   }
-  if (permutation_parity(p) === 1)
+  if (permutation_parity(p) === 1) {
     [p[0], p[1]] = [p[1], p[0]];
+  }
   let o = Array(20).fill(0);
   for (let i = 0; i < 19; i++) {
     o[i] = randomUintBelow2(3);
@@ -237,8 +248,9 @@ function stringify_move_sequence(move_sequence) {
 }
 function apply_move_sequence(state, move_sequence) {
   for (let [m, r] of move_sequence) {
-    for (let i = 0; i < r; i++)
+    for (let i = 0; i < r; i++) {
       state = compose_o(state, moves[m]);
+    }
   }
   return state;
 }
@@ -247,8 +259,10 @@ function generate_random_state_scramble(randomUintBelow2) {
 }
 var translation_amounts;
 {
-  let A = Math.sin(Math.PI / 5), B = Math.cos(Math.PI / 10);
-  let C2 = Math.cos(Math.PI / 5), D = Math.sin(Math.PI / 10);
+  let A = Math.sin(Math.PI / 5);
+  let B = Math.cos(Math.PI / 10);
+  let C2 = Math.cos(Math.PI / 5);
+  let D = Math.sin(Math.PI / 10);
   translation_amounts = {
     U: [0, 0],
     L: [-A - B, C2 - D],
@@ -266,12 +280,15 @@ var translation_amounts;
 }
 function solve_phase1(state) {
   let p = state[0];
-  if (p.slice(15, 20).every((x) => x < 15))
+  if (p.slice(15, 20).every((x) => x < 15)) {
     return [];
-  if (p.slice(0, 5).every((x) => x < 15))
+  }
+  if (p.slice(0, 5).every((x) => x < 15)) {
     return [[6, 1]];
+  }
   let flags = p.map((x) => x >= 15);
-  let depth = 0, sol;
+  let depth = 0;
+  let sol;
   while (sol === void 0) {
     depth++;
     sol = search_phase1(flags, depth, -1);
@@ -280,30 +297,35 @@ function solve_phase1(state) {
   return sol;
 }
 function search_phase1(flags, depth, last) {
-  if (depth == 0) {
-    if (flags.slice(0, 5).some((x) => x))
+  if (depth === 0) {
+    if (flags.slice(0, 5).some((x) => x)) {
       return;
+    }
     return [];
   }
   for (let move_index = 0; move_index < 6; move_index++) {
-    if (move_index === last)
+    if (move_index === 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);
-      if (sol !== void 0)
+      if (sol !== void 0) {
         return [[move_index, r]].concat(sol);
+      }
     }
   }
   return;
 }
 function index_phase2(state) {
-  let p = state[0].slice(0, 15), o = state[1];
+  let p = state[0].slice(0, 15);
+  let o = state[1];
   let 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)
+    if (p[i] < 15) {
       continue;
+    }
     index_o += o[i] * Math.pow(3, j);
     j++;
   }
@@ -326,12 +348,14 @@ function solve_phase2(state) {
 }
 function index_phase3(state) {
   let pieces = [5, 6, 7, 8, 14];
-  let p = state[0].slice(0, 15), o = state[1];
+  let p = state[0].slice(0, 15);
+  let o = state[1];
   let 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)
+    if (pieces.indexOf(p[i]) === -1) {
       continue;
+    }
     index_o += o[i] * Math.pow(3, j);
     j++;
   }
@@ -353,12 +377,15 @@ function solve_phase3(state) {
   return ida_solve(index_phase3(state), mtables, ptables);
 }
 function index_phase4(state) {
-  let p = state[0].slice(0, 14), o = state[1];
-  let index_o = 0, perm = [];
+  let p = state[0].slice(0, 14);
+  let o = state[1];
+  let index_o = 0;
+  let perm = [];
   let j = 0;
   for (let i of [0, 1, 2, 3, 4, 9, 10, 11, 12, 13]) {
-    if (i !== 13)
+    if (i !== 13) {
       index_o += o[i] * Math.pow(3, j);
+    }
     perm[j] = p[i] < 5 ? p[i] : p[i] - 4;
     j++;
   }
@@ -383,9 +410,11 @@ function solve(state) {
 }
 var tables = {};
 function generate_phase23_orientation_mtable() {
-  if (tables.phase23om)
+  if (tables.phase23om) {
     return tables.phase23om;
-  const C15_5 = C(15, 5), THREE = [1, 3, 9, 27, 81, 243];
+  }
+  const C15_5 = C(15, 5);
+  const THREE = [1, 3, 9, 27, 81, 243];
   let phase23om = Array(C(15, 5) * THREE[5]);
   tables.phase23om = phase23om;
   for (let i = 0; i < C15_5; i++) {
@@ -402,8 +431,9 @@ function generate_phase23_orientation_mtable() {
         if (comb[k] === 1) {
           orient_full[k] = (j / THREE[l] | 0) % 3;
           l++;
-        } else
+        } else {
           orient_full[k] = 99;
+        }
       }
       for (let move_index = 0; move_index < 6; move_index++) {
         let move = moves[move_index];
@@ -423,20 +453,23 @@ function generate_phase23_orientation_mtable() {
   return phase23om;
 }
 function generate_phase2_orientation_ptable() {
-  if (tables.phase2op)
+  if (tables.phase2op) {
     return tables.phase2op;
+  }
   let mtable = generate_phase23_orientation_mtable();
   return tables.phase2op = bfs(mtable, [243 * 3002]);
 }
 function generate_phase3_orientation_ptable() {
-  if (tables.phase3op)
+  if (tables.phase3op) {
     return tables.phase3op;
+  }
   let mtable = generate_phase23_orientation_mtable();
   return tables.phase3op = bfs(mtable, [243 * 246]);
 }
 function generate_phase23_permutation_mtable() {
-  if (tables.phase23pm)
+  if (tables.phase23pm) {
     return tables.phase23pm;
+  }
   const FIFTEEN = [
     1,
     15,
@@ -474,20 +507,23 @@ function generate_phase23_permutation_mtable() {
   return tables.phase23pm = phase23pm;
 }
 function generate_phase2_permutation_ptable() {
-  if (tables.phase2pp)
+  if (tables.phase2pp) {
     return tables.phase2pp;
+  }
   let mtable = generate_phase23_permutation_mtable();
   return tables.phase2pp = bfs(mtable, [213090]);
 }
 function generate_phase3_permutation_ptable() {
-  if (tables.phase3pp)
+  if (tables.phase3pp) {
     return tables.phase3pp;
+  }
   let mtable = generate_phase23_permutation_mtable();
   return tables.phase3pp = bfs(mtable, [737420]);
 }
 function generate_phase4_orientation_mtable() {
-  if (tables.phase4om)
+  if (tables.phase4om) {
     return tables.phase4om;
+  }
   const THREE = [1, 3, 9, 27, 81, 243, 729, 2187, 6561, 19683, 59049];
   let mtable = Array(THREE[9]);
   for (let i = 0; i < THREE[9]; i++) {
@@ -505,17 +541,20 @@ function generate_phase4_orientation_mtable() {
         (i2) => o[move[0][i2]] + move[1][i2]
       );
       let new_i = 0;
-      for (let j = 0; j < 9; j++)
+      for (let j = 0; j < 9; j++) {
         new_i += new_o[j] % 3 * THREE[j];
+      }
       mtable[i][move_index] = new_i;
     }
   }
   return tables.phase4om = mtable;
 }
 function generate_phase4_permutation_mtable() {
-  if (tables.phase4pm)
+  if (tables.phase4pm) {
     return tables.phase4pm;
-  const HALFFACT10 = factorial(10) / 2, n = 10;
+  }
+  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 = [
@@ -536,20 +575,23 @@ function generate_phase4_permutation_mtable() {
   return tables.phase4pm = mtable;
 }
 function generate_phase4_orientation_ptable() {
-  if (tables.phase4op)
+  if (tables.phase4op) {
     return tables.phase4op;
+  }
   let mtable = generate_phase4_orientation_mtable();
   return tables.phase4op = bfs(mtable, [0]);
 }
 function generate_phase4_permutation_ptable() {
-  if (tables.phase4pp)
+  if (tables.phase4pp) {
     return tables.phase4pp;
+  }
   let 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)
+  if (tables.phase4np_list && tables.phase4np_list.threshold === threshold) {
     return tables.phase4np_list;
+  }
   let mtables = [
     generate_phase4_orientation_mtable(),
     generate_phase4_permutation_mtable()
@@ -559,12 +601,14 @@ function generate_phase4_near_ptable_list(threshold) {
   populate(threshold, [0, 0], -1);
   function populate(depth, state, last2) {
     states.push(state[0] + base * state[1]);
-    if (depth === 0)
+    if (depth === 0) {
       return;
+    }
     let new_state = [];
     for (let move_index = 0; move_index < 3; move_index++) {
-      if (move_index === last2)
+      if (move_index === last2) {
         continue;
+      }
       new_state[0] = state[0];
       new_state[1] = state[1];
       for (let r = 1; r < 5; r++) {
@@ -576,21 +620,26 @@ function generate_phase4_near_ptable_list(threshold) {
     return;
   }
   states.sort((x, y) => x - y);
-  let unique_states = [], last = -1;
-  for (let state of states)
-    if (state !== last)
+  let unique_states = [];
+  let last = -1;
+  for (let state of states) {
+    if (state !== last) {
       unique_states.push(last = state);
+    }
+  }
   unique_states.threshold = threshold;
   return tables.phase4np_list = unique_states;
 }
 function binary_search(A, x) {
-  let lo = 0, hi = A.length - 1;
+  let lo = 0;
+  let hi = A.length - 1;
   while (hi - lo > 1) {
     let mid = lo + hi >> 1;
-    if (x > A[mid])
+    if (x > A[mid]) {
       lo = mid + 1;
-    else
+    } else {
       hi = mid;
+    }
   }
   return x === A[lo] || x === A[hi];
 }
@@ -627,12 +676,14 @@ function bfs(mtable, goal_states) {
 function ida_solve(indices, mtables, ptables) {
   let ncoords = indices.length;
   let bound = 0;
-  for (let i = 0; i < ncoords; i++)
+  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);
-    if (path !== void 0)
+    if (path !== void 0) {
       return path;
+    }
     bound++;
   }
 }
@@ -640,23 +691,29 @@ function ida_search(indices, mtables, ptables, bound, last) {
   let ncoords = indices.length;
   let nmoves = mtables[0][0].length;
   let heuristic = 0;
-  for (let i = 0; i < ncoords; i++)
+  for (let i = 0; i < ncoords; i++) {
     heuristic = Math.max(heuristic, ptables[i][indices[i]]);
-  if (heuristic > bound)
+  }
+  if (heuristic > bound) {
     return;
-  if (bound === 0 || heuristic === 0)
+  }
+  if (bound === 0 || heuristic === 0) {
     return [];
+  }
   for (let m = 0; m < nmoves; m++) {
-    if (m === last)
+    if (m === last) {
       continue;
+    }
     let new_indices = indices.slice();
-    for (let c = 0; c < ncoords; c++)
+    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])) {
+    while (indices.some((_, i) => indices[i] !== new_indices[i])) {
       let subpath = ida_search(new_indices, mtables, ptables, bound - 1, m);
-      if (subpath !== void 0)
+      if (subpath !== void 0) {
         return [[m, r]].concat(subpath);
+      }
       for (let c = 0; c < ncoords; c++) {
         new_indices[c] = mtables[c][new_indices[c]][m];
       }
@@ -683,24 +740,30 @@ function phase4_ida_solve(indices) {
       ptable_p,
       ptable_n
     );
-    if (path !== void 0)
+    if (path !== void 0) {
       return path;
+    }
     bound++;
   }
 }
 function phase4_ida_search(indices, bound, last, mtable_o, mtable_p, ptable_o, ptable_p, ptable_n) {
   let heuristic = Math.max(ptable_o[indices[0]], ptable_p[indices[1]]);
-  if (heuristic > bound)
+  if (heuristic > bound) {
     return;
-  if (heuristic <= PHASE4_THRESHOLD && !binary_search(ptable_n, indices[0] + 19683 * indices[1]))
+  }
+  if (heuristic <= PHASE4_THRESHOLD && !binary_search(ptable_n, indices[0] + 19683 * indices[1])) {
     heuristic = PHASE4_THRESHOLD + 1;
-  if (heuristic > bound)
+  }
+  if (heuristic > bound) {
     return;
-  if (bound === 0 || heuristic === 0)
+  }
+  if (bound === 0 || heuristic === 0) {
     return [];
+  }
   for (let m = 0; m < 3; m++) {
-    if (m === last)
+    if (m === last) {
       continue;
+    }
     let new_indices = indices.slice();
     for (let r = 1; r < 5; r++) {
       new_indices[0] = mtable_o[new_indices[0]][m];
@@ -715,8 +778,9 @@ function phase4_ida_search(indices, bound, last, mtable_o, mtable_p, ptable_o, p
         ptable_p,
         ptable_n
       );
-      if (subpath !== void 0)
+      if (subpath !== void 0) {
         return [[m, r]].concat(subpath);
+      }
     }
   }
   return;
@@ -733,4 +797,4 @@ getRandomKilominxScramble().then((alg) => alg.log());
 export {
   getRandomKilominxScramble
 };
-//# sourceMappingURL=search-dynamic-solve-kilominx-3HEVQ4MC.js.map
+//# sourceMappingURL=search-dynamic-solve-kilominx-HB2QFUGF.js.map