cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/search/inside/solve/vendor/cstimer/src/js/lib/mathlib.ts

@@ -1,54 +0,0 @@
-const Cnk: number[][] = [],
-  fact = [1];
-for (let i = 0; i < 32; ++i) {
-  Cnk[i] = [];
-  for (let j = 0; j < 32; ++j) {
-    Cnk[i][j] = 0;
-  }
-}
-for (let i = 0; i < 32; ++i) {
-  Cnk[i][0] = Cnk[i][i] = 1;
-  fact[i + 1] = fact[i] * (i + 1);
-  for (let j = 1; j < i; ++j) {
-    Cnk[i][j] = Cnk[i - 1][j - 1] + Cnk[i - 1][j];
-  }
-}
-
-function circle(arr: number[], ...moreArgs: number[]) {
-  const length = moreArgs.length,
-    temp = arr[moreArgs[length - 1]];
-  for (let i = length; i > 0; i--) {
-    arr[moreArgs[i]] = arr[moreArgs[i - 1]];
-  }
-  arr[moreArgs[0]] = temp;
-  return circle;
-}
-
-function set8Perm(arr: number[], idx: number, n?: number, even?: number) {
-  n = (n || 8) - 1;
-  let val = 0x76543210;
-  let prt = 0;
-  even ??= 0;
-  if (even < 0) {
-    idx <<= 1;
-  }
-  for (let i = 0; i < n; ++i) {
-    const p = fact[n - i];
-    let v = ~~(idx / p);
-    prt ^= v;
-    idx %= p;
-    v <<= 2;
-    arr[i] = (val >> v) & 7;
-    const m = (1 << v) - 1;
-    val = (val & m) + ((val >> 4) & ~m);
-  }
-  if (even < 0 && (prt & 1) !== 0) {
-    arr[n] = arr[n - 1];
-    arr[n - 1] = val & 7;
-  } else {
-    arr[n] = val & 7;
-  }
-  return arr;
-}
-
-export { Cnk, set8Perm, circle };

package/src/cubing/search/inside/solve/vendor/min2phase/gwt.d.ts

@@ -1,2 +0,0 @@
-export function initialize(): void;
-export function solveState(state: string): string;

package/src/cubing/search/inside/solve/vendor/random-uint-below/get-random-values.ts

@@ -1,38 +0,0 @@
-export type GetRandomValuesFunction = (arr: Uint32Array) => void;
-
-// This is a workaround for a `node` segfault.
-// In theory, imports are cached and safe to import multiple times: https://nodejs.org/api/esm.html#esm_urls
-// In practice, a rapid series of inline imports inside a worker causes a segfault(!) in `node`.
-// So we cach a single import reference. We avoid populating it until we first need it, so that we don't attempt to perform the import in environments that don't need or have it (e.g. browsers, `deno`).
-let cryptoPromise: Promise<typeof import("crypto")> | null = null;
-
-// We could use top-level await to define this more statically, but that has limited transpilation support.
-export async function getRandomValuesFactory(): Promise<GetRandomValuesFunction> {
-  const hasWebCrypto =
-    typeof crypto !== "undefined" &&
-    typeof crypto.getRandomValues !== "undefined";
-
-  if (hasWebCrypto) {
-    return crypto.getRandomValues.bind(crypto) as GetRandomValuesFunction;
-  } else {
-    const nodeCrypto = await (cryptoPromise ??= import("crypto"));
-    return (arr: Uint32Array) => {
-      if (!(arr instanceof Uint32Array)) {
-        throw new Error(
-          "The getRandomValues() shim only takes unsigned 32-bit int arrays",
-        );
-      }
-      const bytes = nodeCrypto.randomBytes(arr.length * 4);
-      const uint32_list = [];
-      for (let i = 0; i < arr.length; i++) {
-        uint32_list.push(
-          (bytes[i * 4 + 0] << 24) +
-            (bytes[i * 4 + 1] << 16) +
-            (bytes[i * 4 + 2] << 8) +
-            (bytes[i * 4 + 3] << 0),
-        );
-      }
-      arr.set(uint32_list);
-    };
-  }
-}

package/src/cubing/search/inside/solve/vendor/random-uint-below/index.ts

@@ -1,12 +0,0 @@
-export { randomChoiceFactory } from "./random-choice";
-export { randomUIntBelowFactory } from "./random-int";
-
-// TODO: reuse factory properly, move this to a separate file, add to impl.
-import { randomUIntBelowFactory } from "./random-int";
-const randomUIntBelowPromise = randomUIntBelowFactory();
-export async function randomPermute<T>(list: T[]): Promise<void> {
-  for (let i = 1; i < list.length; i++) {
-    const j = (await randomUIntBelowPromise)(i);
-    [list[i], list[j]] = [list[j], list[i]];
-  }
-}

package/src/cubing/search/inside/solve/vendor/random-uint-below/random-choice.ts

@@ -1,9 +0,0 @@
-import { randomUIntBelowFactory } from "./random-int";
-
-// Inspired by https://reference.wolfram.com/language/ref/RandomChoice.html
-// This library itself should be kept small, but a wrapper library may want to implement selecting multiple element without replacement as with replacement:
-// https://reference.wolfram.com/language/ref/RandomSample.html
-export async function randomChoiceFactory<T>(): Promise<(arr: Array<T>) => T> {
-  const randomUIntBelow = await randomUIntBelowFactory();
-  return (arr: Array<T>): T => arr[randomUIntBelow(arr.length)];
-}

package/src/cubing/search/inside/solve/vendor/random-uint-below/random-int.ts

@@ -1,64 +0,0 @@
-import {
-  getRandomValuesFactory,
-  GetRandomValuesFunction,
-} from "./get-random-values";
-
-/*
- * randomInt.below(max) returns a random non-negative integer less than max (0 <= output < max).
- * `max` must be at most 2^53.
- */
-
-const MAX_JS_PRECISE_INT = 9007199254740992;
-
-const UPPER_HALF_MULTIPLIER = 2097152; // 2^21. We have to use multiplication because bit shifts truncate to 32 bits.
-const LOWER_HALF_DIVIDER = 2048;
-
-function random53BitValue(getRandomValues: GetRandomValuesFunction): number {
-  // Construct a random 53-bit value from a 32-bit upper half and a 21-bit lower half.
-  const arr = new Uint32Array(2);
-  getRandomValues(arr);
-  const upper = arr[0];
-  const lower = arr[1];
-  return (
-    Math.floor(upper * UPPER_HALF_MULTIPLIER) +
-    Math.floor(lower / LOWER_HALF_DIVIDER)
-  );
-}
-
-function validateMax(max: number): void {
-  if (typeof max !== "number" || max < 0 || Math.floor(max) !== max) {
-    throw new Error(
-      "randomInt.below() not called with a positive integer value.",
-    );
-  }
-  if (max > MAX_JS_PRECISE_INT) {
-    throw new Error(
-      `Called randomInt.below() with max == ${max}, which is larger than Javascript can handle with integer precision.`,
-    );
-  }
-}
-
-// TODO: cache generated `randomUIntBelow`?
-export async function randomUIntBelowFactory(): Promise<
-  (max: number) => number
-> {
-  const getRandomValues = await getRandomValuesFactory();
-  const randomUIntBelow = (max: number): number => {
-    validateMax(max);
-
-    const val = random53BitValue(getRandomValues);
-    const maxUniformSamplingRange = Math.floor(MAX_JS_PRECISE_INT / max) * max;
-
-    // Rejection sampling:
-    if (val < maxUniformSamplingRange) {
-      return val % max;
-    } else {
-      // val % max would produce a biased result. This bias an be very bad if `max` is on the order of MAX_JS_PRECISE_INT. We have to try again, so just call ourselves recursively.
-      // For some values of `max` just above 9007199254740992 / 2, this happens about once on average. For other values of `max`, it's less than that (and for small values of `max` it's extremely unlikely).
-
-      // TODO: Use more bits of accuracy instead of rejection sampling to avoid DoS.
-      return randomUIntBelow(max);
-    }
-  };
-  return randomUIntBelow;
-}

package/src/cubing/search/instantiator.ts

@@ -1,60 +0,0 @@
-import type { WorkerInsideAPI } from "./inside/api";
-
-import {
-  constructWorkerFromString,
-  workerFileConstructor,
-  wrap,
-} from "./vendor/comlink-everywhere/outside";
-
-import type { esmTestAPIImplementation } from "./esm-test-worker";
-type ESMTestAPI = typeof esmTestAPIImplementation;
-
-// Blocked on:
-// - https://github.com/evanw/esbuild/issues/312
-// - https://bugzilla.mozilla.org/show_bug.cgi?id=1558780
-const TEST_RELATIVE_URL_WORKER = false;
-
-export async function instantiateRelativeURLWorker(): Promise<void> {
-  // eslint-disable-next-line no-async-promise-executor
-  return new Promise(async (resolve, reject) => {
-    setTimeout(() => {
-      reject();
-    }, 1000);
-
-    const Worker = await workerFileConstructor();
-    const worker = new Worker(new URL("./esm-test-worker.js", import.meta.url));
-    const api = wrap<ESMTestAPI>(worker);
-
-    if ((await api.test("to worker")) === "from worker") {
-      resolve();
-    } else {
-      reject();
-    }
-
-    // TODO: terminate worker.
-  });
-}
-
-export async function relativeURLWorkerTest(): Promise<void> {
-  try {
-    await instantiateRelativeURLWorker();
-    console.info("Successful relative URL worker instantiation.");
-  } catch (e) {
-    console.warn(
-      "WARNING: Could not instantiate and communicate with a relative URL worker. This means that your app may have issues with `cubing/solve` in the future.",
-    );
-  }
-}
-
-export async function instantiateWorker(): Promise<WorkerInsideAPI> {
-  const { workerSource } = await import("./worker-inside-generated-string.js");
-  // console.log({ workerSource });
-
-  const worker = await constructWorkerFromString(workerSource);
-
-  if (TEST_RELATIVE_URL_WORKER) {
-    relativeURLWorkerTest(); // do not wait for the result
-  }
-
-  return wrap(worker);
-}

package/src/cubing/search/outside.ts

@@ -1,110 +0,0 @@
-import { Alg } from "../alg";
-// import { preInitialize222 } from "../implementations/2x2x2";
-import { randomClockScrambleString } from "./inside/solve/puzzles/clock"; // TODO: don't reach into `inside` code.
-import { randomMegaminxScrambleString } from "./inside/solve/puzzles/wca-minx"; // TODO: don't reach into `inside` code.
-import { instantiateWorker } from "./instantiator";
-import type { WorkerInsideAPI } from "./inside/api";
-import type { Transformation } from "../kpuzzle";
-
-let cachedWorkerInstance: Promise<WorkerInsideAPI> | null = null;
-async function getCachedWorkerInstance(): Promise<WorkerInsideAPI> {
-  return await (cachedWorkerInstance ??= instantiateWorker());
-}
-
-// Pre-initialize the scrambler for the given event. (Otherwise, an event is
-// initialized the first time you ask for a scramble for that event.)
-//
-// Some typical numbers for a fast computer:
-// - 3x3x3 initialization: 200ms
-// - Each 3x3x3 scramble: 50ms
-// - 4x4x4 initialization: 2500ms
-// - Each 4x4x4 scramble: 300ms to 800ms
-//
-// It is safe to immediately call for a scramble
-// any time after starting pre-initialization, or to call for them without
-// pre-initializing. Pre-initializing essentially gives the scramble worker a
-// head start in case a scramble doesn't get requested immediately.
-//
-// Note that events cannot be pre-initialized in parallel. Attempting to
-// pre-initialize multiple events will initialize them consecutively. Scrambles
-// for a given event cannot be computed while another event is being initialized.
-export function _preInitializationHintForEvent(
-  eventID: string,
-  // callback?: () => void
-): void {
-  switch (eventID) {
-    case "clock":
-    case "minx":
-      return;
-    case "333oh":
-      return _preInitializationHintForEvent("333");
-  }
-  (async () => {
-    await (await getCachedWorkerInstance()).initialize(eventID);
-  })();
-}
-
-export async function randomScrambleForEvent(eventID: string): Promise<Alg> {
-  switch (eventID) {
-    case "clock":
-      return Alg.fromString(await randomClockScrambleString());
-    case "minx":
-      return Alg.fromString(await randomMegaminxScrambleString());
-  }
-  const prom = _randomScrambleStringForEvent(eventID);
-  const wat = await prom;
-  return Alg.fromString(wat);
-}
-
-export async function _randomScrambleStringForEvent(
-  eventID: string,
-): Promise<string> {
-  const cwi = await getCachedWorkerInstance();
-  return cwi.randomScrambleStringForEvent(eventID);
-}
-
-export async function randomScrambleStringForEvent(
-  eventID: string,
-): Promise<string> {
-  switch (eventID) {
-    case "clock":
-      return randomClockScrambleString();
-    case "minx":
-      return randomMegaminxScrambleString();
-  }
-  return await _randomScrambleStringForEvent(eventID);
-}
-
-export async function experimentalSolve3x3x3IgnoringCenters(
-  s: Transformation,
-): Promise<Alg> {
-  const cwi = await getCachedWorkerInstance();
-  return Alg.fromString(await cwi.solve333ToString(s));
-}
-
-export async function experimentalSolve2x2x2(s: Transformation): Promise<Alg> {
-  const cwi = await getCachedWorkerInstance();
-  return Alg.fromString(await cwi.solve222ToString(s));
-}
-
-export async function solveSkewb(s: Transformation): Promise<Alg> {
-  const cwi = await getCachedWorkerInstance();
-  return Alg.fromString(await cwi.solveSkewbToString(s));
-}
-
-export async function solvePyraminx(s: Transformation): Promise<Alg> {
-  const cwi = await getCachedWorkerInstance();
-  return Alg.fromString(await cwi.solvePyraminxToString(s));
-}
-
-export async function solveMegaminx(s: Transformation): Promise<Alg> {
-  const cwi = await getCachedWorkerInstance();
-  return Alg.fromString(await cwi.solveMegaminxToString(s));
-}
-
-export function setDebug(options: { logPerf?: boolean }): void {
-  const { logPerf } = options;
-  if (typeof logPerf !== "undefined") {
-    getCachedWorkerInstance().then((cwi) => cwi.setDebugMeasurePerf(logPerf));
-  }
-}

package/src/cubing/search/vendor/comlink-everywhere/comlink-everywhere.webloc

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>URL</key>
-	<string>https://github.com/cubing/comlink-everywhere</string>
-</dict>
-</plist>

package/src/cubing/search/vendor/comlink-everywhere/inside/index.js

@@ -1,16 +0,0 @@
-import { expose as comlinkExpose } from "comlink";
-
-const useNodeWorkarounds =
-  typeof globalThis.Worker === "undefined" &&
-  typeof globalThis.WorkerNavigator === "undefined";
-
-export function expose(api) {
-  if (useNodeWorkarounds) {
-    (async () => {
-      const { port } = await import("./node.js");
-      comlinkExpose(api, await port());
-    })();
-  } else {
-    comlinkExpose(api);
-  }
-}

package/src/cubing/search/vendor/comlink-everywhere/inside/node.js

@@ -1,6 +0,0 @@
-export async function port() {
-  const { parentPort } = await import("worker_threads").catch();
-  const nodeEndpoint = (await import("comlink/dist/esm/node-adapter.mjs"))
-    .default;
-  return nodeEndpoint(parentPort);
-}

package/src/cubing/search/vendor/comlink-everywhere/outside/index.d.ts

@@ -1,6 +0,0 @@
-export { wrap } from "comlink";
-export function workerFileConstructor(): Promise<typeof Worker>;
-export function constructWorkerFromString(
-  stringSource: string,
-  options?: { type: "classic" | "module" },
-): Promise<Worker>;

package/src/cubing/search/vendor/comlink-everywhere/outside/index.js

@@ -1,31 +0,0 @@
-export { wrap } from "comlink";
-
-const useNodeWorkarounds =
-  typeof globalThis.Worker === "undefined" &&
-  typeof globalThis.WorkerNavigator === "undefined";
-
-export async function workerFileConstructor() {
-  if (useNodeWorkarounds) {
-    return await (await import("./node.js")).NodeWorkerWrapper();
-  } else {
-    return globalThis.Worker;
-  }
-}
-
-export async function constructWorkerFromString(stringSource, options) {
-  let worker;
-  if (useNodeWorkarounds) {
-    const constructor = await (
-      await import("./node.js")
-    ).NodeWorkerStringWrapper();
-    const worker = new constructor(stringSource);
-    return worker;
-  } else {
-    const blob = new Blob([stringSource], { type: "application/javascript" });
-    const workerURL = URL.createObjectURL(blob);
-    worker = new globalThis.Worker(workerURL, {
-      type: options ? options.type : undefined, // TODO: Is it safe to use `options?.type`?
-    });
-  }
-  return worker;
-}

package/src/cubing/search/vendor/comlink-everywhere/outside/node.js

@@ -1,41 +0,0 @@
-async function getImports() {
-  return {
-    NodeWorker: (await import("worker_threads")).Worker,
-    nodeEndpoint: (await import("comlink/dist/esm/node-adapter.mjs")).default,
-  };
-}
-
-function construct(imports, url, nodeOptions) {
-  const worker = new imports.NodeWorker(url, nodeOptions);
-  // Avoid holding up the entire program exit if only workers are running.
-  // https://nodejs.org/api/worker_threads.html#worker_threads_broadcastchannel_unref
-  worker.unref();
-  const wrappedWorker = imports.nodeEndpoint(worker);
-  return wrappedWorker;
-}
-
-let cachedNodeWorkerWrapper = null;
-export async function NodeWorkerWrapper() {
-  const imports = await getImports();
-  return (
-    cachedNodeWorkerWrapper ||
-    (cachedNodeWorkerWrapper = class {
-      constructor(url, _options) {
-        return construct(imports, url);
-      }
-    })
-  );
-}
-
-let cachedNodeWorkerStringWrapper = null;
-export async function NodeWorkerStringWrapper() {
-  const imports = await getImports();
-  return (
-    cachedNodeWorkerStringWrapper ||
-    (cachedNodeWorkerStringWrapper = class {
-      constructor(url, _options) {
-        return construct(imports, url, { eval: true });
-      }
-    })
-  );
-}