@doenet/v06-to-v07 0.7.26-dev.571 → 0.7.26-dev.572

package/{index-Cxf3BQNw.js → index-D-2i13ZI.js}

@@ -1849,16 +1849,16 @@ function findNodesWithPositionInfo(nodes) {
   }
   return ret;
 }
-function macroToString(node) {
+function macroToString(node, forceParens = false) {
   if (Array.isArray(node)) {
-    return node.map((n2) => macroToString(n2)).join("");
+    return arrayToString(node);
   }
   switch (node.type) {
     case "macro": {
       const macro = unwrappedMacroToString$1(node);
       let start = "$";
       let end = "";
-      if (macroNeedsParens$1(node)) {
+      if (macroNeedsParens$1(node) || forceParens) {
         start += "(";
         end += ")";
       }
@@ -1868,11 +1868,11 @@ function macroToString(node) {
       const macro = unwrappedMacroToString$1(node.macro);
       let start = "$$";
       let end = "";
-      if (macroNeedsParens$1(node)) {
+      if (macroNeedsParens$1(node) || forceParens) {
         start += "(";
         end += ")";
       }
-      const args = node.input ? `(${node.input.map(macroToString).join(", ")})` : "";
+      const args = node.input ? `(${node.input.map((arg) => macroToString(arg)).join(", ")})` : "";
       return start + macro + end + args;
     }
     case "text":
@@ -1898,12 +1898,29 @@ function macroPathToString$1(path) {
 function macroPathPartToString$1(pathPart) {
   return pathPart.name + pathPart.index.map((part) => `[${macroToString(part.value)}]`).join("");
 }
+function arrayToString(nodes) {
+  const parts = nodes.map((n2) => macroToString(n2));
+  let nextChar = "";
+  for (let i2 = parts.length - 1; i2 >= 0; i2--) {
+    const child = nodes[i2];
+    if ((child.type === "macro" || child.type === "function") && isNameChar$1(nextChar) && isNameChar$1(parts[i2].slice(-1))) {
+      parts[i2] = macroToString(child, true);
+    }
+    if (parts[i2]) {
+      nextChar = parts[i2][0];
+    }
+  }
+  return parts.join("");
+}
+function isNameChar$1(char) {
+  return /^[a-zA-Z0-9_]$/.test(char);
+}
 function attrToString$1(attr) {
   const name2 = attr.name;
   if (attr.children.length === 0) {
     return name2;
   }
-  const value = attr.children.map(macroToString).join("");
+  const value = arrayToString(attr.children);
   return `${name2}=${quote(value)}`;
 }
 function macroNeedsParens$1(macro) {
@@ -1923,10 +1940,22 @@ function toXml(tree, options) {
   const node = Array.isArray(tree) ? { type: "root", children: tree } : tree;
   return nodesToXml(node, options);
 }
-function nodesToXml(node, options) {
+function nodesToXml(node, options, forceParens = false) {
   if (Array.isArray(node)) {
     if (!node.some((n2) => n2.type === "pathPart")) {
-      return mergeAdjacentTextInArray(node).map((child) => nodesToXml(child, options)).join("");
+      const children = mergeAdjacentTextInArray(node);
+      const parts = children.map((child) => nodesToXml(child, options));
+      let nextChar = "";
+      for (let i2 = parts.length - 1; i2 >= 0; i2--) {
+        const child = children[i2];
+        if ((child.type === "macro" || child.type === "function") && isNameChar(nextChar) && isNameChar(parts[i2].slice(-1))) {
+          parts[i2] = nodesToXml(child, options, true);
+        }
+        if (parts[i2]) {
+          nextChar = parts[i2][0];
+        }
+      }
+      return parts.join("");
     } else {
       return node.map((part) => nodesToXml(part, options)).join(".");
     }
@@ -2011,12 +2040,12 @@ function nodesToXml(node, options) {
     }
     case "macro": {
       if (node.version === "0.6") {
-        return macroToString(node);
+        return macroToString(node, forceParens);
       }
       const macro = unwrappedMacroToString(node, options);
       let start = "$";
       let end = "";
-      if (macroNeedsParens(node)) {
+      if (macroNeedsParens(node) || forceParens) {
         start += "(";
         end += ")";
       }
@@ -2024,12 +2053,12 @@ function nodesToXml(node, options) {
     }
     case "function": {
       if (node.version === "0.6") {
-        return macroToString(node);
+        return macroToString(node, forceParens);
       }
       const macro = unwrappedMacroToString(node, options);
       let start = "$$";
       let end = "";
-      if (macroNeedsParens(node)) {
+      if (macroNeedsParens(node) || forceParens) {
         start += "(";
         end += ")";
       }
@@ -2082,6 +2111,9 @@ function attrToString(attr, options) {
 function macroNeedsParens(macro) {
   return macro.path.some((part) => part.name.includes("-"));
 }
+function isNameChar(char) {
+  return /^[a-zA-Z0-9_]$/.test(char);
+}
 const StartTag = 1, StartCloseTag = 2, MissingCloseTag = 3, mismatchedStartCloseTag = 4, incompleteStartCloseTag = 5, commentContent$1 = 36, piContent$1 = 37, cdataContent$1 = 38, Text$1 = 7, Element = 12, EndTag = 13, OpenTag = 14, TagName = 15, Attribute = 16, AttributeValue = 19, CloseTag = 20, SelfCloseEndTag = 21, SelfClosingTag = 22, MismatchedCloseTag = 25;
 const DefaultBufferLength = 1024;
 let nextPropID = 0;
@@ -31765,7 +31797,7 @@ var init_before = __esmMin((() => {
 })), once_default, init_once = __esmMin((() => {
   init_partial(), init_before(), once_default = partial(before, 2);
 }));
-function findKey(t4, n2, r2) {
+function findKey$2(t4, n2, r2) {
   n2 = cb(n2, r2);
   for (var i2 = keys$1(t4), a2, o2 = 0, s2 = i2.length; o2 < s2; o2++) if (a2 = i2[o2], n2(t4[a2], a2, t4)) return a2;
 }
@@ -31815,7 +31847,7 @@ var init__createIndexFinder = __esmMin((() => {
   init_findLastIndex(), init__createIndexFinder(), lastIndexOf_default = createIndexFinder(-1, findLastIndex_default);
 }));
 function find$1(t4, n2, r2) {
-  var i2 = (_isArrayLike_default(t4) ? findIndex_default : findKey)(t4, n2, r2);
+  var i2 = (_isArrayLike_default(t4) ? findIndex_default : findKey$2)(t4, n2, r2);
   if (i2 !== void 0 && i2 !== -1) return t4[i2];
 }
 var init_find = __esmMin((() => {
@@ -32199,11 +32231,11 @@ var init_mixin = __esmMin((() => {
       return t5 != null && (t5 = n2.apply(t5, arguments)), chainResult(this, t5);
     };
   }), underscore_array_methods_default = _$1$1;
-})), modules_exports = __exportAll({ VERSION: () => VERSION, after: () => after, all: () => every$1, allKeys: () => allKeys, any: () => some$1, assign: () => extendOwn_default, before: () => before, bind: () => bind_default, bindAll: () => bindAll_default, chain: () => chain, chunk: () => chunk, clone: () => clone, collect: () => map$2, compact: () => compact$1, compose: () => compose, constant: () => constant, contains: () => contains$1, countBy: () => countBy_default, create: () => create, debounce: () => debounce, default: () => underscore_array_methods_default, defaults: () => defaults_default, defer: () => defer_default, delay: () => delay_default, detect: () => find$1, difference: () => difference_default, drop: () => rest, each: () => each, escape: () => escape_default, every: () => every$1, extend: () => extend_default, extendOwn: () => extendOwn_default, filter: () => filter$2, find: () => find$1, findIndex: () => findIndex_default, findKey: () => findKey, findLastIndex: () => findLastIndex_default, findWhere: () => findWhere, first: () => first$2, flatten: () => flatten$2, foldl: () => reduce_default, foldr: () => reduceRight_default, forEach: () => each, functions: () => functions$1, get: () => get, groupBy: () => groupBy_default, has: () => has$2, head: () => first$2, identity: () => identity, include: () => contains$1, includes: () => contains$1, indexBy: () => indexBy_default, indexOf: () => indexOf_default, initial: () => initial, inject: () => reduce_default, intersection: () => intersection, invert: () => invert, invoke: () => invoke_default, isArguments: () => isArguments_default, isArray: () => isArray_default, isArrayBuffer: () => isArrayBuffer_default, isBoolean: () => isBoolean$2, isDataView: () => isDataView_default, isDate: () => isDate_default, isElement: () => isElement, isEmpty: () => isEmpty$1, isEqual: () => isEqual, isError: () => isError_default, isFinite: () => isFinite$1, isFunction: () => isFunction_default, isMap: () => isMap_default, isMatch: () => isMatch, isNaN: () => isNaN$1, isNull: () => isNull, isNumber: () => isNumber_default, isObject: () => isObject$2, isRegExp: () => isRegExp_default, isSet: () => isSet_default, isString: () => isString_default, isSymbol: () => isSymbol_default, isTypedArray: () => isTypedArray_default, isUndefined: () => isUndefined$2, isWeakMap: () => isWeakMap_default, isWeakSet: () => isWeakSet_default, iteratee: () => iteratee, keys: () => keys$1, last: () => last$1, lastIndexOf: () => lastIndexOf_default, map: () => map$2, mapObject: () => mapObject, matcher: () => matcher, matches: () => matcher, max: () => max$2, memoize: () => memoize$2, methods: () => functions$1, min: () => min$2, mixin: () => mixin, negate: () => negate, noop: () => noop, now: () => now_default, object: () => object, omit: () => omit_default, once: () => once_default, pairs: () => pairs, partial: () => partial, partition: () => partition_default, pick: () => pick_default, pluck: () => pluck, property: () => property, propertyOf: () => propertyOf, random: () => random, range: () => range, reduce: () => reduce_default, reduceRight: () => reduceRight_default, reject: () => reject$1, rest: () => rest, restArguments: () => restArguments, result: () => result, sample: () => sample, select: () => filter$2, shuffle: () => shuffle, size: () => size, some: () => some$1, sortBy: () => sortBy, sortedIndex: () => sortedIndex, tail: () => rest, take: () => first$2, tap: () => tap, template: () => template, templateSettings: () => templateSettings_default, throttle: () => throttle, times: () => times, toArray: () => toArray, toPath: () => toPath$1, transpose: () => unzip, unescape: () => unescape_default, union: () => union_default, uniq: () => uniq$1, unique: () => uniq$1, uniqueId: () => uniqueId, unzip: () => unzip, values: () => values$2, where: () => where, without: () => without_default, wrap: () => wrap, zip: () => zip_default }), init_modules = __esmMin((() => {
+})), modules_exports = __exportAll({ VERSION: () => VERSION, after: () => after, all: () => every$1, allKeys: () => allKeys, any: () => some$1, assign: () => extendOwn_default, before: () => before, bind: () => bind_default, bindAll: () => bindAll_default, chain: () => chain, chunk: () => chunk, clone: () => clone, collect: () => map$2, compact: () => compact$1, compose: () => compose, constant: () => constant, contains: () => contains$1, countBy: () => countBy_default, create: () => create, debounce: () => debounce, default: () => underscore_array_methods_default, defaults: () => defaults_default, defer: () => defer_default, delay: () => delay_default, detect: () => find$1, difference: () => difference_default, drop: () => rest, each: () => each, escape: () => escape_default, every: () => every$1, extend: () => extend_default, extendOwn: () => extendOwn_default, filter: () => filter$2, find: () => find$1, findIndex: () => findIndex_default, findKey: () => findKey$2, findLastIndex: () => findLastIndex_default, findWhere: () => findWhere, first: () => first$2, flatten: () => flatten$2, foldl: () => reduce_default, foldr: () => reduceRight_default, forEach: () => each, functions: () => functions$1, get: () => get, groupBy: () => groupBy_default, has: () => has$2, head: () => first$2, identity: () => identity, include: () => contains$1, includes: () => contains$1, indexBy: () => indexBy_default, indexOf: () => indexOf_default, initial: () => initial, inject: () => reduce_default, intersection: () => intersection, invert: () => invert, invoke: () => invoke_default, isArguments: () => isArguments_default, isArray: () => isArray_default, isArrayBuffer: () => isArrayBuffer_default, isBoolean: () => isBoolean$2, isDataView: () => isDataView_default, isDate: () => isDate_default, isElement: () => isElement, isEmpty: () => isEmpty$1, isEqual: () => isEqual, isError: () => isError_default, isFinite: () => isFinite$1, isFunction: () => isFunction_default, isMap: () => isMap_default, isMatch: () => isMatch, isNaN: () => isNaN$1, isNull: () => isNull, isNumber: () => isNumber_default, isObject: () => isObject$2, isRegExp: () => isRegExp_default, isSet: () => isSet_default, isString: () => isString_default, isSymbol: () => isSymbol_default, isTypedArray: () => isTypedArray_default, isUndefined: () => isUndefined$2, isWeakMap: () => isWeakMap_default, isWeakSet: () => isWeakSet_default, iteratee: () => iteratee, keys: () => keys$1, last: () => last$1, lastIndexOf: () => lastIndexOf_default, map: () => map$2, mapObject: () => mapObject, matcher: () => matcher, matches: () => matcher, max: () => max$2, memoize: () => memoize$2, methods: () => functions$1, min: () => min$2, mixin: () => mixin, negate: () => negate, noop: () => noop, now: () => now_default, object: () => object, omit: () => omit_default, once: () => once_default, pairs: () => pairs, partial: () => partial, partition: () => partition_default, pick: () => pick_default, pluck: () => pluck, property: () => property, propertyOf: () => propertyOf, random: () => random, range: () => range, reduce: () => reduce_default, reduceRight: () => reduceRight_default, reject: () => reject$1, rest: () => rest, restArguments: () => restArguments, result: () => result, sample: () => sample, select: () => filter$2, shuffle: () => shuffle, size: () => size, some: () => some$1, sortBy: () => sortBy, sortedIndex: () => sortedIndex, tail: () => rest, take: () => first$2, tap: () => tap, template: () => template, templateSettings: () => templateSettings_default, throttle: () => throttle, times: () => times, toArray: () => toArray, toPath: () => toPath$1, transpose: () => unzip, unescape: () => unescape_default, union: () => union_default, uniq: () => uniq$1, unique: () => uniq$1, uniqueId: () => uniqueId, unzip: () => unzip, values: () => values$2, where: () => where, without: () => without_default, wrap: () => wrap, zip: () => zip_default }), init_modules = __esmMin((() => {
   init__setup(), init_restArguments(), init_isObject(), init_isNull(), init_isUndefined(), init_isBoolean(), init_isElement(), init_isString(), init_isNumber(), init_isDate(), init_isRegExp(), init_isError(), init_isSymbol(), init_isArrayBuffer(), init_isDataView(), init_isArray(), init_isFunction(), init_isArguments(), init_isFinite(), init_isNaN(), init_isTypedArray(), init_isEmpty(), init_isMatch(), init_isEqual(), init_isMap(), init_isWeakMap(), init_isSet(), init_isWeakSet(), init_keys(), init_allKeys(), init_values(), init_pairs(), init_invert(), init_functions(), init_extend(), init_extendOwn(), init_defaults(), init_create(), init_clone(), init_tap(), init_get(), init_has(), init_mapObject(), init_identity(), init_constant(), init_noop(), init_toPath(), init_property(), init_propertyOf(), init_matcher(), init_times(), init_random(), init_now(), init_escape(), init_unescape(), init_templateSettings(), init_template(), init_result(), init_uniqueId(), init_chain(), init_iteratee(), init_partial(), init_bind(), init_bindAll(), init_memoize(), init_delay(), init_defer(), init_throttle(), init_debounce(), init_wrap(), init_negate(), init_compose(), init_after(), init_before(), init_once(), init_findKey(), init_findIndex(), init_findLastIndex(), init_sortedIndex(), init_indexOf(), init_lastIndexOf(), init_find(), init_findWhere(), init_each(), init_map(), init_reduce(), init_reduceRight(), init_filter(), init_reject(), init_every(), init_some(), init_contains(), init_invoke(), init_pluck(), init_where(), init_max(), init_min(), init_shuffle(), init_sample(), init_sortBy(), init_groupBy(), init_indexBy(), init_countBy(), init_partition(), init_toArray(), init_size(), init_pick(), init_omit(), init_first(), init_initial(), init_last(), init_rest(), init_compact(), init_flatten(), init_without(), init_uniq(), init_union(), init_intersection(), init_difference(), init_unzip(), init_zip(), init_object(), init_range(), init_chunk(), init_mixin(), init_underscore_array_methods();
 })), _$2, init_index_default = __esmMin((() => {
   init_modules(), _$2 = mixin(modules_exports), _$2._ = _$2;
-})), index_all_exports = __exportAll({ VERSION: () => VERSION, after: () => after, all: () => every$1, allKeys: () => allKeys, any: () => some$1, assign: () => extendOwn_default, before: () => before, bind: () => bind_default, bindAll: () => bindAll_default, chain: () => chain, chunk: () => chunk, clone: () => clone, collect: () => map$2, compact: () => compact$1, compose: () => compose, constant: () => constant, contains: () => contains$1, countBy: () => countBy_default, create: () => create, debounce: () => debounce, default: () => _$2, defaults: () => defaults_default, defer: () => defer_default, delay: () => delay_default, detect: () => find$1, difference: () => difference_default, drop: () => rest, each: () => each, escape: () => escape_default, every: () => every$1, extend: () => extend_default, extendOwn: () => extendOwn_default, filter: () => filter$2, find: () => find$1, findIndex: () => findIndex_default, findKey: () => findKey, findLastIndex: () => findLastIndex_default, findWhere: () => findWhere, first: () => first$2, flatten: () => flatten$2, foldl: () => reduce_default, foldr: () => reduceRight_default, forEach: () => each, functions: () => functions$1, get: () => get, groupBy: () => groupBy_default, has: () => has$2, head: () => first$2, identity: () => identity, include: () => contains$1, includes: () => contains$1, indexBy: () => indexBy_default, indexOf: () => indexOf_default, initial: () => initial, inject: () => reduce_default, intersection: () => intersection, invert: () => invert, invoke: () => invoke_default, isArguments: () => isArguments_default, isArray: () => isArray_default, isArrayBuffer: () => isArrayBuffer_default, isBoolean: () => isBoolean$2, isDataView: () => isDataView_default, isDate: () => isDate_default, isElement: () => isElement, isEmpty: () => isEmpty$1, isEqual: () => isEqual, isError: () => isError_default, isFinite: () => isFinite$1, isFunction: () => isFunction_default, isMap: () => isMap_default, isMatch: () => isMatch, isNaN: () => isNaN$1, isNull: () => isNull, isNumber: () => isNumber_default, isObject: () => isObject$2, isRegExp: () => isRegExp_default, isSet: () => isSet_default, isString: () => isString_default, isSymbol: () => isSymbol_default, isTypedArray: () => isTypedArray_default, isUndefined: () => isUndefined$2, isWeakMap: () => isWeakMap_default, isWeakSet: () => isWeakSet_default, iteratee: () => iteratee, keys: () => keys$1, last: () => last$1, lastIndexOf: () => lastIndexOf_default, map: () => map$2, mapObject: () => mapObject, matcher: () => matcher, matches: () => matcher, max: () => max$2, memoize: () => memoize$2, methods: () => functions$1, min: () => min$2, mixin: () => mixin, negate: () => negate, noop: () => noop, now: () => now_default, object: () => object, omit: () => omit_default, once: () => once_default, pairs: () => pairs, partial: () => partial, partition: () => partition_default, pick: () => pick_default, pluck: () => pluck, property: () => property, propertyOf: () => propertyOf, random: () => random, range: () => range, reduce: () => reduce_default, reduceRight: () => reduceRight_default, reject: () => reject$1, rest: () => rest, restArguments: () => restArguments, result: () => result, sample: () => sample, select: () => filter$2, shuffle: () => shuffle, size: () => size, some: () => some$1, sortBy: () => sortBy, sortedIndex: () => sortedIndex, tail: () => rest, take: () => first$2, tap: () => tap, template: () => template, templateSettings: () => templateSettings_default, throttle: () => throttle, times: () => times, toArray: () => toArray, toPath: () => toPath$1, transpose: () => unzip, unescape: () => unescape_default, union: () => union_default, uniq: () => uniq$1, unique: () => uniq$1, uniqueId: () => uniqueId, unzip: () => unzip, values: () => values$2, where: () => where, without: () => without_default, wrap: () => wrap, zip: () => zip_default }), init_index_all = __esmMin((() => {
+})), index_all_exports = __exportAll({ VERSION: () => VERSION, after: () => after, all: () => every$1, allKeys: () => allKeys, any: () => some$1, assign: () => extendOwn_default, before: () => before, bind: () => bind_default, bindAll: () => bindAll_default, chain: () => chain, chunk: () => chunk, clone: () => clone, collect: () => map$2, compact: () => compact$1, compose: () => compose, constant: () => constant, contains: () => contains$1, countBy: () => countBy_default, create: () => create, debounce: () => debounce, default: () => _$2, defaults: () => defaults_default, defer: () => defer_default, delay: () => delay_default, detect: () => find$1, difference: () => difference_default, drop: () => rest, each: () => each, escape: () => escape_default, every: () => every$1, extend: () => extend_default, extendOwn: () => extendOwn_default, filter: () => filter$2, find: () => find$1, findIndex: () => findIndex_default, findKey: () => findKey$2, findLastIndex: () => findLastIndex_default, findWhere: () => findWhere, first: () => first$2, flatten: () => flatten$2, foldl: () => reduce_default, foldr: () => reduceRight_default, forEach: () => each, functions: () => functions$1, get: () => get, groupBy: () => groupBy_default, has: () => has$2, head: () => first$2, identity: () => identity, include: () => contains$1, includes: () => contains$1, indexBy: () => indexBy_default, indexOf: () => indexOf_default, initial: () => initial, inject: () => reduce_default, intersection: () => intersection, invert: () => invert, invoke: () => invoke_default, isArguments: () => isArguments_default, isArray: () => isArray_default, isArrayBuffer: () => isArrayBuffer_default, isBoolean: () => isBoolean$2, isDataView: () => isDataView_default, isDate: () => isDate_default, isElement: () => isElement, isEmpty: () => isEmpty$1, isEqual: () => isEqual, isError: () => isError_default, isFinite: () => isFinite$1, isFunction: () => isFunction_default, isMap: () => isMap_default, isMatch: () => isMatch, isNaN: () => isNaN$1, isNull: () => isNull, isNumber: () => isNumber_default, isObject: () => isObject$2, isRegExp: () => isRegExp_default, isSet: () => isSet_default, isString: () => isString_default, isSymbol: () => isSymbol_default, isTypedArray: () => isTypedArray_default, isUndefined: () => isUndefined$2, isWeakMap: () => isWeakMap_default, isWeakSet: () => isWeakSet_default, iteratee: () => iteratee, keys: () => keys$1, last: () => last$1, lastIndexOf: () => lastIndexOf_default, map: () => map$2, mapObject: () => mapObject, matcher: () => matcher, matches: () => matcher, max: () => max$2, memoize: () => memoize$2, methods: () => functions$1, min: () => min$2, mixin: () => mixin, negate: () => negate, noop: () => noop, now: () => now_default, object: () => object, omit: () => omit_default, once: () => once_default, pairs: () => pairs, partial: () => partial, partition: () => partition_default, pick: () => pick_default, pluck: () => pluck, property: () => property, propertyOf: () => propertyOf, random: () => random, range: () => range, reduce: () => reduce_default, reduceRight: () => reduceRight_default, reject: () => reject$1, rest: () => rest, restArguments: () => restArguments, result: () => result, sample: () => sample, select: () => filter$2, shuffle: () => shuffle, size: () => size, some: () => some$1, sortBy: () => sortBy, sortedIndex: () => sortedIndex, tail: () => rest, take: () => first$2, tap: () => tap, template: () => template, templateSettings: () => templateSettings_default, throttle: () => throttle, times: () => times, toArray: () => toArray, toPath: () => toPath$1, transpose: () => unzip, unescape: () => unescape_default, union: () => union_default, uniq: () => uniq$1, unique: () => uniq$1, uniqueId: () => uniqueId, unzip: () => unzip, values: () => values$2, where: () => where, without: () => without_default, wrap: () => wrap, zip: () => zip_default }), init_index_all = __esmMin((() => {
   init_index_default(), init_modules();
 }));
 init_index_all();
@@ -47324,7 +47356,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-8sXzDnE0-hQwEEL17-DD-3Noo4.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-8sXzDnE0-hQwEEL17-Br5jiMaf.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -244029,6 +244061,17 @@ const correctAttributeCapitalization = () => {
     });
   };
 };
+const LEGACY_V06_ELEMENT_NAMES = [
+  "copy",
+  "map",
+  "template",
+  "sources",
+  "extract",
+  "customAttribute",
+  "constraints",
+  "styleDefinitions",
+  "feedbackDefinitions"
+];
 const correctElementCapitalization = () => {
   const componentInfoObjects2 = createComponentInfoObjects();
   const correctCapitalization = Object.keys(
@@ -244037,6 +244080,9 @@ const correctElementCapitalization = () => {
   const correctCapitalizationMap = Object.fromEntries(
     correctCapitalization.map((name2) => [name2.toLowerCase(), name2])
   );
+  for (const name2 of LEGACY_V06_ELEMENT_NAMES) {
+    correctCapitalizationMap[name2.toLowerCase()] ??= name2;
+  }
   return (tree) => {
     visit(tree, (node) => {
       if (!isDastElement(node)) {
@@ -244097,34 +244143,6 @@ function renameAttrInPlace(elm, oldName, newName) {
   );
   elm.attributes = newAttrs;
 }
-function getUniqueName(tree, baseName) {
-  const allNames = /* @__PURE__ */ new Set();
-  visit(tree, (node) => {
-    if (!isDastElement(node)) {
-      return;
-    }
-    if (node.attributes["name"]) {
-      allNames.add(toXml(node.attributes["name"].children).trim());
-    }
-    if (node.attributes["assignNames"]) {
-      const assignNames = toXml(
-        node.attributes["assignNames"].children
-      ).trim();
-      if (assignNames) {
-        for (const name22 of assignNames.split(/\s+/)) {
-          allNames.add(name22);
-        }
-      }
-    }
-  });
-  let name2 = baseName;
-  let i2 = 1;
-  while (allNames.has(name2)) {
-    name2 = `${baseName}${i2}`;
-    i2++;
-  }
-  return name2;
-}
 const componentInfoObjects = createComponentInfoObjects();
 function determinePropType(componentType, propName, nIndices = 0) {
   const publicStateVariableInfo = componentInfoObjects.publicStateVariableInfo[componentType];
@@ -244207,10 +244225,889 @@ function componentTypeFromWrapping(wrappingComponents, nDimensions, nIndices) {
   }
   return { foundComponentType: false };
 }
-const upgradeCollectElement = () => {
+function isModuleComponentType(componentType) {
+  return componentInfoObjects.isInheritedComponentType({
+    inheritedComponentType: componentType,
+    baseComponentType: "module"
+  });
+}
+function breakStringInPiecesBySpacesOrParens(string) {
+  if (typeof string !== "string") {
+    return { success: false };
+  }
+  let numParens = 0;
+  const pieces = [];
+  string = string.trim();
+  let beginInd = 0;
+  for (let ind = 0; ind < string.length; ind++) {
+    const char = string[ind];
+    if (char === "(") {
+      if (numParens === 0) {
+        const newPiece2 = string.substring(beginInd, ind).trim();
+        if (newPiece2.length > 0) {
+          pieces.push(newPiece2);
+        }
+        beginInd = ind;
+      }
+      numParens++;
+    } else if (char === ")") {
+      if (numParens === 0) {
+        return { success: false };
+      }
+      if (numParens === 1) {
+        const newPiece2 = string.substring(beginInd + 1, ind).trim();
+        if (newPiece2.length > 0) {
+          const result2 = breakStringInPiecesBySpacesOrParens(newPiece2);
+          if (result2.success === true) {
+            pieces.push(result2.pieces);
+          } else {
+            pieces.push(newPiece2);
+          }
+        }
+        beginInd = ind + 1;
+      }
+      numParens--;
+    } else if (numParens === 0 && char.match(/\s/)) {
+      const newPiece2 = string.substring(beginInd, ind).trim();
+      if (newPiece2.length > 0) {
+        pieces.push(newPiece2);
+      }
+      beginInd = ind;
+    }
+  }
+  if (numParens !== 0) {
+    return { success: false };
+  }
+  const newPiece = string.substring(beginInd, string.length).trim();
+  if (newPiece.length > 0) {
+    pieces.push(newPiece);
+  }
+  return { success: true, pieces };
+}
+function firstLeafName(pieces) {
+  for (const piece of pieces) {
+    if (typeof piece === "string") {
+      return piece;
+    }
+    const nested = firstLeafName(piece);
+    if (nested !== void 0) {
+      return nested;
+    }
+  }
+  return void 0;
+}
+const VALID_REFERENCEABLE_NAME = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+function isValidReferenceableName(name2) {
+  return VALID_REFERENCEABLE_NAME.test(name2);
+}
+function makeIndexedPathPart(name2, indices) {
+  return {
+    type: "pathPart",
+    name: name2,
+    index: indices.map((i2) => ({
+      type: "index",
+      value: [{ type: "text", value: `${i2}` }]
+    }))
+  };
+}
+class RenameRegistry {
+  constructor(existingNames = /* @__PURE__ */ new Set()) {
+    this._renames = /* @__PURE__ */ new Map();
+    this._matched = /* @__PURE__ */ new Set();
+    this._existingNames = existingNames;
+  }
+  /**
+   * Register that `oldName` should be replaced by `replacement` wherever it appears in
+   * a macro path. The first registration of a name wins; a later one warns.
+   *
+   * Pass `undefined` for `replacement` to claim the name without rewriting anything,
+   * which is what a composite that simply took the assigned name as its own `name`
+   * needs: references already resolve, but a later composite assigning the same name
+   * must not silently redirect them.
+   */
+  register(oldName, replacement, origin, file) {
+    if (!oldName) {
+      return;
+    }
+    const existing = this._renames.get(oldName) ?? [];
+    const scope = origin.ancestorNames ?? [];
+    const sameScope = existing.find(
+      (target) => sameScopeAs(target.origin.ancestorNames ?? [], scope)
+    );
+    if (sameScope) {
+      file.message(
+        `The name "${oldName}" is assigned by both <${sameScope.origin.elementName}> and <${origin.elementName}> in the same place; references to it were converted as if they referred to the first.`,
+        {
+          place: origin.position,
+          ruleId: "assign-names/duplicate-name",
+          source: "v06-to-v07"
+        }
+      );
+      return;
+    }
+    if (existing.length === 0 && this._existingNames.has(oldName)) {
+      file.message(
+        `The name "${oldName}" assigned by <${origin.elementName}> is also used as the "name" of another component; all references to "${oldName}" were converted to point at the <${origin.elementName}> replacement.`,
+        {
+          place: origin.position,
+          ruleId: "assign-names/shadows-existing-name",
+          source: "v06-to-v07"
+        }
+      );
+    }
+    existing.push({ replacement, origin });
+    this._renames.set(oldName, existing);
+  }
+  /**
+   * The rename for `name`, chosen by which of them the reference is reaching into.
+   *
+   * `precedingNames` are the path parts written before it, so `$g2.a` looks up `a` with
+   * `["g2"]`. The registration whose enclosing names are the longest match at the end of
+   * that wins; one recorded with no enclosing names matches anything, which is what
+   * keeps an unscoped document behaving exactly as before.
+   */
+  get(name2, precedingNames = [], writtenOn) {
+    const targets = this._renames.get(name2);
+    if (!targets || targets.length === 0) {
+      return void 0;
+    }
+    let best;
+    let bestScore = -1;
+    for (const target of targets) {
+      if (writtenOn && target.origin.element === writtenOn) {
+        continue;
+      }
+      const scope = target.origin.ancestorNames ?? [];
+      if (!isSuffixOf(scope, precedingNames)) {
+        continue;
+      }
+      if (scope.length > bestScore) {
+        best = target;
+        bestScore = scope.length;
+      }
+    }
+    if (best) {
+      this._matched.add(name2);
+    }
+    return best;
+  }
+  /** Whether `name` is registered *and* some registration rewrites references to it. */
+  hasReplacement(name2) {
+    return (this._renames.get(name2) ?? []).some(
+      (target) => target.replacement !== void 0
+    );
+  }
+  get size() {
+    return this._renames.size;
+  }
+  /** Registered names that were never referenced anywhere in the document. */
+  unused() {
+    return [...this._renames.keys()].filter((n2) => !this._matched.has(n2));
+  }
+}
+function sameScopeAs(a2, b2) {
+  return a2.length === b2.length && a2.every((name2, i2) => name2 === b2[i2]);
+}
+function isSuffixOf(scope, path) {
+  if (scope.length > path.length) {
+    return false;
+  }
+  const offset = path.length - scope.length;
+  return scope.every((name2, i2) => name2 === path[offset + i2]);
+}
+function collectExistingNames(tree) {
+  const names = /* @__PURE__ */ new Set();
+  visit(tree, (node) => {
+    if (!isDastElement(node)) {
+      return;
+    }
+    const nameAttr = Object.entries(node.attributes).find(
+      ([name2]) => name2.toLowerCase() === "name"
+    )?.[1];
+    if (nameAttr) {
+      const name2 = toXml(nameAttr.children).trim();
+      if (name2) {
+        names.add(name2);
+      }
+    }
+  });
+  return names;
+}
+function collectAllNames(tree) {
+  const names = collectExistingNames(tree);
+  visit(tree, (node) => {
+    if (!isDastElement(node)) {
+      return;
+    }
+    const assignNamesAttr = Object.entries(node.attributes).find(
+      ([name2]) => name2.toLowerCase() === "assignnames"
+    )?.[1];
+    if (!assignNamesAttr) {
+      return;
+    }
+    const assignNames = toXml(assignNamesAttr.children).trim();
+    for (const name2 of assignNames.split(/[\s()]+/)) {
+      if (name2) {
+        names.add(name2);
+      }
+    }
+  });
+  return names;
+}
+function createUniqueNameFactory(tree) {
+  const used = collectAllNames(tree);
+  return (baseName) => {
+    let name2 = baseName;
+    let i2 = 1;
+    while (used.has(name2)) {
+      name2 = `${baseName}${i2}`;
+      i2++;
+    }
+    used.add(name2);
+    return name2;
+  };
+}
+function isV06True(attr) {
+  if (!attr) {
+    return false;
+  }
+  const value = toXml(attr.children).trim().toLowerCase();
+  return value === "" || value === "true";
+}
+const COMPOSITES = {
+  select: {
+    name: "select",
+    count: { kind: "attr", attr: "numToSelect" },
+    grouping: { childName: "option" }
+  },
+  selectfromsequence: {
+    name: "selectFromSequence",
+    count: { kind: "attr", attr: "numToSelect" }
+  },
+  selectrandomnumbers: {
+    name: "selectRandomNumbers",
+    count: { kind: "attr", attr: "numToSelect" }
+  },
+  samplerandomnumbers: {
+    name: "sampleRandomNumbers",
+    count: { kind: "attr", attr: "numSamples" }
+  },
+  selectprimenumbers: {
+    name: "selectPrimeNumbers",
+    count: { kind: "attr", attr: "numToSelect" }
+  },
+  sampleprimenumbers: {
+    name: "samplePrimeNumbers",
+    count: { kind: "attr", attr: "numSamples" }
+  },
+  conditionalcontent: {
+    name: "conditionalContent",
+    count: { kind: "always-one" },
+    grouping: { childName: "case", alsoMatch: ["else"] }
+  },
+  lorem: { name: "lorem", count: { kind: "unknown" } },
+  sort: { name: "sort", count: { kind: "unknown" } },
+  shuffle: { name: "shuffle", count: { kind: "unknown" } },
+  group: { name: "group", count: { kind: "unknown" } },
+  sequence: { name: "sequence", count: { kind: "unknown" } },
+  substitute: { name: "substitute", count: { kind: "unknown" } },
+  split: { name: "split", count: { kind: "unknown" } },
+  intersection: { name: "intersection", count: { kind: "unknown" } },
+  extract: {
+    name: "extract",
+    count: { kind: "unknown" },
+    noV07Equivalent: true
+  }
+};
+function lookupComposite(node) {
+  return COMPOSITES[node.name.toLowerCase()];
+}
+function producesSingleReplacement(node, spec) {
+  if (spec.count.kind === "always-one") {
+    return true;
+  }
+  if (spec.count.kind === "unknown") {
+    return false;
+  }
+  const attr = findAttribute(node, spec.count.attr);
+  if (!attr) {
+    return true;
+  }
+  const raw = toXml(attr.children).trim();
+  return raw === "" || raw === "1";
+}
+function findAttribute(node, attrName) {
+  return Object.entries(node.attributes).find(
+    ([name2]) => name2.toLowerCase() === attrName.toLowerCase()
+  )?.[1];
+}
+function makePositionMap(node, spec, file) {
+  if (!spec.grouping) {
+    return void 0;
+  }
+  const names = [
+    spec.grouping.childName,
+    ...spec.grouping.alsoMatch || []
+  ].map((n2) => n2.toLowerCase());
+  const branches = node.children.filter(
+    (child) => isDastElement(child) && names.includes(child.name.toLowerCase())
+  );
+  if (branches.length === 0) {
+    return void 0;
+  }
+  return positionMapForBranches(
+    branches.map((branch) => branch.children),
+    node,
+    file
+  );
+}
+function makeTemplatePositionMap(template2, node, file) {
+  return positionMapForBranches([template2.children], node, file);
+}
+function positionMapForBranches(branches, node, file) {
+  const maps = branches.map((children) => branchPositionMap(children));
+  const first2 = maps[0];
+  if (maps.every((m2) => isIdentity(m2))) {
+    return void 0;
+  }
+  if (!maps.every((m2) => sameMap(m2, first2))) {
+    file.message(
+      `The branches of <${node.name}> mix plain text with components differently, so the positions that assignNames referred to cannot be determined; the first branch was used.`,
+      {
+        place: node.position,
+        ruleId: "assign-names/branch-index-skew",
+        source: "v06-to-v07"
+      }
+    );
+  }
+  file.message(
+    `<${node.name}> has a branch that mixes plain text with components. v0.6 skipped the text when assigning names but v0.7 counts it, so the converted indices are a best guess and should be checked.`,
+    {
+      place: node.position,
+      ruleId: "assign-names/primitive-skew",
+      source: "v06-to-v07"
+    }
+  );
+  const insideGroupingDepth = 2;
+  return (depth, ordinal) => {
+    if (depth !== insideGroupingDepth) {
+      return ordinal;
+    }
+    return first2[ordinal - 1];
+  };
+}
+function branchPositionMap(children) {
+  const result2 = [];
+  let position2 = 0;
+  for (const child of children) {
+    if (child.type === "text") {
+      if (child.value.trim() === "") {
+        continue;
+      }
+      position2++;
+      continue;
+    }
+    if (child.type === "comment" || child.type === "instruction") {
+      continue;
+    }
+    position2++;
+    result2.push(position2);
+  }
+  return result2;
+}
+function isIdentity(map2) {
+  return map2.every((v2, i2) => v2 === i2 + 1);
+}
+function sameMap(a2, b2) {
+  return a2.length === b2.length && a2.every((v2, i2) => v2 === b2[i2]);
+}
+function createAssignNamesContext(tree) {
+  const existingNames = collectExistingNames(tree);
+  const namespaceElements = /* @__PURE__ */ new WeakMap();
+  let unnamedCount = 0;
+  visit(tree, (node) => {
+    if (!isDastElement(node)) {
+      return;
+    }
+    const newNamespaceKey = Object.keys(node.attributes).find(
+      (key) => key.toLowerCase() === "newnamespace"
+    );
+    if (newNamespaceKey === void 0) {
+      return;
+    }
+    const newNamespaceValue = toXml(
+      node.attributes[newNamespaceKey].children
+    ).trim().toLowerCase();
+    if (newNamespaceValue !== "" && newNamespaceValue !== "true") {
+      return;
+    }
+    const nameAttr = findAttribute(node, "name");
+    const name2 = nameAttr ? toXml(nameAttr.children).trim() : "";
+    namespaceElements.set(node, name2 || `\0ns${++unnamedCount}`);
+  });
+  const context = {
+    registry: new RenameRegistry(existingNames),
+    uniqueName: createUniqueNameFactory(tree),
+    existingNames,
+    claimedNames: /* @__PURE__ */ new Set(),
+    namespaceElements,
+    existingNameScopes: /* @__PURE__ */ new Map()
+  };
+  visit(tree, (node, info) => {
+    if (!isDastElement(node)) {
+      return;
+    }
+    const nameAttr = findAttribute(node, "name");
+    const name2 = nameAttr ? toXml(nameAttr.children).trim() : "";
+    if (!name2) {
+      return;
+    }
+    const scopes = context.existingNameScopes.get(name2) ?? [];
+    scopes.push(namespaceChainOf(info.parents, context));
+    context.existingNameScopes.set(name2, scopes);
+  });
+  return context;
+}
+function nameTakenInScope(context, name2, ancestorNames) {
+  const scopes = context.existingNameScopes.get(name2);
+  if (!scopes) {
+    return false;
+  }
+  const here = ancestorNames ?? [];
+  return scopes.some(
+    (scope) => scope.length === here.length && scope.every((segment, i2) => segment === here[i2])
+  );
+}
+function chooseCompositeName(node, pieces, fallbackBase, context, file) {
+  const nameAttr = findAttribute(node, "name");
+  const existingName = nameAttr ? toXml(nameAttr.children).trim() : "";
+  if (existingName && isValidReferenceableName(existingName)) {
+    return existingName;
+  }
+  if (existingName) {
+    file?.message(
+      `<${node.name}> is called "${existingName}", which v0.7 cannot use as a name — it must start with a letter and hold only letters, digits, underscores and hyphens. A different name was used instead.`,
+      {
+        place: node.position,
+        ruleId: "assign-names/invalid-name",
+        source: "v06-to-v07"
+      }
+    );
+  }
+  const firstName = firstLeafName(pieces);
+  if (firstName && isValidReferenceableName(firstName) && !context.existingNames.has(firstName) && !context.claimedNames.has(firstName)) {
+    context.claimedNames.add(firstName);
+    return firstName;
+  }
+  return context.uniqueName(fallbackBase);
+}
+function setCompositeName(node, name2) {
+  const nameAttr = findAttribute(node, "name");
+  const oldKey = assignNamesKey(node);
+  if (nameAttr) {
+    if (toXml(nameAttr.children) !== name2) {
+      nameAttr.children = [{ type: "text", value: name2 }];
+    }
+    deleteAssignNames(node);
+    return;
+  }
+  if (oldKey !== void 0) {
+    renameAttrInPlace(node, oldKey, "name");
+    node.attributes["name"].children = [{ type: "text", value: name2 }];
+    return;
+  }
+  node.attributes["name"] = {
+    type: "attribute",
+    name: "name",
+    children: [{ type: "text", value: name2 }]
+  };
+}
+function readAssignNames(node) {
+  const key = assignNamesKey(node);
+  if (key === void 0) {
+    return void 0;
+  }
+  return toXml(node.attributes[key].children).trim();
+}
+function deleteAssignNames(node) {
+  const key = assignNamesKey(node);
+  if (key !== void 0) {
+    delete node.attributes[key];
+  }
+}
+function assignNamesKey(node) {
+  return Object.keys(node.attributes).find(
+    (k2) => k2.toLowerCase() === "assignnames"
+  );
+}
+function namespaceChainOf(parents, context) {
+  const chain2 = [];
+  for (const parent of parents) {
+    const segment = context.namespaceElements.get(parent);
+    if (segment !== void 0) {
+      chain2.push(segment);
+    }
+  }
+  return chain2.reverse();
+}
+function inheritNamespace(from, to2, context) {
+  const segment = context.namespaceElements.get(from);
+  if (segment !== void 0) {
+    context.namespaceElements.set(to2, segment);
+  }
+}
+const identityPositionMap = (_depth, ordinal) => ordinal;
+function registerAssignNames({
+  assignNamesValue,
+  compositeName,
+  registry,
+  origin,
+  file,
+  positionMap = identityPositionMap
+}) {
+  const result2 = breakStringInPiecesBySpacesOrParens(assignNamesValue);
+  if (!result2.success) {
+    file.message(
+      `Could not parse assignNames="${assignNamesValue}" on <${origin.elementName}> because its parentheses are unbalanced; references to those names were not converted.`,
+      {
+        place: origin.position,
+        ruleId: "assign-names/unbalanced-parens",
+        source: "v06-to-v07"
+      }
+    );
+    return false;
+  }
+  registerPieces(result2.pieces, []);
+  return true;
+  function registerPieces(pieces, indexPath) {
+    pieces.forEach((piece, i2) => {
+      const depth = indexPath.length + 1;
+      const position2 = positionMap(depth, i2 + 1);
+      if (position2 === void 0) {
+        reportNamesNothing(piece);
+        return;
+      }
+      const indices = [...indexPath, position2];
+      if (typeof piece === "string") {
+        if (!isValidReferenceableName(piece)) {
+          file.message(
+            `The assignNames token "${piece}" on <${origin.elementName}> is not a valid v0.7 name, so references to it were not converted.`,
+            {
+              place: origin.position,
+              ruleId: "assign-names/invalid-name",
+              source: "v06-to-v07"
+            }
+          );
+          return;
+        }
+        registry.register(
+          piece,
+          [makeIndexedPathPart(compositeName, indices)],
+          origin,
+          file
+        );
+      } else {
+        registerPieces(piece, indices);
+      }
+    });
+  }
+  function reportNamesNothing(piece) {
+    if (typeof piece !== "string") {
+      piece.forEach(reportNamesNothing);
+      return;
+    }
+    file.message(
+      `The assignNames token "${piece}" on <${origin.elementName}> named nothing in v0.6 — the position it was given holds no component — so references to it were not converted.`,
+      {
+        place: origin.position,
+        ruleId: "assign-names/names-nothing",
+        source: "v06-to-v07"
+      }
+    );
+  }
+}
+function registerCompositeAssignNames({
+  node,
+  assignNamesValue,
+  fallbackBase,
+  ancestorNames,
+  context,
+  file,
+  positionMap
+}) {
+  const origin = {
+    elementName: node.name,
+    position: node.position,
+    ancestorNames,
+    element: node
+  };
+  const parsed = breakStringInPiecesBySpacesOrParens(assignNamesValue);
+  if (!parsed.success) {
+    registerAssignNames({
+      assignNamesValue,
+      compositeName: "",
+      registry: context.registry,
+      origin,
+      file
+    });
+    return void 0;
+  }
+  if (firstLeafName(parsed.pieces) === void 0) {
+    return void 0;
+  }
+  const compositeName = chooseCompositeName(
+    node,
+    parsed.pieces,
+    fallbackBase,
+    context,
+    file
+  );
+  registerAssignNames({
+    assignNamesValue,
+    compositeName,
+    registry: context.registry,
+    origin,
+    file,
+    positionMap
+  });
+  return compositeName;
+}
+function visitAll(tree, visitor) {
+  walk(tree, [], void 0);
+  function walk(node, parents, attributeOwner) {
+    const isMacro = node.type === "macro" || node.type === "function";
+    if (!isMacro) {
+      visitor(node, parents, attributeOwner);
+    }
+    const innerParents = isDastElement(node) ? [node, ...parents] : parents;
+    if (isDastElement(node)) {
+      for (const attr of Object.values(node.attributes)) {
+        walkArray(attr.children, innerParents, node);
+      }
+    }
+    if (node.type === "macro") {
+      walkMacroAttributes(node, innerParents, attributeOwner);
+      walkMacroPath(node, innerParents, attributeOwner);
+      const accessedProp = node.accessedProp;
+      if (accessedProp) {
+        walk(accessedProp, innerParents, attributeOwner);
+      }
+    }
+    if (node.type === "function") {
+      const inner = node.macro;
+      if (inner) {
+        walk(inner, innerParents, attributeOwner);
+      }
+      walkMacroPath(node, innerParents, attributeOwner);
+      for (const inputPart of node.input || []) {
+        walkArray(
+          inputPart,
+          innerParents,
+          attributeOwner
+        );
+      }
+    }
+    if ("children" in node && Array.isArray(node.children)) {
+      walkArray(
+        node.children,
+        innerParents,
+        isDastElement(node) ? void 0 : attributeOwner
+      );
+    }
+    if (isMacro) {
+      visitor(node, parents, attributeOwner);
+    }
+  }
+  function walkMacroAttributes(node, parents, attributeOwner) {
+    const attrs = Array.isArray(node.attributes) ? node.attributes : Object.values(node.attributes);
+    for (const attr of attrs) {
+      walkArray(attr.children, parents, attributeOwner);
+    }
+  }
+  function walkMacroPath(node, parents, attributeOwner) {
+    for (const part of node.path || []) {
+      for (const index2 of part.index) {
+        walkArray(index2.value, parents, attributeOwner);
+      }
+    }
+  }
+  function walkArray(nodes, parents, attributeOwner) {
+    for (let i2 = 0; i2 < nodes.length; i2++) {
+      walk(nodes[i2], parents, attributeOwner);
+    }
+  }
+}
+function visitAllMacros(tree, visitor) {
+  visitAll(tree, (node, parents, attributeOwner) => {
+    if (node.type !== "macro" && node.type !== "function") {
+      return;
+    }
+    if (!Array.isArray(node.path)) {
+      return;
+    }
+    visitor(node, parents, attributeOwner);
+  });
+}
+const propAccessParts = /* @__PURE__ */ new WeakSet();
+function markAsPropAccess(part) {
+  propAccessParts.add(part);
+}
+function isPropAccess(part) {
+  return propAccessParts.has(part);
+}
+const rawPropPositions = /* @__PURE__ */ new WeakMap();
+function markRawPropPositions(node, attrName, positions) {
+  let byAttr = rawPropPositions.get(node);
+  if (!byAttr) {
+    byAttr = /* @__PURE__ */ new Map();
+    rawPropPositions.set(node, byAttr);
+  }
+  byAttr.set(attrName.toLowerCase(), positions);
+}
+function restoreRawPropPositions(node, attrName, path) {
+  const positions = rawPropPositions.get(node)?.get(attrName.toLowerCase());
+  if (!positions) {
+    return;
+  }
+  for (const position2 of positions) {
+    const part = path[position2];
+    if (part) {
+      markAsPropAccess(part);
+    }
+  }
+}
+const RAW_REFERENCE_ATTRS = {
+  copy: ["source"],
+  extract: ["source"]
+};
+function applyRefRenames(tree, registry, file, context) {
+  if (registry.size === 0) {
+    return;
+  }
+  visitAllMacros(tree, (node, parents, attributeOwner) => {
+    node.path = renamePath(
+      node.path,
+      registry,
+      file,
+      node.position,
+      namespaceChainOf(parents, context),
+      // A reference written on an element cannot mean the name that element is
+      // about to take: `<copy source="$x0" assignNames="x0">` reaches elsewhere
+      // for the thing it copies. References among its *children* are a different
+      // matter and keep their ownership clear, so `visitAll` reports none for them.
+      attributeOwner
+    );
+  });
+  visitAll(tree, (node, parents) => {
+    if (!isDastElement(node)) {
+      return;
+    }
+    const attrNames = RAW_REFERENCE_ATTRS[node.name.toLowerCase()];
+    if (!attrNames) {
+      return;
+    }
+    const enclosing = namespaceChainOf(parents, context);
+    for (const attrName of attrNames) {
+      renameRawReferenceAttribute(
+        node,
+        attrName,
+        registry,
+        file,
+        enclosing
+      );
+    }
+  });
+}
+function renameRawReferenceAttribute(node, attrName, registry, file, enclosingNames) {
+  const attr = Object.entries(node.attributes).find(
+    ([name2]) => name2.toLowerCase() === attrName.toLowerCase()
+  )?.[1];
+  if (!attr || attr.children.length !== 1) {
+    return;
+  }
+  const child = attr.children[0];
+  if (child.type !== "text") {
+    return;
+  }
+  const value = child.value.trim();
+  if (!value) {
+    return;
+  }
+  if (!value.split(/[^A-Za-z0-9_-]+/).some((piece) => registry.hasReplacement(piece))) {
+    return;
+  }
+  let path;
+  try {
+    path = parseReferencePath(value);
+  } catch (e4) {
+    file.message(
+      `Could not convert a reference to an assignNames name in ${attrName}="${value}".`,
+      {
+        place: node.position,
+        ruleId: "assign-names/unparsable-reference-attribute",
+        source: "v06-to-v07"
+      }
+    );
+    return;
+  }
+  restoreRawPropPositions(node, attrName, path);
+  const asMacro = { type: "macro", path, attributes: {} };
+  visitAllMacros(asMacro, (macro) => {
+    macro.path = renamePath(
+      macro.path,
+      registry,
+      file,
+      node.position,
+      enclosingNames,
+      // A copy's `source` says what it copies, which is never the copy itself:
+      // `<copy source="../x0" assignNames="x0">` names its result `x0` while
+      // reaching out of the namespace for the `x0` it copies.
+      node
+    );
+  });
+  child.value = toXml(asMacro.path);
+}
+function renamePath(path, registry, file, place, enclosingNames = [], writtenOn) {
+  if (!path.some((part) => registry.hasReplacement(part.name))) {
+    return path;
+  }
+  return path.flatMap((part, partIndex) => {
+    const target = registry.get(
+      part.name,
+      [...enclosingNames, ...path.slice(0, partIndex).map((p2) => p2.name)],
+      writtenOn
+    );
+    if (!target?.replacement) {
+      return [part];
+    }
+    if (partIndex > 0 && isPropAccess(part)) {
+      return [part];
+    }
+    const replacement = structuredClone(
+      target.replacement
+    );
+    const last2 = replacement[replacement.length - 1];
+    last2.index = [...last2.index, ...part.index];
+    return replacement;
+  });
+}
+function parseReferencePath(value) {
+  for (const candidate of [`$${value}`, `$(${value})`]) {
+    let reparsed;
+    try {
+      reparsed = reparseAttribute(candidate);
+    } catch (e4) {
+      continue;
+    }
+    if (reparsed.length === 1 && reparsed[0].type === "macro") {
+      return reparsed[0].path;
+    }
+  }
+  throw new Error(`Could not parse "${value}" as a reference`);
+}
+const upgradeCollectElement = (context) => {
   return (tree, file) => {
-    const refsToRename = {};
-    visit(tree, (node) => {
+    visit(tree, (node, info) => {
       if (!isDastElement(node)) {
         return;
       }
@@ -244220,50 +245117,45 @@ const upgradeCollectElement = () => {
       if (node.attributes["componentTypes"]) {
         renameAttrInPlace(node, "componentTypes", "componentType");
       }
-      if (node.attributes["source"]) {
-        renameAttrInPlace(node, "source", "from");
-        const fromValue = toXml(node.attributes["from"].children);
-        if (!fromValue.startsWith("$")) {
-          node.attributes["from"].children = reparseAttribute(
-            `$${fromValue}`
-          );
-        }
-      } else if (node.attributes["target"]) {
-        renameAttrInPlace(node, "target", "from");
-        const fromValue = toXml(node.attributes["from"].children);
-        if (!fromValue.startsWith("$")) {
-          node.attributes["from"].children = reparseAttribute(
-            `$${fromValue}`
-          );
+      for (const oldKey of ["source", "target"]) {
+        if (!node.attributes[oldKey]) {
+          continue;
         }
+        renameAttrInPlace(node, oldKey, "from");
+        makeFromAReference(node, file);
+        break;
       }
-      const assignNames = node.attributes["assignNames"];
-      if (!assignNames) {
+      const assignNamesValue = readAssignNames(node);
+      if (!assignNamesValue) {
+        deleteAssignNames(node);
         return;
       }
-      delete node.attributes["assignNames"];
-      const assignedNames = toXml(assignNames.children).split(/\s+/).filter((n2) => n2);
-      assignedNames.forEach((name2, index2) => {
-        const strRepr = `$${toXml(node.attributes["name"].children)}[${index2 + 1}]`;
-        const attr = reparseAttribute(strRepr)?.[0];
-        if (!attr || attr.type !== "macro") {
-          throw new Error(
-            `Expected attribute to be a single macro, got: ${JSON.stringify(attr)}`
-          );
-        }
-        refsToRename[name2] = attr.path;
+      const compositeName = registerCompositeAssignNames({
+        node,
+        assignNamesValue,
+        fallbackBase: "collect",
+        ancestorNames: namespaceChainOf(info.parents, context),
+        context,
+        file
       });
+      if (compositeName === void 0) {
+        deleteAssignNames(node);
+        return;
+      }
+      setCompositeName(node, compositeName);
     });
     replaceNode(tree, (node) => {
       if (!isDastElement(node) || node.name !== "collect") {
         return;
       }
-      const propAttr = node.attributes["prop"];
-      const propName = toXml(propAttr?.children).trim();
+      const propKey = Object.keys(node.attributes).find(
+        (key) => key.toLowerCase() === "prop"
+      );
+      const propName = propKey ? toXml(node.attributes[propKey].children).trim() : "";
       if (!propName) {
         return;
       }
-      delete node.attributes["prop"];
+      delete node.attributes[propKey];
       const setup = {
         type: "element",
         name: "setup",
@@ -244273,8 +245165,9 @@ const upgradeCollectElement = () => {
       const componentType = toXml(
         node.attributes["componentType"]?.children
       ).trim();
-      const listName = node.attributes["name"] ? toXml(node.attributes["name"].children) : getUniqueName(tree, "list");
-      const collectName = getUniqueName(tree, `collect_${listName}`);
+      const authoredListName = node.attributes["name"] ? toXml(node.attributes["name"].children).trim() : "";
+      const listName = authoredListName && isValidReferenceableName(authoredListName) ? authoredListName : context.uniqueName("list");
+      const collectName = context.uniqueName(`collect_${listName}`);
       node.attributes["name"] = {
         type: "attribute",
         name: "name",
@@ -244284,7 +245177,11 @@ const upgradeCollectElement = () => {
       if (!listType) {
         file.message(
           `Could not determine type for prop "${propName}" of component type "${componentType}". Using "math" as default.`,
-          { place: node.position }
+          {
+            place: node.position,
+            ruleId: "collect/unknown-prop-type",
+            source: "v06-to-v07"
+          }
         );
         listType = "math";
       }
@@ -244302,30 +245199,81 @@ const upgradeCollectElement = () => {
           extend: {
             type: "attribute",
             name: "extend",
-            children: reparseAttribute(
-              `$${collectName}.${propName}`
-            )
+            children: [
+              {
+                type: "macro",
+                path: [
+                  ...parseReferencePath(collectName),
+                  ...propPathParts(propName, node, file)
+                ],
+                attributes: {}
+              }
+            ]
           }
         },
         children: []
       };
       return [setup, list];
     });
-    visit(tree, (node) => {
-      if (node.type !== "macro") {
-        return;
-      }
-      if (!node.path.some((part) => refsToRename[part.name])) {
-        return;
-      }
-      node.path = node.path.flatMap((part) => {
-        return refsToRename[part.name] || [part];
-      });
-    });
   };
 };
+function makeFromAReference(node, file) {
+  const attr = node.attributes["from"];
+  const value = toXml(attr.children).trim();
+  if (!value || value.startsWith("$")) {
+    return;
+  }
+  try {
+    attr.children = [
+      {
+        type: "macro",
+        path: parseReferencePath(value),
+        attributes: {}
+      }
+    ];
+  } catch {
+    file.message(
+      `Could not read "${value}" as the name of what <collect> collects from.`,
+      {
+        place: node.position,
+        ruleId: "collect/unparsable-from",
+        source: "v06-to-v07"
+      }
+    );
+  }
+}
+function propPathParts(propName, node, file) {
+  let parts;
+  try {
+    parts = parseReferencePath(propName);
+  } catch {
+    file.message(
+      `<collect prop="${propName}"> could not be turned into a reference, so the generated list extends a path that needs fixing by hand.`,
+      {
+        place: node.position,
+        ruleId: "collect/unparsable-prop",
+        source: "v06-to-v07"
+      }
+    );
+    return [{ type: "pathPart", name: propName, index: [] }];
+  }
+  parts.forEach(markAsPropAccess);
+  return parts;
+}
 const upgradePathSlashesToDots = () => {
   return (tree, file) => {
+    const warnParentPath = (original) => {
+      file.message(
+        `There is no equivalent to the $(../x) syntax; a best-guess was made when converting ${macroToString(
+          original
+        )}`,
+        {
+          place: original.position,
+          ruleId: "no-v07-equivalent/parent-path",
+          source: "v06-to-v07"
+        }
+      );
+    };
     visit(
       tree,
       // @ts-ignore
@@ -244336,44 +245284,17 @@ const upgradePathSlashesToDots = () => {
         }
         if (isDastElement(node)) {
           for (const attr of Object.values(node.attributes)) {
-            for (const child of attr.children) {
-              if (isV06MacroOrFunctionMacro(child)) {
-                macros.push(child);
-              }
-            }
+            collectV06Macros(attr.children, macros);
           }
         }
         for (const node2 of macros) {
-          const macro = node2.type === "macro" ? v06MacroToV07Macro(node2) : v06FunctionMacroToV07FunctionMacro(node2);
+          const macro = node2.type === "macro" ? v06MacroToV07Macro(node2, warnParentPath) : v06FunctionMacroToV07FunctionMacro(
+            node2,
+            warnParentPath
+          );
           Object.keys(node2).forEach((key) => {
             delete node2[key];
           });
-          if (macro.path.some((p2) => p2.name === "..")) {
-            const newPath = [];
-            let errorMessageWritten = false;
-            for (const part of macro.path) {
-              if (part.name === "..") {
-                if (newPath.length > 0) {
-                  newPath.pop();
-                  if (!errorMessageWritten) {
-                    errorMessageWritten = true;
-                    file.message(
-                      `There is no equivalent to the $(../x) syntax; a best-guess was made when converting ${macroToString(
-                        macro
-                      )}`,
-                      {
-                        start: node2.position?.start,
-                        end: node2.position?.end
-                      }
-                    );
-                  }
-                }
-                continue;
-              }
-              newPath.push(part);
-            }
-            macro.path = newPath;
-          }
           Object.assign(node2, macro);
         }
       }
@@ -244382,24 +245303,54 @@ const upgradePathSlashesToDots = () => {
       if (!isDastElement(node)) {
         return;
       }
+      if (!ELEMENTS_WITH_REFERENCE_SOURCE.has(node.name.toLowerCase())) {
+        return;
+      }
       const sourceAttr = node.attributes["source"];
       if (!sourceAttr) {
         return;
       }
       const sourceName = toXml(sourceAttr.children).trim();
-      if (!sourceName.includes("/")) {
+      const hasSlash = sourceName.includes("/");
+      if (!hasSlash && !sourceName.includes(".")) {
         return;
       }
       const reparsedSource = parseMacrosV06(`$(${sourceName})`);
       if (reparsedSource.length !== 1 || reparsedSource[0].type !== "macro") {
-        file.message(
-          `Could not reparse "source" attribute that contains a slash: "${sourceName}".`,
-          { place: node.position }
-        );
+        if (hasSlash) {
+          file.message(
+            `Could not reparse "source" attribute that contains a slash: "${sourceName}".`,
+            {
+              place: node.position,
+              ruleId: "copy/unparsable-source",
+              source: "v06-to-v07"
+            }
+          );
+        }
         return;
       }
-      const upgradedSource = v06MacroToV07Macro(reparsedSource[0]);
+      const upgradedSource = v06MacroToV07Macro(
+        reparsedSource[0],
+        () => file.message(
+          `There is no equivalent to the ../x syntax; a best-guess was made when converting source="${sourceName}"`,
+          {
+            place: node.position,
+            ruleId: "no-v07-equivalent/parent-path",
+            source: "v06-to-v07"
+          }
+        )
+      );
+      markRawPropPositions(
+        node,
+        "source",
+        upgradedSource.path.flatMap(
+          (part, index2) => isPropAccess(part) ? [index2] : []
+        )
+      );
       const newSourceName = toXml(upgradedSource.path);
+      if (newSourceName === sourceName) {
+        return;
+      }
       sourceAttr.children = [
         {
           type: "text",
@@ -244410,12 +245361,44 @@ const upgradePathSlashesToDots = () => {
     });
   };
 };
-function v06MacroToV07Macro(macro) {
-  const path = flattenedAccessedProps(macro);
+function collectV06Macros(nodes, macros) {
+  for (const node of nodes) {
+    if (isV06MacroOrFunctionMacro(node)) {
+      macros.push(node);
+    }
+  }
+}
+const ELEMENTS_WITH_REFERENCE_SOURCE = /* @__PURE__ */ new Set(["copy", "collect", "extract"]);
+function collapseParentPathParts(path, warn) {
+  if (!path.some((part) => part.name === "..")) {
+    return path;
+  }
+  const newPath = [];
+  let warned = false;
+  for (const part of path) {
+    if (part.name === "..") {
+      if (newPath.length > 0) {
+        newPath.pop();
+      }
+      if (!warned) {
+        warned = true;
+        warn();
+      }
+      continue;
+    }
+    newPath.push(part);
+  }
+  return newPath;
+}
+function v06MacroToV07Macro(macro, warn, reportAs = macro) {
+  const path = collapseParentPathParts(
+    flattenedAccessedProps(macro, warn),
+    () => warn(reportAs)
+  );
   const { accessedProp, version: version2, attributes, ...rest2 } = macro;
   return {
     ...rest2,
-    attributes: v06AttributeToV07Attribute(mergeAttributes(macro)),
+    attributes: v06AttributeToV07Attribute(mergeAttributes(macro), warn),
     path
   };
 }
@@ -244433,35 +245416,56 @@ function mergeAttributes(macro) {
   }
   return ret;
 }
-function v06FunctionMacroToV07FunctionMacro(funcMacro) {
-  const macro = v06MacroToV07Macro(funcMacro.macro);
+function v06FunctionMacroToV07FunctionMacro(funcMacro, warn) {
+  const macro = v06MacroToV07Macro(funcMacro.macro, warn, funcMacro);
   return {
     type: "function",
     path: macro.path,
-    // This cast may be incorrect, but we will leave it to the other processors to upgrade the
-    // the syntax of function arguments.
-    input: funcMacro.input,
+    input: convertArguments(funcMacro.input, warn),
     position: funcMacro.position
   };
 }
-function v06IndexToV07Index(index2) {
+function convertArguments(input, warn) {
+  if (!input) {
+    return null;
+  }
+  return input.map(
+    (argument) => argument.map((node) => {
+      if (isV06MacroOrFunctionMacro(node)) {
+        return node.type === "macro" ? v06MacroToV07Macro(node, warn) : v06FunctionMacroToV07FunctionMacro(node, warn);
+      }
+      return node;
+    })
+  );
+}
+function v06IndexToV07Index(index2, warn) {
   return index2.map((ind) => ({
     ...ind,
-    value: ind.value.map(
-      (v2) => v2.type === "macro" ? v06MacroToV07Macro(v2) : v2
-    )
+    // @ts-ignore -- see the note on `value` below
+    // The DAST types say an index holds only text and plain macros, but the v0.6
+    // parser does put a function macro in one (`$list[$$(g/h)(2)]`), so both have
+    // to be converted here — this is the only pass that reaches them.
+    value: ind.value.map((v2) => {
+      if (v2.type === "macro") {
+        return v06MacroToV07Macro(v2, warn);
+      }
+      if (v2.type === "function") {
+        return v06FunctionMacroToV07FunctionMacro(v2, warn);
+      }
+      return v2;
+    })
   }));
 }
-function v06AttributeToV07Attribute(attrs) {
+function v06AttributeToV07Attribute(attrs, warn) {
   const ret = {};
   attrs = Array.isArray(attrs) ? attrs : Object.values(attrs);
   for (const attr of attrs) {
     const children = attr.children.map((c2) => {
       if (c2.type === "macro") {
-        return v06MacroToV07Macro(c2);
+        return v06MacroToV07Macro(c2, warn);
       }
       if (c2.type === "function") {
-        return v06FunctionMacroToV07FunctionMacro(c2);
+        return v06FunctionMacroToV07FunctionMacro(c2, warn);
       }
       return c2;
     });
@@ -244472,15 +245476,17 @@ function v06AttributeToV07Attribute(attrs) {
   }
   return ret;
 }
-function flattenedAccessedProps(macro) {
+function flattenedAccessedProps(macro, warn) {
   const path = macro.path.map((p2) => {
     return {
       ...p2,
-      index: v06IndexToV07Index(p2.index)
+      index: v06IndexToV07Index(p2.index, warn)
     };
   });
   if (macro.accessedProp) {
-    return [...path, ...flattenedAccessedProps(macro.accessedProp)];
+    const propParts = flattenedAccessedProps(macro.accessedProp, warn);
+    propParts.forEach(markAsPropAccess);
+    return [...path, ...propParts];
   }
   return path;
 }
@@ -245235,9 +246241,26 @@ async function createCoreForLookup({ dast }) {
   const wasmBuffer = (await import("./lib_doenetml_worker_bg-BJtDoC-f.js")).default;
   await __wbg_init({ module_or_path: wasmBuffer });
   const rustCore = PublicDoenetMLCore.new();
-  dast = normalizeDocumentDast(structuredClone(dast), true);
-  rustCore.set_source(dast, toXml(dast));
-  const normalizedRoot = rustCore.return_normalized_dast_root();
+  let core2;
+  async function releaseCores() {
+    try {
+      await core2?.terminate();
+    } catch (e4) {
+    }
+    try {
+      rustCore.free();
+    } catch (e4) {
+    }
+  }
+  let normalizedRoot;
+  try {
+    dast = normalizeDocumentDast(structuredClone(dast), true);
+    rustCore.set_source(dast, toXml(dast));
+    normalizedRoot = rustCore.return_normalized_dast_root();
+  } catch (e4) {
+    await releaseCores();
+    throw e4;
+  }
   function resolvePath(path, origin, skip_parent_search) {
     return rustCore.resolve_path(path, origin, skip_parent_search);
   }
@@ -245248,44 +246271,62 @@ async function createCoreForLookup({ dast }) {
     rustCore.delete_nodes_from_resolver(node_list);
   }
   const flags = { ...defaultFlags };
-  const core2 = new PublicDoenetMLCore$1();
-  core2.setSource(toXml(dast));
-  core2.setFlags(flags);
-  await core2.initializeWorker({
-    activityId: "",
-    docId: "1",
-    requestedVariantIndex: 1,
-    attemptNumber: 1,
-    normalizedRoot,
-    addNodesToResolver,
-    deleteNodesFromResolver,
-    resolvePath
-  });
-  const dastResult = await core2.createCoreGenerateDast(
-    {
-      coreId: "",
-      cid: "",
-      initializeCounters: {},
-      theme: "light"
-    },
-    () => null,
-    () => null,
-    () => null,
-    () => null,
-    () => null,
-    () => null,
-    async () => ({ allowView: true })
-  );
-  if (!dastResult.success) {
-    throw Error(dastResult.errMsg);
+  try {
+    core2 = new PublicDoenetMLCore$1();
+    core2.setSource(toXml(dast));
+    core2.setFlags(flags);
+    await core2.initializeWorker({
+      activityId: "",
+      docId: "1",
+      requestedVariantIndex: 1,
+      attemptNumber: 1,
+      normalizedRoot,
+      addNodesToResolver,
+      deleteNodesFromResolver,
+      resolvePath
+    });
+    const dastResult = await core2.createCoreGenerateDast(
+      {
+        coreId: "",
+        cid: "",
+        initializeCounters: {},
+        theme: "light"
+      },
+      () => null,
+      () => null,
+      () => null,
+      () => null,
+      () => null,
+      () => null,
+      async () => ({ allowView: true })
+    );
+    if (!dastResult.success) {
+      throw Error(dastResult.errMsg);
+    }
+  } catch (e4) {
+    await releaseCores();
+    throw e4;
+  }
+  const readyCore = core2;
+  if (!readyCore) {
+    await releaseCores();
+    throw Error("The DoenetML core was not initialized.");
   }
   function resolvePathToNodeIdx(name2, origin = 0) {
     if (name2.startsWith("$")) {
       name2 = name2.slice(1);
     }
-    return resolvePathImmediatelyToNodeIdx(name2, rustCore, core2, origin);
+    return resolvePathImmediatelyToNodeIdx(
+      name2,
+      rustCore,
+      readyCore,
+      origin
+    );
   }
-  return { core: core2, rustCore, resolvePathToNodeIdx };
+  async function dispose() {
+    await releaseCores();
+  }
+  return { core: readyCore, rustCore, resolvePathToNodeIdx, dispose };
 }
 const upgradeCopySyntax = () => {
   return async (tree, file) => {
@@ -245302,91 +246343,128 @@ const upgradeCopySyntax = () => {
     if (skip) {
       return;
     }
-    const core2 = await createCoreForLookup({ dast: tree });
-    let referenced = [];
-    visit(tree, (node) => {
-      if (!isDastElement(node) || node.name !== "copy") {
-        return;
-      }
-      let referentName = toXml(node.attributes["source"]?.children);
-      if (!referentName) {
-        return;
-      }
-      if (node.attributes["prop"]) {
-        const propName = toXml(node.attributes["prop"].children).trim();
-        if (propName) {
-          referentName += `.${propName}`;
-        }
-        delete node.attributes["prop"];
-      }
-      if (node.attributes["assignNames"]) {
-        if (node.attributes["name"]) {
-          file.message(
-            `The <copy> tag with source="${referentName}" has both "name" and "assignNames" attributes. "name" will be ignored.`,
-            node.position?.start
-          );
-          delete node.attributes["name"];
+    let core2;
+    try {
+      core2 = await createCoreForLookup({ dast: tree });
+    } catch (e4) {
+      file.message(
+        `Could not load the document to work out what the <copy> tags refer to, so they were left as they are: ${e4}`,
+        {
+          ruleId: "copy/could-not-load-document",
+          source: "v06-to-v07"
         }
-        renameAttrInPlace(node, "assignNames", "name");
+      );
+      return;
+    }
+    try {
+      await resolveCopyTags(core2, tree, file);
+    } finally {
+      await core2.dispose();
+    }
+  };
+};
+async function resolveCopyTags(core2, tree, file) {
+  const referenced = [];
+  visit(tree, (node) => {
+    if (!isDastElement(node) || node.name !== "copy") {
+      return;
+    }
+    if (Object.keys(node.attributes).some(
+      (key) => key.toLowerCase() === "uri"
+    )) {
+      return;
+    }
+    let referentName = toXml(node.attributes["source"]?.children).trim();
+    if (!referentName) {
+      return;
+    }
+    const propKey = Object.keys(node.attributes).find(
+      (key) => key.toLowerCase() === "prop"
+    );
+    if (propKey) {
+      const propName = toXml(node.attributes[propKey].children).trim();
+      if (propName) {
+        referentName += `.${propName}`;
       }
-      referenced.push({
-        node,
-        referentType: findReferentType(core2, referentName),
-        referentName
-      });
-    });
-    for (let {
+    }
+    referenced.push({
       node,
-      referentType: referentPromise,
-      referentName
-    } of referenced) {
-      try {
-        const referentType = await referentPromise;
-        const targetTag = toXml(
-          node.attributes["link"]?.children || []
-        ).toLowerCase() === "false" ? "copy" : "extend";
-        if (node.attributes["link"]) {
-          delete node.attributes["link"];
-        }
-        renameAttrInPlace(node, "source", targetTag);
-        if (!referentName.startsWith("$")) {
-          referentName = `$${referentName}`;
-        }
-        node.attributes[targetTag].children = reparseAttribute(referentName);
-        node.name = referentType;
-      } catch (e4) {
-        file.message(
-          `Could not resolve referent type for <copy> tag with source="${referentName}": ${e4}`,
-          node.position?.start
-        );
-        continue;
+      referentType: findReferentType(core2, referentName),
+      referentName,
+      propKey
+    });
+  });
+  for (let {
+    node,
+    referentType: referentPromise,
+    referentName,
+    propKey
+  } of referenced) {
+    try {
+      const referentType = await referentPromise;
+      if (propKey) {
+        delete node.attributes[propKey];
+      }
+      const linkKey = Object.keys(node.attributes).find(
+        (key) => key.toLowerCase() === "link"
+      );
+      const targetTag = linkKey ? isV06True(node.attributes[linkKey]) ? "extend" : "copy" : isModuleComponentType(referentType) ? "copy" : "extend";
+      if (linkKey) {
+        delete node.attributes[linkKey];
       }
+      renameAttrInPlace(node, "source", targetTag);
+      const bareName = referentName.startsWith("$") ? referentName.slice(1) : referentName;
+      node.attributes[targetTag].children = [
+        {
+          type: "macro",
+          path: parseReferencePath(bareName),
+          attributes: {}
+        }
+      ];
+      node.name = referentType;
+    } catch (e4) {
+      file.message(
+        `Could not resolve referent type for <copy> tag with source="${referentName}": ${e4}`,
+        {
+          place: node.position,
+          ruleId: "copy/unresolved-referent",
+          source: "v06-to-v07"
+        }
+      );
+      continue;
     }
-  };
-};
-async function findReferentType(core2, referentName) {
-  if (!referentName.startsWith("$")) {
-    referentName = `$${referentName}`;
   }
-  const reparsed = reparseAttribute(referentName);
-  const path = reparsed[0]?.type === "macro" ? reparsed[0].path : null;
-  if (!path) {
+}
+async function findReferentType(core2, referentName) {
+  const bare = referentName.startsWith("$") ? referentName.slice(1) : referentName;
+  let path;
+  try {
+    path = parseReferencePath(bare);
+  } catch (e4) {
     throw new Error(`Could not parse referent name "${referentName}"`);
   }
   let unresolvedIndex = [];
   let unresolvedProps = [];
   let referentType = void 0;
-  for (let i2 = path.length; i2 > 0; i2--) {
+  search: for (let i2 = path.length; i2 > 0; i2--) {
     const pathParts = path.slice(0, i2);
-    const pathStr = printPathWithoutIndices(pathParts);
-    const referentIdx = await core2.resolvePathToNodeIdx(pathStr);
-    if (referentIdx !== -1) {
-      referentType = core2.core.core?.components?.[referentIdx]?.componentType;
-      if (referentType) {
-        unresolvedIndex = pathParts[pathParts.length - 1].index;
-        unresolvedProps = path.slice(i2);
-        break;
+    for (const keepIndices of [true, false]) {
+      if (keepIndices && !hasOnlyLiteralIndices(pathParts)) {
+        continue;
+      }
+      const pathStr = keepIndices ? printPath(pathParts) : printPathWithoutIndices(pathParts);
+      const referentIdx = await core2.resolvePathToNodeIdx(pathStr);
+      if (referentIdx === -1) {
+        continue;
       }
+      const foundType = core2.core.core?.components?.[referentIdx]?.componentType;
+      if (!foundType || foundType.startsWith("_")) {
+        continue;
+      }
+      referentType = foundType;
+      unresolvedIndex = keepIndices ? [] : pathParts.flatMap((part) => part.index);
+      unresolvedProps = path.slice(i2);
+      break search;
     }
   }
   if (unresolvedIndex.length !== 0) {
@@ -245408,14 +246486,287 @@ async function findReferentType(core2, referentName) {
   }
   throw new Error(`Could not find referent type for "${referentName}"`);
 }
+function hasOnlyLiteralIndices(pathParts) {
+  return pathParts.every(
+    (part) => part.index.every(
+      (index2) => index2.value.length === 1 && index2.value[0].type === "text" && /^\d+$/.test(index2.value[0].value.trim())
+    )
+  );
+}
+function printPath(pathParts) {
+  return pathParts.map(
+    (part) => part.name + part.index.map((index2) => `[${toXml(index2.value).trim()}]`).join("")
+  ).join(".");
+}
 function printPathWithoutIndices(pathParts) {
   return pathParts.map((part) => {
     return part.name;
   }).join(".");
 }
-const upgradeAttributeSyntax = () => {
+const upgradeCopyElements = (context) => {
+  return (tree, file) => {
+    visit(tree, (node, info) => {
+      if (!isDastElement(node)) {
+        return;
+      }
+      if (node.name.toLowerCase() === "ref") {
+        warnAboutExternalRef(node, file);
+        return;
+      }
+      if (node.name.toLowerCase() !== "copy") {
+        return;
+      }
+      convertAssignNames(
+        node,
+        namespaceChainOf(info.parents, context),
+        context,
+        file
+      );
+      const uriKey = findKey$1(node, "uri");
+      if (!uriKey) {
+        return;
+      }
+      const uri = toXml(node.attributes[uriKey].children).trim();
+      if (!uri.toLowerCase().startsWith("doenet:")) {
+        return;
+      }
+      const passedAttributes = Object.keys(node.attributes).filter(
+        (key) => !COPY_OWN_ATTRIBUTES.has(key.toLowerCase())
+      );
+      if (passedAttributes.length === 0) {
+        file.message(
+          `<copy uri="${uri}"> could not be converted: v0.7 loads external content with a "copy" attribute on an element of the same component type as the external document, and this copy passes no attributes to indicate what that type is. Replace it with, for example, <problem copy="doenet:<contentId>" /> once the target has been converted.`,
+          {
+            place: node.position,
+            ruleId: "external-copy/unknown-component-type",
+            source: "v06-to-v07"
+          }
+        );
+        return;
+      }
+      const narrowing = Object.keys(node.attributes).filter(
+        (key) => COPY_NARROWING_ATTRIBUTES.has(key.toLowerCase())
+      );
+      if (narrowing.length > 0) {
+        file.message(
+          `<copy uri="${uri}"> could not be converted because it also sets ${narrowing.join(
+            ", "
+          )}, which changes what it copies; v0.7 has no way to say that on the element that loads an external document. Convert it by hand.`,
+          {
+            place: node.position,
+            ruleId: "external-copy/narrowed",
+            source: "v06-to-v07"
+          }
+        );
+        return;
+      }
+      const dropped = Object.keys(node.attributes).filter(
+        (key) => COPY_CONTROL_ATTRIBUTES.has(key.toLowerCase())
+      );
+      for (const key of dropped) {
+        delete node.attributes[key];
+      }
+      const linkKey = findKey$1(node, "link");
+      const targetTag = linkKey && isV06True(node.attributes[linkKey]) ? "extend" : "copy";
+      if (linkKey) {
+        delete node.attributes[linkKey];
+      }
+      node.name = "module";
+      renameAttrInPlace(node, uriKey, targetTag);
+      if (dropped.length > 0) {
+        file.message(
+          `Dropped ${dropped.join(
+            ", "
+          )} from <copy uri="${uri}">: they controlled how v0.6 copied, and a <module ${targetTag}="doenet:..."> has no equivalent.`,
+          {
+            place: node.position,
+            ruleId: "external-copy/dropped-copy-controls",
+            source: "v06-to-v07"
+          }
+        );
+      }
+      file.message(
+        `Converted <copy uri="${uri}"> to <module ${targetTag}="${uri}">, passing ${passedAttributes.join(", ")}. The identifier in the URI is a v0.6 one; replace it with the v0.7 content id of the converted module, and check that the target really is a <module>.`,
+        {
+          place: node.position,
+          ruleId: "external-copy/needs-new-content-id",
+          source: "v06-to-v07"
+        }
+      );
+    });
+  };
+};
+const COPY_NARROWING_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "componentindex",
+  "createcomponentoftype",
+  "numcomponents",
+  "obtainpropfromcomposite",
+  "prop",
+  "propindex",
+  "removeemptyarrayentries",
+  "source",
+  "sourceindex",
+  "sourcesubnames",
+  "sourcesubnamescomponentindex",
+  "target",
+  "tname"
+]);
+const COPY_CONTROL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "assignnamesskip",
+  "assignnewnamespaces",
+  "sourceattributestoignore"
+]);
+const COPY_OWN_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "assignnames",
+  "assignnamesskip",
+  "assignnewnamespaces",
+  "componentindex",
+  "createcomponentoftype",
+  "link",
+  "name",
+  "newnamespace",
+  "numcomponents",
+  "obtainpropfromcomposite",
+  "prop",
+  "propindex",
+  "removeemptyarrayentries",
+  "source",
+  "sourceattributestoignore",
+  "sourceindex",
+  "sourcesubnames",
+  "sourcesubnamescomponentindex",
+  "target",
+  "tname",
+  "uri"
+]);
+function convertAssignNames(node, ancestorNames, context, file) {
+  const assignNamesValue = readAssignNames(node);
+  if (!assignNamesValue) {
+    deleteAssignNames(node);
+    return;
+  }
+  const origin = {
+    elementName: node.name,
+    position: node.position,
+    ancestorNames,
+    element: node
+  };
+  const parsed = breakStringInPiecesBySpacesOrParens(assignNamesValue);
+  const names = parsed.success && parsed.pieces.every((p2) => typeof p2 === "string") ? parsed.pieces : void 0;
+  if (!names || names.length !== 1) {
+    file.message(
+      `assignNames="${assignNamesValue}" on <${node.name}> could not be converted: the names refer to the replacements of the copied component, and this converter cannot tell how many of those there are. References to those names need fixing by hand.`,
+      {
+        place: node.position,
+        ruleId: "copy/unmapped-assign-names",
+        source: "v06-to-v07"
+      }
+    );
+    deleteAssignNames(node);
+    return;
+  }
+  const [assignedName] = names;
+  const existingName = toXml(
+    node.attributes[findKey$1(node, "name") ?? ""]?.children ?? []
+  ).trim();
+  const nameIsUnusable = !isValidReferenceableName(assignedName);
+  const nameBelongsToAnother = nameIsUnusable || nameTakenInScope(context, assignedName, ancestorNames);
+  const nameIsTaken = nameBelongsToAnother || context.existingNames.has(assignedName) || context.claimedNames.has(assignedName);
+  if (existingName && !isValidReferenceableName(existingName)) {
+    file.message(
+      `<${node.name}> is called "${existingName}", which v0.7 cannot use as a name — it must start with a letter and hold only letters, digits, underscores and hyphens. A generated name was used instead and references to "${assignedName}" were left alone.`,
+      {
+        place: node.position,
+        ruleId: "assign-names/invalid-name",
+        source: "v06-to-v07"
+      }
+    );
+    deleteAssignNames(node);
+    setCompositeName(node, context.uniqueName("copy"));
+    return;
+  }
+  if (existingName) {
+    if (existingName !== assignedName && !nameBelongsToAnother) {
+      context.registry.register(
+        assignedName,
+        [makeIndexedPathPart(existingName, [])],
+        origin,
+        file
+      );
+    } else if (existingName !== assignedName) {
+      reportUnusableName(node, assignedName, nameIsUnusable, file);
+    }
+    deleteAssignNames(node);
+    setCompositeName(node, existingName);
+    return;
+  }
+  if (nameIsTaken) {
+    const generated = context.uniqueName("copy");
+    if (nameBelongsToAnother) {
+      reportUnusableName(node, assignedName, nameIsUnusable, file);
+    } else {
+      context.registry.register(
+        assignedName,
+        [makeIndexedPathPart(generated, [])],
+        origin,
+        file
+      );
+    }
+    deleteAssignNames(node);
+    setCompositeName(node, generated);
+    return;
+  }
+  context.claimedNames.add(assignedName);
+  context.registry.register(assignedName, void 0, origin, file);
+  setCompositeName(node, assignedName);
+}
+function warnAboutExternalRef(node, file) {
+  const toKey = findKey$1(node, "to");
+  if (!toKey) {
+    return;
+  }
+  const target = toXml(node.attributes[toKey].children).trim();
+  if (!/^doenet:.*(activityId|doenetId|cid|pageId)=/i.test(target)) {
+    return;
+  }
+  file.message(
+    `<ref to="${target}"> points at a v0.6 activity; replace the identifier with the v0.7 content id (or a doenet.org URL) of the converted document.`,
+    {
+      place: node.position,
+      ruleId: "external-ref/needs-new-content-id",
+      source: "v06-to-v07"
+    }
+  );
+}
+function reportUnusableName(node, assignedName, nameIsUnusable, file) {
+  if (nameIsUnusable) {
+    file.message(
+      `<${node.name}> assigns the name "${assignedName}", which v0.7 cannot use as a name — it must start with a letter and hold only letters, digits, underscores and hyphens. A generated name was used instead and references to "${assignedName}" were left alone.`,
+      {
+        place: node.position,
+        ruleId: "assign-names/invalid-name",
+        source: "v06-to-v07"
+      }
+    );
+    return;
+  }
+  file.message(
+    `<${node.name}> assigns the name "${assignedName}", but something else in the document is already called that. References to "${assignedName}" were left pointing where they already pointed.`,
+    {
+      place: node.position,
+      ruleId: "copy/name-already-taken",
+      source: "v06-to-v07"
+    }
+  );
+}
+function findKey$1(node, attrName) {
+  return Object.keys(node.attributes).find(
+    (key) => key.toLowerCase() === attrName.toLowerCase()
+  );
+}
+const upgradeAttributeSyntax = (context) => {
   return async (tree, file) => {
-    visit(tree, (node) => {
+    visit(tree, (node, info) => {
       if (node.type !== "macro") {
         return;
       }
@@ -245441,6 +246792,18 @@ const upgradeAttributeSyntax = () => {
         }
       });
       Object.assign(node, copy2);
+      const assigned = readAssignNames(node);
+      convertAssignNames(
+        node,
+        namespaceChainOf(info.parents, context),
+        context,
+        file
+      );
+      warnIfNameCouldNotBeKept(
+        node,
+        assigned,
+        file
+      );
     });
     const macrosInAttributes = [];
     visit(tree, (node, info) => {
@@ -245534,39 +246897,34 @@ const upgradeAttributeSyntax = () => {
     documentElement.children.unshift(setupTag);
   };
 };
-const upgradeMapElement = () => {
+function warnIfNameCouldNotBeKept(node, assigned, file) {
+  if (!assigned) {
+    return;
+  }
+  const name2 = toXml(node.attributes["name"]?.children ?? []).trim();
+  if (name2 === assigned.trim()) {
+    return;
+  }
+  file.message(
+    `A reference wrote assignNames="${assigned}" in its attributes, and that name could not be kept${name2 ? ` (the element is now named "${name2}")` : ""}. References to "${assigned}" need fixing by hand.`,
+    {
+      place: node.position,
+      ruleId: "assign-names/late-attribute-assignment",
+      source: "v06-to-v07"
+    }
+  );
+}
+const upgradeMapElement = (context) => {
   return (tree, file) => {
-    const refsToRename = {};
-    replaceNode(tree, (node) => {
+    replaceNode(tree, (node, info) => {
       if (!isDastElement(node)) {
         return;
       }
-      if (node.name !== "map") {
+      if (node.name.toLowerCase() !== "map") {
         return;
       }
-      const name2 = toXml(node.attributes["name"]?.children).trim();
-      const assignNames = toXml(node.attributes["assignNames"]?.children).trim().split(/\s+/);
-      if (name2 && assignNames.length > 0) {
-        assignNames.forEach((assignName, index2) => {
-          refsToRename[assignName] = [
-            {
-              type: "pathPart",
-              name: name2,
-              index: [
-                {
-                  type: "index",
-                  value: [
-                    {
-                      type: "text",
-                      value: `${index2 + 1}`
-                    }
-                  ]
-                }
-              ]
-            }
-          ];
-        });
-      }
+      let name2 = toXml(node.attributes["name"]?.children).trim();
+      const assignNamesValue = readAssignNames(node);
       const templateNode = node.children.find(
         (child) => isDastElement(child) && child.name === "template"
       );
@@ -245576,10 +246934,32 @@ const upgradeMapElement = () => {
       if (!templateNode || !isDastElement(templateNode) || !sourcesNode || !isDastElement(sourcesNode)) {
         file.message(
           `Map element must have both a template and sources children to be converted`,
-          { place: node.position }
+          {
+            place: node.position,
+            ruleId: "map/missing-template-or-sources",
+            source: "v06-to-v07"
+          }
         );
         return;
       }
+      if (assignNamesValue) {
+        name2 = registerCompositeAssignNames({
+          node,
+          assignNamesValue,
+          fallbackBase: "repeat",
+          ancestorNames: namespaceChainOf(info.parents, context),
+          context,
+          file,
+          // A nested name such as `assignNames="(a b)"` counts positions
+          // inside one iteration, which are the template's children — and
+          // v0.6 skipped bare text there while v0.7 counts it.
+          positionMap: makeTemplatePositionMap(
+            templateNode,
+            node,
+            file
+          )
+        }) ?? name2;
+      }
       const valueName = toXml(
         sourcesNode.attributes["alias"]?.children
       ).trim();
@@ -245591,6 +246971,7 @@ const upgradeMapElement = () => {
         (child) => isDastElement(child) && child.name === "sequence"
       )) {
         if (name2) {
+          warnIfNameLost(sequenceNode, name2, file);
           sequenceNode.attributes["name"] = {
             type: "attribute",
             name: "name",
@@ -245598,6 +246979,7 @@ const upgradeMapElement = () => {
           };
         }
         sequenceNode.name = "repeatForSequence";
+        inheritNamespace(templateNode, sequenceNode, context);
         if (valueName) {
           sequenceNode.attributes["valueName"] = {
             type: "attribute",
@@ -245627,12 +247009,15 @@ const upgradeMapElement = () => {
           attributes: {},
           children: [groupTag]
         };
-        const groupName = getUniqueName(tree, "group");
+        const groupName = context.uniqueName("group");
         groupTag.attributes["name"] = {
           type: "attribute",
           name: "name",
           children: reparseAttribute(groupName)
         };
+        if (name2) {
+          warnIfNameLost(templateNode, name2, file);
+        }
         templateNode.name = "repeat";
         templateNode.attributes["for"] = {
           type: "attribute",
@@ -245663,19 +247048,22 @@ const upgradeMapElement = () => {
         return [setupTag, templateNode];
       }
     });
-    visit(tree, (node) => {
-      if (node.type !== "macro") {
-        return;
-      }
-      if (!node.path.some((part) => refsToRename[part.name])) {
-        return;
-      }
-      node.path = node.path.flatMap((part) => {
-        return refsToRename[part.name] || [part];
-      });
-    });
   };
 };
+function warnIfNameLost(node, newName, file) {
+  const existing = toXml(node.attributes["name"]?.children).trim();
+  if (!existing || existing === newName) {
+    return;
+  }
+  file.message(
+    `<${node.name} name="${existing}"> becomes the <repeat> that takes the name "${newName}", so "${existing}" is gone; references to it need fixing by hand.`,
+    {
+      place: node.position,
+      ruleId: "map/name-overwritten",
+      source: "v06-to-v07"
+    }
+  );
+}
 const upgradeModuleElement = () => {
   return (tree, file) => {
     visit(tree, (node) => {
@@ -245691,14 +247079,30 @@ const upgradeModuleElement = () => {
       if (!setupNode) {
         return;
       }
-      node.children.filter(
-        (child) => !isDastElement(child) || child.name !== "setup"
-      );
+      const isCustomAttribute = (child) => isDastElement(child) && child.name === "customAttribute";
       const customAttributeNodes = setupNode.children.filter(
-        (child) => isDastElement(child) && child.name === "customAttribute"
+        (child) => isCustomAttribute(child)
+      );
+      const otherSetupChildren = setupNode.children.filter(
+        (child) => !isCustomAttribute(child)
       );
       setupNode.children = [];
       setupNode.name = "moduleAttributes";
+      if (otherSetupChildren.some(
+        (child) => child.type !== "text" || child.value.trim() !== ""
+      )) {
+        const newSetup = {
+          type: "element",
+          name: "setup",
+          attributes: {},
+          children: otherSetupChildren
+        };
+        node.children.splice(
+          node.children.indexOf(setupNode) + 1,
+          0,
+          newSetup
+        );
+      }
       for (const customAttributeNode of customAttributeNodes) {
         const name2 = toXml(
           customAttributeNode.attributes["assignNames"]?.children
@@ -245710,7 +247114,9 @@ const upgradeModuleElement = () => {
           file.message(
             `Module "customAttribute" is missing a "componentType"; the syntax cannot be upgraded with a "componentType".`,
             {
-              place: customAttributeNode.position
+              place: customAttributeNode.position,
+              ruleId: "module/custom-attribute-without-type",
+              source: "v06-to-v07"
             }
           );
           continue;
@@ -245773,10 +247179,459 @@ const removeDefinitionsElement = () => {
     });
   };
 };
+const GLOBAL_RULES = {
+  // v0.6 renamed `targets*` to `sources*`; v0.7 renamed them again to `references*`.
+  sourcesareresponses: {
+    kind: "renameToReferenceList",
+    to: "referencesAreResponses"
+  },
+  targetsareresponses: {
+    kind: "renameToReferenceList",
+    to: "referencesAreResponses"
+  },
+  sourcesarefunctionsymbols: {
+    kind: "renameToReferenceList",
+    to: "referencesAreFunctionSymbols"
+  },
+  targetsarefunctionsymbols: {
+    kind: "renameToReferenceList",
+    to: "referencesAreFunctionSymbols"
+  },
+  triggerwithtargets: { kind: "renameToReferenceList", to: "triggerWith" },
+  triggerwithtnames: { kind: "renameToReferenceList", to: "triggerWith" },
+  updatewithtname: { kind: "rename", to: "updateWith" },
+  updatewithtarget: { kind: "rename", to: "updateWith" },
+  // `tname` was the pre-v0.6 spelling of the attribute naming what to act on. On
+  // components that *copy*, it became `source`; everywhere else it became `target`.
+  // The element-specific tables below override this for the copying components.
+  tname: { kind: "rename", to: "target" }
+};
+const ELEMENT_RULES = {
+  copy: { tname: { kind: "rename", to: "source" } },
+  collect: {
+    tname: { kind: "rename", to: "source" },
+    draggable: {
+      kind: "remove",
+      because: "<collect> does not take `draggable` in v0.7"
+    }
+  },
+  extract: { tname: { kind: "rename", to: "source" } },
+  updatevalue: {
+    // `<updateValue target="x" prop="y">` is a single path in v0.7.
+    prop: { kind: "mergeInto", target: "target" }
+  },
+  animatefromsequence: { prop: { kind: "mergeInto", target: "target" } },
+  ref: {
+    page: {
+      kind: "remove",
+      because: "v0.7 documents are not paginated, so <ref> has no `page`; link to the individual document instead",
+      ruleId: "deprecated/ref-page"
+    }
+  },
+  variantcontrol: { nvariants: { kind: "rename", to: "numVariants" } },
+  option: {
+    selectforvariantnames: { kind: "rename", to: "selectForVariants" }
+  },
+  graph: {
+    xlabel: { kind: "toChildElement", elementName: "xLabel" },
+    ylabel: { kind: "toChildElement", elementName: "yLabel" },
+    height: {
+      kind: "remove",
+      because: "v0.7 graphs are sized with `size`, `width` and `aspectRatio`"
+    }
+  },
+  image: {
+    // v0.6 rendered `description` as the image's `alt` text. v0.7 carries that in a
+    // `<shortDescription>` child, which the reference pages describe as required for
+    // accessibility, so this must be converted rather than dropped.
+    description: {
+      kind: "toChildElement",
+      elementName: "shortDescription"
+    }
+  },
+  conditionalcontent: {
+    maximumnumbertoshow: {
+      kind: "remove",
+      because: "v0.7 <conditionalContent> always shows one case"
+    }
+  },
+  embed: {
+    encodedgeogebracontent: {
+      kind: "unsupported",
+      because: "v0.7 has no <embed> element and no GeoGebra support; this content must be replaced by hand",
+      ruleId: "no-v07-equivalent/embed-geogebra"
+    }
+  },
+  point: {
+    link: {
+      kind: "remove",
+      because: "`link` only means something alongside `copySource`",
+      // `copySourceToExtendOrCopy` needs `link` when there is a `copySource`.
+      when: (_value, node) => !findAttrKey(node, "copySource") && !findAttrKey(node, "source")
+    }
+  },
+  tabular: removeSides(),
+  row: removeSides(),
+  cell: removeSides()
+};
+function removeSides() {
+  const rule = {
+    kind: "remove",
+    because: "v0.7 tables do not take per-side border attributes"
+  };
+  return { top: rule, bottom: rule, left: rule, right: rule };
+}
+const upgradeDeprecatedAttributes = () => {
+  return (tree, file) => {
+    visit(tree, (node) => {
+      if (!isDastElement(node)) {
+        return;
+      }
+      const elm = node;
+      const rules = {
+        ...GLOBAL_RULES,
+        ...ELEMENT_RULES[elm.name.toLowerCase()] || {}
+      };
+      const keys2 = Object.keys(elm.attributes);
+      const isMerge = (key) => rules[key.toLowerCase()]?.kind === "mergeInto";
+      for (const key of [
+        ...keys2.filter((k2) => !isMerge(k2)),
+        ...keys2.filter(isMerge)
+      ]) {
+        const rule = rules[key.toLowerCase()];
+        if (!rule) {
+          continue;
+        }
+        const attr = elm.attributes[key];
+        if (!attr) {
+          continue;
+        }
+        const value = toXml(attr.children).trim();
+        if (rule.when && !rule.when(value, elm)) {
+          continue;
+        }
+        applyRule(elm, key, attr, value, rule, file);
+      }
+    });
+  };
+};
+const prependedChildCount = /* @__PURE__ */ new WeakMap();
+function applyRule(elm, key, attr, value, rule, file) {
+  switch (rule.kind) {
+    case "rename": {
+      renameAttrInPlace(elm, key, rule.to);
+      return;
+    }
+    case "renameToReferenceList": {
+      renameAttrInPlace(elm, key, rule.to);
+      const dollared = value.split(/\s+/).filter((t4) => t4).map(referenceTo).join(" ");
+      elm.attributes[rule.to].children = reparseAttributeV6(dollared);
+      return;
+    }
+    case "mergeInto": {
+      const targetKey = findAttrKey(elm, rule.target);
+      if (!targetKey || !value) {
+        return;
+      }
+      const targetValue = toXml(
+        elm.attributes[targetKey].children
+      ).trim();
+      elm.attributes[targetKey].children = reparseAttributeV6(
+        `${targetValue}.${value}`
+      );
+      delete elm.attributes[key];
+      return;
+    }
+    case "toChildElement": {
+      if (!value) {
+        delete elm.attributes[key];
+        return;
+      }
+      const child = {
+        type: "element",
+        name: rule.elementName,
+        attributes: {},
+        children: attr.children,
+        position: attr.position
+      };
+      const alreadyPrepended = prependedChildCount.get(elm) || 0;
+      elm.children.splice(alreadyPrepended, 0, child);
+      prependedChildCount.set(elm, alreadyPrepended + 1);
+      delete elm.attributes[key];
+      return;
+    }
+    case "remove": {
+      delete elm.attributes[key];
+      file.message(
+        `Removed ${key}="${value}" from <${elm.name}>: ${rule.because}.`,
+        {
+          place: elm.position,
+          ruleId: rule.ruleId || `deprecated/${key.toLowerCase()}`,
+          source: "v06-to-v07"
+        }
+      );
+      return;
+    }
+    case "unsupported": {
+      file.message(
+        `<${elm.name} ${key}="..."> was left unchanged: ${rule.because}.`,
+        {
+          place: elm.position,
+          ruleId: rule.ruleId || `no-v07-equivalent/${key.toLowerCase()}`,
+          source: "v06-to-v07"
+        }
+      );
+      return;
+    }
+  }
+}
+function findAttrKey(elm, attrName) {
+  return Object.keys(elm.attributes).find(
+    (key) => key.toLowerCase() === attrName.toLowerCase()
+  );
+}
+function referenceTo(token) {
+  if (token.startsWith("$(")) {
+    return token;
+  }
+  const name2 = token.startsWith("$") ? token.slice(1) : token;
+  return /^[a-zA-Z0-9_]+$/.test(name2) ? `$${name2}` : `$(${name2})`;
+}
+const ALL_ITEMS_PROPS = /* @__PURE__ */ new Set(["maths", "texts", "numbers", "booleans"]);
+const NUMBERED_ITEM_PROP = /^(math|text|number|boolean)(\d+)$/;
+const ELEMENTS_WITH_PROP = /* @__PURE__ */ new Set(["copy", "extract"]);
+const upgradeListProps = () => {
+  return (tree, file) => {
+    visitAllMacros(tree, (node) => {
+      node.path = rewritePath(node.path);
+    });
+    visitAll(tree, (node) => {
+      if (!isDastElement(node) || !ELEMENTS_WITH_PROP.has(node.name.toLowerCase())) {
+        return;
+      }
+      rewritePropAttribute(node, file);
+      rewriteRawSourceAttribute(node);
+    });
+  };
+};
+const ELEMENTS_WITH_RAW_SOURCE = /* @__PURE__ */ new Set(["copy", "extract"]);
+function rewriteRawSourceAttribute(node) {
+  if (!ELEMENTS_WITH_RAW_SOURCE.has(node.name.toLowerCase())) {
+    return;
+  }
+  const sourceKey = findKey(node, "source");
+  if (!sourceKey) {
+    return;
+  }
+  const attr = node.attributes[sourceKey];
+  if (attr.children.length !== 1 || attr.children[0].type !== "text") {
+    return;
+  }
+  const child = attr.children[0];
+  const value = child.value.trim();
+  if (!value || value.startsWith("$") || !value.includes(".")) {
+    return;
+  }
+  let path;
+  try {
+    path = parseReferencePath(value);
+  } catch {
+    return;
+  }
+  restoreRawPropPositions(node, sourceKey, path);
+  const rewritten = rewritePath(path);
+  if (rewritten === path) {
+    return;
+  }
+  child.value = toXml(rewritten);
+}
+function rewritePath(path) {
+  if (path.length < 2) {
+    return path;
+  }
+  const result2 = [path[0]];
+  for (const part of path.slice(1)) {
+    const previous = result2[result2.length - 1];
+    if (!isPropAccess(part)) {
+      result2.push(part);
+      continue;
+    }
+    if (ALL_ITEMS_PROPS.has(part.name)) {
+      previous.index = [...previous.index, ...part.index];
+      continue;
+    }
+    const numbered = NUMBERED_ITEM_PROP.exec(part.name);
+    if (numbered) {
+      previous.index = [
+        ...previous.index,
+        {
+          type: "index",
+          value: [{ type: "text", value: numbered[2] }]
+        },
+        ...part.index
+      ];
+      continue;
+    }
+    result2.push(part);
+  }
+  return result2;
+}
+function rewritePropAttribute(node, file) {
+  const propKey = findKey(node, "prop");
+  if (!propKey) {
+    return;
+  }
+  const prop = toXml(node.attributes[propKey].children).trim();
+  const numbered = NUMBERED_ITEM_PROP.exec(prop);
+  if (!ALL_ITEMS_PROPS.has(prop) && !numbered) {
+    return;
+  }
+  const sourceKey = findKey(node, "source");
+  if (!sourceKey) {
+    return;
+  }
+  const sourceAttr = node.attributes[sourceKey];
+  const source = toXml(sourceAttr.children).trim();
+  if (!source) {
+    return;
+  }
+  if (!numbered) {
+    if (node.name.toLowerCase() === "extract") {
+      file.message(
+        `<extract prop="${prop}"> has no v0.7 equivalent and was left as it is; the prop names the whole list, which v0.7 reaches as $${source}.`,
+        {
+          place: node.position,
+          ruleId: "no-v07-equivalent/extract",
+          source: "v06-to-v07"
+        }
+      );
+      return;
+    }
+    delete node.attributes[propKey];
+    return;
+  }
+  const hadDollar = source.startsWith("$");
+  let path;
+  try {
+    path = parseReferencePath(hadDollar ? source.slice(1) : source);
+  } catch (e4) {
+    return;
+  }
+  const last2 = path[path.length - 1];
+  last2.index = [
+    ...last2.index,
+    { type: "index", value: [{ type: "text", value: numbered[2] }] }
+  ];
+  sourceAttr.children = hadDollar ? [{ type: "macro", path, attributes: {} }] : [{ type: "text", value: toXml(path) }];
+  delete node.attributes[propKey];
+}
+function findKey(node, attrName) {
+  return Object.keys(node.attributes).find(
+    (key) => key.toLowerCase() === attrName.toLowerCase()
+  );
+}
+const upgradeAssignNames = (context) => {
+  return (tree, file) => {
+    visitAll(tree, (node, parents) => {
+      if (!isDastElement(node)) {
+        return;
+      }
+      const spec = lookupComposite(node);
+      if (!spec) {
+        return;
+      }
+      const assignNamesValue = readAssignNames(node);
+      if (assignNamesValue === void 0) {
+        return;
+      }
+      if (spec.noV07Equivalent) {
+        file.message(
+          `<${node.name}> has no v0.7 equivalent and must be rewritten by hand; its references were converted as if it behaved like a v0.6 composite.`,
+          {
+            place: node.position,
+            ruleId: `no-v07-equivalent/${spec.name.toLowerCase()}`,
+            source: "v06-to-v07"
+          }
+        );
+      }
+      if (!assignNamesValue) {
+        deleteAssignNames(node);
+        return;
+      }
+      const parsed = breakStringInPiecesBySpacesOrParens(assignNamesValue);
+      if (parsed.success && firstLeafName(parsed.pieces) === void 0) {
+        deleteAssignNames(node);
+        return;
+      }
+      const onlyPiece = parsed.success && parsed.pieces.length === 1 && typeof parsed.pieces[0] === "string" ? parsed.pieces[0] : void 0;
+      if (onlyPiece !== void 0 && isValidReferenceableName(onlyPiece) && !findAttribute(node, "name") && !context.existingNames.has(onlyPiece) && !context.claimedNames.has(onlyPiece) && producesSingleReplacement(node, spec)) {
+        context.claimedNames.add(onlyPiece);
+        context.registry.register(
+          onlyPiece,
+          void 0,
+          {
+            elementName: node.name,
+            position: node.position,
+            ancestorNames: namespaceChainOf(parents, context),
+            element: node
+          },
+          file
+        );
+        warnIfSelfReferential(node, onlyPiece, file);
+        setCompositeName(node, onlyPiece);
+        return;
+      }
+      const compositeName = registerCompositeAssignNames({
+        node,
+        assignNamesValue,
+        fallbackBase: spec.name,
+        ancestorNames: namespaceChainOf(parents, context),
+        context,
+        file,
+        positionMap: makePositionMap(node, spec, file)
+      });
+      if (compositeName === void 0) {
+        deleteAssignNames(node);
+        return;
+      }
+      warnIfSelfReferential(node, compositeName, file);
+      setCompositeName(node, compositeName);
+    });
+  };
+};
+function warnIfSelfReferential(node, compositeName, file) {
+  let referencesSelf = false;
+  for (const attr of Object.values(node.attributes)) {
+    for (const child of attr.children) {
+      visitAllMacros(child, (macro) => {
+        if (macro.path[0]?.name === compositeName) {
+          referencesSelf = true;
+        }
+      });
+    }
+  }
+  if (!referencesSelf) {
+    return;
+  }
+  file.message(
+    `<${node.name}> is being named "${compositeName}", but one of its own attributes already refers to $${compositeName}. That reference resolved to nothing in v0.6; in v0.7 it is a circular reference and the document will not load.`,
+    {
+      place: node.position,
+      ruleId: "assign-names/self-reference",
+      source: "v06-to-v07"
+    }
+  );
+}
+const applyAssignNameRenames = (context) => {
+  return (tree, file) => {
+    applyRefRenames(tree, context.registry, file, context);
+  };
+};
 async function updateSyntaxFromV06toV07_root(dast, options) {
-  let processor = unified$1().use(correctElementCapitalization).use(correctAttributeCapitalization).use(correctComponentTypesAttributeCapitalization).use(ensureDollarBeforeNamesOnSpecificAttributes).use(upgradePathSlashesToDots).use(removeNewNamespaceAttribute).use(upgradeRefElement).use(copySourceToExtendOrCopy).use(upgradeCollectElement).use(upgradeMapElement).use(upgradeModuleElement).use(removeConstraintsElement).use(removeDefinitionsElement);
+  const assignNamesContext = createAssignNamesContext(dast);
+  let processor = unified$1().use(correctElementCapitalization).use(correctAttributeCapitalization).use(correctComponentTypesAttributeCapitalization).use(upgradeDeprecatedAttributes).use(ensureDollarBeforeNamesOnSpecificAttributes).use(upgradePathSlashesToDots).use(removeNewNamespaceAttribute).use(upgradeRefElement).use(copySourceToExtendOrCopy, assignNamesContext).use(upgradeCollectElement, assignNamesContext).use(upgradeMapElement, assignNamesContext).use(upgradeAssignNames, assignNamesContext).use(upgradeCopyElements, assignNamesContext).use(applyAssignNameRenames, assignNamesContext).use(upgradeListProps).use(upgradeModuleElement).use(removeConstraintsElement).use(removeDefinitionsElement);
   if (!options.doNotUpgradeAttributeSyntax) {
-    processor = processor.use(upgradeAttributeSyntax);
+    processor = processor.use(upgradeAttributeSyntax, assignNamesContext);
   }
   if (!options.doNotUpgradeCopyTags) {
     processor = processor.use(upgradeCopySyntax);
@@ -245817,31 +247672,44 @@ const ensureDollarBeforeNamesOnSpecificAttributes = () => {
     });
   };
 };
-const copySourceToExtendOrCopy = () => {
-  return (tree) => {
-    visit(tree, (node) => {
+const copySourceToExtendOrCopy = (context) => {
+  return (tree, file) => {
+    visit(tree, (node, info) => {
       if (!isDastElement(node)) {
         return;
       }
       const copySourceAttr = node.attributes["copySource"];
       const linkAttr = node.attributes["link"];
-      const assignNamesAttr = node.attributes["assignNames"];
       const copyPropAttr = node.attributes["copyProp"];
       if (!copySourceAttr) {
         return;
       }
-      const targetTag = toXml(linkAttr?.children || []).toLowerCase() === "false" ? "copy" : "extend";
+      const targetTag = linkAttr ? isV06True(linkAttr) ? "extend" : "copy" : isModuleComponentType(node.name) ? "copy" : "extend";
       const baseValue = toXml(copySourceAttr.children).trim();
       let extendValue = baseValue.startsWith("$") ? baseValue : `$${baseValue}`;
       copySourceAttr.name = targetTag;
+      let appendedPropName;
       if (copyPropAttr) {
-        extendValue += `.${toXml(copyPropAttr.children).trim()}`;
+        appendedPropName = toXml(copyPropAttr.children).trim();
+        extendValue += `.${appendedPropName}`;
         delete node.attributes["copyProp"];
       }
       copySourceAttr.children = reparseAttribute(extendValue);
-      if (assignNamesAttr && toXml(assignNamesAttr.children).trim().indexOf(" ") === -1) {
-        assignNamesAttr.name = "name";
+      if (appendedPropName) {
+        const macro = copySourceAttr.children[0];
+        if (macro?.type === "macro") {
+          const last2 = macro.path[macro.path.length - 1];
+          if (last2) {
+            markAsPropAccess(last2);
+          }
+        }
       }
+      convertAssignNames(
+        node,
+        namespaceChainOf(info.parents, context),
+        context,
+        file
+      );
       if (linkAttr) {
         delete node.attributes["link"];
       }
@@ -245876,4 +247744,4 @@ export {
   getDefaultExportFromCjs$1 as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-Cxf3BQNw.js.map
+//# sourceMappingURL=index-D-2i13ZI.js.map