cubing 0.26.7 → 0.28.1

package/dist/esm/{chunk-FCB447RN.js → chunk-CSBUJ64Q.js}

@@ -33,11 +33,6 @@ var AlgCommon = class extends Comparable {
 };
 
 // src/cubing/alg/iteration.ts
-var IterationDirection = /* @__PURE__ */ ((IterationDirection3) => {
-  IterationDirection3[IterationDirection3["Forwards"] = 1] = "Forwards";
-  IterationDirection3[IterationDirection3["Backwards"] = -1] = "Backwards";
-  return IterationDirection3;
-})(IterationDirection || {});
 function toggleDirection(iterationDirection, flip = true) {
   if (!flip) {
     return iterationDirection;
@@ -70,32 +65,42 @@ var MAX_INT_DESCRIPTION = "2^31 - 1";
 var MIN_INT = -2147483648;
 
 // src/cubing/alg/AlgBuilder.ts
-var _units;
+var _algNode;
 var AlgBuilder = class {
   constructor() {
-    __privateAdd(this, _units, []);
+    __privateAdd(this, _algNode, []);
   }
   push(u) {
-    __privateGet(this, _units).push(u);
+    __privateGet(this, _algNode).push(u);
   }
   experimentalPushAlg(alg) {
-    for (const u of alg.units()) {
+    for (const u of alg.childAlgNodes()) {
       this.push(u);
     }
   }
-  experimentalNumUnits() {
-    return __privateGet(this, _units).length;
+  experimentalNumAlgNodes() {
+    return __privateGet(this, _algNode).length;
   }
   toAlg() {
-    return new Alg(__privateGet(this, _units));
+    return new Alg(__privateGet(this, _algNode));
   }
   reset() {
-    __privateSet(this, _units, []);
+    __privateSet(this, _algNode, []);
   }
 };
-_units = new WeakMap();
+_algNode = new WeakMap();
+
+// src/cubing/alg/debug.ts
+var algDebugGlobals = {
+  caratNISSNotationEnabled: false
+};
+function setAlgDebug(options) {
+  if ("caratNISSNotationEnabled" in options) {
+    algDebugGlobals.caratNISSNotationEnabled = !!options.caratNISSNotationEnabled;
+  }
+}
 
-// src/cubing/alg/units/containers/Commutator.ts
+// src/cubing/alg/alg-nodes/containers/Commutator.ts
 var _A, _B;
 var _Commutator = class extends AlgCommon {
   constructor(aSource, bSource) {
@@ -144,7 +149,7 @@ var Commutator = _Commutator;
 _A = new WeakMap();
 _B = new WeakMap();
 
-// src/cubing/alg/units/containers/Conjugate.ts
+// src/cubing/alg/alg-nodes/containers/Conjugate.ts
 var _A2, _B2;
 var _Conjugate = class extends AlgCommon {
   constructor(aSource, bSource) {
@@ -185,7 +190,7 @@ var Conjugate = _Conjugate;
 _A2 = new WeakMap();
 _B2 = new WeakMap();
 
-// src/cubing/alg/units/leaves/LineComment.ts
+// src/cubing/alg/alg-nodes/leaves/LineComment.ts
 var _text;
 var _LineComment = class extends AlgCommon {
   constructor(commentText) {
@@ -216,7 +221,7 @@ var _LineComment = class extends AlgCommon {
 var LineComment = _LineComment;
 _text = new WeakMap();
 
-// src/cubing/alg/units/leaves/Newline.ts
+// src/cubing/alg/alg-nodes/leaves/Newline.ts
 var Newline = class extends AlgCommon {
   toString() {
     return `
@@ -233,7 +238,7 @@ var Newline = class extends AlgCommon {
   }
 };
 
-// src/cubing/alg/units/leaves/Pause.ts
+// src/cubing/alg/alg-nodes/leaves/Pause.ts
 var Pause = class extends AlgCommon {
   toString() {
     return `.`;
@@ -249,16 +254,16 @@ var Pause = class extends AlgCommon {
   }
 };
 
-// src/cubing/alg/parse.ts
+// src/cubing/alg/parseAlg.ts
 function parseIntWithEmptyFallback(n, emptyFallback) {
   return n ? parseInt(n) : emptyFallback;
 }
-var amountRegex = /^(\d+)?('?)/;
-var moveStartRegex = /^[_\dA-Za-z]/;
-var quantumMoveRegex = /^((([1-9]\d*)-)?([1-9]\d*))?([_A-Za-z]+)?/;
-var commentTextRegex = /^[^\n]*/;
-var square1PairStart = /^(-?\d+), ?/;
-var square1PairEnd = /^(-?\d+)\)/;
+var AMOUNT_REGEX = /^(\d+)?('?)/;
+var MOVE_START_REGEX = /^[_\dA-Za-z]/;
+var QUANTUM_MOVE_REGEX = /^((([1-9]\d*)-)?([1-9]\d*))?([_A-Za-z]+)?/;
+var COMMENT_TEXT_REGEX = /^[^\n]*/;
+var SQUARE1_PAIR_START_REGEX = /^(-?\d+), ?/;
+var SQUARE1_PAIR_END_REGEX = /^(-?\d+)\)/;
 function parseAlg(s) {
   return new AlgParser().parseAlg(s);
 }
@@ -283,18 +288,28 @@ function transferCharIndex(from, to) {
   }
   return to;
 }
-var _input, _idx;
+var _input, _idx, _nissQueue;
 var AlgParser = class {
   constructor() {
     __privateAdd(this, _input, "");
     __privateAdd(this, _idx, 0);
+    __privateAdd(this, _nissQueue, []);
   }
   parseAlg(input) {
     __privateSet(this, _input, input);
     __privateSet(this, _idx, 0);
     const alg = this.parseAlgWithStopping([]);
     this.mustBeAtEndOfInput();
-    return alg;
+    const algNodes = Array.from(alg.childAlgNodes());
+    if (__privateGet(this, _nissQueue).length > 0) {
+      for (const nissGrouping of __privateGet(this, _nissQueue).reverse()) {
+        algNodes.push(nissGrouping);
+      }
+    }
+    const newAlg = new Alg(algNodes);
+    const { startCharIndex, endCharIndex } = alg;
+    addCharIndices(newAlg, startCharIndex, endCharIndex);
+    return newAlg;
   }
   parseMove(input) {
     __privateSet(this, _input, input);
@@ -333,11 +348,11 @@ var AlgParser = class {
         }
         if (this.tryConsumeNext(" ")) {
           crowded = false;
-          if (algBuilder.experimentalNumUnits() === 0) {
+          if (algBuilder.experimentalNumAlgNodes() === 0) {
             algStartIdx = __privateGet(this, _idx);
           }
           continue mainLoop;
-        } else if (moveStartRegex.test(__privateGet(this, _input)[__privateGet(this, _idx)])) {
+        } else if (MOVE_START_REGEX.test(__privateGet(this, _input)[__privateGet(this, _idx)])) {
           mustNotBeCrowded(savedCharIndex);
           const move = this.parseMoveImpl();
           algBuilder.push(move);
@@ -346,11 +361,11 @@ var AlgParser = class {
           continue mainLoop;
         } else if (this.tryConsumeNext("(")) {
           mustNotBeCrowded(savedCharIndex);
-          const sq1PairStartMatch = this.tryRegex(square1PairStart);
+          const sq1PairStartMatch = this.tryRegex(SQUARE1_PAIR_START_REGEX);
           if (sq1PairStartMatch) {
             const topAmountString = sq1PairStartMatch[1];
             const savedCharIndexD = __privateGet(this, _idx);
-            const sq1PairEndMatch = this.parseRegex(square1PairEnd);
+            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);
@@ -367,6 +382,19 @@ var AlgParser = class {
             algEndIdx = __privateGet(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.");
+          }
+          this.mustConsumeNext("(");
+          const alg = this.parseAlgWithStopping([")"]);
+          this.popNext();
+          const grouping = new Grouping(alg, -1);
+          const placeholder = new Pause();
+          grouping.experimentalNISSPlaceholder = placeholder;
+          placeholder.experimentalNISSGrouping = grouping;
+          __privateGet(this, _nissQueue).push(grouping);
+          algBuilder.push(placeholder);
         } else if (this.tryConsumeNext("[")) {
           mustNotBeCrowded(savedCharIndex);
           const A = this.parseAlgWithStopping([",", ":"]);
@@ -395,7 +423,7 @@ var AlgParser = class {
         } else if (this.tryConsumeNext("/")) {
           if (this.tryConsumeNext("/")) {
             mustNotBeCrowded(savedCharIndex);
-            const [text] = this.parseRegex(commentTextRegex);
+            const [text] = this.parseRegex(COMMENT_TEXT_REGEX);
             algBuilder.push(addCharIndices(new LineComment(text), savedCharIndex, __privateGet(this, _idx)));
             crowded = false;
             algEndIdx = __privateGet(this, _idx);
@@ -425,7 +453,7 @@ var AlgParser = class {
     return addCharIndices(algBuilder.toAlg(), algStartIdx, algEndIdx);
   }
   parseQuantumMoveImpl() {
-    const [, , , outerLayerStr, innerLayerStr, family] = this.parseRegex(quantumMoveRegex);
+    const [, , , outerLayerStr, innerLayerStr, family] = this.parseRegex(QUANTUM_MOVE_REGEX);
     return new QuantumMove(family, parseIntWithEmptyFallback(innerLayerStr, void 0), parseIntWithEmptyFallback(outerLayerStr, void 0));
   }
   parseMoveImpl() {
@@ -481,7 +509,7 @@ var AlgParser = class {
   }
   parseAmountAndTrackEmptyAbsAmount() {
     const savedIdx = __privateGet(this, _idx);
-    const [, absAmountStr, primeStr] = this.parseRegex(amountRegex);
+    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.`);
     }
@@ -492,7 +520,7 @@ var AlgParser = class {
   }
   parseAmount() {
     const savedIdx = __privateGet(this, _idx);
-    const [, absAmountStr, primeStr] = this.parseRegex(amountRegex);
+    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.`);
     }
@@ -539,6 +567,7 @@ var AlgParser = class {
 };
 _input = new WeakMap();
 _idx = new WeakMap();
+_nissQueue = new WeakMap();
 
 // src/cubing/alg/warnOnce.ts
 var warned = /* @__PURE__ */ new Set();
@@ -549,13 +578,13 @@ function warnOnce(s) {
   }
 }
 
-// src/cubing/alg/units/QuantumWithAmount.ts
+// src/cubing/alg/alg-nodes/QuantumWithAmount.ts
 var QuantumWithAmount = class {
   constructor(quantum, amount = 1) {
     this.quantum = quantum;
     this.amount = amount;
     if (!Number.isInteger(this.amount) || this.amount < MIN_INT || this.amount > MAX_INT) {
-      throw new Error(`Unit amount absolute value must be a non-negative integer from ${MAX_INT_DESCRIPTION} to ${MAX_INT_DESCRIPTION}.`);
+      throw new Error(`AlgNode amount absolute value must be a non-negative integer below ${MAX_INT_DESCRIPTION}.`);
     }
   }
   suffix() {
@@ -581,7 +610,7 @@ var QuantumWithAmount = class {
   }
 };
 
-// src/cubing/alg/units/leaves/Move.ts
+// src/cubing/alg/alg-nodes/leaves/Move.ts
 var _family, _innerLayer, _outerLayer;
 var _QuantumMove = class extends Comparable {
   constructor(family, innerLayer, outerLayer) {
@@ -716,7 +745,7 @@ var _Move = class extends AlgCommon {
 var Move = _Move;
 _quantumWithAmount = new WeakMap();
 
-// src/cubing/alg/units/containers/Grouping.ts
+// src/cubing/alg/alg-nodes/containers/Grouping.ts
 var Square1TupleFormatter = class {
   constructor() {
     this.quantumU_SQ_ = null;
@@ -733,8 +762,8 @@ var Square1TupleFormatter = class {
     this.quantumU_SQ_ || (this.quantumU_SQ_ = new QuantumMove("U_SQ_"));
     this.quantumD_SQ_ || (this.quantumD_SQ_ = new QuantumMove("D_SQ_"));
     const quantumAlg = grouping.alg;
-    if (quantumAlg.experimentalNumUnits() === 2) {
-      const [U, D] = quantumAlg.units();
+    if (quantumAlg.experimentalNumChildAlgNodes() === 2) {
+      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.");
@@ -795,66 +824,71 @@ _quantumWithAmount2 = new WeakMap();
 function experimentalIs(v, c) {
   return v instanceof c;
 }
-function experimentalIsUnit(v) {
+function experimentalIsAlgNode(v) {
   return experimentalIs(v, Grouping) || experimentalIs(v, LineComment) || experimentalIs(v, Commutator) || experimentalIs(v, Conjugate) || experimentalIs(v, Move) || experimentalIs(v, Newline) || experimentalIs(v, Pause);
 }
 
 // src/cubing/alg/traversal.ts
-function dispatch(t, unit, dataDown) {
-  if (unit.is(Grouping)) {
-    return t.traverseGrouping(unit, dataDown);
+function dispatch(t, algNode, dataDown) {
+  if (algNode.is(Grouping)) {
+    return t.traverseGrouping(algNode, dataDown);
   }
-  if (unit.is(Move)) {
-    return t.traverseMove(unit, dataDown);
+  if (algNode.is(Move)) {
+    return t.traverseMove(algNode, dataDown);
   }
-  if (unit.is(Commutator)) {
-    return t.traverseCommutator(unit, dataDown);
+  if (algNode.is(Commutator)) {
+    return t.traverseCommutator(algNode, dataDown);
   }
-  if (unit.is(Conjugate)) {
-    return t.traverseConjugate(unit, dataDown);
+  if (algNode.is(Conjugate)) {
+    return t.traverseConjugate(algNode, dataDown);
   }
-  if (unit.is(Pause)) {
-    return t.traversePause(unit, dataDown);
+  if (algNode.is(Pause)) {
+    return t.traversePause(algNode, dataDown);
   }
-  if (unit.is(Newline)) {
-    return t.traverseNewline(unit, dataDown);
+  if (algNode.is(Newline)) {
+    return t.traverseNewline(algNode, dataDown);
   }
-  if (unit.is(LineComment)) {
-    return t.traverseLineComment(unit, dataDown);
+  if (algNode.is(LineComment)) {
+    return t.traverseLineComment(algNode, dataDown);
   }
-  throw new Error(`unknown unit`);
+  throw new Error(`unknown AlgNode`);
 }
-function assertIsUnit(t) {
+function mustBeAlgNode(t) {
   if (t.is(Grouping) || t.is(Move) || t.is(Commutator) || t.is(Conjugate) || t.is(Pause) || t.is(Newline) || t.is(LineComment)) {
     return t;
   }
-  throw new Error("internal error: expected unit");
+  throw new Error("internal error: expected AlgNode");
 }
 var TraversalDownUp = class {
-  traverseUnit(unit, dataDown) {
-    return dispatch(this, unit, dataDown);
+  traverseAlgNode(algNode, dataDown) {
+    return dispatch(this, algNode, dataDown);
   }
-  traverseIntoUnit(unit, dataDown) {
-    return assertIsUnit(this.traverseUnit(unit, dataDown));
+  traverseIntoAlgNode(algNode, dataDown) {
+    return mustBeAlgNode(this.traverseAlgNode(algNode, dataDown));
   }
 };
 var TraversalUp = class extends TraversalDownUp {
-  traverseUnit(unit) {
-    return dispatch(this, unit, void 0);
+  traverseAlgNode(algNode) {
+    return dispatch(this, algNode, void 0);
   }
-  traverseIntoUnit(unit) {
-    return assertIsUnit(this.traverseUnit(unit));
+  traverseIntoAlgNode(algNode) {
+    return mustBeAlgNode(this.traverseAlgNode(algNode));
   }
 };
-var _newAmount, newAmount_fn;
+var _newPlaceholderAssociationsMap, _newPlaceholderAssociations, newPlaceholderAssociations_fn, _newAmount, newAmount_fn;
 var _Simplify = class extends TraversalDownUp {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _newPlaceholderAssociations);
+    __privateAdd(this, _newPlaceholderAssociationsMap, void 0);
+  }
   *traverseAlg(alg, options) {
     if (options.depth === 0) {
-      yield* alg.units();
+      yield* alg.childAlgNodes();
       return;
     }
-    const newUnits = [];
-    let lastUnit = null;
+    const newAlgNodes = [];
+    let lastAlgNode = null;
     const collapseMoves = options?.collapseMoves ?? true;
     function appendMoveWithNewAmount(move, deltaAmount) {
       var _a;
@@ -863,35 +897,35 @@ var _Simplify = class extends TraversalDownUp {
         return false;
       }
       const newMove = new Move(move.quantum, newAmount);
-      newUnits.push(newMove);
-      lastUnit = newMove;
+      newAlgNodes.push(newMove);
+      lastAlgNode = newMove;
       return true;
     }
-    function appendCollapsed(newUnit) {
-      if (collapseMoves && lastUnit?.is(Move) && newUnit.is(Move) && lastUnit.quantum.isIdentical(newUnit.quantum)) {
-        newUnits.pop();
-        if (!appendMoveWithNewAmount(lastUnit, newUnit.amount)) {
-          lastUnit = newUnits.slice(-1)[0];
+    function appendCollapsed(newAlgNode) {
+      if (collapseMoves && lastAlgNode?.is(Move) && newAlgNode.is(Move) && lastAlgNode.quantum.isIdentical(newAlgNode.quantum)) {
+        newAlgNodes.pop();
+        if (!appendMoveWithNewAmount(lastAlgNode, newAlgNode.amount)) {
+          lastAlgNode = newAlgNodes.slice(-1)[0];
         }
       } else {
-        if (newUnit.is(Move)) {
-          appendMoveWithNewAmount(newUnit, 0);
+        if (newAlgNode.is(Move)) {
+          appendMoveWithNewAmount(newAlgNode, 0);
         } else {
-          newUnits.push(newUnit);
-          lastUnit = newUnit;
+          newAlgNodes.push(newAlgNode);
+          lastAlgNode = newAlgNode;
         }
       }
     }
     const newOptions = {
       depth: options.depth ? options.depth - 1 : null
     };
-    for (const unit of alg.units()) {
-      for (const ancestorUnit of this.traverseUnit(unit, newOptions)) {
-        appendCollapsed(ancestorUnit);
+    for (const algNode of alg.childAlgNodes()) {
+      for (const ancestorAlgNode of this.traverseAlgNode(algNode, newOptions)) {
+        appendCollapsed(ancestorAlgNode);
       }
     }
-    for (const unit of newUnits) {
-      yield unit;
+    for (const newAlgNode of newAlgNodes) {
+      yield newAlgNode;
     }
   }
   *traverseGrouping(grouping, options) {
@@ -902,7 +936,13 @@ var _Simplify = class extends TraversalDownUp {
     const newOptions = {
       depth: options.depth ? options.depth - 1 : null
     };
-    yield new Grouping(this.traverseAlg(grouping.alg, newOptions));
+    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;
+      newPlaceholder.experimentalNISSGrouping = newGrouping;
+    }
+    yield newGrouping;
   }
   *traverseMove(move, _options) {
     yield move;
@@ -928,7 +968,13 @@ var _Simplify = class extends TraversalDownUp {
     yield new Conjugate(this.traverseAlg(conjugate.A, newOptions), this.traverseAlg(conjugate.B, newOptions));
   }
   *traversePause(pause, _options) {
-    yield pause;
+    if (pause.experimentalNISSGrouping) {
+      const newPause = new Pause();
+      __privateMethod(this, _newPlaceholderAssociations, newPlaceholderAssociations_fn).call(this).set(pause.experimentalNISSGrouping, newPause);
+      yield newPause;
+    } else {
+      yield pause;
+    }
   }
   *traverseNewline(newline, _options) {
     yield newline;
@@ -938,6 +984,11 @@ var _Simplify = class extends TraversalDownUp {
   }
 };
 var Simplify = _Simplify;
+_newPlaceholderAssociationsMap = new WeakMap();
+_newPlaceholderAssociations = new WeakSet();
+newPlaceholderAssociations_fn = function() {
+  return __privateGet(this, _newPlaceholderAssociationsMap) ?? __privateSet(this, _newPlaceholderAssociationsMap, /* @__PURE__ */ new Map());
+};
 _newAmount = new WeakSet();
 newAmount_fn = function(move, deltaAmount, options) {
   let newAmount = move.amount + deltaAmount;
@@ -958,16 +1009,16 @@ function toIterable(input) {
     return [];
   }
   if (experimentalIs(input, Alg)) {
-    return input.units();
+    return input.childAlgNodes();
   }
   if (typeof input === "string") {
-    return parseAlg(input).units();
+    return parseAlg(input).childAlgNodes();
   }
   const iter = input;
   if (typeof iter[Symbol.iterator] === "function") {
     return iter;
   }
-  throw new Error("Invalid unit");
+  throw new Error("Invalid AlgNode");
 }
 function experimentalEnsureAlg(alg) {
   if (experimentalIs(alg, Alg)) {
@@ -975,15 +1026,15 @@ function experimentalEnsureAlg(alg) {
   }
   return new Alg(alg);
 }
-var _units2;
+var _algNodes;
 var _Alg = class extends AlgCommon {
   constructor(alg) {
     super();
-    __privateAdd(this, _units2, void 0);
-    __privateSet(this, _units2, Array.from(toIterable(alg)));
-    for (const unit of __privateGet(this, _units2)) {
-      if (!experimentalIsUnit(unit)) {
-        throw new Error("An alg can only contain units.");
+    __privateAdd(this, _algNodes, void 0);
+    __privateSet(this, _algNodes, Array.from(toIterable(alg)));
+    for (const algNode of __privateGet(this, _algNodes)) {
+      if (!experimentalIsAlgNode(algNode)) {
+        throw new Error("An alg can only contain alg nodes.");
       }
     }
   }
@@ -992,8 +1043,8 @@ var _Alg = class extends AlgCommon {
     if (!other.is(_Alg)) {
       return false;
     }
-    const l1 = Array.from(__privateGet(this, _units2));
-    const l2 = Array.from(__privateGet(otherAsAlg, _units2));
+    const l1 = Array.from(__privateGet(this, _algNodes));
+    const l2 = Array.from(__privateGet(otherAsAlg, _algNodes));
     if (l1.length !== l2.length) {
       return false;
     }
@@ -1005,12 +1056,12 @@ var _Alg = class extends AlgCommon {
     return true;
   }
   invert() {
-    return new _Alg(reverse(Array.from(__privateGet(this, _units2)).map((u) => u.invert())));
+    return new _Alg(reverse(Array.from(__privateGet(this, _algNodes)).map((u) => u.invert())));
   }
   *experimentalExpand(iterDir = 1 /* Forwards */, depth) {
     depth ?? (depth = Infinity);
-    for (const unit of direct(__privateGet(this, _units2), iterDir)) {
-      yield* unit.experimentalExpand(iterDir, depth);
+    for (const algNode of direct(__privateGet(this, _algNodes), iterDir)) {
+      yield* algNode.experimentalExpand(iterDir, depth);
     }
   }
   expand(options) {
@@ -1024,10 +1075,10 @@ var _Alg = class extends AlgCommon {
     }
   }
   concat(input) {
-    return new _Alg(Array.from(__privateGet(this, _units2)).concat(Array.from(toIterable(input))));
+    return new _Alg(Array.from(__privateGet(this, _algNodes)).concat(Array.from(toIterable(input))));
   }
   experimentalIsEmpty() {
-    for (const _ of __privateGet(this, _units2)) {
+    for (const _ of __privateGet(this, _algNodes)) {
       return false;
     }
     return true;
@@ -1035,13 +1086,19 @@ var _Alg = class extends AlgCommon {
   static fromString(s) {
     return parseAlg(s);
   }
-  *units() {
-    for (const unit of __privateGet(this, _units2)) {
-      yield unit;
+  units() {
+    return this.childAlgNodes();
+  }
+  *childAlgNodes() {
+    for (const algNode of __privateGet(this, _algNodes)) {
+      yield algNode;
     }
   }
   experimentalNumUnits() {
-    return Array.from(__privateGet(this, _units2)).length;
+    return this.experimentalNumChildAlgNodes();
+  }
+  experimentalNumChildAlgNodes() {
+    return Array.from(__privateGet(this, _algNodes)).length;
   }
   get type() {
     warnOnce("deprecated: type");
@@ -1049,13 +1106,22 @@ var _Alg = class extends AlgCommon {
   }
   toString() {
     let output = "";
-    let previousUnit = null;
-    for (const unit of __privateGet(this, _units2)) {
-      if (previousUnit) {
-        output += spaceBetween(previousUnit, unit);
+    let previousVisibleAlgNode = null;
+    for (const algNode of __privateGet(this, _algNodes)) {
+      if (previousVisibleAlgNode) {
+        output += spaceBetween(previousVisibleAlgNode, algNode);
       }
-      output += unit.toString();
-      previousUnit = unit;
+      const nissGrouping = algNode.as(Pause)?.experimentalNISSGrouping;
+      if (nissGrouping) {
+        if (nissGrouping.amount !== -1) {
+          throw new Error("Invalid NISS Grouping amount!");
+        }
+        output += `^(${nissGrouping.alg.toString()})`;
+      } else if (algNode.as(Grouping)?.experimentalNISSPlaceholder) {
+      } else {
+        output += algNode.toString();
+      }
+      previousVisibleAlgNode = algNode;
     }
     return output;
   }
@@ -1064,11 +1130,14 @@ var _Alg = class extends AlgCommon {
   }
 };
 var Alg = _Alg;
-_units2 = new WeakMap();
+_algNodes = new WeakMap();
 function spaceBetween(u1, u2) {
   if (u1.is(Newline) || u2.is(Newline)) {
     return "";
   }
+  if (u2.as(Grouping)?.experimentalNISSPlaceholder) {
+    return "";
+  }
   if (u1.is(LineComment) && !u2.is(Newline)) {
     return "\n";
   }
@@ -1211,7 +1280,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.");
@@ -1288,10 +1357,10 @@ function algCubingNetLink(options) {
 
 // src/cubing/alg/operation.ts
 function experimentalAppendMove(alg, newMove, options) {
-  const oldUnits = Array.from(alg.units());
-  const oldLastMove = oldUnits[oldUnits.length - 1];
+  const oldAlgNodes = Array.from(alg.childAlgNodes());
+  const oldLastMove = oldAlgNodes[oldAlgNodes.length - 1];
   if (options?.coalesce && oldLastMove && oldLastMove.quantum && oldLastMove.quantum.isIdentical(newMove.quantum)) {
-    const newUnits = oldUnits.slice(0, oldUnits.length - 1);
+    const newAlgNodes = oldAlgNodes.slice(0, oldAlgNodes.length - 1);
     let newAmount = oldLastMove.amount + newMove.amount;
     const mod = options?.mod;
     if (mod) {
@@ -1301,19 +1370,19 @@ function experimentalAppendMove(alg, newMove, options) {
       }
     }
     if (newAmount !== 0) {
-      newUnits.push(oldLastMove.modified({ amount: newAmount }));
+      newAlgNodes.push(oldLastMove.modified({ amount: newAmount }));
     }
-    return new Alg(newUnits);
+    return new Alg(newAlgNodes);
   } else {
-    return new Alg([...oldUnits, newMove]);
+    return new Alg([...oldAlgNodes, newMove]);
   }
 }
 
 export {
-  IterationDirection,
   direct,
   directedGenerator,
   AlgBuilder,
+  setAlgDebug,
   Commutator,
   Conjugate,
   LineComment,
@@ -1328,7 +1397,7 @@ export {
   Alg,
   Example,
   keyToMove,
-  algCubingNetLink,
+  experimentalAlgCubingNetLink,
   experimentalAppendMove
 };
-//# sourceMappingURL=chunk-FCB447RN.js.map
+//# sourceMappingURL=chunk-CSBUJ64Q.js.map