cubing 0.66.0 → 0.66.1

package/dist/lib/cubing/chunks/{search-dynamic-solve-master_tetraminx-GIS7T5B7.js → search-dynamic-solve-master_tetraminx-ZQ25QK7E.js}

@@ -1,4 +1,4 @@
-// src/cubing/vendor/mpl/xyzzy/master_tetraminx-solver.js
+// src/cubing/vendor/mpl/xyzzy/master_tetraminx-solver.ts
 import { randomUIntBelow } from "random-uint-below";
 function factorial(n) {
   if (n < 2) {
@@ -11,7 +11,7 @@ function factorial(n) {
   return f;
 }
 function identity_permutation(n) {
-  let a = Array(n);
+  const a = Array(n);
   for (let i = 0; i < n; i++) {
     a[i] = i;
   }
@@ -24,10 +24,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;
@@ -35,7 +35,7 @@ function permutation_to_index(perm) {
   return ind;
 }
 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++) {
@@ -62,8 +62,8 @@ function evenpermutation_to_index(perm) {
   return permutation_to_index(perm) >> 1;
 }
 var [evenpermutation12_to_index, index_to_evenpermutation12] = (() => {
-  let index_in_set_bits = new Int8Array(4096 * 12);
-  let look_up_set_bits = new Int8Array(4096 * 12);
+  const index_in_set_bits = new Int8Array(4096 * 12);
+  const look_up_set_bits = new Int8Array(4096 * 12);
   for (let i = 0; i < 4096; i++) {
     for (let j = 0, counter = 0; j < 12; j++) {
       if ((i >>> j & 1) === 0) {
@@ -79,7 +79,7 @@ var [evenpermutation12_to_index, index_to_evenpermutation12] = (() => {
     let f = 19958400;
     let ind = 0;
     for (let i = 0; i < 10; i++) {
-      let v = perm[i];
+      const v = perm[i];
       ind += index_in_set_bits[unused | v << 12] * f;
       unused &= ~(1 << v);
       f /= 11 - i;
@@ -91,10 +91,10 @@ var [evenpermutation12_to_index, index_to_evenpermutation12] = (() => {
     let f = 19958400;
     let parity = 0;
     for (let i = 0; i < 10; 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 << 12];
+      const v = look_up_set_bits[unused | a << 12];
       perm[i] = v;
       unused &= ~(1 << v);
       f /= 11 - i;
@@ -106,21 +106,21 @@ var [evenpermutation12_to_index, index_to_evenpermutation12] = (() => {
   return [evenpermutation12_to_index2, index_to_evenpermutation122];
 })();
 function compose(A, B) {
-  let C = [];
+  const C = [];
   for (let i = 0; i < B.length; i++) {
     C[i] = A[B[i]];
   }
   return C;
 }
 function invert(perm) {
-  let inv = [];
+  const inv = [];
   for (let i = 0; i < perm.length; i++) {
     inv[perm[i]] = i;
   }
   return inv;
 }
 function permutation_from_cycle(cycle, n) {
-  let perm = [];
+  const perm = [];
   for (let i = 0; i < n; i++) {
     perm[i] = i;
   }
@@ -136,13 +136,13 @@ function permutation_from_cycles(cycles, n) {
   return cycles.map((cycle) => permutation_from_cycle(cycle, n)).reduce(compose);
 }
 function compose_state(state1, state2) {
-  let co = Array(4);
+  const co = Array(4);
   for (let i = 0; i < 4; i++) {
     co[i] = (state1.co[i] + state2.co[i]) % 3;
   }
-  let mp = compose(state1.mp, state2.mp);
-  let wp = compose(state1.wp, state2.wp);
-  let cp = compose(state1.cp, state2.cp);
+  const mp = compose(state1.mp, state2.mp);
+  const wp = compose(state1.wp, state2.wp);
+  const cp = compose(state1.cp, state2.cp);
   return { co, mp, wp, cp };
 }
 var solved = {
@@ -270,24 +270,24 @@ function moves_commute(i, j) {
   return (i ^ j) === 4;
 }
 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 co = Array(4);
+  const co = Array(4);
   for (let i = 0; i < 4; i++) {
     co[i] = randomUIntBelow(3);
   }
-  let mp = index_to_evenpermutation(randomUIntBelow(factorial(6) / 2), 6);
+  const mp = index_to_evenpermutation(randomUIntBelow(factorial(6) / 2), 6);
   for (let i = 0, parity = 0; i < 6; i++) {
-    let eo = i === 5 ? parity : randomUIntBelow(2);
+    const eo = i === 5 ? parity : randomUIntBelow(2);
     parity ^= eo;
     mp[i] += eo * 6;
     mp[i + 6] = (mp[i] + 6) % 12;
   }
-  let wp = index_to_evenpermutation(randomUIntBelow(factorial(12) / 2), 12);
-  let cp = index_to_evenpermutation(randomUIntBelow(factorial(4) / 2), 4);
+  const wp = index_to_evenpermutation(randomUIntBelow(factorial(12) / 2), 12);
+  const cp = index_to_evenpermutation(randomUIntBelow(factorial(4) / 2), 4);
   return { co, mp, wp, cp };
 }
 function generate_random_state_scramble() {
@@ -300,67 +300,67 @@ function generate_scramble_sequence(tips = true, obfuscate_tips = false) {
   if (!tips) {
     return scramble_string;
   }
-  let tip_names = ["u", "l", "r", "b"];
-  let suffixes = ["0", "", "'"];
+  const tip_names = ["u", "l", "r", "b"];
+  const suffixes = ["0", "", "'"];
   if (!obfuscate_tips) {
     for (let i = 0; i < 4; i++) {
-      let x = randomUIntBelow(3);
+      const x = randomUIntBelow(3);
       if (x !== 0) {
         scramble_string += ` ${tip_names[i]}${suffixes[x]}`;
       }
     }
     return scramble_string.trim();
   }
-  let amount = [];
-  let amount_pre = [];
-  let amount_post = [];
+  const amount = [];
+  const amount_pre = [];
+  const amount_post = [];
   for (let i = 0; i < 4; i++) {
     amount[i] = randomUIntBelow(3);
     amount_pre[i] = randomUIntBelow(3);
     amount_post[i] = (amount[i] - amount_pre[i] + 3) % 3;
   }
-  let weight = (arr) => arr.filter((x) => x !== 0).length;
+  const weight = (arr) => arr.filter((x) => x !== 0).length;
   while (!(weight(amount_pre) >= 1 && weight(amount_post) >= 1 && weight(amount_pre) + weight(amount_post) >= 4)) {
     for (let i = 0; i < 4; i++) {
       amount_pre[i] = randomUIntBelow(3);
       amount_post[i] = (amount[i] - amount_pre[i] + 3) % 3;
     }
   }
-  let prepend = amount_pre.map((x, i) => x !== 0 ? `${tip_names[i]}${suffixes[x]} ` : "").join("");
-  let append = amount_post.map((x, i) => x !== 0 ? ` ${tip_names[i]}${suffixes[x]}` : "").join("");
+  const prepend = amount_pre.map((x, i) => x !== 0 ? `${tip_names[i]}${suffixes[x]} ` : "").join("");
+  const append = amount_post.map((x, i) => x !== 0 ? ` ${tip_names[i]}${suffixes[x]}` : "").join("");
   return prepend + scramble_string + append;
 }
 function solve(state) {
-  let phase1_indices = index_phase1(state);
-  let phase2_mtables = [
+  const phase1_indices = index_phase1(state);
+  const phase2_mtables = [
     generate_phase2_permutation_mtable(),
     generate_phase2_orientation_mtable()
   ];
-  let phase2_ptables = [
+  const phase2_ptables = [
     generate_phase2_permutation_ptable(),
     generate_phase2_orientation_ptable()
   ];
-  let phase1gen = phase1_ida_solve_gen(phase1_indices);
-  let best = void 0;
-  let intermediate_states = /* @__PURE__ */ new Set();
-  let start_time = performance.now();
+  const phase1gen = phase1_ida_solve_gen(phase1_indices);
+  let best;
+  const intermediate_states = /* @__PURE__ */ new Set();
+  const start_time = performance.now();
   for (let i = 0; i < 22; 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]);
       }
     }
-    let stringified_state = JSON.stringify(new_state);
+    const stringified_state = JSON.stringify(new_state);
     if (intermediate_states.has(stringified_state)) {
       continue;
     } else {
       intermediate_states.add(stringified_state);
     }
-    let phase2_indices = index_phase2(new_state);
-    let moves_left = best ? best.length - sol1.length - 1 : 999999;
-    let sol2 = ida_solve_gen(
+    const phase2_indices = index_phase2(new_state);
+    const moves_left = best ? best.length - sol1.length - 1 : 999999;
+    const sol2 = ida_solve_gen(
       phase2_indices,
       phase2_mtables,
       phase2_ptables,
@@ -382,8 +382,8 @@ function determine_V_coset(p) {
   return p[3 ^ p.indexOf(3)];
 }
 function index_phase1(state) {
-  let w = compose(invert(state.mp), state.wp);
-  let c = (state.co.reduce((x, y) => x + y) - determine_V_coset(state.cp) + 3) % 3;
+  const w = compose(invert(state.mp), state.wp);
+  const c = (state.co.reduce((x, y) => x + y) - determine_V_coset(state.cp) + 3) % 3;
   return [0, 1, 2, 3, 4, 5].map(
     (i) => i + 6 * w.indexOf(i) + 72 * w.indexOf(i + 6) + 864 * c
   );
@@ -393,7 +393,7 @@ var phase1_permtable_minv = [];
 var phase1_permtable_w = [];
 var phase1_permtable_winv = [];
 for (let i = 0; i < N_MOVES; i++) {
-  let move = moves[i];
+  const move = moves[i];
   phase1_permtable_m[i] = move.mp;
   phase1_permtable_minv[i] = invert(move.mp);
   phase1_permtable_w[i] = move.wp;
@@ -466,7 +466,7 @@ var phase1_coord_to_score = new Int8Array(6 * 12 * 12 * 3);
 for (let i = 0; i < 6; i++) {
   for (let j = 0; j < 12; j++) {
     for (let k = 0; k < 12; k++) {
-      let index = i + 6 * j + 72 * k;
+      const index = i + 6 * j + 72 * k;
       let score = 2;
       if (j === i) {
         score++;
@@ -485,17 +485,17 @@ for (let i = 0; i < 6; i++) {
 }
 function* phase1_ida_solve_gen(coords) {
   let bound = 0;
-  let mtable = generate_phase1_pairingc_mtable();
-  let ptable = generate_phase1_pairing2c_ptable();
+  const mtable = generate_phase1_pairingc_mtable();
+  const ptable = generate_phase1_pairing2c_ptable();
   while (true) {
     yield* phase1_ida_search_gen(...coords, mtable, ptable, bound, -1);
     bound++;
   }
 }
 function* phase1_ida_search_gen(a, b, c, d, e, f, mtable, ptable, bound, last) {
-  let nmoves = N_MOVES;
-  let score = phase1_coord_to_score[a] + phase1_coord_to_score[b] + phase1_coord_to_score[c] + phase1_coord_to_score[d] + phase1_coord_to_score[e] + phase1_coord_to_score[f];
-  let heuristic = Math.max(
+  const nmoves = N_MOVES;
+  const score = phase1_coord_to_score[a] + phase1_coord_to_score[b] + phase1_coord_to_score[c] + phase1_coord_to_score[d] + phase1_coord_to_score[e] + phase1_coord_to_score[f];
+  const heuristic = Math.max(
     ptable[a % 864 + b * 864],
     ptable[c % 864 + b * 864],
     ptable[e % 864 + b * 864],
@@ -543,7 +543,7 @@ function* phase1_ida_search_gen(a, b, c, d, e, f, mtable, ptable, bound, last) {
       D = mtable[D][m];
       E = mtable[E][m];
       F = mtable[F][m];
-      let subpath_gen = phase1_ida_search_gen(
+      const subpath_gen = phase1_ida_search_gen(
         A,
         B,
         C,
@@ -556,7 +556,7 @@ function* phase1_ida_search_gen(a, b, c, d, e, f, mtable, ptable, bound, last) {
         m
       );
       while (true) {
-        let { value: subpath, done } = subpath_gen.next();
+        const { value: subpath, done } = subpath_gen.next();
         if (done) {
           break;
         }
@@ -566,11 +566,11 @@ function* phase1_ida_search_gen(a, b, c, d, e, f, mtable, ptable, bound, last) {
   }
 }
 function index_phase2(state) {
-  let edges = state.mp;
-  let ep = evenpermutation_to_index(edges.slice(0, 6).map((x) => x % 6));
-  let eo = edges.slice(0, 5).map((x, i) => (x >= 6) * 2 ** i).reduce((x, y) => x + y);
-  let co = state.co.map((x, i) => x * 3 ** i).reduce((x, y) => x + y);
-  let cloc = state.cp.indexOf(0);
+  const edges = state.mp;
+  const ep = evenpermutation_to_index(edges.slice(0, 6).map((x) => x % 6));
+  const eo = edges.slice(0, 5).map((x, i) => (x >= 6) * 2 ** i).reduce((x, y) => x + y);
+  const co = state.co.map((x, i) => x * 3 ** i).reduce((x, y) => x + y);
+  const cloc = state.cp.indexOf(0);
   return [ep + 360 * cloc, eo + 32 * co];
 }
 var tables = {};
@@ -578,18 +578,18 @@ function generate_phase1_pairing_mtable() {
   if (tables.phase1pm) {
     return tables.phase1pm;
   }
-  let mtable = Array(6 * 12 * 12).fill().map(() => Array(N_MOVES).fill(-1));
+  const mtable = Array(6 * 12 * 12).fill().map(() => Array(N_MOVES).fill(-1));
   for (let midge = 0; midge < 6; midge++) {
     for (let wingl = 0; wingl < 12; wingl++) {
       for (let wingh = 0; wingh < 12; wingh++) {
         if (wingl === wingh) {
           continue;
         }
-        let index = midge + 6 * wingl + 72 * wingh;
+        const index = midge + 6 * wingl + 72 * wingh;
         for (let m = 0; m < N_MOVES; m++) {
-          let new_midge = phase1_permtable_minv[m][midge];
-          let new_wingl = phase1_permtable_winv[m][wingl];
-          let new_wingh = phase1_permtable_winv[m][wingh];
+          const new_midge = phase1_permtable_minv[m][midge];
+          const new_wingl = phase1_permtable_winv[m][wingl];
+          const new_wingh = phase1_permtable_winv[m][wingh];
           if (new_midge < 6) {
             mtable[index][m] = new_midge + 6 * new_wingl + 72 * new_wingh;
           } else {
@@ -605,11 +605,11 @@ function generate_phase1_pairingc_mtable() {
   if (tables.phase1pcm) {
     return tables.phase1pcm;
   }
-  let mtable_pairing = generate_phase1_pairing_mtable();
-  let mtable = Array(mtable_pairing.length * 3).fill().map(() => Array(N_MOVES).fill(-1));
+  const mtable_pairing = generate_phase1_pairing_mtable();
+  const mtable = Array(mtable_pairing.length * 3).fill().map(() => Array(N_MOVES).fill(-1));
   for (let index = 0; index < mtable_pairing.length; index++) {
     for (let m = 0; m < N_MOVES; m++) {
-      let new_index = mtable_pairing[index][m];
+      const new_index = mtable_pairing[index][m];
       mtable[index][m] = new_index + 6 * 12 * 12 * phase1_c_update[m];
       mtable[index + 6 * 12 * 12][m] = new_index + 6 * 12 * 12 * ((phase1_c_update[m] + 1) % 3);
       mtable[index + 2 * 6 * 12 * 12][m] = new_index + 6 * 12 * 12 * ((phase1_c_update[m] + 2) % 3);
@@ -621,11 +621,11 @@ function generate_phase1_pairing2c_ptable() {
   if (tables.phase1p2cp) {
     return tables.phase1p2cp;
   }
-  let mtable_noc = generate_phase1_pairing_mtable();
-  let mtable = generate_phase1_pairingc_mtable();
-  let ptable = new Int8Array((6 * 12 * 12) ** 2 * 3);
+  const mtable_noc = generate_phase1_pairing_mtable();
+  const mtable = generate_phase1_pairingc_mtable();
+  const ptable = new Int8Array((6 * 12 * 12) ** 2 * 3);
   ptable.fill(-1);
-  let g = [0, 1, 2, 3, 4, 5].map((x) => x + 6 * x + 72 * (x + 6));
+  const g = [0, 1, 2, 3, 4, 5].map((x) => x + 6 * x + 72 * (x + 6));
   for (let i = 0; i < 6; i++) {
     for (let j = 0; j < 6; j++) {
       if (i === j) {
@@ -641,15 +641,15 @@ function generate_phase1_pairing2c_ptable() {
       if (ptable[index] !== dist) {
         continue;
       }
-      let index0 = index % 864;
-      let index1 = Math.floor(index / 864);
+      const index0 = index % 864;
+      const index1 = Math.floor(index / 864);
       for (let m = 0; m < N_MOVES; m++) {
         let new_index0 = index0;
         let new_index1 = index1;
         for (let r = 1; r <= 2; r++) {
           new_index0 = mtable_noc[new_index0][m];
           new_index1 = mtable[new_index1][m];
-          let new_index = new_index0 + 864 * new_index1;
+          const new_index = new_index0 + 864 * new_index1;
           if (ptable[new_index] === -1) {
             changed = true;
             ptable[new_index] = dist + 1;
@@ -668,19 +668,19 @@ function generate_phase2_permutation_mtable() {
   if (tables.phase2pm) {
     return tables.phase2pm;
   }
-  let mtable = Array(1440).fill().map(() => Array(N_MOVES_PHASE2));
+  const mtable = Array(1440).fill().map(() => Array(N_MOVES_PHASE2));
   for (let ep = 0; ep < 360; ep++) {
-    let perm = index_to_evenpermutation(ep, 6);
+    const perm = index_to_evenpermutation(ep, 6);
     for (let i = 0; i < 6; i++) {
       perm[i + 6] = perm[i] + 6;
     }
     for (let m = 0; m < N_MOVES_PHASE2; m++) {
-      let new_perm = compose(perm, moves[m].mp);
-      let new_ep = evenpermutation_to_index(
+      const new_perm = compose(perm, moves[m].mp);
+      const new_ep = evenpermutation_to_index(
         new_perm.slice(0, 6).map((x) => x % 6)
       );
       for (let new_cloc = 0; new_cloc < 4; new_cloc++) {
-        let cloc = moves[m].cp[new_cloc];
+        const cloc = moves[m].cp[new_cloc];
         mtable[ep + 360 * cloc][m] = new_ep + 360 * new_cloc;
       }
     }
@@ -691,25 +691,25 @@ function generate_phase2_orientation_mtable() {
   if (tables.phase2om) {
     return tables.phase2om;
   }
-  let mtable = Array(32 * 81).fill().map(() => Array(N_MOVES_PHASE2));
+  const mtable = Array(32 * 81).fill().map(() => Array(N_MOVES_PHASE2));
   for (let eo = 0; eo < 32; eo++) {
-    let eo_array = [0, 1, 2, 3, 4].map((i) => eo >> i & 1);
+    const eo_array = [0, 1, 2, 3, 4].map((i) => eo >> i & 1);
     eo_array[5] = eo_array.reduce((x, y) => x ^ y);
-    let perm = [];
+    const perm = [];
     for (let i = 0; i < 6; i++) {
       perm[i] = i + 6 * eo_array[i];
       perm[i + 6] = i + 6 * (eo_array[i] ^ 1);
     }
     for (let co = 0; co < 81; co++) {
-      let co_array = [0, 1, 2, 3].map((i) => Math.floor(co / 3 ** i) % 3);
+      const co_array = [0, 1, 2, 3].map((i) => Math.floor(co / 3 ** i) % 3);
       for (let m = 0; m < N_MOVES_PHASE2; m++) {
-        let new_perm = compose(perm, moves[m].mp);
-        let new_eo_array = new_perm.slice(0, 5).map((x) => +(x >= 6));
+        const new_perm = compose(perm, moves[m].mp);
+        const new_eo_array = new_perm.slice(0, 5).map((x) => +(x >= 6));
         let new_eo = 0;
         for (let i = 0; i < 5; i++) {
           new_eo += new_eo_array[i] << i;
         }
-        let new_co_array = co_array.map((x, i) => (x + moves[m].co[i]) % 3);
+        const new_co_array = co_array.map((x, i) => (x + moves[m].co[i]) % 3);
         let new_co = 0;
         for (let i = 0; i < 4; i++) {
           new_co += new_co_array[i] * 3 ** i;
@@ -733,15 +733,15 @@ function generate_phase2_orientation_ptable() {
   return tables.phase2op = bfs(generate_phase2_orientation_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;
       }
@@ -760,7 +760,7 @@ function bfs(mtable, goal_states) {
   return ptable;
 }
 function* ida_solve_gen(indices, mtables, ptables, moves_left) {
-  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]]);
@@ -771,8 +771,8 @@ function* ida_solve_gen(indices, mtables, ptables, moves_left) {
   }
 }
 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]]);
@@ -794,13 +794,13 @@ function* ida_search_gen(indices, mtables, ptables, bound, last) {
     if (m < last && moves_commute(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_gen = ida_search_gen(
+      const subpath_gen = ida_search_gen(
         new_indices,
         mtables,
         ptables,
@@ -808,7 +808,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;
         }
@@ -827,4 +827,3 @@ async function randomMasterTetraminxScrambleString() {
 export {
   randomMasterTetraminxScrambleString
 };
-//# sourceMappingURL=search-dynamic-solve-master_tetraminx-GIS7T5B7.js.map

package/dist/lib/cubing/chunks/search-worker-entry.js

@@ -1,10 +1,10 @@
 import {
   exposeAPI
-} from "./chunk-7GUL3OBQ.js";
+} from "./chunk-BHVTDDUY.js";
 
 // src/cubing/search/worker-workarounds/search-worker-entry.js
 if (exposeAPI.expose) {
-  void import("./inside-BAQGCKLY.js").then(() => {
+  void import("./inside-UWSZBO4Y.js").then(() => {
     if (globalThis.postMessage) {
       globalThis.postMessage("comlink-exposed");
     } else {
@@ -16,4 +16,3 @@ var WORKER_ENTRY_FILE_URL = import.meta.url;
 export {
   WORKER_ENTRY_FILE_URL
 };
-//# sourceMappingURL=search-worker-entry.js.map

package/dist/lib/cubing/chunks/{twips-J732JDZJ.js → twips-IMF5RNH5.js}

@@ -1,7 +1,7 @@
-import "./chunk-GHFBZYSV.js";
+import "./chunk-YJH5LHFN.js";
 import {
   Alg
-} from "./chunk-CFZLXDM6.js";
+} from "./chunk-QZK3M7IM.js";
 
 // src/cubing/vendor/mpl/twips/index.js
 var wasm;
@@ -387,7 +387,7 @@ var twips_wasm_default = __wbg_init;
 var cachedInitWrapper;
 async function initWrapper() {
   await (cachedInitWrapper ??= (async () => {
-    const wasmUint8Array = (await import("./twips_wasm_bg-TJNYGA2C-AP2O4LGG.js")).default;
+    const wasmUint8Array = (await import("./twips_wasm_bg-TJNYGA2C-4JIZWC6Q.js")).default;
     await twips_wasm_default({ module_or_path: wasmUint8Array.buffer });
   })());
 }
@@ -430,4 +430,3 @@ export {
   wasmRandomScrambleForEvent2 as wasmRandomScrambleForEvent,
   wasmTwips2 as wasmTwips
 };
-//# sourceMappingURL=twips-J732JDZJ.js.map