cubing 0.40.0 → 0.41.0

package/dist/types/bluetooth/index.d.ts

@@ -1,6 +1,6 @@
-import { K as KState } from '../KState-33ce1f57.js';
-import { B as BluetoothPuzzle } from '../bluetooth-puzzle-29072a56.js';
-export { B as BluetoothPuzzle, A as MoveEvent, O as OrientationEvent } from '../bluetooth-puzzle-29072a56.js';
+import { K as KPattern } from '../KPattern-85fd8579.js';
+import { B as BluetoothPuzzle } from '../bluetooth-puzzle-da601f13.js';
+export { B as BluetoothPuzzle, A as MoveEvent, O as OrientationEvent } from '../bluetooth-puzzle-da601f13.js';
 import { a as Alg, M as Move } from '../Alg-c6770822.js';
 
 declare function enableDebugLogging(enable: boolean): void;
@@ -14,7 +14,7 @@ declare class KeyboardPuzzle extends BluetoothPuzzle {
     constructor(target: Element);
     name(): string | undefined;
     disconnect(): void;
-    getState(): Promise<KState>;
+    getState(): Promise<KPattern>;
     private onKeyDown;
 }
 /** @category Keyboard Puzzles */
@@ -50,7 +50,7 @@ declare class GanCube extends BluetoothPuzzle {
     stopTrackingMoves(): void;
     intervalHandler(): Promise<void>;
     getBattery(): Promise<number>;
-    getState(): Promise<KState>;
+    getState(): Promise<KPattern>;
     faceletStatus1Characteristic(): Promise<BluetoothRemoteGATTCharacteristic>;
     faceletStatus2Characteristic(): Promise<BluetoothRemoteGATTCharacteristic>;
     actualAngleAndBatteryCharacteristic(): Promise<BluetoothRemoteGATTCharacteristic>;
@@ -69,7 +69,7 @@ declare class GiiKERCube extends BluetoothPuzzle {
     private constructor();
     name(): string | undefined;
     disconnect(): void;
-    getState(): Promise<KState>;
+    getState(): Promise<KPattern>;
     private getBit;
     private toReid333;
     private onCubeCharacteristicChanged;

package/dist/types/{bluetooth-puzzle-29072a56.d.ts → bluetooth-puzzle-da601f13.d.ts}

@@ -1,5 +1,5 @@
 import { d as AlgLeaf } from './Alg-c6770822.js';
-import { K as KState } from './KState-33ce1f57.js';
+import { K as KPattern } from './KPattern-85fd8579.js';
 
 interface StreamTransformer {
     transformAlgLeaf(algLeafEvent: AlgLeafEvent): void;
@@ -12,7 +12,7 @@ interface AlgLeafEvent {
     latestAlgLeaf: AlgLeaf;
     timeStamp: number;
     debug?: Record<string, unknown>;
-    state?: KState;
+    state?: KPattern;
     quaternion?: any;
 }
 /** @category Smart Puzzles */
@@ -33,7 +33,7 @@ declare abstract class BluetoothPuzzle extends EventTarget {
     protected orientationListeners: Array<(e: OrientationEvent) => void>;
     abstract name(): string | undefined;
     abstract disconnect(): void;
-    getState(): Promise<KState>;
+    getState(): Promise<KPattern>;
     addAlgLeafListener(listener: (e: AlgLeafEvent) => void): void;
     addOrientationListener(listener: (e: OrientationEvent) => void): void;
     experimentalAddBasicRotationTransformer(): void;

package/dist/types/kpuzzle/index.d.ts

@@ -1,2 +1,2 @@
-export { a as KPuzzle, b as KPuzzleDefinition, K as KState, c as KStateData, d as KStateOrbitData, g as KTransformation, e as KTransformationData, f as KTransformationOrbitData } from '../KState-33ce1f57.js';
+export { K as KPattern, c as KPatternData, d as KPatternOrbitData, a as KPuzzle, b as KPuzzleDefinition, g as KTransformation, e as KTransformationData, f as KTransformationOrbitData } from '../KPattern-85fd8579.js';
 import '../Alg-c6770822.js';

package/dist/types/notation/index.d.ts

@@ -1,8 +1,8 @@
 import { a as Alg } from '../Alg-c6770822.js';
-import { P as PuzzleLoader } from '../TwizzleLink-19143923.js';
+import { P as PuzzleLoader } from '../TwizzleLink-7d147be8.js';
 import 'three';
 import '../parseAlg-d2c83795.js';
-import '../KState-33ce1f57.js';
+import '../KPattern-85fd8579.js';
 
 declare enum CommonMetric {
     OuterBlockTurnMetric = "OBTM",

package/dist/types/{outside-b7760f77.d.ts → outside-51ce651a.d.ts}

@@ -1,5 +1,5 @@
 import { a as Alg } from './Alg-c6770822.js';
-import { K as KState, a as KPuzzle } from './KState-33ce1f57.js';
+import { K as KPattern, a as KPuzzle } from './KPattern-85fd8579.js';
 
 declare enum PrefetchLevel {
     Auto = "auto",
@@ -8,17 +8,17 @@ declare enum PrefetchLevel {
 }
 
 declare function randomScrambleForEvent(eventID: string): Promise<Alg>;
-declare function experimentalSolve3x3x3IgnoringCenters(state: KState): Promise<Alg>;
-declare function experimentalSolve2x2x2(state: KState): Promise<Alg>;
-declare function solveSkewb(state: KState): Promise<Alg>;
-declare function solvePyraminx(state: KState): Promise<Alg>;
-declare function solveMegaminx(state: KState): Promise<Alg>;
+declare function experimentalSolve3x3x3IgnoringCenters(state: KPattern): Promise<Alg>;
+declare function experimentalSolve2x2x2(state: KPattern): Promise<Alg>;
+declare function solveSkewb(state: KPattern): Promise<Alg>;
+declare function solvePyraminx(state: KPattern): Promise<Alg>;
+declare function solveMegaminx(state: KPattern): Promise<Alg>;
 interface SolveTwsearchOptions {
     moveSubset?: string[];
-    startState?: KState;
+    startState?: KPattern;
     minDepth?: number;
 }
-declare function solveTwsearch(kpuzzle: KPuzzle, state: KState, options?: SolveTwsearchOptions): Promise<Alg>;
+declare function solveTwsearch(kpuzzle: KPuzzle, state: KPattern, options?: SolveTwsearchOptions): Promise<Alg>;
 interface SearchOutsideDebugGlobals {
     logPerf: boolean;
     scramblePrefetchLevel: `${PrefetchLevel}`;

package/dist/types/protocol/index.d.ts

@@ -1,4 +1,4 @@
-import { K as KState } from '../KState-33ce1f57.js';
+import { K as KPattern } from '../KPattern-85fd8579.js';
 import '../Alg-c6770822.js';
 
 type Binary3x3x3State = ArrayBuffer;
@@ -13,13 +13,13 @@ interface Binary3x3x3Components {
     moMask: number;
 }
 /** @category Binary 3x3x3 Format */
-declare function reid3x3x3ToTwizzleBinary(state: KState): Binary3x3x3State;
+declare function reid3x3x3ToTwizzleBinary(state: KPattern): Binary3x3x3State;
 /** @category Binary 3x3x3 Format */
 declare function twizzleBinaryToBinaryComponents(buffer: ArrayBuffer): Binary3x3x3Components;
 /** @category Binary 3x3x3 Format */
-declare function binaryComponentsToReid3x3x3(components: Binary3x3x3Components): KState;
+declare function binaryComponentsToReid3x3x3(components: Binary3x3x3Components): KPattern;
 /** @category Binary 3x3x3 Format */
-declare function twizzleBinaryToReid3x3x3(buffy: ArrayBuffer): KState;
+declare function twizzleBinaryToReid3x3x3(buffy: ArrayBuffer): KPattern;
 
 declare function bufferToSpacedHex(buffer: ArrayBuffer): string;
 declare function spacedHexToBuffer(hex: string): Uint8Array;

package/dist/types/puzzle-geometry/index.d.ts

@@ -1,5 +1,5 @@
-import { i as Perm } from '../KState-33ce1f57.js';
-export { x as EXPERIMENTAL_PUZZLE_BASE_SHAPES, v as EXPERIMENTAL_PUZZLE_CUT_TYPES, s as ExperimentalPGNotation, y as ExperimentalPuzzleBaseShape, t as ExperimentalPuzzleCutDescription, w as ExperimentalPuzzleCutType, u as ExperimentalPuzzleDescription, P as PuzzleGeometry, Q as Quat, S as StickerDat, n as StickerDatAxis, o as StickerDatFace, q as StickerDatSticker, m as getPG3DNamedPuzzles, j as getPuzzleDescriptionString, k as getPuzzleGeometryByDesc, l as getPuzzleGeometryByName, r as parseOptions, p as parsePuzzleDescription } from '../KState-33ce1f57.js';
+import { i as Perm } from '../KPattern-85fd8579.js';
+export { x as EXPERIMENTAL_PUZZLE_BASE_SHAPES, v as EXPERIMENTAL_PUZZLE_CUT_TYPES, s as ExperimentalPGNotation, y as ExperimentalPuzzleBaseShape, t as ExperimentalPuzzleCutDescription, w as ExperimentalPuzzleCutType, u as ExperimentalPuzzleDescription, P as PuzzleGeometry, Q as Quat, S as StickerDat, n as StickerDatAxis, o as StickerDatFace, q as StickerDatSticker, m as getPG3DNamedPuzzles, j as getPuzzleDescriptionString, k as getPuzzleGeometryByDesc, l as getPuzzleGeometryByName, r as parseOptions, p as parsePuzzleDescription } from '../KPattern-85fd8579.js';
 import '../Alg-c6770822.js';
 
 declare function schreierSims(g: Perm[], disp: (s: string) => void): bigint;

package/dist/types/puzzles/index.d.ts

@@ -1,7 +1,7 @@
-import { a as PuzzleID, P as PuzzleLoader, E as ExperimentalStickering, S as StickeringMask } from '../TwizzleLink-19143923.js';
-export { P as PuzzleLoader } from '../TwizzleLink-19143923.js';
+import { a as PuzzleID, P as PuzzleLoader, E as ExperimentalStickering, S as StickeringMask } from '../TwizzleLink-7d147be8.js';
+export { P as PuzzleLoader } from '../TwizzleLink-7d147be8.js';
 import { g as PuzzleSpecificSimplifyOptions } from '../Alg-c6770822.js';
-import { a as KPuzzle, P as PuzzleGeometry } from '../KState-33ce1f57.js';
+import { a as KPuzzle, P as PuzzleGeometry } from '../KPattern-85fd8579.js';
 import 'three';
 import '../parseAlg-d2c83795.js';
 

package/dist/types/scramble/index.d.ts

@@ -1,3 +1,3 @@
-export { r as randomScrambleForEvent } from '../outside-b7760f77.js';
+export { r as randomScrambleForEvent } from '../outside-51ce651a.js';
 import '../Alg-c6770822.js';
-import '../KState-33ce1f57.js';
+import '../KPattern-85fd8579.js';

package/dist/types/search/index.d.ts

@@ -1,7 +1,7 @@
-export { a as experimentalSolve2x2x2, e as experimentalSolve3x3x3IgnoringCenters, f as experimentalSolveTwsearch, d as setSearchDebug, c as solveMegaminx, b as solvePyraminx, s as solveSkewb } from '../outside-b7760f77.js';
-import { K as KState } from '../KState-33ce1f57.js';
+export { a as experimentalSolve2x2x2, e as experimentalSolve3x3x3IgnoringCenters, f as experimentalSolveTwsearch, d as setSearchDebug, c as solveMegaminx, b as solvePyraminx, s as solveSkewb } from '../outside-51ce651a.js';
+import { K as KPattern } from '../KPattern-85fd8579.js';
 import '../Alg-c6770822.js';
 
-declare function random333State(): Promise<KState>;
+declare function random333State(): Promise<KPattern>;
 
 export { random333State };

package/dist/types/stream/index.d.ts

@@ -1,6 +1,6 @@
-import { A as AlgLeafEvent, O as OrientationEvent } from '../bluetooth-puzzle-29072a56.js';
+import { A as AlgLeafEvent, O as OrientationEvent } from '../bluetooth-puzzle-da601f13.js';
 import '../Alg-c6770822.js';
-import '../KState-33ce1f57.js';
+import '../KPattern-85fd8579.js';
 
 interface ProxyMoveEvent {
     event: "move";

package/dist/types/twisty/index.d.ts

@@ -1,7 +1,7 @@
-import { A as AlgIndexer, T as Timestamp, D as Duration, S as StickeringMask } from '../TwizzleLink-19143923.js';
-export { A as AlgIndexer, B as BackViewLayout, N as EXPERIMENTAL_PROP_NO_VALUE, M as ExperimentalMillisecondTimestamp, E as ExperimentalStickering, a as PuzzleID, d as TwistyAlgEditor, c as TwistyAlgViewer, b as TwistyPlayer, e as TwistyPlayerConfig, g as TwizzleLink, V as VisualizationFormat, f as backViewLayouts } from '../TwizzleLink-19143923.js';
+import { A as AlgIndexer, T as Timestamp, D as Duration, S as StickeringMask } from '../TwizzleLink-7d147be8.js';
+export { A as AlgIndexer, B as BackViewLayout, N as EXPERIMENTAL_PROP_NO_VALUE, M as ExperimentalMillisecondTimestamp, E as ExperimentalStickering, a as PuzzleID, d as TwistyAlgEditor, c as TwistyAlgViewer, b as TwistyPlayer, e as TwistyPlayerConfig, g as TwizzleLink, V as VisualizationFormat, f as backViewLayouts } from '../TwizzleLink-7d147be8.js';
 import { a as Alg, M as Move } from '../Alg-c6770822.js';
-import { a as KPuzzle, K as KState, g as KTransformation } from '../KState-33ce1f57.js';
+import { a as KPuzzle, K as KPattern, g as KTransformation } from '../KPattern-85fd8579.js';
 import 'three';
 import '../parseAlg-d2c83795.js';
 
@@ -19,7 +19,7 @@ declare class SimpleAlgIndexer implements AlgIndexer {
     getAnimLeaf(index: number): Move;
     indexToMoveStartTimestamp(index: number): Timestamp;
     timestampToIndex(timestamp: Timestamp): number;
-    stateAtIndex(index: number): KState;
+    stateAtIndex(index: number): KPattern;
     transformationAtIndex(index: number): KTransformation;
     algDuration(): Duration;
     numAnimatedLeaves(): number;
@@ -34,7 +34,7 @@ declare class TreeAlgIndexer implements AlgIndexer {
     getAnimLeaf(index: number): Move | null;
     indexToMoveStartTimestamp(index: number): Timestamp;
     indexToMovesInProgress(index: number): Timestamp;
-    stateAtIndex(index: number, startState?: KState): KState;
+    stateAtIndex(index: number, startState?: KPattern): KPattern;
     transformationAtIndex(index: number): KTransformation;
     numAnimatedLeaves(): number;
     timestampToIndex(timestamp: Timestamp): number;
@@ -52,8 +52,8 @@ declare class TwistyAnimatedSVG {
     private gradients;
     private svgID;
     constructor(kpuzzle: KPuzzle, svgSource: string, experimentalStickeringMask?: StickeringMask, showUnknownOrientations?: boolean);
-    drawState(state: KState, nextState?: KState, fraction?: number): void;
-    draw(state: KState, nextState?: KState, fraction?: number): void;
+    drawState(state: KPattern, nextState?: KPattern, fraction?: number): void;
+    draw(state: KPattern, nextState?: KPattern, fraction?: number): void;
     private newGradient;
     private elementID;
     private elementByID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cubing",
-  "version": "0.40.0",
+  "version": "0.41.0",
   "description": "A collection of JavaScript cubing libraries.",
   "author": "The js.cubing.net team",
   "type": "module",

package/dist/esm/chunk-2UHC65GH.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/cubing/protocol/binary/orbit-indexing.ts", "../../src/cubing/protocol/binary/binary3x3x3.ts", "../../src/cubing/protocol/binary/hex.ts"],
-  "sourcesContent": ["export function identityPermutation(numElems: number): number[] {\n  const arr = new Array<number>(numElems);\n  for (let i = 0; i < numElems; i++) {\n    arr[i] = i;\n  }\n  return arr;\n}\n\n// Inclusive start, exclusive end (similar to `Array.prototype.slice`)\nexport function orientationsToMask(\n  radix: number,\n  orientations: number[],\n): number {\n  let val = 0;\n  for (const orientation of orientations) {\n    val *= radix;\n    val += orientation;\n  }\n  return val;\n}\n\n// Inclusive start, exclusive end (similar to `Array.prototype.slice`)\nexport function maskToOrientations(\n  radix: number,\n  numElems: number,\n  mask: number,\n): number[] {\n  const arr = [];\n  while (mask > 0) {\n    arr.push(mask % radix);\n    mask = Math.floor(mask / radix);\n  }\n  return new Array<number>(numElems - arr.length).fill(0).concat(arr.reverse());\n}\n\n// From https://www.jaapsch.net/puzzles/compindx.htm#perm\nexport function permutationToLex(permutation: number[]): number {\n  const n = permutation.length;\n  let lexicographicIdx = 0;\n  for (let i = 0; i < n - 1; i++) {\n    lexicographicIdx = lexicographicIdx * (n - i);\n    for (let j = i + 1; j < n; j++) {\n      if (permutation[i] > permutation[j]) {\n        lexicographicIdx += 1;\n      }\n    }\n  }\n  return lexicographicIdx;\n}\n\n// From https://www.jaapsch.net/puzzles/compindx.htm#perm\nexport function lexToPermutation(\n  numPieces: number,\n  lexicographicIdx: number,\n): number[] {\n  const permutation: number[] = new Array(numPieces);\n  permutation[numPieces - 1] = 0;\n  for (let i = numPieces - 2; i >= 0; i--) {\n    permutation[i] = lexicographicIdx % (numPieces - i);\n    lexicographicIdx = Math.floor(lexicographicIdx / (numPieces - i));\n    for (let j = i + 1; j < numPieces; j++) {\n      if (permutation[j] >= permutation[i]) {\n        permutation[j] = permutation[j] + 1;\n      }\n    }\n  }\n  return permutation;\n}\n", "import { KState, type KStateData } from \"../../kpuzzle\";\nimport {\n  experimental3x3x3KPuzzle,\n  experimentalNormalize3x3x3Orientation,\n  experimentalPuzzleOrientation3x3x3Cache,\n  experimentalPuzzleOrientation3x3x3Idx,\n} from \"../../puzzles/cubing-private\";\nimport {\n  identityPermutation,\n  lexToPermutation,\n  maskToOrientations,\n  orientationsToMask,\n  permutationToLex,\n} from \"./orbit-indexing\";\n\n// TODO: combine with `orientPuzzle`?\nexport function reorientPuzzle(\n  state: KState,\n  idxU: number,\n  idxL: number,\n): KState {\n  return state.applyTransformation(\n    experimentalPuzzleOrientation3x3x3Cache()[idxU][idxL].invert(),\n  );\n}\n\ntype Binary3x3x3State = ArrayBuffer;\n\n// Bit lengths of the encoded components, in order.\nconst BIT_LENGTHS = [29, 12, 16, 13, 3, 2, 1, 12];\n\n// These fields are sorted by the order in which they appear in the binary format.\nexport interface Binary3x3x3Components {\n  epLex: number; // 29 bits, edge permutation\n  eoMask: number; // 12 bits, edge orientation\n  cpLex: number; // 16 bits, corner permutation\n  coMask: number; // 13 bits, corner orientation\n  poIdxU: number; // 3 bits, puzzle orientation (U face)\n  poIdxL: number; // 2 bits, puzzle orientation (L face)\n  moSupport: number; // 1 bit, center orientation support\n  moMask: number; // 12 bits, center orientation\n}\n\n// There are various clever ways to do this, but this is simple and efficient.\nfunction arraySum(arr: number[]): number {\n  let total = 0;\n  for (const entry of arr) {\n    total += entry;\n  }\n  return total;\n}\n\n// Due to limitations in JS bit operations, this is unsafe if any of the bit lengths span across the contents of more than 4 bytes.\n// - Safe: [8, 32]\n// - Unsafe: [4, 32, 4]\n// - Unsafe: [40, 4]\nfunction splitBinary(bitLengths: number[], buffy: ArrayBuffer): number[] {\n  const u8buffy = new Uint8Array(buffy);\n  let at = 0;\n  let bits = 0;\n  let accum = 0;\n  const values: number[] = [];\n  for (const bitLength of bitLengths) {\n    while (bits < bitLength) {\n      accum = (accum << 8) | u8buffy[at++];\n      bits += 8;\n    }\n    values.push((accum >> (bits - bitLength)) & ((1 << bitLength) - 1));\n    bits -= bitLength;\n  }\n  return values;\n}\n\n// See above for safety notes.\nfunction concatBinary(bitLengths: number[], values: number[]): ArrayBuffer {\n  const buffy = new Uint8Array(Math.ceil(arraySum(bitLengths) / 8));\n  let at = 0;\n  let bits = 0;\n  let accum = 0;\n  for (let i = 0; i < bitLengths.length; i++) {\n    accum = (accum << bitLengths[i]) | values[i];\n    bits += bitLengths[i];\n    while (bits >= 8) {\n      buffy[at++] = accum >> (bits - 8);\n      bits -= 8;\n    }\n  }\n  if (bits > 0) {\n    buffy[at++] = accum << (8 - bits);\n  }\n  return buffy;\n}\n\n// 0x111 (for idxU) means \"not supported\"\nfunction supportsPuzzleOrientation(components: Binary3x3x3Components): boolean {\n  return components.poIdxU !== 7;\n}\n\nfunction hasFullMOData(centerOrientationModData: number[] | undefined): 0 | 1 {\n  if (!centerOrientationModData) {\n    return 1;\n  }\n  for (let i = 0; i < 6; i++) {\n    if (centerOrientationModData[i] !== 0) {\n      return 0;\n    }\n  }\n  return 1;\n}\n\nexport function reid3x3x3ToBinaryComponents(\n  state: KState,\n): Binary3x3x3Components {\n  const normedState = experimentalNormalize3x3x3Orientation(state);\n\n  const epLex = permutationToLex(normedState.stateData[\"EDGES\"].pieces);\n  const eoMask = orientationsToMask(\n    2,\n    normedState.stateData[\"EDGES\"].orientation,\n  );\n  const cpLex = permutationToLex(normedState.stateData[\"CORNERS\"].pieces);\n  const coMask = orientationsToMask(\n    3,\n    normedState.stateData[\"CORNERS\"].orientation,\n  );\n  const [poIdxU, poIdxL] = experimentalPuzzleOrientation3x3x3Idx(state);\n\n  const moSupport = hasFullMOData(state.stateData[\"CENTERS\"].orientationMod); // Required for now.\n  const moMask = moSupport\n    ? orientationsToMask(4, normedState.stateData[\"CENTERS\"].orientation)\n    : 0;\n\n  return {\n    epLex,\n    eoMask,\n    cpLex,\n    coMask,\n    poIdxU,\n    poIdxL,\n    moSupport,\n    moMask,\n  };\n}\n\nexport function binaryComponentsToTwizzleBinary(\n  components: Binary3x3x3Components,\n): Binary3x3x3State {\n  const { epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask } =\n    components;\n\n  return concatBinary(BIT_LENGTHS, [\n    epLex,\n    eoMask,\n    cpLex,\n    coMask,\n    poIdxU,\n    poIdxL,\n    moSupport,\n    moMask,\n  ]);\n}\n\n/** @category Binary 3x3x3 Format */\nexport function reid3x3x3ToTwizzleBinary(state: KState): Binary3x3x3State {\n  const components: Binary3x3x3Components = reid3x3x3ToBinaryComponents(state);\n  return binaryComponentsToTwizzleBinary(components);\n}\n\n/** @category Binary 3x3x3 Format */\nexport function twizzleBinaryToBinaryComponents(\n  buffer: ArrayBuffer,\n): Binary3x3x3Components {\n  const [epLex, eoMask, cpLex, coMask, poIdxU, poIdxL, moSupport, moMask] =\n    splitBinary(BIT_LENGTHS, buffer);\n\n  return {\n    epLex,\n    eoMask,\n    cpLex,\n    coMask,\n    poIdxU,\n    poIdxL,\n    moSupport,\n    moMask,\n  };\n}\n\n/** @category Binary 3x3x3 Format */\nexport function binaryComponentsToReid3x3x3(\n  components: Binary3x3x3Components,\n): KState {\n  const stateData: KStateData = {\n    EDGES: {\n      pieces: lexToPermutation(12, components.epLex),\n      orientation: maskToOrientations(2, 12, components.eoMask),\n    },\n    CORNERS: {\n      pieces: lexToPermutation(8, components.cpLex),\n      orientation: maskToOrientations(3, 8, components.coMask),\n    },\n    CENTERS: {\n      pieces: identityPermutation(6),\n      orientation: maskToOrientations(4, 6, components.moMask),\n    },\n  };\n  if (!components.moSupport) {\n    stateData.CENTERS.orientationMod = new Array(6).fill(1);\n  }\n  const normedState = new KState(experimental3x3x3KPuzzle, stateData);\n\n  if (!supportsPuzzleOrientation(components)) {\n    return normedState;\n  }\n\n  return reorientPuzzle(normedState, components.poIdxU, components.poIdxL);\n}\n\n// Returns a list of error string.\n// An empty list means validation success.\nfunction validateComponents(components: Binary3x3x3Components): string[] {\n  const errors = [];\n  if (components.epLex < 0 || components.epLex >= 479001600) {\n    errors.push(`epLex (${components.epLex}) out of range`);\n  }\n  if (components.cpLex < 0 || components.cpLex >= 40320) {\n    errors.push(`cpLex (${components.cpLex}) out of range`);\n  }\n  if (components.coMask < 0 || components.coMask >= 6561) {\n    errors.push(`coMask (${components.coMask}) out of range`);\n  }\n  if (components.poIdxU < 0 || components.poIdxU >= 6) {\n    // 0x111 (for idxU) means \"not supported\"\n    if (supportsPuzzleOrientation(components)) {\n      errors.push(`poIdxU (${components.poIdxU}) out of range`);\n    }\n  }\n  // The following cannot be (f decoded from binary properl) out of rangey.\n  if (components.eoMask < 0 || components.eoMask >= 4096) {\n    errors.push(`eoMask (${components.eoMask}) out of range`);\n  }\n  if (components.moMask < 0 || components.moMask >= 4096) {\n    errors.push(`moMask (${components.moMask}) out of range`);\n  }\n  if (components.poIdxL < 0 || components.poIdxL >= 4) {\n    errors.push(`poIdxL (${components.poIdxL}) out of range`);\n  }\n  if (components.moSupport < 0 || components.moSupport >= 2) {\n    errors.push(`moSupport (${components.moSupport}) out of range`);\n  }\n  return errors;\n}\n\n/** @category Binary 3x3x3 Format */\nexport function twizzleBinaryToReid3x3x3(buffy: ArrayBuffer): KState {\n  const components = twizzleBinaryToBinaryComponents(buffy);\n  const errors = validateComponents(components);\n  if (errors.length !== 0) {\n    throw new Error(`Invalid binary state components: ${errors.join(\", \")}`);\n  }\n  return binaryComponentsToReid3x3x3(components);\n}\n", "export function bufferToSpacedHex(buffer: ArrayBuffer): string {\n  // buffer is an ArrayBuffer\n  return (\n    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>\n      `00${x.toString(16)}`.slice(-2),\n    ) as string[]\n  ).join(\" \");\n}\n\nexport function spacedHexToBuffer(hex: string): Uint8Array {\n  return new Uint8Array(hex.split(\" \").map((c) => parseInt(c, 16)));\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/esm/chunk-45VMKYXT.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/cubing/notation/commonMetrics.ts", "../../src/cubing/notation/cube3x3x3Metrics.ts", "../../src/cubing/notation/CountMoves.ts", "../../src/cubing/notation/CountAnimatedLeaves.ts"],
-  "sourcesContent": ["export enum CommonMetric {\n  // OBTM (Outer Block Turn Metric)\n  OuterBlockTurnMetric = \"OBTM\",\n  // RBTM (Range Block Turn Metric)\n  RangeBlockTurnMetric = \"RBTM\",\n  // SSTM (Single Slice Turn Metric)\n  SingleSliceTurnMetric = \"SSTM\",\n  // OBQTM (Outer Block Quantum Turn Metric)\n  OuterBlockQuantumTurnMetric = \"OBQTM\",\n  // RBQTM (Range Block Quantum Turn Metric)\n  RangeBlockQuantumTurnMetric = \"RBQTM\",\n  // SSQTM (Single Slice Quantum Turn Metric)\n  SingleSliceQuantumTurnMetric = \"SSQTM\",\n  ExecutionTurnMetric = \"ETM\",\n}\n\nexport enum CommonMetricAlias {\n  // QTM (Quantum Turn Metric)\n  QuantumTurnMetric = \"OBQTM\",\n  // HTM (Hand Turn Metric)\n  HandTurnMetric = \"OBTM\",\n  // STM (Slice Turn Metric)\n  SliceTurnMetric = \"RBTM\",\n}\n", "// TODO: move this into the 3x3x3 puzzle loader.\n\nimport type { Move } from \"../alg\";\nimport { experimentalCube3x3x3KPuzzleDefinition } from \"../puzzles/cubing-private\";\nimport { CommonMetric } from \"./commonMetrics\";\n\nenum MoveType {\n  Rotation = \"Rotation\",\n  Outer = \"Outer\",\n  Inner = \"Inner\",\n}\n\nfunction uncachedMoveCount(moveQuantumString: string): MoveType {\n  if (\n    moveQuantumString.endsWith(\"v\") ||\n    [\"x\", \"y\", \"z\"].includes(moveQuantumString)\n  ) {\n    // Rv\n    return MoveType.Rotation;\n  }\n  if (\n    moveQuantumString.startsWith(\"2\") ||\n    [\"M\", \"E\", \"S\"].includes(moveQuantumString)\n  ) {\n    return MoveType.Inner;\n  }\n  return MoveType.Outer;\n}\n\nlet cache: Record<string, MoveType> | undefined;\nfunction getCache(): Record<string, MoveType> {\n  if (cache) {\n    return cache;\n  }\n  cache = {};\n  const moveQuantumStrings = [\n    ...Object.keys(experimentalCube3x3x3KPuzzleDefinition.moves),\n    ...Object.keys(\n      experimentalCube3x3x3KPuzzleDefinition.experimentalDerivedMoves!,\n    ),\n  ];\n  for (const moveQuantumString of moveQuantumStrings) {\n    cache[moveQuantumString] = uncachedMoveCount(moveQuantumString);\n  }\n  return cache;\n}\n\n// Ancient wisdom: https://github.com/cubing/alg.js/blob/0599fad84d81b8d943ad3ea3e5dc191db8b6c157/alg.js#L638-L651\n/**\n * A move with an amount of 0 always has 0 cost. Else, the cost is\n *\n * constantFactor + amountFactor * Math.abs(move.amount)\n *\n */\nexport const costFactorsByMetric: Partial<\n  Record<\n    CommonMetric,\n    Record<\n      MoveType,\n      {\n        constantFactor: number;\n        amountFactor: number;\n      }\n    >\n  >\n> = {\n  // Note: these are hardcoded for 3x3x3. They will not automatically generalize to any other puzzles.\n  [CommonMetric.OuterBlockTurnMetric]: {\n    [MoveType.Rotation]: { constantFactor: 0, amountFactor: 0 },\n    [MoveType.Outer]: { constantFactor: 1, amountFactor: 0 },\n    [MoveType.Inner]: { constantFactor: 2, amountFactor: 0 },\n  },\n  [CommonMetric.RangeBlockTurnMetric]: {\n    [MoveType.Rotation]: { constantFactor: 0, amountFactor: 0 },\n    [MoveType.Outer]: { constantFactor: 1, amountFactor: 0 },\n    [MoveType.Inner]: { constantFactor: 1, amountFactor: 0 },\n  },\n  [CommonMetric.OuterBlockQuantumTurnMetric]: {\n    [MoveType.Rotation]: { constantFactor: 0, amountFactor: 0 },\n    [MoveType.Outer]: { constantFactor: 0, amountFactor: 1 },\n    [MoveType.Inner]: { constantFactor: 0, amountFactor: 2 },\n  },\n  [CommonMetric.RangeBlockQuantumTurnMetric]: {\n    [MoveType.Rotation]: { constantFactor: 0, amountFactor: 0 },\n    [MoveType.Outer]: { constantFactor: 0, amountFactor: 1 },\n    [MoveType.Inner]: { constantFactor: 0, amountFactor: 1 },\n  },\n  [CommonMetric.ExecutionTurnMetric]: {\n    [MoveType.Rotation]: { constantFactor: 1, amountFactor: 0 },\n    [MoveType.Outer]: { constantFactor: 1, amountFactor: 0 },\n    [MoveType.Inner]: { constantFactor: 1, amountFactor: 0 },\n  },\n};\n\nexport function countMove3x3x3(metric: CommonMetric, move: Move): number {\n  const costFactors = costFactorsByMetric[metric];\n  if (!costFactors) {\n    throw new Error(`Invalid metric for 3x3x3: ${metric}`);\n  }\n  const cache = getCache();\n  const moveQuantumString = move.quantum.toString();\n  if (!(moveQuantumString in cache)) {\n    throw new Error(`Invalid move for 3x3x3 ${metric}: ${moveQuantumString}`);\n  }\n  const costType = cache[moveQuantumString];\n  const { constantFactor, amountFactor } = costFactors[costType];\n  return constantFactor + amountFactor * Math.abs(move.amount);\n}\n", "// TODO: move this file somewhere permanent.\nimport {\n  Alg,\n  Commutator,\n  Conjugate,\n  functionFromTraversal,\n  Grouping,\n  LineComment,\n  Move,\n  Newline,\n  Pause,\n  TraversalUp,\n} from \"../alg\";\nimport type { PuzzleLoader } from \"../puzzles\";\nimport { CommonMetric } from \"./commonMetrics\";\nimport { costFactorsByMetric, countMove3x3x3 } from \"./cube3x3x3Metrics\";\n\n/*\n *   For movecount, that understands puzzle rotations.  This code\n *   should be moved to the alg class, probably.\n */\nclass CountMoves extends TraversalUp<number> {\n  constructor(private metric: (move: Move) => number) {\n    super();\n  }\n\n  public traverseAlg(alg: Alg): number {\n    let r = 0;\n    for (const algNode of alg.childAlgNodes()) {\n      r += this.traverseAlgNode(algNode);\n    }\n    return r;\n  }\n\n  public traverseGrouping(grouping: Grouping): number {\n    const alg: Alg = grouping.alg;\n    return this.traverseAlg(alg) * Math.abs(grouping.amount);\n  }\n\n  public traverseMove(move: Move): number {\n    return this.metric(move);\n  }\n\n  public traverseCommutator(commutator: Commutator): number {\n    return (\n      2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B))\n    );\n  }\n\n  public traverseConjugate(conjugate: Conjugate): number {\n    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);\n  }\n\n  // TODO: Remove spaces between repeated pauses (in traverseSequence)\n  public traversePause(_pause: Pause): number {\n    return 0;\n  }\n\n  public traverseNewline(_newLine: Newline): number {\n    return 0;\n  }\n\n  // TODO: Enforce being followed by a newline (or the end of the alg)?\n  public traverseLineComment(_comment: LineComment): number {\n    return 0;\n  }\n}\n\nfunction isCharUppercase(c: string): boolean {\n  return \"A\" <= c && c <= \"Z\";\n}\n\n// TODO: Implement a puzzle-specific way to calculate this.\nfunction baseMetric(move: Move): number {\n  const fam = move.family;\n  if (\n    (isCharUppercase(fam[0]) && fam[fam.length - 1] === \"v\") ||\n    fam === \"x\" ||\n    fam === \"y\" ||\n    fam === \"z\" ||\n    fam === \"T\"\n  ) {\n    return 0;\n  } else {\n    return 1;\n  }\n}\n\nfunction etmMetric(_move: Move): number {\n  return 1;\n}\n\n// TODO: Implement a puzzle-specific way to calculate this.\nfunction rangeBlockTurnMetric(move: Move): number {\n  const fam = move.family;\n  if (\n    (isCharUppercase(fam[0]) && fam[fam.length - 1] === \"v\") ||\n    fam === \"x\" ||\n    fam === \"y\" ||\n    fam === \"z\" ||\n    fam === \"T\"\n  ) {\n    return 0;\n  } else {\n    return 1;\n  }\n}\n\n// TODO: Implement a puzzle-specific way to calculate this.\nfunction quantumMetric(move: Move): number {\n  return Math.abs(move.amount) * rangeBlockTurnMetric(move);\n}\n\nexport const countMoves = functionFromTraversal(CountMoves, [baseMetric]);\nexport const countMovesETM = functionFromTraversal(CountMoves, [etmMetric]);\nexport const countRangeBlockQuantumMovesPG = functionFromTraversal(CountMoves, [\n  quantumMetric,\n]);\nexport const countRangeBlockMovesPG = functionFromTraversal(CountMoves, [\n  rangeBlockTurnMetric,\n]);\n\n/**\n * Only implemented so far:\n *\n * - 3x3x3: OBTM, RBTM, ETM\n */\nexport function countMetricMoves(\n  puzzleLoader: PuzzleLoader,\n  metric: CommonMetric,\n  alg: Alg,\n): number {\n  if (puzzleLoader.id === \"3x3x3\") {\n    if (metric in costFactorsByMetric) {\n      return functionFromTraversal(CountMoves, [\n        (move: Move) => countMove3x3x3(metric, move),\n      ])(alg);\n    }\n  } else {\n    switch (metric) {\n      case CommonMetric.ExecutionTurnMetric:\n        return countMovesETM(alg);\n      case CommonMetric.RangeBlockTurnMetric:\n        if (puzzleLoader.pg) {\n          return countRangeBlockMovesPG(alg);\n        }\n      case CommonMetric.RangeBlockQuantumTurnMetric:\n        if (puzzleLoader.pg) {\n          return countRangeBlockQuantumMovesPG(alg);\n        }\n    }\n  }\n  throw new Error(\"Unsupported puzzle or metric.\");\n}\n", "import {\n  Alg,\n  Commutator,\n  Conjugate,\n  Grouping,\n  LineComment,\n  Move,\n  Newline,\n  Pause,\n  TraversalUp,\n} from \"../alg\";\nimport { functionFromTraversal } from \"../alg\";\n\n// TODO: Include Pause, include amounts\nclass CountAnimatedLeaves extends TraversalUp<number, number> {\n  public traverseAlg(alg: Alg): number {\n    let total = 0;\n    for (const part of alg.childAlgNodes()) {\n      total += this.traverseAlgNode(part);\n    }\n    return total;\n  }\n\n  public traverseGrouping(grouping: Grouping): number {\n    return this.traverseAlg(grouping.alg) * Math.abs(grouping.amount);\n  }\n\n  public traverseMove(_move: Move): number {\n    return 1;\n  }\n\n  public traverseCommutator(commutator: Commutator): number {\n    return (\n      2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B))\n    );\n  }\n\n  public traverseConjugate(conjugate: Conjugate): number {\n    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);\n  }\n\n  public traversePause(_pause: Pause): number {\n    return 1;\n  }\n\n  public traverseNewline(_newline: Newline): number {\n    return 0;\n  }\n\n  public traverseLineComment(_comment: LineComment): number {\n    return 0;\n  }\n}\n\nexport const countAnimatedLeaves = functionFromTraversal(CountAnimatedLeaves);\n"],
-  "mappings": "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",
-  "names": ["CommonMetric", "CommonMetricAlias", "cache"]
-}

package/dist/esm/chunk-F6V2QBMP.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/cubing/kpuzzle/combine.ts", "../../src/cubing/kpuzzle/construct.ts", "../../src/cubing/kpuzzle/KState.ts", "../../src/cubing/kpuzzle/KTransformation.ts", "../../src/cubing/kpuzzle/calculate.ts", "../../src/cubing/kpuzzle/KPuzzle.ts"],
-  "sourcesContent": ["import { isOrbitTransformationDataIdentityUncached } from \"./calculate\";\nimport type {\n  KPuzzleDefinition,\n  KStateData,\n  KStateOrbitData,\n  KTransformationData,\n} from \"./KPuzzleDefinition\";\n\nexport function combineTransformationData(\n  definition: KPuzzleDefinition,\n  transformationData1: KTransformationData,\n  transformationData2: KTransformationData,\n): KTransformationData {\n  const newTransformationData = {} as KTransformationData;\n  for (const orbitName in definition.orbits) {\n    const orbitDefinition = definition.orbits[orbitName];\n    const orbit1 = transformationData1[orbitName];\n    const orbit2 = transformationData2[orbitName];\n    if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        orbit2,\n      )\n    ) {\n      // common case for big cubes\n      newTransformationData[orbitName] = orbit1;\n    } else if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        orbit1,\n      )\n    ) {\n      newTransformationData[orbitName] = orbit2;\n    } else {\n      const newPerm = new Array(orbitDefinition.numPieces);\n      if (orbitDefinition.numOrientations === 1) {\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          newPerm[idx] = orbit1.permutation[orbit2.permutation[idx]];\n        }\n        newTransformationData[orbitName] = {\n          permutation: newPerm,\n          orientation: orbit1.orientation,\n        };\n      } else {\n        const newOri = new Array(orbitDefinition.numPieces);\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          newOri[idx] =\n            (orbit1.orientation[orbit2.permutation[idx]] +\n              orbit2.orientation[idx]) %\n            orbitDefinition.numOrientations;\n          newPerm[idx] = orbit1.permutation[orbit2.permutation[idx]];\n        }\n        newTransformationData[orbitName] = {\n          permutation: newPerm,\n          orientation: newOri,\n        };\n      }\n    }\n  }\n  return newTransformationData;\n}\n\nexport function applyTransformationDataToStateData(\n  definition: KPuzzleDefinition,\n  stateData: KStateData,\n  transformationData: KTransformationData,\n): KStateData {\n  const newStateData = {} as KStateData;\n  for (const orbitName in definition.orbits) {\n    const orbitDefinition = definition.orbits[orbitName];\n    const stateOrbit = stateData[orbitName];\n    const transformationOrbit = transformationData[orbitName];\n    if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        transformationOrbit,\n      )\n    ) {\n      // common case for big cubes\n      newStateData[orbitName] = stateOrbit;\n    } else {\n      const newPieces = new Array(orbitDefinition.numPieces);\n      if (orbitDefinition.numOrientations === 1) {\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          newPieces[idx] =\n            stateOrbit.pieces[transformationOrbit.permutation[idx]];\n        }\n        const newOrbitData: KStateOrbitData = {\n          pieces: newPieces,\n          orientation: stateOrbit.orientation, // copy all 0\n        };\n        newStateData[orbitName] = newOrbitData;\n      } else {\n        const newOrientation = new Array(orbitDefinition.numPieces);\n        const newOrientationMod: number[] | undefined =\n          stateOrbit.orientationMod\n            ? new Array(orbitDefinition.numPieces)\n            : undefined;\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          const transformationIdx = transformationOrbit.permutation[idx];\n          let mod = orbitDefinition.numOrientations;\n          if (stateOrbit.orientationMod) {\n            const orientationMod = stateOrbit.orientationMod[transformationIdx];\n            newOrientationMod![idx] = orientationMod;\n            mod = orientationMod || orbitDefinition.numOrientations;\n          }\n          newOrientation[idx] =\n            (stateOrbit.orientation[transformationIdx] +\n              transformationOrbit.orientation[idx]) %\n            mod; // We don't have to use `modIntoRange` (assuming input is well-formed), because we're adding.\n          newPieces[idx] = stateOrbit.pieces[transformationIdx];\n        }\n        const newOrbitData: KStateOrbitData = {\n          pieces: newPieces,\n          orientation: newOrientation,\n        };\n        if (newOrientationMod) {\n          newOrbitData.orientationMod = newOrientationMod;\n        }\n        newStateData[orbitName] = newOrbitData;\n      }\n    }\n  }\n  return newStateData;\n}\n", "import type { Move } from \"../alg\";\nimport { repeatTransformationUncached } from \"./calculate\";\nimport type { KPuzzle } from \"./KPuzzle\";\nimport type {\n  KPuzzleDefinition,\n  KTransformationData,\n  KTransformationOrbitData,\n} from \"./KPuzzleDefinition\";\n\nconst FREEZE: boolean = false;\n\nconst identityOrbitCache = new Map<number, KTransformationOrbitData>();\nfunction constructIdentityOrbitTransformation(\n  numPieces: number,\n): KTransformationOrbitData {\n  const cached = identityOrbitCache.get(numPieces);\n  if (cached) {\n    return cached;\n  }\n\n  const newPermutation = new Array(numPieces);\n  const newOrientation = new Array(numPieces);\n  for (let i = 0; i < numPieces; i++) {\n    newPermutation[i] = i;\n    newOrientation[i] = 0;\n  }\n  const orbitTransformation = {\n    permutation: newPermutation,\n    orientation: newOrientation,\n  };\n  if (FREEZE) {\n    Object.freeze(newPermutation); // TODO\n    Object.freeze(newOrientation); // TODO\n    Object.freeze(orbitTransformation); // TODO\n  }\n  identityOrbitCache.set(numPieces, orbitTransformation);\n  return orbitTransformation;\n}\n\nexport function constructIdentityTransformationDataUncached(\n  definition: KPuzzleDefinition,\n): KTransformationData {\n  const transformation = {} as KTransformationData;\n  for (const [orbitName, orbitDefinition] of Object.entries(\n    definition.orbits,\n  )) {\n    transformation[orbitName] = constructIdentityOrbitTransformation(\n      orbitDefinition.numPieces,\n    );\n  }\n  if (FREEZE) {\n    Object.freeze(transformation); // TODO\n  }\n  return transformation;\n}\n\nexport function moveToTransformationUncached(\n  kpuzzle: KPuzzle,\n  move: Move,\n): KTransformationData {\n  const quantumKey = move.quantum.toString();\n  let quantumMoveDefinition = kpuzzle.definition.moves[quantumKey] as\n    | KTransformationData\n    | undefined;\n\n  if (!quantumMoveDefinition) {\n    const derivedFrom =\n      kpuzzle.definition.experimentalDerivedMoves?.[quantumKey];\n\n    if (derivedFrom) {\n      // TODO: avoid the round trip?\n      quantumMoveDefinition =\n        kpuzzle.algToTransformation(derivedFrom).transformationData;\n    }\n  }\n\n  if (quantumMoveDefinition) {\n    return repeatTransformationUncached(\n      kpuzzle,\n      quantumMoveDefinition,\n      move.amount,\n    );\n  }\n\n  // Handle e.g. `y2` if `y2` is defined.\n  // Note: this doesn't handle multiples.\n  const moveDefinition = kpuzzle.definition.moves[move.toString()];\n  if (moveDefinition) {\n    return moveDefinition;\n  }\n\n  // Handle e.g. `y2'` if `y2` is defined.\n  // Note: this doesn't handle multiples.\n  const inverseMoveDefinition =\n    kpuzzle.definition.moves[move.invert().toString()];\n  if (inverseMoveDefinition) {\n    return repeatTransformationUncached(kpuzzle, inverseMoveDefinition, -1);\n  }\n\n  throw new Error(`Invalid move for KPuzzle (${kpuzzle.name()}): ${move}`);\n}\n", "import type { KPuzzle } from \"./KPuzzle\";\nimport type { Alg, Move } from \"../alg\";\nimport { applyTransformationDataToStateData } from \"./combine\";\nimport type { KTransformationSource } from \"./KPuzzle\";\nimport type {\n  KStateData,\n  KTransformationData,\n  KTransformationOrbitData,\n} from \"./KPuzzleDefinition\";\nimport { KTransformation } from \"./KTransformation\";\n\nexport class KState {\n  constructor(\n    public readonly kpuzzle: KPuzzle,\n    public readonly stateData: KStateData,\n  ) {}\n\n  toJSON(): any {\n    return {\n      experimentalPuzzleName: this.kpuzzle.name(),\n      stateData: this.stateData,\n    };\n  }\n\n  static fromTransformation(transformation: KTransformation): KState {\n    const newStateData = applyTransformationDataToStateData(\n      transformation.kpuzzle.definition,\n      transformation.kpuzzle.definition.startStateData,\n      transformation.transformationData,\n    );\n    return new KState(transformation.kpuzzle, newStateData);\n  }\n\n  // Convenience function\n  /** @deprecated */\n  apply(source: KTransformationSource): KState {\n    return this.applyTransformation(this.kpuzzle.toTransformation(source));\n  }\n\n  applyTransformation(transformation: KTransformation): KState {\n    if (transformation.isIdentityTransformation()) {\n      return new KState(this.kpuzzle, this.stateData);\n    }\n    const newStateData = applyTransformationDataToStateData(\n      this.kpuzzle.definition,\n      this.stateData,\n      transformation.transformationData,\n    );\n    return new KState(this.kpuzzle, newStateData);\n  }\n\n  applyMove(move: Move | string): KState {\n    return this.applyTransformation(this.kpuzzle.moveToTransformation(move));\n  }\n\n  applyAlg(alg: Alg | string): KState {\n    return this.applyTransformation(this.kpuzzle.algToTransformation(alg));\n  }\n\n  /** @deprecated */\n  experimentalToTransformation(): KTransformation | null {\n    if (!this.kpuzzle.canConvertStateToUniqueTransformation()) {\n      return null;\n    }\n    const transformationData: KTransformationData = {};\n    for (const [orbitName, stateOrbitData] of Object.entries(this.stateData)) {\n      const transformationOrbit: KTransformationOrbitData = {\n        permutation: stateOrbitData.pieces,\n        orientation: stateOrbitData.orientation,\n      };\n      transformationData[orbitName] = transformationOrbit;\n    }\n    return new KTransformation(this.kpuzzle, transformationData);\n  }\n\n  experimentalIsSolved(options: {\n    ignorePuzzleOrientation: boolean;\n    ignoreCenterOrientation: boolean;\n  }): boolean {\n    if (!this.kpuzzle.definition.experimentalIsStateSolved) {\n      throw new Error(\n        \"`KState.experimentalIsSolved()` is not supported for this puzzle at the moment.\",\n      );\n    }\n    return this.kpuzzle.definition.experimentalIsStateSolved(this, options);\n  }\n}\n", "import type { Alg, Move } from \"../alg\";\nimport {\n  invertTransformation,\n  isTransformationDataIdentical,\n  repeatTransformationUncached,\n  transformationRepetitionOrder,\n} from \"./calculate\";\nimport { combineTransformationData } from \"./combine\";\nimport { constructIdentityTransformationDataUncached } from \"./construct\";\nimport type { KPuzzle, KTransformationSource } from \"./KPuzzle\";\nimport type { KTransformationData } from \"./KPuzzleDefinition\";\nimport { KState } from \"./KState\";\n\nexport class KTransformation {\n  constructor(\n    public readonly kpuzzle: KPuzzle,\n    public readonly transformationData: KTransformationData,\n  ) {}\n\n  toJSON(): any {\n    return {\n      experimentalPuzzleName: this.kpuzzle.name(),\n      transformationData: this.transformationData,\n    };\n  }\n\n  invert(): KTransformation {\n    return new KTransformation(\n      this.kpuzzle,\n      invertTransformation(this.kpuzzle, this.transformationData),\n    );\n  }\n\n  // For optimizations, we want to make it cheap to rely on optimizations when a\n  // transformation is an identity. Here, we try to make it cheaper by:\n  // - only calculating when needed, and\n  // - caching the result.\n  #cachedIsIdentity: boolean | undefined; // TODO: is `null` worse here?\n  isIdentityTransformation(): boolean {\n    return (this.#cachedIsIdentity ??= this.isIdentical(\n      this.kpuzzle.identityTransformation(),\n    ));\n  }\n\n  /** @deprecated */\n  static experimentalConstructIdentity(kpuzzle: KPuzzle) {\n    const transformation = new KTransformation(\n      kpuzzle,\n      constructIdentityTransformationDataUncached(kpuzzle.definition),\n    );\n    transformation.#cachedIsIdentity = true;\n    return transformation;\n  }\n\n  isIdentical(t2: KTransformation): boolean {\n    return isTransformationDataIdentical(\n      this.kpuzzle,\n      this.transformationData,\n      t2.transformationData,\n    );\n  }\n\n  // Convenience function\n  /** @deprecated */\n  apply(source: KTransformationSource): KTransformation {\n    return this.applyTransformation(this.kpuzzle.toTransformation(source));\n  }\n\n  applyTransformation(t2: KTransformation): KTransformation {\n    if (this.kpuzzle !== t2.kpuzzle) {\n      throw new Error(\n        `Tried to apply a transformation for a KPuzzle (${t2.kpuzzle.name()}) to a different KPuzzle (${this.kpuzzle.name()}).`,\n      );\n    }\n\n    if (this.#cachedIsIdentity) {\n      return new KTransformation(this.kpuzzle, t2.transformationData);\n    }\n    if (t2.#cachedIsIdentity) {\n      return new KTransformation(this.kpuzzle, this.transformationData);\n    }\n\n    return new KTransformation(\n      this.kpuzzle,\n      combineTransformationData(\n        this.kpuzzle.definition,\n        this.transformationData,\n        t2.transformationData,\n      ),\n    );\n  }\n\n  applyMove(move: Move | string): KTransformation {\n    return this.applyTransformation(this.kpuzzle.moveToTransformation(move));\n  }\n\n  applyAlg(alg: Alg | string): KTransformation {\n    return this.applyTransformation(this.kpuzzle.algToTransformation(alg));\n  }\n\n  // Convenience. Useful for chaining.\n  toKState(): KState {\n    return KState.fromTransformation(this);\n  }\n\n  repetitionOrder(): number {\n    return transformationRepetitionOrder(this.kpuzzle.definition, this);\n  }\n\n  selfMultiply(amount: number): KTransformation {\n    return new KTransformation(\n      this.kpuzzle,\n      repeatTransformationUncached(\n        this.kpuzzle,\n        this.transformationData,\n        amount,\n      ),\n    );\n  }\n}\n", "import {\n  Alg,\n  Commutator,\n  Conjugate,\n  Grouping,\n  LineComment,\n  Move,\n  Newline,\n  Pause,\n  TraversalDownUp,\n} from \"../alg\";\nimport { functionFromTraversal } from \"../alg\";\nimport { combineTransformationData } from \"./combine\";\nimport type { KPuzzle } from \"./KPuzzle\";\nimport type {\n  KPuzzleOrbitDefinition,\n  KTransformationOrbitData,\n  KTransformationData,\n  KPuzzleDefinition,\n} from \"./KPuzzleDefinition\";\nimport { KTransformation } from \"./KTransformation\";\n\nexport function isOrbitTransformationDataIdentityUncached(\n  numOrientations: number,\n  orbitTransformationData: KTransformationOrbitData,\n): boolean {\n  // TODO\n  // if (o === lasto) {\n  //   return true;\n  // }\n  const { permutation } = orbitTransformationData;\n  const numPieces = permutation.length;\n  for (let idx = 0; idx < numPieces; idx++) {\n    if (permutation[idx] !== idx) {\n      return false;\n    }\n  }\n  if (numOrientations > 1) {\n    const { orientation } = orbitTransformationData;\n    for (let idx = 0; idx < numPieces; idx++) {\n      if (orientation[idx] !== 0) {\n        return false;\n      }\n    }\n  }\n  // lasto = o; // TODO\n  return true;\n}\n\nexport function isOrbitTransformationDataIdentical(\n  orbitDefinition: KPuzzleOrbitDefinition,\n  orbitTransformationData1: KTransformationOrbitData,\n  orbitTransformationData2: KTransformationOrbitData,\n  options: {\n    ignoreOrientation?: boolean;\n    ignorePermutation?: boolean;\n  } = {},\n): boolean {\n  for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n    if (\n      !options?.ignoreOrientation &&\n      orbitTransformationData1.orientation[idx] !==\n        orbitTransformationData2.orientation[idx]\n    ) {\n      return false;\n    }\n    if (\n      !options?.ignorePermutation &&\n      orbitTransformationData1.permutation[idx] !==\n        orbitTransformationData2.permutation[idx]\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isTransformationDataIdentical(\n  kpuzzle: KPuzzle,\n  transformationData1: KTransformationData,\n  transformationData2: KTransformationData,\n): boolean {\n  for (const [orbitName, orbitDefinition] of Object.entries(\n    kpuzzle.definition.orbits,\n  )) {\n    if (\n      !isOrbitTransformationDataIdentical(\n        orbitDefinition,\n        transformationData1[orbitName],\n        transformationData2[orbitName],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function invertTransformation(\n  kpuzzle: KPuzzle,\n  transformationData: KTransformationData,\n): KTransformationData {\n  const newTransformationData: KTransformationData = {};\n  for (const orbitName in kpuzzle.definition.orbits) {\n    const orbitDefinition: KPuzzleOrbitDefinition =\n      kpuzzle.definition.orbits[orbitName];\n    const orbitTransformationData = transformationData[orbitName];\n    if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        orbitTransformationData,\n      )\n    ) {\n      newTransformationData[orbitName] = orbitTransformationData;\n    } else if (orbitDefinition.numOrientations === 1) {\n      const newPerm = new Array(orbitDefinition.numPieces);\n      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n        newPerm[orbitTransformationData.permutation[idx]] = idx;\n      }\n      newTransformationData[orbitName] = {\n        permutation: newPerm,\n        orientation: orbitTransformationData.orientation,\n      };\n    } else {\n      const newPerm = new Array(orbitDefinition.numPieces);\n      const newOri = new Array(orbitDefinition.numPieces);\n      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n        const fromIdx = orbitTransformationData.permutation[idx];\n        newPerm[fromIdx] = idx;\n        newOri[fromIdx] =\n          (orbitDefinition.numOrientations -\n            orbitTransformationData.orientation[idx] +\n            orbitDefinition.numOrientations) %\n          orbitDefinition.numOrientations;\n      }\n      newTransformationData[orbitName] = {\n        permutation: newPerm,\n        orientation: newOri,\n      };\n    }\n  }\n  return newTransformationData;\n}\n\nexport function repeatTransformationUncached(\n  kpuzzle: KPuzzle,\n  transformationData: KTransformationData,\n  amount: number,\n): KTransformationData {\n  // This is used for move construction, so we optimize for the quantum move case.\n  if (amount === 1) {\n    return transformationData;\n  }\n  if (amount < 0) {\n    return repeatTransformationUncached(\n      kpuzzle,\n      invertTransformation(kpuzzle, transformationData),\n      -amount,\n    );\n  }\n  if (amount === 0) {\n    // TODO\n    const { transformationData } = kpuzzle.identityTransformation();\n    return transformationData;\n  }\n  let halfish = transformationData;\n  if (amount !== 2) {\n    halfish = repeatTransformationUncached(\n      kpuzzle,\n      transformationData,\n      Math.floor(amount / 2),\n    );\n  }\n  const twiceHalfish = combineTransformationData(\n    kpuzzle.definition,\n    halfish,\n    halfish,\n  );\n  if (amount % 2 === 0) {\n    return twiceHalfish;\n  } else {\n    return combineTransformationData(\n      kpuzzle.definition,\n      transformationData,\n      twiceHalfish,\n    );\n  }\n}\n\nclass AlgToTransformationTraversal extends TraversalDownUp<\n  KPuzzle,\n  KTransformation\n> {\n  traverseAlg(alg: Alg, kpuzzle: KPuzzle): KTransformation {\n    let transformation: KTransformation | null = null;\n    for (const algNode of alg.childAlgNodes()) {\n      if (transformation) {\n        transformation = transformation.applyTransformation(\n          this.traverseAlgNode(algNode, kpuzzle),\n        );\n      } else {\n        transformation = this.traverseAlgNode(algNode, kpuzzle);\n      }\n    }\n    return transformation ?? kpuzzle.identityTransformation();\n  }\n  traverseGrouping(grouping: Grouping, kpuzzle: KPuzzle): KTransformation {\n    const algTransformation = this.traverseAlg(grouping.alg, kpuzzle);\n    return new KTransformation(\n      kpuzzle,\n      repeatTransformationUncached(\n        kpuzzle,\n        algTransformation.transformationData,\n        grouping.amount,\n      ),\n    );\n  }\n  traverseMove(move: Move, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.moveToTransformation(move);\n  }\n  traverseCommutator(\n    commutator: Commutator,\n    kpuzzle: KPuzzle,\n  ): KTransformation {\n    const aTransformation = this.traverseAlg(commutator.A, kpuzzle);\n    const bTransformation = this.traverseAlg(commutator.B, kpuzzle);\n    return aTransformation\n      .applyTransformation(bTransformation)\n      .applyTransformation(aTransformation.invert())\n      .applyTransformation(bTransformation.invert());\n  }\n  traverseConjugate(conjugate: Conjugate, kpuzzle: KPuzzle): KTransformation {\n    const aTransformation = this.traverseAlg(conjugate.A, kpuzzle);\n    const bTransformation = this.traverseAlg(conjugate.B, kpuzzle);\n    return aTransformation\n      .applyTransformation(bTransformation)\n      .applyTransformation(aTransformation.invert());\n  }\n  traversePause(_: Pause, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.identityTransformation();\n  }\n  traverseNewline(_: Newline, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.identityTransformation();\n  }\n  traverseLineComment(_: LineComment, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.identityTransformation();\n  }\n}\n\nexport const algToTransformation = functionFromTraversal(\n  AlgToTransformationTraversal,\n);\n\nexport function canConvertStateToUniqueTransformationUncached(\n  definition: KPuzzleDefinition,\n): boolean {\n  for (const [orbitName, orbitDefinition] of Object.entries(definition)) {\n    const pieces = new Array(orbitDefinition.numPieces).fill(false);\n    for (const piece of this.definition.startStateData[orbitName].pieces) {\n      pieces[piece] = true;\n    }\n    for (const piece of pieces) {\n      if (!piece) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nfunction gcd(a: number, b: number): number {\n  if (b) {\n    return gcd(b, a % b);\n  }\n  return a;\n}\n\n/* calculate the order of a particular transformation. */\nexport function transformationRepetitionOrder(\n  definition: KPuzzleDefinition,\n  transformation: KTransformation,\n): number {\n  let order: number = 1;\n  for (const orbitName in definition.orbits) {\n    const orbitDefinition = definition.orbits[orbitName];\n    const transformationOrbit = transformation.transformationData[orbitName];\n    const orbitPieces = new Array(orbitDefinition.numPieces);\n    for (let startIdx = 0; startIdx < orbitDefinition.numPieces; startIdx++) {\n      if (!orbitPieces[startIdx]) {\n        let currentIdx = startIdx;\n        let orientationSum = 0;\n        let cycleLength = 0;\n        for (;;) {\n          orbitPieces[currentIdx] = true;\n          orientationSum =\n            orientationSum + transformationOrbit.orientation[currentIdx];\n          cycleLength = cycleLength + 1;\n          currentIdx = transformationOrbit.permutation[currentIdx];\n          if (currentIdx === startIdx) {\n            break;\n          }\n        }\n        if (orientationSum !== 0) {\n          cycleLength =\n            (cycleLength * orbitDefinition.numOrientations) /\n            gcd(orbitDefinition.numOrientations, Math.abs(orientationSum));\n        }\n        order = (order * cycleLength) / gcd(order, cycleLength);\n      }\n    }\n  }\n  return order;\n}\n", "import { Alg, Move } from \"../alg\";\nimport type { PGNotation } from \"../puzzle-geometry/PuzzleGeometry\";\nimport { algToTransformation } from \"./calculate\";\nimport { moveToTransformationUncached } from \"./construct\";\nimport type {\n  KPuzzleDefinition,\n  KTransformationData,\n} from \"./KPuzzleDefinition\";\nimport { KState } from \"./KState\";\nimport { KTransformation } from \"./KTransformation\";\n\nexport type KTransformationSource = Alg | Move | string | KTransformation;\n\nexport class KPuzzle {\n  private experimentalPGNotation: PGNotation | undefined;\n  constructor(\n    public readonly definition: KPuzzleDefinition,\n    options?: {\n      experimentalPGNotation?: PGNotation;\n    },\n  ) {\n    this.experimentalPGNotation = options?.experimentalPGNotation;\n  }\n\n  name(): string {\n    return this.definition.name; // TODO\n  }\n\n  identityTransformation(): KTransformation {\n    return KTransformation.experimentalConstructIdentity(this);\n  }\n\n  #moveToTransformationDataCache = new Map<string, KTransformationData>();\n  moveToTransformation(move: Move | string): KTransformation {\n    if (typeof move === \"string\") {\n      move = new Move(move);\n    }\n    const cacheKey = move.toString();\n    const cachedTransformationData: KTransformationData | undefined =\n      this.#moveToTransformationDataCache.get(cacheKey);\n    if (cachedTransformationData) {\n      return new KTransformation(this, cachedTransformationData);\n    }\n\n    if (this.experimentalPGNotation) {\n      const transformationData = this.experimentalPGNotation.lookupMove(move);\n      if (!transformationData) {\n        throw new Error(`could not map to internal move: ${move}`);\n      }\n      this.#moveToTransformationDataCache.set(cacheKey, transformationData);\n      return new KTransformation(this, transformationData);\n    }\n\n    const transformationData = moveToTransformationUncached(this, move);\n    this.#moveToTransformationDataCache.set(cacheKey, transformationData);\n    return new KTransformation(this, transformationData);\n  }\n\n  algToTransformation(alg: Alg | string): KTransformation {\n    if (typeof alg === \"string\") {\n      alg = new Alg(alg);\n    }\n    return algToTransformation(alg, this);\n  }\n\n  /** @deprecated */\n  toTransformation(source: KTransformationSource): KTransformation {\n    if (typeof source === \"string\") {\n      return this.algToTransformation(source);\n    } else if ((source as Alg | null)?.is?.(Alg)) {\n      return this.algToTransformation(source as Alg);\n    } else if ((source as Move | null)?.is?.(Move)) {\n      return this.moveToTransformation(source as Move);\n    } else {\n      return source as KTransformation;\n    }\n  }\n\n  startState(): KState {\n    return new KState(this, this.definition.startStateData);\n  }\n\n  #cachedCanConvertStateToUniqueTransformation: boolean | undefined;\n  // TODO: Handle incomplete start state data\n  canConvertStateToUniqueTransformation(): boolean {\n    return (this.#cachedCanConvertStateToUniqueTransformation ??=\n      ((): boolean => {\n        for (const [orbitName, orbitDefinition] of Object.entries(\n          this.definition.orbits,\n        )) {\n          const pieces = new Array(orbitDefinition.numPieces).fill(false);\n          for (const piece of this.definition.startStateData[orbitName]\n            .pieces) {\n            pieces[piece] = true;\n          }\n          for (const piece of pieces) {\n            if (!piece) {\n              return false;\n            }\n          }\n        }\n        return true;\n      })());\n  }\n}\n"],
-  "mappings": ";;;;;;;;AAQO,SAAS,0BACd,YACA,qBACA,qBACqB;AACrB,QAAM,wBAAwB,CAAC;AAC/B,aAAW,aAAa,WAAW,QAAQ;AACzC,UAAM,kBAAkB,WAAW,OAAO,SAAS;AACnD,UAAM,SAAS,oBAAoB,SAAS;AAC5C,UAAM,SAAS,oBAAoB,SAAS;AAC5C,QACE;AAAA,MACE,gBAAgB;AAAA,MAChB;AAAA,IACF,GACA;AAEA,4BAAsB,SAAS,IAAI;AAAA,IACrC,WACE;AAAA,MACE,gBAAgB;AAAA,MAChB;AAAA,IACF,GACA;AACA,4BAAsB,SAAS,IAAI;AAAA,IACrC,OAAO;AACL,YAAM,UAAU,IAAI,MAAM,gBAAgB,SAAS;AACnD,UAAI,gBAAgB,oBAAoB,GAAG;AACzC,iBAAS,MAAM,GAAG,MAAM,gBAAgB,WAAW,OAAO;AACxD,kBAAQ,GAAG,IAAI,OAAO,YAAY,OAAO,YAAY,GAAG,CAAC;AAAA,QAC3D;AACA,8BAAsB,SAAS,IAAI;AAAA,UACjC,aAAa;AAAA,UACb,aAAa,OAAO;AAAA,QACtB;AAAA,MACF,OAAO;AACL,cAAM,SAAS,IAAI,MAAM,gBAAgB,SAAS;AAClD,iBAAS,MAAM,GAAG,MAAM,gBAAgB,WAAW,OAAO;AACxD,iBAAO,GAAG,KACP,OAAO,YAAY,OAAO,YAAY,GAAG,CAAC,IACzC,OAAO,YAAY,GAAG,KACxB,gBAAgB;AAClB,kBAAQ,GAAG,IAAI,OAAO,YAAY,OAAO,YAAY,GAAG,CAAC;AAAA,QAC3D;AACA,8BAAsB,SAAS,IAAI;AAAA,UACjC,aAAa;AAAA,UACb,aAAa;AAAA,QACf;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,mCACd,YACA,WACA,oBACY;AACZ,QAAM,eAAe,CAAC;AACtB,aAAW,aAAa,WAAW,QAAQ;AACzC,UAAM,kBAAkB,WAAW,OAAO,SAAS;AACnD,UAAM,aAAa,UAAU,SAAS;AACtC,UAAM,sBAAsB,mBAAmB,SAAS;AACxD,QACE;AAAA,MACE,gBAAgB;AAAA,MAChB;AAAA,IACF,GACA;AAEA,mBAAa,SAAS,IAAI;AAAA,IAC5B,OAAO;AACL,YAAM,YAAY,IAAI,MAAM,gBAAgB,SAAS;AACrD,UAAI,gBAAgB,oBAAoB,GAAG;AACzC,iBAAS,MAAM,GAAG,MAAM,gBAAgB,WAAW,OAAO;AACxD,oBAAU,GAAG,IACX,WAAW,OAAO,oBAAoB,YAAY,GAAG,CAAC;AAAA,QAC1D;AACA,cAAM,eAAgC;AAAA,UACpC,QAAQ;AAAA,UACR,aAAa,WAAW;AAAA;AAAA,QAC1B;AACA,qBAAa,SAAS,IAAI;AAAA,MAC5B,OAAO;AACL,cAAM,iBAAiB,IAAI,MAAM,gBAAgB,SAAS;AAC1D,cAAM,oBACJ,WAAW,iBACP,IAAI,MAAM,gBAAgB,SAAS,IACnC;AACN,iBAAS,MAAM,GAAG,MAAM,gBAAgB,WAAW,OAAO;AACxD,gBAAM,oBAAoB,oBAAoB,YAAY,GAAG;AAC7D,cAAI,MAAM,gBAAgB;AAC1B,cAAI,WAAW,gBAAgB;AAC7B,kBAAM,iBAAiB,WAAW,eAAe,iBAAiB;AAClE,8BAAmB,GAAG,IAAI;AAC1B,kBAAM,kBAAkB,gBAAgB;AAAA,UAC1C;AACA,yBAAe,GAAG,KACf,WAAW,YAAY,iBAAiB,IACvC,oBAAoB,YAAY,GAAG,KACrC;AACF,oBAAU,GAAG,IAAI,WAAW,OAAO,iBAAiB;AAAA,QACtD;AACA,cAAM,eAAgC;AAAA,UACpC,QAAQ;AAAA,UACR,aAAa;AAAA,QACf;AACA,YAAI,mBAAmB;AACrB,uBAAa,iBAAiB;AAAA,QAChC;AACA,qBAAa,SAAS,IAAI;AAAA,MAC5B;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;;;ACnHA,IAAM,SAAkB;AAExB,IAAM,qBAAqB,oBAAI,IAAsC;AACrE,SAAS,qCACP,WAC0B;AAC1B,QAAM,SAAS,mBAAmB,IAAI,SAAS;AAC/C,MAAI,QAAQ;AACV,WAAO;AAAA,EACT;AAEA,QAAM,iBAAiB,IAAI,MAAM,SAAS;AAC1C,QAAM,iBAAiB,IAAI,MAAM,SAAS;AAC1C,WAAS,IAAI,GAAG,IAAI,WAAW,KAAK;AAClC,mBAAe,CAAC,IAAI;AACpB,mBAAe,CAAC,IAAI;AAAA,EACtB;AACA,QAAM,sBAAsB;AAAA,IAC1B,aAAa;AAAA,IACb,aAAa;AAAA,EACf;AACA,MAAI,QAAQ;AACV,WAAO,OAAO,cAAc;AAC5B,WAAO,OAAO,cAAc;AAC5B,WAAO,OAAO,mBAAmB;AAAA,EACnC;AACA,qBAAmB,IAAI,WAAW,mBAAmB;AACrD,SAAO;AACT;AAEO,SAAS,4CACd,YACqB;AACrB,QAAM,iBAAiB,CAAC;AACxB,aAAW,CAAC,WAAW,eAAe,KAAK,OAAO;AAAA,IAChD,WAAW;AAAA,EACb,GAAG;AACD,mBAAe,SAAS,IAAI;AAAA,MAC1B,gBAAgB;AAAA,IAClB;AAAA,EACF;AACA,MAAI,QAAQ;AACV,WAAO,OAAO,cAAc;AAAA,EAC9B;AACA,SAAO;AACT;AAEO,SAAS,6BACd,SACA,MACqB;AACrB,QAAM,aAAa,KAAK,QAAQ,SAAS;AACzC,MAAI,wBAAwB,QAAQ,WAAW,MAAM,UAAU;AAI/D,MAAI,CAAC,uBAAuB;AAC1B,UAAM,cACJ,QAAQ,WAAW,2BAA2B,UAAU;AAE1D,QAAI,aAAa;AAEf,8BACE,QAAQ,oBAAoB,WAAW,EAAE;AAAA,IAC7C;AAAA,EACF;AAEA,MAAI,uBAAuB;AACzB,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,KAAK;AAAA,IACP;AAAA,EACF;AAIA,QAAM,iBAAiB,QAAQ,WAAW,MAAM,KAAK,SAAS,CAAC;AAC/D,MAAI,gBAAgB;AAClB,WAAO;AAAA,EACT;AAIA,QAAM,wBACJ,QAAQ,WAAW,MAAM,KAAK,OAAO,EAAE,SAAS,CAAC;AACnD,MAAI,uBAAuB;AACzB,WAAO,6BAA6B,SAAS,uBAAuB,EAAE;AAAA,EACxE;AAEA,QAAM,IAAI,MAAM,6BAA6B,QAAQ,KAAK,CAAC,MAAM,IAAI,EAAE;AACzE;;;ACzFO,IAAM,SAAN,MAAM,QAAO;AAAA,EAClB,YACkB,SACA,WAChB;AAFgB;AACA;AAAA,EACf;AAAA,EAEH,SAAc;AACZ,WAAO;AAAA,MACL,wBAAwB,KAAK,QAAQ,KAAK;AAAA,MAC1C,WAAW,KAAK;AAAA,IAClB;AAAA,EACF;AAAA,EAEA,OAAO,mBAAmB,gBAAyC;AACjE,UAAM,eAAe;AAAA,MACnB,eAAe,QAAQ;AAAA,MACvB,eAAe,QAAQ,WAAW;AAAA,MAClC,eAAe;AAAA,IACjB;AACA,WAAO,IAAI,QAAO,eAAe,SAAS,YAAY;AAAA,EACxD;AAAA;AAAA;AAAA,EAIA,MAAM,QAAuC;AAC3C,WAAO,KAAK,oBAAoB,KAAK,QAAQ,iBAAiB,MAAM,CAAC;AAAA,EACvE;AAAA,EAEA,oBAAoB,gBAAyC;AAC3D,QAAI,eAAe,yBAAyB,GAAG;AAC7C,aAAO,IAAI,QAAO,KAAK,SAAS,KAAK,SAAS;AAAA,IAChD;AACA,UAAM,eAAe;AAAA,MACnB,KAAK,QAAQ;AAAA,MACb,KAAK;AAAA,MACL,eAAe;AAAA,IACjB;AACA,WAAO,IAAI,QAAO,KAAK,SAAS,YAAY;AAAA,EAC9C;AAAA,EAEA,UAAU,MAA6B;AACrC,WAAO,KAAK,oBAAoB,KAAK,QAAQ,qBAAqB,IAAI,CAAC;AAAA,EACzE;AAAA,EAEA,SAAS,KAA2B;AAClC,WAAO,KAAK,oBAAoB,KAAK,QAAQ,oBAAoB,GAAG,CAAC;AAAA,EACvE;AAAA;AAAA,EAGA,+BAAuD;AACrD,QAAI,CAAC,KAAK,QAAQ,sCAAsC,GAAG;AACzD,aAAO;AAAA,IACT;AACA,UAAM,qBAA0C,CAAC;AACjD,eAAW,CAAC,WAAW,cAAc,KAAK,OAAO,QAAQ,KAAK,SAAS,GAAG;AACxE,YAAM,sBAAgD;AAAA,QACpD,aAAa,eAAe;AAAA,QAC5B,aAAa,eAAe;AAAA,MAC9B;AACA,yBAAmB,SAAS,IAAI;AAAA,IAClC;AACA,WAAO,IAAI,gBAAgB,KAAK,SAAS,kBAAkB;AAAA,EAC7D;AAAA,EAEA,qBAAqB,SAGT;AACV,QAAI,CAAC,KAAK,QAAQ,WAAW,2BAA2B;AACtD,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,WAAO,KAAK,QAAQ,WAAW,0BAA0B,MAAM,OAAO;AAAA,EACxE;AACF;;;ACzEO,IAAM,kBAAN,MAAM,iBAAgB;AAAA,EAC3B,YACkB,SACA,oBAChB;AAFgB;AACA;AAAA,EACf;AAAA,EAEH,SAAc;AACZ,WAAO;AAAA,MACL,wBAAwB,KAAK,QAAQ,KAAK;AAAA,MAC1C,oBAAoB,KAAK;AAAA,IAC3B;AAAA,EACF;AAAA,EAEA,SAA0B;AACxB,WAAO,IAAI;AAAA,MACT,KAAK;AAAA,MACL,qBAAqB,KAAK,SAAS,KAAK,kBAAkB;AAAA,IAC5D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA;AAAA;AAAA,EACA,2BAAoC;AAClC,WAAQ,oDAA2B,KAAK;AAAA,MACtC,KAAK,QAAQ,uBAAuB;AAAA,IACtC;AAAA,EACF;AAAA;AAAA,EAGA,OAAO,8BAA8B,SAAkB;AACrD,UAAM,iBAAiB,IAAI;AAAA,MACzB;AAAA,MACA,4CAA4C,QAAQ,UAAU;AAAA,IAChE;AACA,mBAAe,oBAAoB;AACnC,WAAO;AAAA,EACT;AAAA,EAEA,YAAY,IAA8B;AACxC,WAAO;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,GAAG;AAAA,IACL;AAAA,EACF;AAAA;AAAA;AAAA,EAIA,MAAM,QAAgD;AACpD,WAAO,KAAK,oBAAoB,KAAK,QAAQ,iBAAiB,MAAM,CAAC;AAAA,EACvE;AAAA,EAEA,oBAAoB,IAAsC;AACxD,QAAI,KAAK,YAAY,GAAG,SAAS;AAC/B,YAAM,IAAI;AAAA,QACR,kDAAkD,GAAG,QAAQ,KAAK,CAAC,6BAA6B,KAAK,QAAQ,KAAK,CAAC;AAAA,MACrH;AAAA,IACF;AAEA,QAAI,KAAK,mBAAmB;AAC1B,aAAO,IAAI,iBAAgB,KAAK,SAAS,GAAG,kBAAkB;AAAA,IAChE;AACA,QAAI,GAAG,mBAAmB;AACxB,aAAO,IAAI,iBAAgB,KAAK,SAAS,KAAK,kBAAkB;AAAA,IAClE;AAEA,WAAO,IAAI;AAAA,MACT,KAAK;AAAA,MACL;AAAA,QACE,KAAK,QAAQ;AAAA,QACb,KAAK;AAAA,QACL,GAAG;AAAA,MACL;AAAA,IACF;AAAA,EACF;AAAA,EAEA,UAAU,MAAsC;AAC9C,WAAO,KAAK,oBAAoB,KAAK,QAAQ,qBAAqB,IAAI,CAAC;AAAA,EACzE;AAAA,EAEA,SAAS,KAAoC;AAC3C,WAAO,KAAK,oBAAoB,KAAK,QAAQ,oBAAoB,GAAG,CAAC;AAAA,EACvE;AAAA;AAAA,EAGA,WAAmB;AACjB,WAAO,OAAO,mBAAmB,IAAI;AAAA,EACvC;AAAA,EAEA,kBAA0B;AACxB,WAAO,8BAA8B,KAAK,QAAQ,YAAY,IAAI;AAAA,EACpE;AAAA,EAEA,aAAa,QAAiC;AAC5C,WAAO,IAAI;AAAA,MACT,KAAK;AAAA,MACL;AAAA,QACE,KAAK;AAAA,QACL,KAAK;AAAA,QACL;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;;;ACjGO,SAAS,0CACd,iBACA,yBACS;AAKT,QAAM,EAAE,YAAY,IAAI;AACxB,QAAM,YAAY,YAAY;AAC9B,WAAS,MAAM,GAAG,MAAM,WAAW,OAAO;AACxC,QAAI,YAAY,GAAG,MAAM,KAAK;AAC5B,aAAO;AAAA,IACT;AAAA,EACF;AACA,MAAI,kBAAkB,GAAG;AACvB,UAAM,EAAE,YAAY,IAAI;AACxB,aAAS,MAAM,GAAG,MAAM,WAAW,OAAO;AACxC,UAAI,YAAY,GAAG,MAAM,GAAG;AAC1B,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEO,SAAS,mCACd,iBACA,0BACA,0BACA,UAGI,CAAC,GACI;AACT,WAAS,MAAM,GAAG,MAAM,gBAAgB,WAAW,OAAO;AACxD,QACE,CAAC,SAAS,qBACV,yBAAyB,YAAY,GAAG,MACtC,yBAAyB,YAAY,GAAG,GAC1C;AACA,aAAO;AAAA,IACT;AACA,QACE,CAAC,SAAS,qBACV,yBAAyB,YAAY,GAAG,MACtC,yBAAyB,YAAY,GAAG,GAC1C;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,8BACd,SACA,qBACA,qBACS;AACT,aAAW,CAAC,WAAW,eAAe,KAAK,OAAO;AAAA,IAChD,QAAQ,WAAW;AAAA,EACrB,GAAG;AACD,QACE,CAAC;AAAA,MACC;AAAA,MACA,oBAAoB,SAAS;AAAA,MAC7B,oBAAoB,SAAS;AAAA,IAC/B,GACA;AACA,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,qBACd,SACA,oBACqB;AACrB,QAAM,wBAA6C,CAAC;AACpD,aAAW,aAAa,QAAQ,WAAW,QAAQ;AACjD,UAAM,kBACJ,QAAQ,WAAW,OAAO,SAAS;AACrC,UAAM,0BAA0B,mBAAmB,SAAS;AAC5D,QACE;AAAA,MACE,gBAAgB;AAAA,MAChB;AAAA,IACF,GACA;AACA,4BAAsB,SAAS,IAAI;AAAA,IACrC,WAAW,gBAAgB,oBAAoB,GAAG;AAChD,YAAM,UAAU,IAAI,MAAM,gBAAgB,SAAS;AACnD,eAAS,MAAM,GAAG,MAAM,gBAAgB,WAAW,OAAO;AACxD,gBAAQ,wBAAwB,YAAY,GAAG,CAAC,IAAI;AAAA,MACtD;AACA,4BAAsB,SAAS,IAAI;AAAA,QACjC,aAAa;AAAA,QACb,aAAa,wBAAwB;AAAA,MACvC;AAAA,IACF,OAAO;AACL,YAAM,UAAU,IAAI,MAAM,gBAAgB,SAAS;AACnD,YAAM,SAAS,IAAI,MAAM,gBAAgB,SAAS;AAClD,eAAS,MAAM,GAAG,MAAM,gBAAgB,WAAW,OAAO;AACxD,cAAM,UAAU,wBAAwB,YAAY,GAAG;AACvD,gBAAQ,OAAO,IAAI;AACnB,eAAO,OAAO,KACX,gBAAgB,kBACf,wBAAwB,YAAY,GAAG,IACvC,gBAAgB,mBAClB,gBAAgB;AAAA,MACpB;AACA,4BAAsB,SAAS,IAAI;AAAA,QACjC,aAAa;AAAA,QACb,aAAa;AAAA,MACf;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAEO,SAAS,6BACd,SACA,oBACA,QACqB;AAErB,MAAI,WAAW,GAAG;AAChB,WAAO;AAAA,EACT;AACA,MAAI,SAAS,GAAG;AACd,WAAO;AAAA,MACL;AAAA,MACA,qBAAqB,SAAS,kBAAkB;AAAA,MAChD,CAAC;AAAA,IACH;AAAA,EACF;AACA,MAAI,WAAW,GAAG;AAEhB,UAAM,EAAE,oBAAAA,oBAAmB,IAAI,QAAQ,uBAAuB;AAC9D,WAAOA;AAAA,EACT;AACA,MAAI,UAAU;AACd,MAAI,WAAW,GAAG;AAChB,cAAU;AAAA,MACR;AAAA,MACA;AAAA,MACA,KAAK,MAAM,SAAS,CAAC;AAAA,IACvB;AAAA,EACF;AACA,QAAM,eAAe;AAAA,IACnB,QAAQ;AAAA,IACR;AAAA,IACA;AAAA,EACF;AACA,MAAI,SAAS,MAAM,GAAG;AACpB,WAAO;AAAA,EACT,OAAO;AACL,WAAO;AAAA,MACL,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACF;AAEA,IAAM,+BAAN,cAA2C,gBAGzC;AAAA,EACA,YAAY,KAAU,SAAmC;AACvD,QAAI,iBAAyC;AAC7C,eAAW,WAAW,IAAI,cAAc,GAAG;AACzC,UAAI,gBAAgB;AAClB,yBAAiB,eAAe;AAAA,UAC9B,KAAK,gBAAgB,SAAS,OAAO;AAAA,QACvC;AAAA,MACF,OAAO;AACL,yBAAiB,KAAK,gBAAgB,SAAS,OAAO;AAAA,MACxD;AAAA,IACF;AACA,WAAO,kBAAkB,QAAQ,uBAAuB;AAAA,EAC1D;AAAA,EACA,iBAAiB,UAAoB,SAAmC;AACtE,UAAM,oBAAoB,KAAK,YAAY,SAAS,KAAK,OAAO;AAChE,WAAO,IAAI;AAAA,MACT;AAAA,MACA;AAAA,QACE;AAAA,QACA,kBAAkB;AAAA,QAClB,SAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF;AAAA,EACA,aAAa,MAAY,SAAmC;AAC1D,WAAO,QAAQ,qBAAqB,IAAI;AAAA,EAC1C;AAAA,EACA,mBACE,YACA,SACiB;AACjB,UAAM,kBAAkB,KAAK,YAAY,WAAW,GAAG,OAAO;AAC9D,UAAM,kBAAkB,KAAK,YAAY,WAAW,GAAG,OAAO;AAC9D,WAAO,gBACJ,oBAAoB,eAAe,EACnC,oBAAoB,gBAAgB,OAAO,CAAC,EAC5C,oBAAoB,gBAAgB,OAAO,CAAC;AAAA,EACjD;AAAA,EACA,kBAAkB,WAAsB,SAAmC;AACzE,UAAM,kBAAkB,KAAK,YAAY,UAAU,GAAG,OAAO;AAC7D,UAAM,kBAAkB,KAAK,YAAY,UAAU,GAAG,OAAO;AAC7D,WAAO,gBACJ,oBAAoB,eAAe,EACnC,oBAAoB,gBAAgB,OAAO,CAAC;AAAA,EACjD;AAAA,EACA,cAAc,GAAU,SAAmC;AACzD,WAAO,QAAQ,uBAAuB;AAAA,EACxC;AAAA,EACA,gBAAgB,GAAY,SAAmC;AAC7D,WAAO,QAAQ,uBAAuB;AAAA,EACxC;AAAA,EACA,oBAAoB,GAAgB,SAAmC;AACrE,WAAO,QAAQ,uBAAuB;AAAA,EACxC;AACF;AAEO,IAAM,sBAAsB;AAAA,EACjC;AACF;AAmBA,SAAS,IAAI,GAAW,GAAmB;AACzC,MAAI,GAAG;AACL,WAAO,IAAI,GAAG,IAAI,CAAC;AAAA,EACrB;AACA,SAAO;AACT;AAGO,SAAS,8BACd,YACA,gBACQ;AACR,MAAI,QAAgB;AACpB,aAAW,aAAa,WAAW,QAAQ;AACzC,UAAM,kBAAkB,WAAW,OAAO,SAAS;AACnD,UAAM,sBAAsB,eAAe,mBAAmB,SAAS;AACvE,UAAM,cAAc,IAAI,MAAM,gBAAgB,SAAS;AACvD,aAAS,WAAW,GAAG,WAAW,gBAAgB,WAAW,YAAY;AACvE,UAAI,CAAC,YAAY,QAAQ,GAAG;AAC1B,YAAI,aAAa;AACjB,YAAI,iBAAiB;AACrB,YAAI,cAAc;AAClB,mBAAS;AACP,sBAAY,UAAU,IAAI;AAC1B,2BACE,iBAAiB,oBAAoB,YAAY,UAAU;AAC7D,wBAAc,cAAc;AAC5B,uBAAa,oBAAoB,YAAY,UAAU;AACvD,cAAI,eAAe,UAAU;AAC3B;AAAA,UACF;AAAA,QACF;AACA,YAAI,mBAAmB,GAAG;AACxB,wBACG,cAAc,gBAAgB,kBAC/B,IAAI,gBAAgB,iBAAiB,KAAK,IAAI,cAAc,CAAC;AAAA,QACjE;AACA,gBAAS,QAAQ,cAAe,IAAI,OAAO,WAAW;AAAA,MACxD;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;;;AC3SO,IAAM,UAAN,MAAc;AAAA,EAEnB,YACkB,YAChB,SAGA;AAJgB;AAgBlB,0CAAiC,oBAAI,IAAiC;AAXpE,SAAK,yBAAyB,SAAS;AAAA,EACzC;AAAA,EAEA,OAAe;AACb,WAAO,KAAK,WAAW;AAAA,EACzB;AAAA,EAEA,yBAA0C;AACxC,WAAO,gBAAgB,8BAA8B,IAAI;AAAA,EAC3D;AAAA,EAEA;AAAA,EACA,qBAAqB,MAAsC;AACzD,QAAI,OAAO,SAAS,UAAU;AAC5B,aAAO,IAAI,KAAK,IAAI;AAAA,IACtB;AACA,UAAM,WAAW,KAAK,SAAS;AAC/B,UAAM,2BACJ,KAAK,+BAA+B,IAAI,QAAQ;AAClD,QAAI,0BAA0B;AAC5B,aAAO,IAAI,gBAAgB,MAAM,wBAAwB;AAAA,IAC3D;AAEA,QAAI,KAAK,wBAAwB;AAC/B,YAAMC,sBAAqB,KAAK,uBAAuB,WAAW,IAAI;AACtE,UAAI,CAACA,qBAAoB;AACvB,cAAM,IAAI,MAAM,mCAAmC,IAAI,EAAE;AAAA,MAC3D;AACA,WAAK,+BAA+B,IAAI,UAAUA,mBAAkB;AACpE,aAAO,IAAI,gBAAgB,MAAMA,mBAAkB;AAAA,IACrD;AAEA,UAAM,qBAAqB,6BAA6B,MAAM,IAAI;AAClE,SAAK,+BAA+B,IAAI,UAAU,kBAAkB;AACpE,WAAO,IAAI,gBAAgB,MAAM,kBAAkB;AAAA,EACrD;AAAA,EAEA,oBAAoB,KAAoC;AACtD,QAAI,OAAO,QAAQ,UAAU;AAC3B,YAAM,IAAI,IAAI,GAAG;AAAA,IACnB;AACA,WAAO,oBAAoB,KAAK,IAAI;AAAA,EACtC;AAAA;AAAA,EAGA,iBAAiB,QAAgD;AAC/D,QAAI,OAAO,WAAW,UAAU;AAC9B,aAAO,KAAK,oBAAoB,MAAM;AAAA,IACxC,WAAY,QAAuB,KAAK,GAAG,GAAG;AAC5C,aAAO,KAAK,oBAAoB,MAAa;AAAA,IAC/C,WAAY,QAAwB,KAAK,IAAI,GAAG;AAC9C,aAAO,KAAK,qBAAqB,MAAc;AAAA,IACjD,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAAA,EAEA,aAAqB;AACnB,WAAO,IAAI,OAAO,MAAM,KAAK,WAAW,cAAc;AAAA,EACxD;AAAA,EAEA;AAAA;AAAA,EAEA,wCAAiD;AAC/C,WAAQ,2GACL,MAAe;AACd,iBAAW,CAAC,WAAW,eAAe,KAAK,OAAO;AAAA,QAChD,KAAK,WAAW;AAAA,MAClB,GAAG;AACD,cAAM,SAAS,IAAI,MAAM,gBAAgB,SAAS,EAAE,KAAK,KAAK;AAC9D,mBAAW,SAAS,KAAK,WAAW,eAAe,SAAS,EACzD,QAAQ;AACT,iBAAO,KAAK,IAAI;AAAA,QAClB;AACA,mBAAW,SAAS,QAAQ;AAC1B,cAAI,CAAC,OAAO;AACV,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF;AACA,aAAO;AAAA,IACT,GAAG;AAAA,EACP;AACF;",
-  "names": ["transformationData", "transformationData"]
-}

package/dist/esm/chunk-IZJ3YK5S.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/cubing/search/inside/solve/parseSGS.ts"],
-  "sourcesContent": ["import { Alg } from \"../../../alg\";\nimport type { KPuzzle, KTransformation } from \"../../../kpuzzle\";\n\ninterface PieceReference {\n  orbitName: string;\n  permutationIdx: number;\n}\n\nexport interface SGSAction {\n  alg: Alg;\n  transformation: KTransformation;\n}\n\nexport interface SGSCachedData {\n  ordering: {\n    pieceOrdering: PieceReference[];\n    lookup: Record<string, SGSAction>;\n  }[];\n}\n\nexport function parseSGS(kpuzzle: KPuzzle, sgs: string): SGSCachedData {\n  const subgroupSizes: number[] = [];\n  const sgsActions: SGSAction[] = [];\n  for (const line of sgs.split(\"\\n\")) {\n    const lineTokens = line.split(\" \");\n    if (line.startsWith(\"SetOrder \")) {\n      // ignore\n    } else if (line.startsWith(\"Alg \")) {\n      const alg = Alg.fromString(line.substring(4));\n      sgsActions.push({\n        alg: alg,\n        transformation: kpuzzle.algToTransformation(alg),\n      });\n    } else if (line.startsWith(\"SubgroupSizes \")) {\n      for (let j = 1; j < lineTokens.length; j++) {\n        subgroupSizes.push(parseInt(lineTokens[j]));\n      }\n    }\n  }\n\n  const sgsCachedData: SGSCachedData = {\n    ordering: new Array(subgroupSizes.length),\n  };\n  const subgroupAlgOffsets: number[] = [];\n  let sum = 0;\n  subgroupAlgOffsets.push(0);\n  const emptyAlg = Alg.fromString(\"\");\n  const identity = kpuzzle.identityTransformation();\n  for (let i = 0; i < subgroupSizes.length; i++) {\n    sum += subgroupSizes[i];\n    subgroupAlgOffsets.push(sum);\n    sgsActions.splice(sum - 1, 0, { alg: emptyAlg, transformation: identity });\n  }\n  if (sgsActions.length !== sum) {\n    throw Error(\n      `Bad sgs; expected ${sum - subgroupSizes.length} algs but saw ${\n        sgsActions.length - subgroupSizes.length\n      }`,\n    );\n  }\n  const processedPieces: Record<string, boolean[]> = {};\n  for (const orbitName in kpuzzle.definition.orbits) {\n    const orbitDefinition = kpuzzle.definition.orbits[orbitName];\n    processedPieces[orbitName] = new Array(orbitDefinition.numPieces).fill(\n      false,\n    );\n  }\n  for (let i = subgroupSizes.length - 1; i >= 0; i--) {\n    const pieceOrdering: PieceReference[] = [];\n    for (let j = subgroupAlgOffsets[i]; j < subgroupAlgOffsets[i + 1]; j++) {\n      const transformation = sgsActions[j].transformation;\n      for (const orbitName in kpuzzle.definition.orbits) {\n        const orbitDefinition = kpuzzle.definition.orbits[orbitName];\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          if (\n            transformation.transformationData[orbitName].permutation[idx] !==\n              idx ||\n            transformation.transformationData[orbitName].orientation[idx] !== 0\n          ) {\n            if (!processedPieces[orbitName][idx]) {\n              pieceOrdering.push({ orbitName: orbitName, permutationIdx: idx });\n              processedPieces[orbitName][idx] = true;\n            }\n          }\n        }\n      }\n    }\n    const lookup: Record<string, SGSAction> = {};\n    for (let j = subgroupAlgOffsets[i]; j < subgroupAlgOffsets[i + 1]; j++) {\n      const transformation = sgsActions[j].transformation.invert();\n      let key = \"\";\n      for (let k = 0; k < pieceOrdering.length; k++) {\n        const loc = pieceOrdering[k];\n        key = `${key} ${\n          transformation.transformationData[loc.orbitName].permutation[\n            loc.permutationIdx\n          ]\n        } ${\n          transformation.transformationData[loc.orbitName].orientation[\n            loc.permutationIdx\n          ]\n        }`;\n      }\n      lookup[key] = sgsActions[j];\n      sgsActions[j].alg = sgsActions[j].alg.invert();\n      sgsActions[j].transformation = sgsActions[j].transformation.invert();\n    }\n    sgsCachedData.ordering[i] = {\n      pieceOrdering: pieceOrdering,\n      lookup: lookup,\n    };\n  }\n  return sgsCachedData;\n}\n"],
-  "mappings": "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",
-  "names": []
-}