cubing 0.28.0 → 0.28.4

package/dist/esm/{chunk-GXZIBFSN.js → chunk-NI7U4XAZ.js}

@@ -2,9 +2,8 @@ import {
   __privateAdd,
   __privateGet,
   __privateMethod,
-  __privateSet,
-  __privateWrapper
-} from "./chunk-MGJA5U5O.js";
+  __privateSet
+} from "./chunk-SBZRVSPK.js";
 
 // src/cubing/alg/common.ts
 var writeAlgDebugField = false;
@@ -65,13 +64,10 @@ var MAX_INT_DESCRIPTION = "2^31 - 1";
 var MIN_INT = -2147483648;
 
 // src/cubing/alg/AlgBuilder.ts
-var _algNode;
 var AlgBuilder = class {
-  constructor() {
-    __privateAdd(this, _algNode, []);
-  }
+  #algNode = [];
   push(u) {
-    __privateGet(this, _algNode).push(u);
+    this.#algNode.push(u);
   }
   experimentalPushAlg(alg) {
     for (const u of alg.childAlgNodes()) {
@@ -79,16 +75,15 @@ var AlgBuilder = class {
     }
   }
   experimentalNumAlgNodes() {
-    return __privateGet(this, _algNode).length;
+    return this.#algNode.length;
   }
   toAlg() {
-    return new Alg(__privateGet(this, _algNode));
+    return new Alg(this.#algNode);
   }
   reset() {
-    __privateSet(this, _algNode, []);
+    this.#algNode = [];
   }
 };
-_algNode = new WeakMap();
 
 // src/cubing/alg/debug.ts
 var algDebugGlobals = {
@@ -101,27 +96,26 @@ function setAlgDebug(options) {
 }
 
 // src/cubing/alg/alg-nodes/containers/Commutator.ts
-var _A, _B;
-var _Commutator = class extends AlgCommon {
+var Commutator = class extends AlgCommon {
+  #A;
+  #B;
   constructor(aSource, bSource) {
     super();
-    __privateAdd(this, _A, void 0);
-    __privateAdd(this, _B, void 0);
-    __privateSet(this, _A, experimentalEnsureAlg(aSource));
-    __privateSet(this, _B, experimentalEnsureAlg(bSource));
+    this.#A = experimentalEnsureAlg(aSource);
+    this.#B = experimentalEnsureAlg(bSource);
   }
   get A() {
-    return __privateGet(this, _A);
+    return this.#A;
   }
   get B() {
-    return __privateGet(this, _B);
+    return this.#B;
   }
   isIdentical(other) {
-    const otherAsCommutator = other.as(_Commutator);
+    const otherAsCommutator = other.as(Commutator);
     return !!(otherAsCommutator?.A.isIdentical(this.A) && otherAsCommutator?.B.isIdentical(this.B));
   }
   invert() {
-    return new _Commutator(__privateGet(this, _B), __privateGet(this, _A));
+    return new Commutator(this.#B, this.#A);
   }
   *experimentalExpand(iterDir = 1 /* Forwards */, depth) {
     depth ?? (depth = Infinity);
@@ -129,48 +123,68 @@ var _Commutator = class extends AlgCommon {
       yield iterDir === 1 /* Forwards */ ? this : this.invert();
     } else {
       if (iterDir === 1 /* Forwards */) {
-        yield* this.A.experimentalExpand(1 /* Forwards */, depth - 1);
-        yield* this.B.experimentalExpand(1 /* Forwards */, depth - 1);
-        yield* this.A.experimentalExpand(-1 /* Backwards */, depth - 1);
-        yield* this.B.experimentalExpand(-1 /* Backwards */, depth - 1);
+        yield* this.A.experimentalExpand(
+          1 /* Forwards */,
+          depth - 1
+        );
+        yield* this.B.experimentalExpand(
+          1 /* Forwards */,
+          depth - 1
+        );
+        yield* this.A.experimentalExpand(
+          -1 /* Backwards */,
+          depth - 1
+        );
+        yield* this.B.experimentalExpand(
+          -1 /* Backwards */,
+          depth - 1
+        );
       } else {
-        yield* this.B.experimentalExpand(1 /* Forwards */, depth - 1);
-        yield* this.A.experimentalExpand(1 /* Forwards */, depth - 1);
-        yield* this.B.experimentalExpand(-1 /* Backwards */, depth - 1);
-        yield* this.A.experimentalExpand(-1 /* Backwards */, depth - 1);
+        yield* this.B.experimentalExpand(
+          1 /* Forwards */,
+          depth - 1
+        );
+        yield* this.A.experimentalExpand(
+          1 /* Forwards */,
+          depth - 1
+        );
+        yield* this.B.experimentalExpand(
+          -1 /* Backwards */,
+          depth - 1
+        );
+        yield* this.A.experimentalExpand(
+          -1 /* Backwards */,
+          depth - 1
+        );
       }
     }
   }
   toString() {
-    return `[${__privateGet(this, _A).toString()}, ${__privateGet(this, _B).toString()}]`;
+    return `[${this.#A.toString()}, ${this.#B.toString()}]`;
   }
 };
-var Commutator = _Commutator;
-_A = new WeakMap();
-_B = new WeakMap();
 
 // src/cubing/alg/alg-nodes/containers/Conjugate.ts
-var _A2, _B2;
-var _Conjugate = class extends AlgCommon {
+var Conjugate = class extends AlgCommon {
+  #A;
+  #B;
   constructor(aSource, bSource) {
     super();
-    __privateAdd(this, _A2, void 0);
-    __privateAdd(this, _B2, void 0);
-    __privateSet(this, _A2, experimentalEnsureAlg(aSource));
-    __privateSet(this, _B2, experimentalEnsureAlg(bSource));
+    this.#A = experimentalEnsureAlg(aSource);
+    this.#B = experimentalEnsureAlg(bSource);
   }
   get A() {
-    return __privateGet(this, _A2);
+    return this.#A;
   }
   get B() {
-    return __privateGet(this, _B2);
+    return this.#B;
   }
   isIdentical(other) {
-    const otherAsConjugate = other.as(_Conjugate);
+    const otherAsConjugate = other.as(Conjugate);
     return !!(otherAsConjugate?.A.isIdentical(this.A) && otherAsConjugate?.B.isIdentical(this.B));
   }
   invert() {
-    return new _Conjugate(__privateGet(this, _A2), __privateGet(this, _B2).invert());
+    return new Conjugate(this.#A, this.#B.invert());
   }
   *experimentalExpand(iterDir, depth) {
     depth ?? (depth = Infinity);
@@ -186,27 +200,23 @@ var _Conjugate = class extends AlgCommon {
     return `[${this.A}: ${this.B}]`;
   }
 };
-var Conjugate = _Conjugate;
-_A2 = new WeakMap();
-_B2 = new WeakMap();
 
 // src/cubing/alg/alg-nodes/leaves/LineComment.ts
-var _text;
-var _LineComment = class extends AlgCommon {
+var LineComment = class extends AlgCommon {
+  #text;
   constructor(commentText) {
     super();
-    __privateAdd(this, _text, void 0);
     if (commentText.includes("\n") || commentText.includes("\r")) {
       throw new Error("LineComment cannot contain newline");
     }
-    __privateSet(this, _text, commentText);
+    this.#text = commentText;
   }
   get text() {
-    return __privateGet(this, _text);
+    return this.#text;
   }
   isIdentical(other) {
     const otherAsLineComment = other;
-    return other.is(_LineComment) && __privateGet(this, _text) === __privateGet(otherAsLineComment, _text);
+    return other.is(LineComment) && this.#text === otherAsLineComment.#text;
   }
   invert() {
     return this;
@@ -215,11 +225,9 @@ var _LineComment = class extends AlgCommon {
     yield this;
   }
   toString() {
-    return `//${__privateGet(this, _text)}`;
+    return `//${this.#text}`;
   }
 };
-var LineComment = _LineComment;
-_text = new WeakMap();
 
 // src/cubing/alg/alg-nodes/leaves/Newline.ts
 var Newline = class extends AlgCommon {
@@ -254,7 +262,7 @@ var Pause = class extends AlgCommon {
   }
 };
 
-// src/cubing/alg/parse.ts
+// src/cubing/alg/parseAlg.ts
 function parseIntWithEmptyFallback(n, emptyFallback) {
   return n ? parseInt(n) : emptyFallback;
 }
@@ -288,100 +296,124 @@ function transferCharIndex(from, to) {
   }
   return to;
 }
-var _input, _idx, _nissQueue;
 var AlgParser = class {
-  constructor() {
-    __privateAdd(this, _input, "");
-    __privateAdd(this, _idx, 0);
-    __privateAdd(this, _nissQueue, []);
-  }
+  #input = "";
+  #idx = 0;
+  #nissQueue = [];
   parseAlg(input) {
-    __privateSet(this, _input, input);
-    __privateSet(this, _idx, 0);
+    this.#input = input;
+    this.#idx = 0;
     const alg = this.parseAlgWithStopping([]);
     this.mustBeAtEndOfInput();
     const algNodes = Array.from(alg.childAlgNodes());
-    if (__privateGet(this, _nissQueue).length > 0) {
-      for (const nissGrouping of __privateGet(this, _nissQueue).reverse()) {
+    if (this.#nissQueue.length > 0) {
+      for (const nissGrouping of this.#nissQueue.reverse()) {
         algNodes.push(nissGrouping);
       }
     }
-    return new Alg(algNodes);
+    const newAlg = new Alg(algNodes);
+    const { startCharIndex, endCharIndex } = alg;
+    addCharIndices(newAlg, startCharIndex, endCharIndex);
+    return newAlg;
   }
   parseMove(input) {
-    __privateSet(this, _input, input);
-    __privateSet(this, _idx, 0);
+    this.#input = input;
+    this.#idx = 0;
     const move = this.parseMoveImpl();
     this.mustBeAtEndOfInput();
     return move;
   }
   parseQuantumMove(input) {
-    __privateSet(this, _input, input);
-    __privateSet(this, _idx, 0);
+    this.#input = input;
+    this.#idx = 0;
     const quantumMove = this.parseQuantumMoveImpl();
     this.mustBeAtEndOfInput();
     return quantumMove;
   }
   mustBeAtEndOfInput() {
-    if (__privateGet(this, _idx) !== __privateGet(this, _input).length) {
+    if (this.#idx !== this.#input.length) {
       throw new Error("parsing unexpectedly ended early");
     }
   }
   parseAlgWithStopping(stopBefore) {
-    let algStartIdx = __privateGet(this, _idx);
-    let algEndIdx = __privateGet(this, _idx);
+    let algStartIdx = this.#idx;
+    let algEndIdx = this.#idx;
     const algBuilder = new AlgBuilder();
     let crowded = false;
     const mustNotBeCrowded = (idx) => {
       if (crowded) {
-        throw new Error(`Unexpected character at index ${idx}. Are you missing a space?`);
+        throw new Error(
+          `Unexpected character at index ${idx}. Are you missing a space?`
+        );
       }
     };
     mainLoop:
-      while (__privateGet(this, _idx) < __privateGet(this, _input).length) {
-        const savedCharIndex = __privateGet(this, _idx);
-        if (stopBefore.includes(__privateGet(this, _input)[__privateGet(this, _idx)])) {
+      while (this.#idx < this.#input.length) {
+        const savedCharIndex = this.#idx;
+        if (stopBefore.includes(this.#input[this.#idx])) {
           return addCharIndices(algBuilder.toAlg(), algStartIdx, algEndIdx);
         }
         if (this.tryConsumeNext(" ")) {
           crowded = false;
           if (algBuilder.experimentalNumAlgNodes() === 0) {
-            algStartIdx = __privateGet(this, _idx);
+            algStartIdx = this.#idx;
           }
           continue mainLoop;
-        } else if (MOVE_START_REGEX.test(__privateGet(this, _input)[__privateGet(this, _idx)])) {
+        } else if (MOVE_START_REGEX.test(this.#input[this.#idx])) {
           mustNotBeCrowded(savedCharIndex);
           const move = this.parseMoveImpl();
           algBuilder.push(move);
           crowded = true;
-          algEndIdx = __privateGet(this, _idx);
+          algEndIdx = this.#idx;
           continue mainLoop;
         } else if (this.tryConsumeNext("(")) {
           mustNotBeCrowded(savedCharIndex);
           const sq1PairStartMatch = this.tryRegex(SQUARE1_PAIR_START_REGEX);
           if (sq1PairStartMatch) {
             const topAmountString = sq1PairStartMatch[1];
-            const savedCharIndexD = __privateGet(this, _idx);
+            const savedCharIndexD = this.#idx;
             const sq1PairEndMatch = this.parseRegex(SQUARE1_PAIR_END_REGEX);
-            const uMove = addCharIndices(new Move(new QuantumMove("U_SQ_"), parseInt(topAmountString)), savedCharIndex + 1, savedCharIndex + 1 + topAmountString.length);
-            const dMove = addCharIndices(new Move(new QuantumMove("D_SQ_"), parseInt(sq1PairEndMatch[1])), savedCharIndexD, __privateGet(this, _idx) - 1);
-            const alg = addCharIndices(new Alg([uMove, dMove]), savedCharIndex + 1, __privateGet(this, _idx) - 1);
-            algBuilder.push(addCharIndices(new Grouping(alg), savedCharIndex, __privateGet(this, _idx)));
+            const uMove = addCharIndices(
+              new Move(new QuantumMove("U_SQ_"), parseInt(topAmountString)),
+              savedCharIndex + 1,
+              savedCharIndex + 1 + topAmountString.length
+            );
+            const dMove = addCharIndices(
+              new Move(new QuantumMove("D_SQ_"), parseInt(sq1PairEndMatch[1])),
+              savedCharIndexD,
+              this.#idx - 1
+            );
+            const alg = addCharIndices(
+              new Alg([uMove, dMove]),
+              savedCharIndex + 1,
+              this.#idx - 1
+            );
+            algBuilder.push(
+              addCharIndices(new Grouping(alg), savedCharIndex, this.#idx)
+            );
             crowded = true;
-            algEndIdx = __privateGet(this, _idx);
+            algEndIdx = this.#idx;
             continue mainLoop;
           } else {
             const alg = this.parseAlgWithStopping([")"]);
             this.mustConsumeNext(")");
             const amount = this.parseAmount();
-            algBuilder.push(addCharIndices(new Grouping(alg, amount), savedCharIndex, __privateGet(this, _idx)));
+            algBuilder.push(
+              addCharIndices(
+                new Grouping(alg, amount),
+                savedCharIndex,
+                this.#idx
+              )
+            );
             crowded = true;
-            algEndIdx = __privateGet(this, _idx);
+            algEndIdx = this.#idx;
             continue mainLoop;
           }
         } else if (this.tryConsumeNext("^")) {
           if (!algDebugGlobals.caratNISSNotationEnabled) {
-            throw new Error("Alg contained a carat but carat NISS notation is not enabled.");
+            throw new Error(
+              "Alg contained a carat but carat NISS notation is not enabled."
+            );
           }
           this.mustConsumeNext("(");
           const alg = this.parseAlgWithStopping([")"]);
@@ -390,7 +422,7 @@ var AlgParser = class {
           const placeholder = new Pause();
           grouping.experimentalNISSPlaceholder = placeholder;
           placeholder.experimentalNISSGrouping = grouping;
-          __privateGet(this, _nissQueue).push(grouping);
+          this.#nissQueue.push(grouping);
           algBuilder.push(placeholder);
         } else if (this.tryConsumeNext("[")) {
           mustNotBeCrowded(savedCharIndex);
@@ -400,48 +432,58 @@ var AlgParser = class {
           this.mustConsumeNext("]");
           switch (separator) {
             case ":":
-              algBuilder.push(addCharIndices(new Conjugate(A, B), savedCharIndex, __privateGet(this, _idx)));
+              algBuilder.push(
+                addCharIndices(new Conjugate(A, B), savedCharIndex, this.#idx)
+              );
               crowded = true;
-              algEndIdx = __privateGet(this, _idx);
+              algEndIdx = this.#idx;
               continue mainLoop;
             case ",":
-              algBuilder.push(addCharIndices(new Commutator(A, B), savedCharIndex, __privateGet(this, _idx)));
+              algBuilder.push(
+                addCharIndices(new Commutator(A, B), savedCharIndex, this.#idx)
+              );
               crowded = true;
-              algEndIdx = __privateGet(this, _idx);
+              algEndIdx = this.#idx;
               continue mainLoop;
             default:
               throw new Error("unexpected parsing error");
           }
         } else if (this.tryConsumeNext("\n")) {
-          algBuilder.push(addCharIndices(new Newline(), savedCharIndex, __privateGet(this, _idx)));
+          algBuilder.push(
+            addCharIndices(new Newline(), savedCharIndex, this.#idx)
+          );
           crowded = false;
-          algEndIdx = __privateGet(this, _idx);
+          algEndIdx = this.#idx;
           continue mainLoop;
         } else if (this.tryConsumeNext("/")) {
           if (this.tryConsumeNext("/")) {
             mustNotBeCrowded(savedCharIndex);
             const [text] = this.parseRegex(COMMENT_TEXT_REGEX);
-            algBuilder.push(addCharIndices(new LineComment(text), savedCharIndex, __privateGet(this, _idx)));
+            algBuilder.push(
+              addCharIndices(new LineComment(text), savedCharIndex, this.#idx)
+            );
             crowded = false;
-            algEndIdx = __privateGet(this, _idx);
+            algEndIdx = this.#idx;
             continue mainLoop;
           } else {
-            algBuilder.push(addCharIndices(new Move("_SLASH_"), savedCharIndex, __privateGet(this, _idx)));
+            algBuilder.push(
+              addCharIndices(new Move("_SLASH_"), savedCharIndex, this.#idx)
+            );
             crowded = true;
-            algEndIdx = __privateGet(this, _idx);
+            algEndIdx = this.#idx;
             continue mainLoop;
           }
         } else if (this.tryConsumeNext(".")) {
           mustNotBeCrowded(savedCharIndex);
-          algBuilder.push(addCharIndices(new Pause(), savedCharIndex, __privateGet(this, _idx)));
+          algBuilder.push(addCharIndices(new Pause(), savedCharIndex, this.#idx));
           crowded = true;
-          algEndIdx = __privateGet(this, _idx);
+          algEndIdx = this.#idx;
           continue mainLoop;
         } else {
           throw new Error(`Unexpected character: ${this.popNext()}`);
         }
       }
-    if (__privateGet(this, _idx) !== __privateGet(this, _input).length) {
+    if (this.#idx !== this.#input.length) {
       throw new Error("did not finish parsing?");
     }
     if (stopBefore.length > 0) {
@@ -451,12 +493,16 @@ var AlgParser = class {
   }
   parseQuantumMoveImpl() {
     const [, , , outerLayerStr, innerLayerStr, family] = this.parseRegex(QUANTUM_MOVE_REGEX);
-    return new QuantumMove(family, parseIntWithEmptyFallback(innerLayerStr, void 0), parseIntWithEmptyFallback(outerLayerStr, void 0));
+    return new QuantumMove(
+      family,
+      parseIntWithEmptyFallback(innerLayerStr, void 0),
+      parseIntWithEmptyFallback(outerLayerStr, void 0)
+    );
   }
   parseMoveImpl() {
-    const savedCharIndex = __privateGet(this, _idx);
+    const savedCharIndex = this.#idx;
     if (this.tryConsumeNext("/")) {
-      return addCharIndices(new Move("_SLASH_"), savedCharIndex, __privateGet(this, _idx));
+      return addCharIndices(new Move("_SLASH_"), savedCharIndex, this.#idx);
     }
     let quantumMove = this.parseQuantumMoveImpl();
     let [amount, hadEmptyAbsAmount] = this.parseAmountAndTrackEmptyAbsAmount();
@@ -466,13 +512,19 @@ var AlgParser = class {
         throw new Error("uh-oh");
       }
       if ((suffix === "++" || suffix === "--") && amount !== 1) {
-        throw new Error("Pochmann ++ or -- moves cannot have an amount other than 1.");
+        throw new Error(
+          "Pochmann ++ or -- moves cannot have an amount other than 1."
+        );
       }
       if ((suffix === "++" || suffix === "--") && !hadEmptyAbsAmount) {
-        throw new Error("Pochmann ++ or -- moves cannot have an amount written as a number.");
+        throw new Error(
+          "Pochmann ++ or -- moves cannot have an amount written as a number."
+        );
       }
       if ((suffix === "+" || suffix === "-") && hadEmptyAbsAmount) {
-        throw new Error("Clock dial moves must have an amount written as a natural number followed by + or -.");
+        throw new Error(
+          "Clock dial moves must have an amount written as a natural number followed by + or -."
+        );
       }
       if (suffix.startsWith("+")) {
         quantumMove = quantumMove.modified({
@@ -486,7 +538,11 @@ var AlgParser = class {
         amount *= -1;
       }
     }
-    const move = addCharIndices(new Move(quantumMove, amount), savedCharIndex, __privateGet(this, _idx));
+    const move = addCharIndices(
+      new Move(quantumMove, amount),
+      savedCharIndex,
+      this.#idx
+    );
     return move;
   }
   parseMoveSuffix() {
@@ -505,10 +561,12 @@ var AlgParser = class {
     return null;
   }
   parseAmountAndTrackEmptyAbsAmount() {
-    const savedIdx = __privateGet(this, _idx);
+    const savedIdx = this.#idx;
     const [, absAmountStr, primeStr] = this.parseRegex(AMOUNT_REGEX);
     if (absAmountStr?.startsWith("0") && absAmountStr !== "0") {
-      throw new Error(`Error at char index ${savedIdx}: An amount can only start with 0 if it's exactly the digit 0.`);
+      throw new Error(
+        `Error at char index ${savedIdx}: An amount can only start with 0 if it's exactly the digit 0.`
+      );
     }
     return [
       parseIntWithEmptyFallback(absAmountStr, 1) * (primeStr === "'" ? -1 : 1),
@@ -516,10 +574,12 @@ var AlgParser = class {
     ];
   }
   parseAmount() {
-    const savedIdx = __privateGet(this, _idx);
+    const savedIdx = this.#idx;
     const [, absAmountStr, primeStr] = this.parseRegex(AMOUNT_REGEX);
     if (absAmountStr?.startsWith("0") && absAmountStr !== "0") {
-      throw new Error(`Error at char index ${savedIdx}: An amount number can only start with 0 if it's exactly the digit 0.`);
+      throw new Error(
+        `Error at char index ${savedIdx}: An amount number can only start with 0 if it's exactly the digit 0.`
+      );
     }
     return parseIntWithEmptyFallback(absAmountStr, 1) * (primeStr === "'" ? -1 : 1);
   }
@@ -528,7 +588,7 @@ var AlgParser = class {
     if (arr === null) {
       throw new Error("internal parsing error");
     }
-    __privateSet(this, _idx, __privateGet(this, _idx) + arr[0].length);
+    this.#idx += arr[0].length;
     return arr;
   }
   tryRegex(regex) {
@@ -536,20 +596,20 @@ var AlgParser = class {
     if (arr === null) {
       return null;
     }
-    __privateSet(this, _idx, __privateGet(this, _idx) + arr[0].length);
+    this.#idx += arr[0].length;
     return arr;
   }
   remaining() {
-    return __privateGet(this, _input).slice(__privateGet(this, _idx));
+    return this.#input.slice(this.#idx);
   }
   popNext() {
-    const next = __privateGet(this, _input)[__privateGet(this, _idx)];
-    __privateWrapper(this, _idx)._++;
+    const next = this.#input[this.#idx];
+    this.#idx++;
     return next;
   }
   tryConsumeNext(expected) {
-    if (__privateGet(this, _input)[__privateGet(this, _idx)] === expected) {
-      __privateWrapper(this, _idx)._++;
+    if (this.#input[this.#idx] === expected) {
+      this.#idx++;
       return true;
     }
     return false;
@@ -557,14 +617,13 @@ var AlgParser = class {
   mustConsumeNext(expected) {
     const next = this.popNext();
     if (next !== expected) {
-      throw new Error(`expected \`${expected}\` while parsing, encountered ${next}`);
+      throw new Error(
+        `expected \`${expected}\` while parsing, encountered ${next}`
+      );
     }
     return next;
   }
 };
-_input = new WeakMap();
-_idx = new WeakMap();
-_nissQueue = new WeakMap();
 
 // src/cubing/alg/warnOnce.ts
 var warned = /* @__PURE__ */ new Set();
@@ -581,7 +640,9 @@ var QuantumWithAmount = class {
     this.quantum = quantum;
     this.amount = amount;
     if (!Number.isInteger(this.amount) || this.amount < MIN_INT || this.amount > MAX_INT) {
-      throw new Error(`AlgNode amount absolute value must be a non-negative integer below ${MAX_INT_DESCRIPTION}.`);
+      throw new Error(
+        `AlgNode amount absolute value must be a non-negative integer below ${MAX_INT_DESCRIPTION}.`
+      );
     }
   }
   suffix() {
@@ -608,88 +669,105 @@ var QuantumWithAmount = class {
 };
 
 // src/cubing/alg/alg-nodes/leaves/Move.ts
-var _family, _innerLayer, _outerLayer;
-var _QuantumMove = class extends Comparable {
+var QuantumMove = class extends Comparable {
+  #family;
+  #innerLayer;
+  #outerLayer;
   constructor(family, innerLayer, outerLayer) {
     super();
-    __privateAdd(this, _family, void 0);
-    __privateAdd(this, _innerLayer, void 0);
-    __privateAdd(this, _outerLayer, void 0);
-    __privateSet(this, _family, family);
-    __privateSet(this, _innerLayer, innerLayer ?? null);
-    __privateSet(this, _outerLayer, outerLayer ?? null);
+    this.#family = family;
+    this.#innerLayer = innerLayer ?? null;
+    this.#outerLayer = outerLayer ?? null;
     Object.freeze(this);
-    if (__privateGet(this, _innerLayer) !== null && (!Number.isInteger(__privateGet(this, _innerLayer)) || __privateGet(this, _innerLayer) < 1 || __privateGet(this, _innerLayer) > MAX_INT)) {
-      throw new Error(`QuantumMove inner layer must be a positive integer below ${MAX_INT_DESCRIPTION}.`);
+    if (this.#innerLayer !== null && (!Number.isInteger(this.#innerLayer) || this.#innerLayer < 1 || this.#innerLayer > MAX_INT)) {
+      throw new Error(
+        `QuantumMove inner layer must be a positive integer below ${MAX_INT_DESCRIPTION}.`
+      );
     }
-    if (__privateGet(this, _outerLayer) !== null && (!Number.isInteger(__privateGet(this, _outerLayer)) || __privateGet(this, _outerLayer) < 1 || __privateGet(this, _outerLayer) > MAX_INT)) {
-      throw new Error(`QuantumMove outer layer must be a positive integer below ${MAX_INT_DESCRIPTION}.`);
+    if (this.#outerLayer !== null && (!Number.isInteger(this.#outerLayer) || this.#outerLayer < 1 || this.#outerLayer > MAX_INT)) {
+      throw new Error(
+        `QuantumMove outer layer must be a positive integer below ${MAX_INT_DESCRIPTION}.`
+      );
     }
-    if (__privateGet(this, _outerLayer) !== null && __privateGet(this, _innerLayer) !== null && __privateGet(this, _innerLayer) <= __privateGet(this, _outerLayer)) {
-      throw new Error("QuantumMove outer layer must be smaller than inner layer.");
+    if (this.#outerLayer !== null && this.#innerLayer !== null && this.#innerLayer <= this.#outerLayer) {
+      throw new Error(
+        "QuantumMove outer layer must be smaller than inner layer."
+      );
     }
-    if (__privateGet(this, _outerLayer) !== null && __privateGet(this, _innerLayer) === null) {
-      throw new Error("QuantumMove with an outer layer must have an inner layer");
+    if (this.#outerLayer !== null && this.#innerLayer === null) {
+      throw new Error(
+        "QuantumMove with an outer layer must have an inner layer"
+      );
     }
   }
   static fromString(s) {
     return parseQuantumMove(s);
   }
   modified(modifications) {
-    return new _QuantumMove(modifications.family ?? __privateGet(this, _family), modifications.innerLayer ?? __privateGet(this, _innerLayer), modifications.outerLayer ?? __privateGet(this, _outerLayer));
+    return new QuantumMove(
+      modifications.family ?? this.#family,
+      modifications.innerLayer ?? this.#innerLayer,
+      modifications.outerLayer ?? this.#outerLayer
+    );
   }
   isIdentical(other) {
     const otherAsQuantumMove = other;
-    return other.is(_QuantumMove) && __privateGet(this, _family) === __privateGet(otherAsQuantumMove, _family) && __privateGet(this, _innerLayer) === __privateGet(otherAsQuantumMove, _innerLayer) && __privateGet(this, _outerLayer) === __privateGet(otherAsQuantumMove, _outerLayer);
+    return other.is(QuantumMove) && this.#family === otherAsQuantumMove.#family && this.#innerLayer === otherAsQuantumMove.#innerLayer && this.#outerLayer === otherAsQuantumMove.#outerLayer;
   }
   get family() {
-    return __privateGet(this, _family);
+    return this.#family;
   }
   get outerLayer() {
-    return __privateGet(this, _outerLayer);
+    return this.#outerLayer;
   }
   get innerLayer() {
-    return __privateGet(this, _innerLayer);
+    return this.#innerLayer;
   }
   experimentalExpand() {
-    throw new Error("experimentalExpand() cannot be called on a `QuantumMove` directly.");
+    throw new Error(
+      "experimentalExpand() cannot be called on a `QuantumMove` directly."
+    );
   }
   toString() {
-    let s = __privateGet(this, _family);
-    if (__privateGet(this, _innerLayer) !== null) {
-      s = String(__privateGet(this, _innerLayer)) + s;
-      if (__privateGet(this, _outerLayer) !== null) {
-        s = String(__privateGet(this, _outerLayer)) + "-" + s;
+    let s = this.#family;
+    if (this.#innerLayer !== null) {
+      s = String(this.#innerLayer) + s;
+      if (this.#outerLayer !== null) {
+        s = String(this.#outerLayer) + "-" + s;
       }
     }
     return s;
   }
 };
-var QuantumMove = _QuantumMove;
-_family = new WeakMap();
-_innerLayer = new WeakMap();
-_outerLayer = new WeakMap();
-var _quantumWithAmount;
-var _Move = class extends AlgCommon {
+var Move = class extends AlgCommon {
+  #quantumWithAmount;
   constructor(...args) {
     super();
-    __privateAdd(this, _quantumWithAmount, void 0);
     if (typeof args[0] === "string") {
       if (args[1] ?? null) {
-        __privateSet(this, _quantumWithAmount, new QuantumWithAmount(QuantumMove.fromString(args[0]), args[1]));
+        this.#quantumWithAmount = new QuantumWithAmount(
+          QuantumMove.fromString(args[0]),
+          args[1]
+        );
         return;
       } else {
-        return _Move.fromString(args[0]);
+        return Move.fromString(args[0]);
       }
     }
-    __privateSet(this, _quantumWithAmount, new QuantumWithAmount(args[0], args[1]));
+    this.#quantumWithAmount = new QuantumWithAmount(
+      args[0],
+      args[1]
+    );
   }
   isIdentical(other) {
-    const otherAsMove = other.as(_Move);
-    return !!otherAsMove && __privateGet(this, _quantumWithAmount).isIdentical(__privateGet(otherAsMove, _quantumWithAmount));
+    const otherAsMove = other.as(Move);
+    return !!otherAsMove && this.#quantumWithAmount.isIdentical(otherAsMove.#quantumWithAmount);
   }
   invert() {
-    return transferCharIndex(this, new _Move(__privateGet(this, _quantumWithAmount).quantum, -this.amount));
+    return transferCharIndex(
+      this,
+      new Move(this.#quantumWithAmount.quantum, -this.amount)
+    );
   }
   *experimentalExpand(iterDir = 1 /* Forwards */) {
     if (iterDir === 1 /* Forwards */) {
@@ -701,46 +779,47 @@ var _Move = class extends AlgCommon {
     }
   }
   get quantum() {
-    return __privateGet(this, _quantumWithAmount).quantum;
+    return this.#quantumWithAmount.quantum;
   }
   modified(modifications) {
-    return new _Move(__privateGet(this, _quantumWithAmount).quantum.modified(modifications), modifications.amount ?? this.amount);
+    return new Move(
+      this.#quantumWithAmount.quantum.modified(modifications),
+      modifications.amount ?? this.amount
+    );
   }
   static fromString(s) {
     return parseMove(s);
   }
   get amount() {
-    return __privateGet(this, _quantumWithAmount).amount;
+    return this.#quantumWithAmount.amount;
   }
   get type() {
     warnOnce("deprecated: type");
     return "blockMove";
   }
   get family() {
-    return __privateGet(this, _quantumWithAmount).quantum.family ?? void 0;
+    return this.#quantumWithAmount.quantum.family ?? void 0;
   }
   get outerLayer() {
-    return __privateGet(this, _quantumWithAmount).quantum.outerLayer ?? void 0;
+    return this.#quantumWithAmount.quantum.outerLayer ?? void 0;
   }
   get innerLayer() {
-    return __privateGet(this, _quantumWithAmount).quantum.innerLayer ?? void 0;
+    return this.#quantumWithAmount.quantum.innerLayer ?? void 0;
   }
   toString() {
     if (this.family === "_SLASH_") {
       return "/";
     }
     if (this.family.endsWith("_PLUS_")) {
-      return __privateGet(this, _quantumWithAmount).quantum.toString().slice(0, -6) + Math.abs(this.amount) + (this.amount < 0 ? "-" : "+");
+      return this.#quantumWithAmount.quantum.toString().slice(0, -6) + Math.abs(this.amount) + (this.amount < 0 ? "-" : "+");
     }
     if (this.family.endsWith("_PLUSPLUS_")) {
       const absAmount = Math.abs(this.amount);
-      return __privateGet(this, _quantumWithAmount).quantum.toString().slice(0, -10) + (absAmount === 1 ? "" : absAmount) + (this.amount < 0 ? "--" : "++");
+      return this.#quantumWithAmount.quantum.toString().slice(0, -10) + (absAmount === 1 ? "" : absAmount) + (this.amount < 0 ? "--" : "++");
     }
-    return __privateGet(this, _quantumWithAmount).quantum.toString() + __privateGet(this, _quantumWithAmount).suffix();
+    return this.#quantumWithAmount.quantum.toString() + this.#quantumWithAmount.suffix();
   }
 };
-var Move = _Move;
-_quantumWithAmount = new WeakMap();
 
 // src/cubing/alg/alg-nodes/containers/Grouping.ts
 var Square1TupleFormatter = class {
@@ -763,7 +842,9 @@ var Square1TupleFormatter = class {
       const [U, D] = quantumAlg.childAlgNodes();
       if (U.as(Move)?.quantum.isIdentical(this.quantumU_SQ_) && D.as(Move)?.quantum.isIdentical(this.quantumD_SQ_)) {
         if (grouping.amount !== 1) {
-          throw new Error("Square-1 tuples cannot have an amount other than 1.");
+          throw new Error(
+            "Square-1 tuples cannot have an amount other than 1."
+          );
         }
         return [U, D];
       }
@@ -772,50 +853,50 @@ var Square1TupleFormatter = class {
   }
 };
 var square1TupleFormatterInstance = new Square1TupleFormatter();
-var _quantumWithAmount2;
-var _Grouping = class extends AlgCommon {
+var Grouping = class extends AlgCommon {
   constructor(algSource, amount) {
     super();
-    __privateAdd(this, _quantumWithAmount2, void 0);
     const alg = experimentalEnsureAlg(algSource);
-    __privateSet(this, _quantumWithAmount2, new QuantumWithAmount(alg, amount));
+    this.#quantumWithAmount = new QuantumWithAmount(alg, amount);
   }
+  #quantumWithAmount;
   isIdentical(other) {
     const otherAsGrouping = other;
-    return other.is(_Grouping) && __privateGet(this, _quantumWithAmount2).isIdentical(__privateGet(otherAsGrouping, _quantumWithAmount2));
+    return other.is(Grouping) && this.#quantumWithAmount.isIdentical(otherAsGrouping.#quantumWithAmount);
   }
   get alg() {
-    return __privateGet(this, _quantumWithAmount2).quantum;
+    return this.#quantumWithAmount.quantum;
   }
   get amount() {
-    return __privateGet(this, _quantumWithAmount2).amount;
+    return this.#quantumWithAmount.amount;
   }
   get experimentalRepetitionSuffix() {
-    return __privateGet(this, _quantumWithAmount2).suffix();
+    return this.#quantumWithAmount.suffix();
   }
   invert() {
-    return new _Grouping(__privateGet(this, _quantumWithAmount2).quantum, -__privateGet(this, _quantumWithAmount2).amount);
+    return new Grouping(
+      this.#quantumWithAmount.quantum,
+      -this.#quantumWithAmount.amount
+    );
   }
   *experimentalExpand(iterDir = 1 /* Forwards */, depth) {
     depth ?? (depth = Infinity);
     if (depth === 0) {
       yield iterDir === 1 /* Forwards */ ? this : this.invert();
     } else {
-      yield* __privateGet(this, _quantumWithAmount2).experimentalExpand(iterDir, depth - 1);
+      yield* this.#quantumWithAmount.experimentalExpand(iterDir, depth - 1);
     }
   }
   static fromString() {
     throw new Error("unimplemented");
   }
   toString() {
-    return square1TupleFormatterInstance.format(this) ?? `(${__privateGet(this, _quantumWithAmount2).quantum.toString()})${__privateGet(this, _quantumWithAmount2).suffix()}`;
+    return square1TupleFormatterInstance.format(this) ?? `(${this.#quantumWithAmount.quantum.toString()})${this.#quantumWithAmount.suffix()}`;
   }
   experimentalAsSquare1Tuple() {
     return square1TupleFormatterInstance.tuple(this);
   }
 };
-var Grouping = _Grouping;
-_quantumWithAmount2 = new WeakMap();
 
 // src/cubing/alg/is.ts
 function experimentalIs(v, c) {
@@ -866,7 +947,11 @@ var TraversalDownUp = class {
 };
 var TraversalUp = class extends TraversalDownUp {
   traverseAlgNode(algNode) {
-    return dispatch(this, algNode, void 0);
+    return dispatch(
+      this,
+      algNode,
+      void 0
+    );
   }
   traverseIntoAlgNode(algNode) {
     return mustBeAlgNode(this.traverseAlgNode(algNode));
@@ -901,7 +986,10 @@ var _Simplify = class extends TraversalDownUp {
     function appendCollapsed(newAlgNode) {
       if (collapseMoves && lastAlgNode?.is(Move) && newAlgNode.is(Move) && lastAlgNode.quantum.isIdentical(newAlgNode.quantum)) {
         newAlgNodes.pop();
-        if (!appendMoveWithNewAmount(lastAlgNode, newAlgNode.amount)) {
+        if (!appendMoveWithNewAmount(
+          lastAlgNode,
+          newAlgNode.amount
+        )) {
           lastAlgNode = newAlgNodes.slice(-1)[0];
         }
       } else {
@@ -933,7 +1021,10 @@ var _Simplify = class extends TraversalDownUp {
     const newOptions = {
       depth: options.depth ? options.depth - 1 : null
     };
-    const newGrouping = new Grouping(this.traverseAlg(grouping.alg, newOptions), grouping.amount);
+    const newGrouping = new Grouping(
+      this.traverseAlg(grouping.alg, newOptions),
+      grouping.amount
+    );
     const newPlaceholder = __privateMethod(this, _newPlaceholderAssociations, newPlaceholderAssociations_fn).call(this).get(grouping);
     if (newPlaceholder) {
       newGrouping.experimentalNISSPlaceholder = newPlaceholder;
@@ -952,7 +1043,10 @@ var _Simplify = class extends TraversalDownUp {
     const newOptions = {
       depth: options.depth ? options.depth - 1 : null
     };
-    yield new Commutator(this.traverseAlg(commutator.A, newOptions), this.traverseAlg(commutator.B, newOptions));
+    yield new Commutator(
+      this.traverseAlg(commutator.A, newOptions),
+      this.traverseAlg(commutator.B, newOptions)
+    );
   }
   *traverseConjugate(conjugate, options) {
     if (options.depth === 0) {
@@ -962,12 +1056,18 @@ var _Simplify = class extends TraversalDownUp {
     const newOptions = {
       depth: options.depth ? options.depth - 1 : null
     };
-    yield new Conjugate(this.traverseAlg(conjugate.A, newOptions), this.traverseAlg(conjugate.B, newOptions));
+    yield new Conjugate(
+      this.traverseAlg(conjugate.A, newOptions),
+      this.traverseAlg(conjugate.B, newOptions)
+    );
   }
   *traversePause(pause, _options) {
     if (pause.experimentalNISSGrouping) {
       const newPause = new Pause();
-      __privateMethod(this, _newPlaceholderAssociations, newPlaceholderAssociations_fn).call(this).set(pause.experimentalNISSGrouping, newPause);
+      __privateMethod(this, _newPlaceholderAssociations, newPlaceholderAssociations_fn).call(this).set(
+        pause.experimentalNISSGrouping,
+        newPause
+      );
       yield newPause;
     } else {
       yield pause;
@@ -1023,13 +1123,12 @@ function experimentalEnsureAlg(alg) {
   }
   return new Alg(alg);
 }
-var _algNodes;
-var _Alg = class extends AlgCommon {
+var Alg = class extends AlgCommon {
+  #algNodes;
   constructor(alg) {
     super();
-    __privateAdd(this, _algNodes, void 0);
-    __privateSet(this, _algNodes, Array.from(toIterable(alg)));
-    for (const algNode of __privateGet(this, _algNodes)) {
+    this.#algNodes = Array.from(toIterable(alg));
+    for (const algNode of this.#algNodes) {
       if (!experimentalIsAlgNode(algNode)) {
         throw new Error("An alg can only contain alg nodes.");
       }
@@ -1037,11 +1136,11 @@ var _Alg = class extends AlgCommon {
   }
   isIdentical(other) {
     const otherAsAlg = other;
-    if (!other.is(_Alg)) {
+    if (!other.is(Alg)) {
       return false;
     }
-    const l1 = Array.from(__privateGet(this, _algNodes));
-    const l2 = Array.from(__privateGet(otherAsAlg, _algNodes));
+    const l1 = Array.from(this.#algNodes);
+    const l2 = Array.from(otherAsAlg.#algNodes);
     if (l1.length !== l2.length) {
       return false;
     }
@@ -1053,16 +1152,21 @@ var _Alg = class extends AlgCommon {
     return true;
   }
   invert() {
-    return new _Alg(reverse(Array.from(__privateGet(this, _algNodes)).map((u) => u.invert())));
+    return new Alg(reverse(Array.from(this.#algNodes).map((u) => u.invert())));
   }
   *experimentalExpand(iterDir = 1 /* Forwards */, depth) {
     depth ?? (depth = Infinity);
-    for (const algNode of direct(__privateGet(this, _algNodes), iterDir)) {
+    for (const algNode of direct(this.#algNodes, iterDir)) {
       yield* algNode.experimentalExpand(iterDir, depth);
     }
   }
   expand(options) {
-    return new _Alg(this.experimentalExpand(1 /* Forwards */, options?.depth ?? Infinity));
+    return new Alg(
+      this.experimentalExpand(
+        1 /* Forwards */,
+        options?.depth ?? Infinity
+      )
+    );
   }
   *experimentalLeafMoves() {
     for (const leaf of this.experimentalExpand()) {
@@ -1072,10 +1176,12 @@ var _Alg = class extends AlgCommon {
     }
   }
   concat(input) {
-    return new _Alg(Array.from(__privateGet(this, _algNodes)).concat(Array.from(toIterable(input))));
+    return new Alg(
+      Array.from(this.#algNodes).concat(Array.from(toIterable(input)))
+    );
   }
   experimentalIsEmpty() {
-    for (const _ of __privateGet(this, _algNodes)) {
+    for (const _ of this.#algNodes) {
       return false;
     }
     return true;
@@ -1087,7 +1193,7 @@ var _Alg = class extends AlgCommon {
     return this.childAlgNodes();
   }
   *childAlgNodes() {
-    for (const algNode of __privateGet(this, _algNodes)) {
+    for (const algNode of this.#algNodes) {
       yield algNode;
     }
   }
@@ -1095,7 +1201,7 @@ var _Alg = class extends AlgCommon {
     return this.experimentalNumChildAlgNodes();
   }
   experimentalNumChildAlgNodes() {
-    return Array.from(__privateGet(this, _algNodes)).length;
+    return Array.from(this.#algNodes).length;
   }
   get type() {
     warnOnce("deprecated: type");
@@ -1104,7 +1210,7 @@ var _Alg = class extends AlgCommon {
   toString() {
     let output = "";
     let previousVisibleAlgNode = null;
-    for (const algNode of __privateGet(this, _algNodes)) {
+    for (const algNode of this.#algNodes) {
       if (previousVisibleAlgNode) {
         output += spaceBetween(previousVisibleAlgNode, algNode);
       }
@@ -1123,11 +1229,9 @@ var _Alg = class extends AlgCommon {
     return output;
   }
   simplify(options) {
-    return new _Alg(simplify(this, options ?? {}));
+    return new Alg(simplify(this, options ?? {}));
   }
 };
-var Alg = _Alg;
-_algNodes = new WeakMap();
 function spaceBetween(u1, u2) {
   if (u1.is(Newline) || u2.is(Newline)) {
     return "";
@@ -1162,9 +1266,12 @@ var Example = {
     new Move("R", -1)
   ]),
   SuneCommutator: new Alg([
-    new Commutator(new Alg([new Move("R", 1), new Move("U", 1), new Move("R", -2)]), new Alg([
-      new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
-    ]))
+    new Commutator(
+      new Alg([new Move("R", 1), new Move("U", 1), new Move("R", -2)]),
+      new Alg([
+        new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
+      ])
+    )
   ]),
   Niklas: new Alg([
     new Move("R", 1),
@@ -1178,23 +1285,44 @@ var Example = {
   ]),
   EPerm: new Alg([
     new Move("x", -1),
-    new Commutator(new Alg([
-      new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", -1)]))
-    ]), new Alg([new Move("D", 1)])),
-    new Commutator(new Alg([
-      new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
-    ]), new Alg([new Move("D", 1)])),
+    new Commutator(
+      new Alg([
+        new Conjugate(
+          new Alg([new Move("R", 1)]),
+          new Alg([new Move("U", -1)])
+        )
+      ]),
+      new Alg([new Move("D", 1)])
+    ),
+    new Commutator(
+      new Alg([
+        new Conjugate(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
+      ]),
+      new Alg([new Move("D", 1)])
+    ),
     new Move("x", 1)
   ]),
   FURURFCompact: new Alg([
-    new Conjugate(new Alg([new Move("F", 1)]), new Alg([
-      new Commutator(new Alg([new Move("U", 1)]), new Alg([new Move("R", 1)]))
-    ]))
+    new Conjugate(
+      new Alg([new Move("F", 1)]),
+      new Alg([
+        new Commutator(
+          new Alg([new Move("U", 1)]),
+          new Alg([new Move("R", 1)])
+        )
+      ])
+    )
   ]),
   APermCompact: new Alg([
-    new Conjugate(new Alg([new Move("R", 2)]), new Alg([
-      new Commutator(new Alg([new Move("F", 2)]), new Alg([new Move("R", -1), new Move("B", -1), new Move("R", 1)]))
-    ]))
+    new Conjugate(
+      new Alg([new Move("R", 2)]),
+      new Alg([
+        new Commutator(
+          new Alg([new Move("F", 2)]),
+          new Alg([new Move("R", -1), new Move("B", -1), new Move("R", 1)])
+        )
+      ])
+    )
   ]),
   FURURFMoves: new Alg([
     new Move("F", 1),
@@ -1221,11 +1349,20 @@ var Example = {
     new Move("F", -1)
   ]),
   HeadlightSwaps: new Alg([
-    new Conjugate(new Alg([new Move("F", 1)]), new Alg([
-      new Grouping(new Alg([
-        new Commutator(new Alg([new Move("R", 1)]), new Alg([new Move("U", 1)]))
-      ]), 3)
-    ]))
+    new Conjugate(
+      new Alg([new Move("F", 1)]),
+      new Alg([
+        new Grouping(
+          new Alg([
+            new Commutator(
+              new Alg([new Move("R", 1)]),
+              new Alg([new Move("U", 1)])
+            )
+          ]),
+          3
+        )
+      ])
+    )
   ]),
   TriplePause: new Alg([new Pause(), new Pause(), new Pause()])
 };
@@ -1260,7 +1397,8 @@ var cubeKeyMapping = {
   80: new Move("z"),
   81: new Move("z'"),
   90: new Move("M'"),
-  190: new Move("M'")
+  190: new Move("M'"),
+  192: new Pause()
 };
 function keyToMove(e) {
   if (e.altKey || e.ctrlKey) {
@@ -1277,7 +1415,7 @@ function serializeURLParam(a) {
   escaped = escaped.replace(/-/g, "&#45;").replace(/'/g, "-");
   return escaped;
 }
-function algCubingNetLink(options) {
+function experimentalAlgCubingNetLink(options) {
   const url = new URL("https://alg.cubing.net");
   if (!options.alg) {
     throw new Error("An alg parameter is required.");
@@ -1394,7 +1532,7 @@ export {
   Alg,
   Example,
   keyToMove,
-  algCubingNetLink,
+  experimentalAlgCubingNetLink,
   experimentalAppendMove
 };
-//# sourceMappingURL=chunk-GXZIBFSN.js.map
+//# sourceMappingURL=chunk-NI7U4XAZ.js.map