@helping-ai-workflow/md2doc 3.12.1 → 3.13.1

package/lib/editor/wave-codec.js

@@ -452,7 +452,7 @@ function parseWord(st) {
  * characters, so a write-back that re-serialised or "normalised" a wave string
  * would change the picture the user is looking at.
  *
- * Three kinds of edit:
+ * The kinds of edit:
  *
  *   {path, value} or {op:'set', path, value}
  *       Replace the value at `path`. Refused when nothing is parsed at that
@@ -482,7 +482,33 @@ function parseWord(st) {
  *       so the comment the author wrote beside it travels with it, which a
  *       remove plus an insert cannot do because an insert renders a value and a
  *       value carries no comment. An array the element leaves with no lane in it
- *       goes too, the same rule `removeLane` follows.
+ *       goes too, the same rule `removeLane` follows. The element may be a
+ *       whole group: its title and members are one member's bytes and travel
+ *       together, which is how a group's 上移 / 下移 is written.
+ *
+ *   {op:'wrap', path, count, title}
+ *       Make the `count` elements of one array starting at `path` the members
+ *       of a new group in their place — what `groupLanes` does to a run of
+ *       sibling lanes. Only the group's own syntax is written: `[`, the title
+ *       (a string, or absent for an untitled group) and `]`. Every member keeps
+ *       its bytes, its indentation and the comments beside and above it. The
+ *       title is spelled the way an inserted string is (`dominantQuote`) and
+ *       laid out like its neighbours: when the first member starts its own
+ *       line, the `[` and title get a line of their own at that member's
+ *       indentation, above the comments that belong to it; on a shared line
+ *       they go inline in front of it, spaced like the array's other elements
+ *       (`inlineGap`). The `]` goes straight after the last
+ *       member's value, so the comma that separated that member from what
+ *       follows now separates the group. Only lanes and groups can be wrapped.
+ *
+ *   {op:'unwrap', path}
+ *       The inverse: the group at `path` goes and its members take its place —
+ *       `ungroupLanes`. Removed are the `[`, the title member and the `]`
+ *       (plus a separating comma the members no longer need, or one added after
+ *       the last member when the group had one and it did not), and a line
+ *       those leave holding nothing at all. Members, and every comment
+ *       anywhere — including one written beside the title — stay byte for
+ *       byte. `unwrap` of a `wrap` reads back as the original text.
  *
  *   {op:'replace', path, value}
  *       Replace the value at `path` with a fresh serialization, keeping the key,
@@ -609,6 +635,8 @@ function resolveEdit(ctx, edit) {
   if (op === 'remove') return resolveRemove(ctx, edit);
   if (op === 'move') return resolveMove(ctx, edit);
   if (op === 'replace') return resolveReplace(ctx, edit);
+  if (op === 'wrap') return resolveWrap(ctx, edit);
+  if (op === 'unwrap') return resolveUnwrap(ctx, edit);
   return refuse('unknown edit op ' + JSON.stringify(edit.op), nearestRange(ctx, edit.path));
 }
 
@@ -1125,6 +1153,286 @@ function resolveRemove(ctx, edit) {
   return { ok: true, path: path, start: range[0], end: range[1], text: '' };
 }
 
+/**
+ * Wrap a run of array elements into a new group without touching their bytes.
+ *
+ * Writing the new group as a value would re-serialise every lane in it and drop
+ * the comments the author put beside them; a group is only an array around its
+ * members, so the edit is two insertions — the `[` and title in front of the
+ * run, the `]` behind it — and nothing between them moves. The layout rule for
+ * the title is stated on `patchSource`.
+ */
+function resolveWrap(ctx, edit) {
+  const path = edit.path;
+  if (path.length === 0 || typeof path[path.length - 1] !== 'number') {
+    return refuse('wrap addresses the first of a run of array elements, so its path must end ' +
+      'in a numeric index', nearestRange(ctx, path));
+  }
+  const parentPath = path.slice(0, -1);
+  const parentSpan = ctx.parsed.spans.get(JSON.stringify(parentPath));
+  const parent = lookup(ctx.parsed.doc, parentPath);
+  if (!parentSpan || !parent.found || !Array.isArray(parent.value)) {
+    return refuse('wrap needs an array at ' + JSON.stringify(parentPath), nearestRange(ctx, parentPath));
+  }
+  const first = path[path.length - 1];
+  const count = edit.count;
+  if (!Number.isInteger(first) || !Number.isInteger(count) || first < 0 || count < 1 ||
+      first + count > parent.value.length) {
+    return refuse('wrap needs a run of one or more elements inside the array at ' +
+      JSON.stringify(parentPath) + ', which holds ' + parent.value.length,
+    rangeOf(path, parentPath, parentSpan));
+  }
+  if (edit.title !== undefined && typeof edit.title !== 'string') {
+    return refuse('a group title is a string', rangeOf(path, parentPath, parentSpan));
+  }
+  for (let i = first; i < first + count; i++) {
+    const item = parent.value[i];
+    if (!isLane(item) && !Array.isArray(item)) {
+      return refuse('only lanes and groups can be wrapped into a group, and ' +
+        JSON.stringify(parentPath.concat([i])) + ' is neither (a group title is a string)',
+      rangeOf(path, parentPath, parentSpan));
+    }
+  }
+  if (touchesDuplicateKey(ctx, parentPath)) {
+    return refuse(duplicateWhy(path), rangeOf(path, parentPath, parentSpan));
+  }
+  if (deepestContainerUnder(ctx, parentPath, first, first + count) >= MAX_DEPTH - 1) {
+    return refuse('wrapping these elements would nest something under them past the reader\'s ' +
+      'limit of ' + MAX_DEPTH + ' levels', rangeOf(path, parentPath, parentSpan));
+  }
+  const firstKey = JSON.stringify(path);
+  const lastPath = parentPath.concat([first + count - 1]);
+  const firstMember = ctx.parsed.members.get(firstKey);
+  const lastValue = ctx.parsed.spans.get(JSON.stringify(lastPath));
+  if (!firstMember || !lastValue) {
+    return refuse('no member span for the run starting at ' + firstKey,
+      rangeOf(path, parentPath, parentSpan));
+  }
+  const lead = ctx.parsed.leads.get(firstKey);
+  // Above the comments that belong to the first member, so they stay its own.
+  const at = commentRunStart(ctx.text, lead === undefined ? firstMember[0] : lead, firstMember[0]);
+  let open = '[';
+  if (typeof edit.title === 'string') {
+    const ser = serialize(edit.title, dominantQuote(ctx), MAX_DEPTH - path.length);
+    if (ser.ok !== true) return refuse(ser.why, rangeOf(path, parentPath, parentSpan));
+    const indent = lineIndentBefore(ctx.text, at);
+    open += ser.text + ',' +
+      (indent === null ? inlineGap(ctx, parentPath, first) : lineBreakBefore(ctx.text, at) + indent);
+  }
+  return {
+    ok: true,
+    path: path,
+    parts: [
+      { ok: true, path: path, start: at, end: at, text: open },
+      { ok: true, path: lastPath, start: lastValue[1], end: lastValue[1], text: ']' },
+    ],
+  };
+}
+
+/**
+ * The spaces this array writes after a comma when its elements share a line —
+ * read off the element at `index`, or the second one when `index` is the first
+ * — so a title put in front of an element on a shared line is spaced like its
+ * neighbours: `["", {…}` in a source written `{…}, {…}`, `["",{…}` in compact
+ * JSON. One space when the array has no such gap to read.
+ */
+function inlineGap(ctx, parentPath, index) {
+  const k = JSON.stringify(parentPath.concat([index > 0 ? index : 1]));
+  const lead = ctx.parsed.leads.get(k);
+  const member = ctx.parsed.members.get(k);
+  if (lead === undefined || !member) return ' ';
+  const gap = ctx.text.slice(lead, member[0]);
+  return /^[ \t]*$/.test(gap) ? gap : ' ';
+}
+
+/**
+ * The longest path of any container at or under elements `[from, to)` of the
+ * array at `parentPath` — how deep a wrap around them would push the deepest
+ * thing the reader has to open, measured on the parse rather than recomputed.
+ */
+function deepestContainerUnder(ctx, parentPath, from, to) {
+  let deepest = 0;
+  const heads = [];
+  for (let i = from; i < to; i++) heads.push(JSON.stringify(parentPath.concat([i])));
+  for (const [key, span] of ctx.parsed.spans) {
+    const c = ctx.text[span[0]];
+    if (c !== '{' && c !== '[') continue;
+    for (const head of heads) {
+      if (key === head || key.startsWith(head.slice(0, -1) + ',')) {
+        const depth = JSON.parse(key).length;
+        if (depth > deepest) deepest = depth;
+        break;
+      }
+    }
+  }
+  return deepest;
+}
+
+/**
+ * Dissolve the group at `path` into its parent, members' bytes untouched.
+ *
+ * Two replacements: the opening loses `[`, the title's value and its comma, and
+ * the closing stretch from the last member's value to the end of the group's
+ * own member is rewritten without its `]` — with the separating comma moved to
+ * where the members now need it. A line either of them leaves holding only
+ * whitespace goes with it, so a group written one member per line comes apart
+ * into those same lines. Comments are never deleted here: one that sat beside
+ * the title stays where it was, on its own line.
+ */
+function resolveUnwrap(ctx, edit) {
+  const path = edit.path;
+  if (path.length === 0 || typeof path[path.length - 1] !== 'number') {
+    return refuse('unwrap addresses a group inside an array, so its path must end in a numeric index',
+      nearestRange(ctx, path));
+  }
+  const key = JSON.stringify(path);
+  const member = ctx.parsed.members.get(key);
+  const span = ctx.parsed.spans.get(key);
+  const found = lookup(ctx.parsed.doc, path);
+  if (!member || !span || !found.found) {
+    return refuse('nothing is parsed at ' + key + ', so there is no group to unwrap',
+      nearestRange(ctx, path));
+  }
+  if (!Array.isArray(found.value)) {
+    return refuse('the value at ' + key + ' is not a group, so there is nothing to unwrap',
+      rangeOf(path, path, span));
+  }
+  if (touchesDuplicateKey(ctx, path)) return refuse(duplicateWhy(path), rangeOf(path, path, span));
+  const group = found.value;
+  const titled = group.length > 0 && typeof group[0] === 'string';
+  if (group.length <= (titled ? 1 : 0)) {
+    return refuse('the group at ' + key + ' has no members, so unwrapping it would only delete ' +
+      'it; remove it instead', rangeOf(path, path, span));
+  }
+  const text = ctx.text;
+
+  // The opening: exactly three tokens go — `[`, the title's value and the comma
+  // after it. Whatever sits between them (a comment after `[`, beside the
+  // title, before its comma) stays; `unwrapOpening` decides the whitespace.
+  const deleted = [[span[0], span[0] + 1]];
+  let titleEnd = span[0] + 1;
+  if (titled) {
+    const titlePath = JSON.stringify(path.concat([0]));
+    const title = ctx.parsed.members.get(titlePath);
+    const titleValue = ctx.parsed.spans.get(titlePath);
+    if (!title || !titleValue || text[title[1] - 1] !== ',') {
+      return refuse('no member span for the title of ' + key, rangeOf(path, path, span));
+    }
+    deleted.push(titleValue, [title[1] - 1, title[1]]);
+    titleEnd = title[1];
+  }
+  const opening = unwrapOpening(text, span[0], titleEnd, deleted);
+
+  // The closing: from the last member's value to the end of the group's member.
+  const lastPath = path.concat([group.length - 1]);
+  const lastValue = ctx.parsed.spans.get(JSON.stringify(lastPath));
+  const lastMember = ctx.parsed.members.get(JSON.stringify(lastPath));
+  if (!lastValue || !lastMember) {
+    return refuse('no member span for the last member of ' + key, rangeOf(path, path, span));
+  }
+  const close = span[1] - 1;                          // the group's own `]`
+  const groupHasComma = member[1] > span[1];          // its member runs on past `]` to a comma
+  const lastHasComma = lastMember[1] > lastValue[1];  // likewise for the last member
+  // What sits between the last member's value and `]` (its comma, its comment,
+  // the break before the bracket), and between `]` and the group's comma.
+  let before = text.slice(lastValue[1], close);
+  let after = text.slice(span[1], groupHasComma ? member[1] - 1 : member[1]);
+  let closeEnd = member[1];
+  // The group's comma separated it from what follows; that is now the last
+  // member's job, so it moves to the member when the member had none.
+  if (groupHasComma && !lastHasComma) before = ',' + before;
+  let restEnd = closeEnd;
+  while (text[restEnd] === ' ' || text[restEnd] === '\t') restEnd++;
+  const lineBreak = /(?:\r\n|\r|\n)[ \t]*$/.exec(before);
+  if (lineBreak !== null && /^[ \t]*$/.test(after) &&
+      (restEnd >= text.length || text[restEnd] === '\n' || text[restEnd] === '\r')) {
+    // The `]` line held nothing else: it goes, and the members' last line ends
+    // where the group's line used to.
+    before = before.slice(0, lineBreak.index);
+    after = '';
+    closeEnd = restEnd;
+  } else if (/^,?[ \t]*$/.test(before)) {
+    // `{c}]` or `{c} ], {d}` on one line: of what stood between the value and
+    // the bracket only the comma is worth keeping.
+    before = before[0] === ',' ? ',' : '';
+  }
+  return {
+    ok: true,
+    path: path,
+    parts: [
+      { ok: true, path: path, start: opening.start, end: opening.end, text: opening.text },
+      { ok: true, path: lastPath, start: lastValue[1], end: closeEnd, text: before + after },
+    ],
+  };
+}
+
+/**
+ * The opening half of an unwrap: the text from the start of the `[`'s line (or
+ * the `[` itself, when something precedes it on that line) to just past the
+ * title's comma, its trailing spaces and — when nothing else follows on that
+ * line — its line break, rewritten without the `deleted` ranges.
+ *
+ * Whitespace on either side of a deleted token collapses to the side that was
+ * there first, so `[ /*c*\/ "g", {b}` keeps one space on each side of its
+ * comment. A line the deletions leave holding only whitespace goes, break and
+ * all; on the `[`'s own line when the `[` was not first on it, the break stays
+ * and the spaces before the `[` go instead, so the line before simply ends.
+ * Comments are text like any other here, so none is ever lost.
+ */
+function unwrapOpening(text, bracket, titleEnd, deleted) {
+  const indent = lineIndentBefore(text, bracket);
+  const ownsLine = indent !== null;
+  let start = ownsLine ? bracket - indent.length : bracket;
+  let end = titleEnd;
+  while (text[end] === ' ' || text[end] === '\t') end++;
+  if (text[end] === '\r' && text[end + 1] === '\n') end += 2;
+  else if (text[end] === '\n' || text[end] === '\r') end++;
+  let joined = '';
+  let at = start;
+  for (const cut of deleted) {
+    joined = joinKeep(joined, text.slice(at, cut[0]));
+    at = cut[1];
+  }
+  joined = joinKeep(joined, text.slice(at, end));
+  // Line by line, keeping each line's own break.
+  const lines = [];
+  let from = 0;
+  for (let j = 0; j < joined.length; j++) {
+    if (joined[j] === '\n' || (joined[j] === '\r' && joined[j + 1] !== '\n')) {
+      lines.push(joined.slice(from, j + 1));
+      from = j + 1;
+    }
+  }
+  lines.push(joined.slice(from));
+  let out = '';
+  for (let k = 0; k < lines.length; k++) {
+    const line = lines[k];
+    const body = line.replace(/\r?\n$|\r$/, '');
+    const broken = body.length !== line.length;
+    if (!/^[ \t]*$/.test(body)) {
+      out += line;
+    } else if (k === 0 && !ownsLine) {
+      // The `[`'s own line, with something in front of it. Broken: that line
+      // now ends where its last real character does. Not broken (all on one
+      // line): the spaces before the `[` already separate it from what follows.
+      if (broken) {
+        while (start > 0 && (text[start - 1] === ' ' || text[start - 1] === '\t')) start--;
+        out += line.slice(body.length);
+      }
+    } else if (!broken) {
+      out += line;            // the indentation of whatever follows on that line
+    }
+    // else: a line holding nothing any more, which goes with its break
+  }
+  return { start: start, end: end, text: out };
+}
+
+/** Join two pieces of text that a deleted token stood between. */
+function joinKeep(left, right) {
+  const leftSpace = /[ \t]$/.test(left);
+  return leftSpace ? left + right.replace(/^[ \t]+/, '') : left + right;
+}
+
 /**
  * A key written twice in the same object is legal WaveJSON and the later one
  * wins, which leaves the earlier one's subtree still holding spans that the doc
@@ -2532,8 +2840,9 @@ function moveLane(doc, from, to) {
  * group's LAST lane lands the copy just outside the group (append to `signal`
  * itself), while duplicating any other lane in the group — including its
  * first — keeps the copy inside. That is not a special case written for
- * duplication; it is the same rule the rail's own insert button already
- * surfaces to the user, reached through the same door.
+ * duplication; it is the same rule every lane insert surfaces to the user
+ * (the ⠿ menu's 在下方新增訊號 today, the retired rail's insert button
+ * before it), reached through the same door.
  */
 function duplicateLane(doc, at) {
   const flat = flattenLanes(doc);
@@ -2567,7 +2876,7 @@ function duplicateLane(doc, at) {
  * that path names a real lane too.
  *
  * So every structural edit this module can produce has exactly one supported way
- * to be written back. All five are pinned as tests against a grouped fixture in
+ * to be written back. All eight are pinned as tests against a grouped fixture in
  * `test/wave-codec.test.js`; this list is a map to them, not the authority:
  *
  *     renameLane(doc, k, n), lane already has a name
@@ -2581,6 +2890,18 @@ function duplicateLane(doc, at) {
  *     moveLane(doc, f, t)
  *         {op: 'move', path: lanePath(doc, f),
  *          to: laneInsertPath(doc, t < f ? t : t + 1)}
+ *     groupLanes(doc, ks, t), the lanes in ks siblings in one array
+ *         {op: 'wrap', path: lanePath(doc, min of ks), count: ks.length, title: t}
+ *     ungroupLanes(doc, k)
+ *         {op: 'unwrap', path: lanePath(doc, k).slice(0, -1)}
+ *     a whole group moved inside the array that holds it (the name column's
+ *     group 上移 / 下移, `wave-panels.js` `commitGroupMove`)
+ *         {op: 'move', path: <the group's path>, to: <its array's path>.concat([d])}
+ *         where d counts the array as it stands, like every move destination
+ *
+ * A `groupLanes` selection that swallows a whole sub-group flattens that group
+ * into the new one (its title goes); that is a wrap and an unwrap at once and
+ * has no single recipe here, so a store asked to write it refuses.
  *
  * The rename is the one with a branch, and picking the wrong side of it cannot
  * go unnoticed: `set` on a lane with no `name` refuses because nothing is parsed
@@ -2917,10 +3238,10 @@ function groupLanes(doc, ats, label) {
  * ungrouping always names one group unambiguously. It also means a group made
  * of nothing but sub-groups — no lane of its own anywhere in it — cannot be
  * named this way; there is no lane whose immediate parent IS that group. The
- * UI does not offer the control there for the same reason: v3.6.0 Task 14's
- * 解散群組 button is enabled only when the SELECTED lane is a direct member
- * of some group (`laneIsInGroup` in `wave-ui.js`), and a group made only of
- * sub-groups has no such lane to select.
+ * UI asks for a direct member for the same reason: the name column's group
+ * ⠿ → 解散群組 (`ungroupSpan` in `wave-ui.js`) looks for one in the group's
+ * span, and for a group made only of sub-groups says to dissolve the inner
+ * group first.
  *
  * `at` outside the document, or a lane that is not inside any group (`signal`
  * is not one), answers the document unchanged.
@@ -3119,6 +3440,30 @@ function parseEdge(entry) {
   return { from: from, to: to, shape: shape, label: rest === '' ? '' : rest.slice(1) };
 }
 
+/**
+ * 單點標註：`<字母> <文字>`。引擎把一字元的 head 讀成 from === to、shape ''，
+ * 於是在那個 node 畫零長度的線加標籤。parseEdge 仍拒絕這種 entry（它不是關聯線），
+ * 標註走自己的這組函數。
+ */
+function parseNote(entry) {
+  if (typeof entry !== 'string') return null;
+  const text = entry.trim();
+  if (text === '') return null;
+  const head = text.split(/\s+/)[0];
+  if (head.length !== 1 || !isNodeLetter(head)) return null;
+  const rest = text.slice(1).trim();
+  return { letter: head, text: rest };
+}
+
+/** `{letter, text}` → 一條標註 entry；字母不合法或文字為空回 null。 */
+function formatNote(note) {
+  if (note === null || typeof note !== 'object') return null;
+  if (!isNodeLetter(note.letter)) return null;
+  const text = typeof note.text === 'string' ? note.text.trim() : '';
+  if (text === '') return null;
+  return note.letter + ' ' + text;
+}
+
 /** `{from, to, shape, label}` → 一條 entry，不合法回 null。 */
 function formatEdge(edge) {
   if (edge === null || typeof edge !== 'object') return null;
@@ -3164,8 +3509,10 @@ function nodesOf(doc) {
   return out;
 }
 
+// 大寫優先：作者手寫的 anchor 慣例是小寫（a、b…），編輯器自動配的字母從大寫
+// 開始，兩邊不會互相踩到；池子大小與總數不變（52）。
 const NODE_LETTER_POOL =
-  'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
 
 /**
  * 保證 `(at, cell)` 這一格有一個 anchor 字母。
@@ -3219,7 +3566,10 @@ function pruneNodes(doc) {
     ? doc.edge : [];
   for (let i = 0; i < list.length; i += 1) {
     const e = parseEdge(list[i]);
-    if (e !== null) { referenced[e.from] = true; referenced[e.to] = true; }
+    if (e !== null) { referenced[e.from] = true; referenced[e.to] = true; continue; }
+    // 標註也引用它的字母，否則任何一次 prune 都會把標註的錨點清掉。
+    const n = parseNote(list[i]);
+    if (n !== null) referenced[n.letter] = true;
   }
 
   const flat = flattenLanes(doc);
@@ -3390,7 +3740,63 @@ function moveEdgeEnd(doc, index, end, at, cell) {
   return pruneNodes(updateEdge(ensured.doc, index, nextEdge));
 }
 
+/** doc.edge 裡所有標註；`index` 是在 `doc.edge` 的原始索引。 */
+function notesOf(doc) {
+  const out = [];
+  const list = (doc !== null && typeof doc === 'object' && Array.isArray(doc.edge))
+    ? doc.edge : [];
+  for (let i = 0; i < list.length; i += 1) {
+    const n = parseNote(list[i]);
+    if (n !== null) out.push({ index: i, letter: n.letter, text: n.text });
+  }
+  return out;
+}
+
+/** 在 `(at, cell)` 加一條標註（必要時配字母）；放不下／文字為空回原 doc。 */
+function addNote(doc, at, cell, text) {
+  if (formatNote({ letter: 'A', text: text }) === null) return doc;
+  const ensured = ensureNode(doc, at, cell);
+  if (ensured.letter === null) return doc;
+  const entry = formatNote({ letter: ensured.letter, text: text });
+  const base = ensured.doc;
+  const list = Array.isArray(base.edge) ? base.edge.slice() : [];
+  list.push(entry);
+  const copy = copyObject(base);
+  copy.edge = list;
+  return copy;
+}
+
+/** 改第 `index` 條 edge（必須是標註）的文字；不是標註或文字為空回原 doc。 */
+function updateNote(doc, index, text) {
+  const list = (doc !== null && typeof doc === 'object' && Array.isArray(doc.edge))
+    ? doc.edge : [];
+  if (!isIndex(index, list.length)) return doc;
+  const n = parseNote(list[index]);
+  if (n === null) return doc;
+  const entry = formatNote({ letter: n.letter, text: text });
+  if (entry === null) return doc;
+  const next = list.slice();
+  next[index] = entry;
+  const copy = copyObject(doc);
+  copy.edge = next;
+  return copy;
+}
+
+/** 移除第 `index` 條標註並清掉不再被引用的字母。 */
+function removeNote(doc, index) {
+  const list = (doc !== null && typeof doc === 'object' && Array.isArray(doc.edge))
+    ? doc.edge : [];
+  if (!isIndex(index, list.length)) return doc;
+  if (parseNote(list[index]) === null) return doc;
+  const next = list.slice();
+  next.splice(index, 1);
+  const copy = copyObject(doc);
+  copy.edge = next;
+  return pruneNodes(copy);
+}
+
 module.exports = {
+  parseNote, formatNote, notesOf, addNote, updateNote, removeNote, NODE_LETTER_POOL,
   parseSource, patchSource,
   expandWave, collapseWave, levelsOf,
   setCell, setCellRange, insertCycles, deleteCycles, copyCycles, pasteCycles,