@doenet/v06-to-v07 0.7.26-dev.545 → 0.7.26-dev.546

package/{index-BsToiKop.js → index-CJq47FJf.js}

@@ -47282,7 +47282,7 @@ async function cidFromArrayBuffer(data) {
       await crypto.subtle.digest("SHA-256", new Uint8Array());
       digest = (data2) => crypto.subtle.digest("SHA-256", data2);
     } catch (e22) {
-      const sha256 = (await import("./sha256-DT5xJ2Hv-CgHLfxWZ-kZCUXDZV.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-DT5xJ2Hv-B_Fz0Lp3-K5IslGl5.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -48538,6 +48538,182 @@ function find_effective_domains_piecewise_children({
   }
   return effectiveChildDomains;
 }
+function groupCompositeRanges({
+  children,
+  ranges,
+  isAbsent = () => false,
+  isBlank = () => false,
+  skipRange = () => false,
+  trimEnd = (value) => value,
+  startInd = 0,
+  endInd = children.length - 1,
+  removedInd = null
+}) {
+  const ordered = (ranges ?? []).flatMap((range2) => {
+    const span = shiftForRemovedChild(range2, removedInd);
+    return span && span.firstInd >= startInd && span.lastInd <= endInd ? [{ range: range2, ...span }] : [];
+  }).sort((a2, b2) => a2.firstInd - b2.firstInd || b2.lastInd - a2.lastInd);
+  const root2 = {
+    range: null,
+    firstInd: startInd,
+    lastInd: endInd,
+    nextInd: startInd,
+    eligibility: null,
+    items: [],
+    eligible: []
+  };
+  const open = [root2];
+  function addPlainChildren(node, upTo) {
+    for (; node.nextInd < upTo; node.nextInd++) {
+      const value = children[node.nextInd];
+      if (isAbsent(value)) {
+        continue;
+      }
+      node.items.push({ kind: "child", value, index: node.nextInd });
+      if (node.eligibility) {
+        node.eligible.push(
+          node.eligibility[node.nextInd - node.firstInd] ?? false
+        );
+      }
+    }
+  }
+  function closeInnermost() {
+    const node = open.pop();
+    addPlainChildren(node, node.lastInd + 1);
+    if (node.items.length === 0) {
+      return;
+    }
+    const parent = open[open.length - 1];
+    const listItems = node.items.filter(
+      (item) => !isBlankGroup(item, isBlank)
+    );
+    const allEligible = node.eligible.every(
+      (value, ind) => value || isBlankGroup(node.items[ind], isBlank)
+    );
+    const asList = Boolean(node.range.asList) && allEligible && listItems.length > 1;
+    parent.items.push({
+      kind: "composite",
+      range: node.range,
+      asList,
+      items: asList ? prepareListItems(node.items, isBlank, trimEnd) : node.items
+    });
+    if (parent.eligibility) {
+      parent.eligible.push(allEligible);
+    }
+  }
+  for (const { range: range2, firstInd, lastInd } of ordered) {
+    while (open.length > 1 && lastInd > open[open.length - 1].lastInd) {
+      closeInnermost();
+    }
+    const parent = open[open.length - 1];
+    if (firstInd < parent.nextInd) {
+      continue;
+    }
+    addPlainChildren(parent, firstInd);
+    parent.nextInd = lastInd + 1;
+    if (skipRange(range2)) {
+      continue;
+    }
+    open.push({
+      range: range2,
+      firstInd,
+      lastInd,
+      nextInd: firstInd,
+      eligibility: range2.potentialListComponents ?? null,
+      items: [],
+      eligible: []
+    });
+  }
+  while (open.length > 1) {
+    closeInnermost();
+  }
+  addPlainChildren(root2, endInd + 1);
+  return root2.items;
+}
+function shiftForRemovedChild(range2, removedInd) {
+  let { firstInd, lastInd } = range2;
+  if (removedInd === null) {
+    return { firstInd, lastInd };
+  }
+  if (firstInd === removedInd || lastInd === removedInd) {
+    return void 0;
+  }
+  if (firstInd > removedInd) {
+    firstInd -= 1;
+  }
+  if (lastInd > removedInd) {
+    lastInd -= 1;
+  }
+  return { firstInd, lastInd };
+}
+function isBlankGroup(group2, isBlank) {
+  if (group2.kind === "child") {
+    return isBlank(group2.value);
+  }
+  return group2.items.every((item) => isBlankGroup(item, isBlank));
+}
+function listCommaPositions(blank) {
+  const commaBefore = new Array(blank.length);
+  let itemAtOrAfter = false;
+  for (let ind = blank.length - 1; ind >= 0; ind--) {
+    itemAtOrAfter ||= !blank[ind];
+    commaBefore[ind] = ind > 0 && !blank[ind - 1] && itemAtOrAfter;
+  }
+  return commaBefore;
+}
+function joinListText(parts, blank) {
+  const commaBefore = listCommaPositions(blank);
+  return parts.map((part, ind) => commaBefore[ind + 1] ? part.trimEnd() : part).map((part, ind) => commaBefore[ind] ? ", " + part : part).join("");
+}
+function prepareListItems(items, isBlank, trimEnd) {
+  const firstItemInd = items.findIndex(
+    (item) => !isBlankGroup(item, isBlank)
+  );
+  let lastItemInd = items.length - 1;
+  while (lastItemInd > firstItemInd && isBlankGroup(items[lastItemInd], isBlank)) {
+    lastItemInd--;
+  }
+  const prepared = [];
+  for (const [ind, item] of items.entries()) {
+    if (ind < firstItemInd || ind >= lastItemInd) {
+      prepared.push(item);
+    } else if (!isBlankGroup(item, isBlank)) {
+      prepared.push(trimItemEnd(item, isBlank, trimEnd));
+    } else if (item.kind === "composite") {
+      prepared.push(withoutBlankChildren(item));
+    }
+  }
+  return prepared;
+}
+function withoutBlankChildren(group2) {
+  return {
+    ...group2,
+    items: group2.items.flatMap(
+      (item) => item.kind === "composite" ? [withoutBlankChildren(item)] : []
+    )
+  };
+}
+function trimItemEnd(item, isBlank, trimEnd) {
+  if (item.kind === "child") {
+    const trimmed = trimEnd(item.value);
+    return trimmed === item.value ? item : { ...item, value: trimmed };
+  }
+  let end = item.items.length;
+  while (isBlankGroup(item.items[end - 1], isBlank)) {
+    end--;
+  }
+  const emptiedComposites = item.items.slice(end).flatMap(
+    (sub2) => sub2.kind === "composite" ? [withoutBlankChildren(sub2)] : []
+  );
+  return {
+    ...item,
+    items: [
+      ...item.items.slice(0, end - 1),
+      trimItemEnd(item.items[end - 1], isBlank, trimEnd),
+      ...emptiedComposites
+    ]
+  };
+}
 const { gcd: gcd$3, lcm: lcm$1 } = Context.math;
 function enumerateSelectionCombinations({
   numberOfIndices,
@@ -55808,11 +55984,11 @@ async function determineParentAndIndexResolutionForResolver({
   let update_start = updateOldReplacementsStart;
   let update_end = updateOldReplacementsEnd;
   if (updateOldReplacementsStart !== void 0 && updateOldReplacementsEnd !== void 0) {
-    for (const [i2, isBlankString] of (blankStringReplacements ?? []).entries()) {
+    for (const [i2, isBlankString2] of (blankStringReplacements ?? []).entries()) {
       if (i2 >= updateOldReplacementsEnd) {
         break;
       }
-      if (isBlankString) {
+      if (isBlankString2) {
         update_end--;
         if (i2 < updateOldReplacementsStart) {
           update_start--;
@@ -56876,7 +57052,8 @@ function recursivelyReplaceCompositesWithReplacements({
   replacements,
   recurseNonStandardComposites = false,
   includeWithheldReplacements = false,
-  stopIfHaveProp
+  stopIfHaveProp,
+  stopAtListComposites = false
 }) {
   let compositesFound = [];
   let newReplacements = [];
@@ -56901,6 +57078,10 @@ function recursivelyReplaceCompositesWithReplacements({
         continue;
       }
     }
+    if (stopAtListComposites && "asList" in replacement.state) {
+      newReplacements.push(replacement);
+      continue;
+    }
     compositesFound.push(replacement.componentIdx);
     if (!replacement.isExpanded) {
       if (replacement.state.readyToExpandWhenResolved.isResolved) {
@@ -56923,7 +57104,8 @@ function recursivelyReplaceCompositesWithReplacements({
       replacements: replacementReplacements,
       recurseNonStandardComposites,
       includeWithheldReplacements,
-      stopIfHaveProp
+      stopIfHaveProp,
+      stopAtListComposites
     });
     compositesFound.push(...recursionResult.compositesFound);
     newReplacements.push(...recursionResult.newReplacements);
@@ -63628,6 +63810,7 @@ const _ReplacementDependency = class _ReplacementDependency2 extends Dependency
       }
     }
     this.stopIfHaveProp = this.definition.stopIfHaveProp;
+    this.stopAtListComposites = this.definition.stopAtListComposites;
     this.includeWithheldReplacements = this.definition.includeWithheldReplacements;
     this.expandReplacements = true;
   }
@@ -63736,6 +63919,7 @@ const _ReplacementDependency = class _ReplacementDependency2 extends Dependency
         core: this.dependencyHandler.core,
         replacements,
         recurseNonStandardComposites: this.recurseNonStandardComposites,
+        stopAtListComposites: this.stopAtListComposites,
         includeWithheldReplacements: this.includeWithheldReplacements,
         stopIfHaveProp: this.stopIfHaveProp
       });
@@ -76564,98 +76748,33 @@ function textFromComponent(component) {
     return " ";
   }
 }
+function isBlankString(child) {
+  return typeof child === "string" && child.trim() === "";
+}
 function textFromChildren(children, textFromComponentConverter = textFromComponent) {
-  let result2 = textFromChildrenSub({
-    compositeReplacementRange: children.compositeReplacementRange,
+  const groups = groupCompositeRanges({
     children,
-    startInd: 0,
-    endInd: children.length - 1,
-    textFromComponentConverter
+    ranges: children.compositeReplacementRange,
+    isBlank: isBlankString,
+    // A hidden composite contributes nothing, not even its children's text.
+    skipRange: (range2) => Boolean(range2.hidden)
   });
-  return result2.newChildren.map(textFromComponentConverter).join("");
+  return groups.map((group2) => textFromGroup(group2, textFromComponentConverter)).join("");
 }
-function textFromChildrenSub({
-  compositeReplacementRange,
-  children,
-  startInd,
-  endInd,
-  textFromComponentConverter,
-  potentialListComponents
-}) {
-  let newChildren = [];
-  let newPotentialListComponents = [];
-  let lastChildInd = startInd - 1;
-  let lastChildIndIncludingEmptyComposites = lastChildInd;
-  for (let rangeInd = 0; rangeInd < compositeReplacementRange.length; rangeInd++) {
-    let range2 = compositeReplacementRange[rangeInd];
-    let rangeFirstInd = range2.firstInd;
-    let rangeLastInd = range2.lastInd;
-    if (rangeFirstInd > lastChildInd && rangeLastInd <= endInd) {
-      if (lastChildInd + 1 < rangeFirstInd) {
-        newChildren.push(
-          ...children.slice(lastChildInd + 1, rangeFirstInd)
-        );
-        if (potentialListComponents) {
-          newPotentialListComponents.push(
-            ...potentialListComponents.slice(
-              lastChildInd - startInd + 1,
-              rangeFirstInd - startInd
-            )
-          );
-        }
-      }
-      if (!range2.hidden) {
-        let subReplacementRange = compositeReplacementRange.slice(
-          rangeInd + 1
-        );
-        let {
-          newChildren: childrenInRange,
-          newPotentialListComponents: potentialListComponentsInRange
-        } = textFromChildrenSub({
-          compositeReplacementRange: subReplacementRange,
-          children,
-          startInd: rangeFirstInd,
-          endInd: rangeLastInd,
-          textFromComponentConverter,
-          potentialListComponents: range2.potentialListComponents
-        });
-        let allAreListComponents = potentialListComponentsInRange.every(
-          (x2) => x2
-        );
-        if (range2.asList && allAreListComponents && childrenInRange.length > 1) {
-          newChildren.push(
-            childrenInRange.map(textFromComponentConverter).filter((v2) => v2 !== "").map(
-              (v2, i2, a2) => i2 === a2.length - 1 ? v2 : v2.trimEnd()
-            ).join(", ")
-          );
-        } else {
-          newChildren.push(
-            childrenInRange.map(textFromComponentConverter).join("")
-          );
-        }
-        if (potentialListComponents) {
-          newPotentialListComponents.push(allAreListComponents);
-        }
-      }
-      lastChildInd = rangeLastInd;
-      lastChildIndIncludingEmptyComposites = Math.max(
-        rangeFirstInd,
-        rangeLastInd
-      );
-    }
+function textFromGroup(group2, convert) {
+  if (group2.kind === "child") {
+    return convert(group2.value);
   }
-  if (lastChildInd < endInd) {
-    newChildren.push(...children.slice(lastChildInd + 1, endInd + 1));
-    if (potentialListComponents) {
-      newPotentialListComponents.push(
-        ...potentialListComponents.slice(
-          lastChildIndIncludingEmptyComposites - startInd + 1,
-          endInd - startInd + 1
-        )
-      );
-    }
+  const parts = group2.items.map((item) => textFromGroup(item, convert));
+  if (!group2.asList) {
+    return parts.join("");
   }
-  return { newChildren, newPotentialListComponents };
+  return joinListText(
+    parts,
+    group2.items.map(
+      (item, ind) => parts[ind] === "" || isBlankGroup(item, isBlankString)
+    )
+  );
 }
 function returnTextPieceStateVariableDefinitions() {
   let stateVariableDefinitions = {};
@@ -79319,198 +79438,111 @@ function createInputStringFromChildren({
       nonStringInd++;
     }
   }
-  let result2 = createInputStringFromChildrenSub({
-    compositeReplacementRange: children.compositeReplacementRange,
+  const groups = groupCompositeRanges({
+    children,
+    ranges: children.compositeReplacementRange,
+    isBlank: (child) => typeof child === "string" && child.trim() === ""
+  });
+  const context = {
     children,
-    startInd: 0,
-    endInd: children.length - 1,
     nonStringIndByChild,
     format: format2,
     codePre,
     createInternalLists,
     nextInternalListInd: nonStringInd,
+    internalLists: {},
     parser: parser2,
     createDisplayedMathString,
     displayedMathSlotForChild
-  });
+  };
   let joinString = createDisplayedMathString ? " " : "";
   return {
-    string: result2.newChildren.join(joinString),
-    internalLists: result2.internalLists
+    string: stringFromGroups(groups, context).join(joinString),
+    internalLists: context.internalLists
   };
 }
-function createInputStringFromChildrenSub({
-  compositeReplacementRange,
-  children,
-  startInd,
-  endInd,
-  nonStringIndByChild,
-  format: format2,
-  codePre,
-  potentialListComponents,
-  createInternalLists,
-  nextInternalListInd,
-  parser: parser2,
-  createDisplayedMathString,
-  displayedMathSlotForChild
-}) {
-  let newChildren = [];
-  let newPotentialListComponents = [];
-  let lastChildInd = startInd - 1;
-  let internalLists = {};
-  let leftDelimiters = ["{", "[", "(", "|", ","];
-  let rightDelimiters = ["}", "]", ")", "|", ","];
-  if (compositeReplacementRange) {
-    for (let rangeInd = 0; rangeInd < compositeReplacementRange.length; rangeInd++) {
-      let range2 = compositeReplacementRange[rangeInd];
-      let rangeFirstInd = range2.firstInd;
-      let rangeLastInd = range2.lastInd;
-      if (rangeFirstInd > lastChildInd && rangeLastInd <= endInd) {
-        if (lastChildInd + 1 < rangeFirstInd) {
-          for (let ind = lastChildInd + 1; ind < rangeFirstInd; ind++) {
-            newChildren.push(
-              baseStringFromChildren({
-                children,
-                startInd: ind,
-                endInd: ind,
-                nonStringIndByChild,
-                format: format2,
-                codePre,
-                createDisplayedMathString,
-                displayedMathSlotForChild
-              })
-            );
-          }
-          if (potentialListComponents) {
-            newPotentialListComponents.push(
-              ...potentialListComponents.slice(
-                lastChildInd - startInd + 1,
-                rangeFirstInd - startInd
-              )
-            );
-          }
-        }
-        let subReplacementRange = compositeReplacementRange.slice(
-          rangeInd + 1
-        );
-        let {
-          newChildren: childrenInRange,
-          newPotentialListComponents: potentialListComponentsInRange,
-          internalLists: newInternalLists
-        } = createInputStringFromChildrenSub({
-          compositeReplacementRange: subReplacementRange,
-          children,
-          startInd: rangeFirstInd,
-          endInd: rangeLastInd,
-          nonStringIndByChild,
-          format: format2,
-          codePre,
-          potentialListComponents: range2.potentialListComponents,
-          createInternalLists,
-          nextInternalListInd,
-          parser: parser2,
-          createDisplayedMathString,
-          displayedMathSlotForChild
-        });
-        Object.assign(internalLists, newInternalLists);
-        nextInternalListInd += Object.keys(newInternalLists).length;
-        let allAreListComponents = potentialListComponentsInRange.every(
-          (x2) => x2
-        );
-        if (range2.asList && allAreListComponents && childrenInRange.length > 1) {
-          let listString = childrenInRange.filter((v2) => v2.trim() !== "").map(
-            (v2, i2, a2) => i2 === a2.length - 1 ? v2 : v2.trimEnd()
-          ).join(", ");
-          let wrap2 = false;
-          for (let prevInd = rangeFirstInd - 1; prevInd >= 0; prevInd--) {
-            let prevChild = children[prevInd];
-            if (typeof prevChild !== "string") {
-              wrap2 = true;
-              break;
-            }
-            prevChild = prevChild.trim();
-            if (prevChild.length === 0) {
-              continue;
-            }
-            if (!leftDelimiters.includes(
-              prevChild[prevChild.length - 1]
-            )) {
-              wrap2 = true;
-            }
-            break;
-          }
-          if (!wrap2) {
-            for (let nextInd = rangeLastInd + 1; nextInd < children.length; nextInd++) {
-              let nextChild = children[nextInd];
-              if (typeof nextChild !== "string") {
-                wrap2 = true;
-                break;
-              }
-              nextChild = nextChild.trim();
-              if (nextChild.length === 0) {
-                continue;
-              }
-              let nextChar = nextChild[0];
-              if (format2 === "latex" && nextChar === "\\" && nextChild.length > 1) {
-                nextChar = nextChild[1];
-              }
-              if (!rightDelimiters.includes(nextChar)) {
-                wrap2 = true;
-              }
-              break;
-            }
-          }
-          if (wrap2) {
-            if (createInternalLists) {
-              let code = codePre + nextInternalListInd;
-              internalLists[code] = parser2?.(listString) ?? "";
-              nextInternalListInd++;
-              listString = returnStringForCode(format2, code);
-            } else if (!createDisplayedMathString) {
-              listString = "(" + listString + ")";
-            }
-          }
-          newChildren.push(listString);
-        } else {
-          let joinString = createDisplayedMathString ? " " : "";
-          newChildren.push(childrenInRange.join(joinString));
-        }
-        if (potentialListComponents) {
-          newPotentialListComponents.push(allAreListComponents);
-        }
-        lastChildInd = rangeLastInd;
-      }
-    }
-  }
-  if (lastChildInd < endInd) {
-    for (let ind = lastChildInd + 1; ind <= endInd; ind++) {
-      newChildren.push(
+function stringFromGroups(groups, context) {
+  const strings = [];
+  for (const group2 of groups) {
+    if (group2.kind === "child") {
+      strings.push(
         baseStringFromChildren({
-          children,
-          startInd: ind,
-          endInd: ind,
-          nonStringIndByChild,
-          format: format2,
-          codePre,
-          createDisplayedMathString,
-          displayedMathSlotForChild
+          ...context,
+          startInd: group2.index,
+          endInd: group2.index
         })
       );
+      continue;
     }
-    if (potentialListComponents) {
-      newPotentialListComponents.push(
-        ...potentialListComponents.slice(
-          lastChildInd - startInd + 1,
-          endInd - startInd + 1
-        )
+    const parts = stringFromGroups(group2.items, context);
+    if (!group2.asList) {
+      strings.push(
+        parts.join(context.createDisplayedMathString ? " " : "")
       );
+      continue;
     }
+    const listString = joinListText(
+      parts,
+      parts.map((part) => part.trim() === "")
+    );
+    strings.push(wrapListIfNeeded(listString, group2.range, context));
+  }
+  return strings;
+}
+function wrapListIfNeeded(listString, range2, context) {
+  const { children, format: format2, codePre, createInternalLists, parser: parser2 } = context;
+  const leftDelimiters = ["{", "[", "(", "|", ","];
+  const rightDelimiters = ["}", "]", ")", "|", ","];
+  let wrap2 = false;
+  for (let prevInd = range2.firstInd - 1; prevInd >= 0; prevInd--) {
+    let prevChild = children[prevInd];
+    if (typeof prevChild !== "string") {
+      wrap2 = true;
+      break;
+    }
+    prevChild = prevChild.trim();
+    if (prevChild.length === 0) {
+      continue;
+    }
+    if (!leftDelimiters.includes(prevChild[prevChild.length - 1])) {
+      wrap2 = true;
+    }
+    break;
   }
-  return {
-    newChildren,
-    newPotentialListComponents,
-    internalLists
-  };
+  if (!wrap2) {
+    for (let nextInd = range2.lastInd + 1; nextInd < children.length; nextInd++) {
+      let nextChild = children[nextInd];
+      if (typeof nextChild !== "string") {
+        wrap2 = true;
+        break;
+      }
+      nextChild = nextChild.trim();
+      if (nextChild.length === 0) {
+        continue;
+      }
+      let nextChar = nextChild[0];
+      if (format2 === "latex" && nextChar === "\\" && nextChild.length > 1) {
+        nextChar = nextChild[1];
+      }
+      if (!rightDelimiters.includes(nextChar)) {
+        wrap2 = true;
+      }
+      break;
+    }
+  }
+  if (!wrap2) {
+    return listString;
+  }
+  if (createInternalLists) {
+    const code = codePre + context.nextInternalListInd;
+    context.internalLists[code] = parser2?.(listString) ?? "";
+    context.nextInternalListInd++;
+    return returnStringForCode(format2, code);
+  }
+  if (context.createDisplayedMathString) {
+    return listString;
+  }
+  return "(" + listString + ")";
 }
 function baseStringFromChildren({
   children,
@@ -235526,6 +235558,12 @@ class Copy extends CompositeComponent {
               compositeIdx: stateValues.extendedComponent.componentIdx,
               recursive: true,
               recurseNonStandardComposites: stateValues.unresolvedPath != null,
+              // While a path is still to be resolved, the
+              // recursion has to reach every replacement. Once
+              // the reference has resolved to the composite
+              // itself, a list composite among its replacements
+              // is kept whole, so the copy shows its commas.
+              stopAtListComposites: stateValues.unresolvedPath == null,
               includeWithheldReplacements: true,
               stopIfHaveProp: firstPropNameFromPath
             };
@@ -241107,4 +241145,4 @@ export {
   getDefaultExportFromCjs$1 as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-BsToiKop.js.map
+//# sourceMappingURL=index-CJq47FJf.js.map