@doenet/v06-to-v07 0.7.20-dev.318 → 0.7.20-dev.320

package/{index-BBh2EPqg.js → index-D7QB7nkv.js}

@@ -40963,7 +40963,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-C0vj3HDn-B-uuLxXp-p9edzkPO.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-BWgi3hyU-CUhpeiV-.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -49611,6 +49611,1261 @@ function recursivelyReplaceCompositesWithReplacements({
     unexpandedCompositesNotReady
   };
 }
+function renameStateVariable({
+  stateVariableDefinitions,
+  oldName,
+  newName
+}) {
+  let stateVarDef = stateVariableDefinitions[newName] = stateVariableDefinitions[oldName];
+  delete stateVariableDefinitions[oldName];
+  stateVarDef.excludeFromSchema = true;
+  if (stateVarDef.additionalStateVariablesDefined) {
+    let ind = stateVarDef.additionalStateVariablesDefined.indexOf(oldName);
+    if (ind !== -1) {
+      stateVarDef.additionalStateVariablesDefined[ind] = newName;
+    }
+  }
+  let originalDefinition = stateVarDef.definition;
+  let keysInObjects = [
+    "setValue",
+    "useEssentialOrDefaultValue",
+    "setEssentialValue"
+  ];
+  let entriesInArrays = ["noChanges"];
+  stateVarDef.definition = function(args) {
+    let result2 = originalDefinition(args);
+    for (let key of keysInObjects) {
+      if (result2[key] && oldName in result2[key]) {
+        result2[key][newName] = result2[key][oldName];
+        delete result2[key][oldName];
+      }
+    }
+    for (let key of entriesInArrays) {
+      if (result2[key]) {
+        let ind = result2[key].indexOf(oldName);
+        if (ind !== -1) {
+          result2[key][ind] = newName;
+        }
+      }
+    }
+    return result2;
+  };
+  let originalInverseDefinition = stateVarDef.inverseDefinition;
+  if (originalInverseDefinition) {
+    stateVarDef.inverseDefinition = async function(args) {
+      let desiredStateVariableValues = args.desiredStateVariableValues;
+      desiredStateVariableValues[oldName] = desiredStateVariableValues[newName];
+      delete desiredStateVariableValues[newName];
+      let results = await originalInverseDefinition(args);
+      if (results.success) {
+        for (let instruction of results.instructions) {
+          if (instruction.setEssentialValue === oldName) {
+            instruction.setEssentialValue = newName;
+          }
+        }
+      }
+      return results;
+    };
+  }
+}
+function defaultGetArrayKeysFromVarNameMultiDim({
+  arrayEntryPrefix,
+  varEnding,
+  arraySize: arraySize2,
+  numDimensions
+}) {
+  let indices = varEnding.split("_").map((x2) => Number(x2) - 1);
+  if (indices.length === numDimensions && indices.every((x2, i2) => Number.isInteger(x2) && x2 >= 0)) {
+    if (arraySize2) {
+      if (indices.every((x2, i2) => x2 < arraySize2[i2])) {
+        return [String(indices)];
+      } else {
+        return [];
+      }
+    } else {
+      return [String(indices)];
+    }
+  } else {
+    return [];
+  }
+}
+function defaultGetArrayKeysFromVarNameOneDim({
+  arrayEntryPrefix,
+  varEnding,
+  arraySize: arraySize2
+}) {
+  let index2 = Number(varEnding) - 1;
+  if (Number.isInteger(index2) && index2 >= 0) {
+    if (arraySize2) {
+      if (index2 < arraySize2[0]) {
+        return [String(index2)];
+      } else {
+        return [];
+      }
+    } else {
+      return [String(index2)];
+    }
+  } else {
+    return [];
+  }
+}
+function returnDefaultGetArrayKeysFromVarName(numDim) {
+  if (numDim > 1) {
+    return defaultGetArrayKeysFromVarNameMultiDim;
+  } else {
+    return defaultGetArrayKeysFromVarNameOneDim;
+  }
+}
+function returnDefaultArrayVarNameFromPropIndex(numDim, arrayEntryPrefix) {
+  if (numDim > 1) {
+    return function(propIndex, varName) {
+      return arrayEntryPrefix + [
+        ...propIndex.map((x2) => Math.round(Number(x2))),
+        ...Array(numDim - propIndex.length).fill(1)
+      ].join("_");
+    };
+  } else {
+    return function(propIndex, varName) {
+      return arrayEntryPrefix + propIndex[0];
+    };
+  }
+}
+function getStaleStateVariableValue() {
+  return this.svComponent.coreFunctions.getStateVariableValue({
+    component: this.svComponent,
+    stateVariable: this.svVarName
+  });
+}
+const STALE_VALUE_DESCRIPTOR = Object.freeze({
+  get: getStaleStateVariableValue,
+  configurable: true
+});
+function installStaleValueGetter(stateVarObj) {
+  delete stateVarObj.value;
+  Object.defineProperty(stateVarObj, "value", STALE_VALUE_DESCRIPTOR);
+}
+async function entryGetValueViaGetEntryValues() {
+  const arrayStateVarObj = this.svComponent.state[this.arrayStateVariable];
+  return await arrayStateVarObj.getEntryValues({
+    varName: this.svVarName
+  });
+}
+async function entryGetValueFromArrayValues() {
+  const arrayStateVarObj = this.svComponent.state[this.arrayStateVariable];
+  const arrayKeys = await this.arrayKeys;
+  if (arrayKeys.length === 0) {
+    return;
+  }
+  const value = [];
+  for (const arrayKey of arrayKeys) {
+    value.push(arrayStateVarObj.getArrayValue({ arrayKey }));
+  }
+  if (value.length === 1) {
+    return value[0];
+  } else {
+    return value;
+  }
+}
+function getEntryArrayKeys() {
+  return (async () => {
+    await this.svComponent.state[this.arrayStateVariable].arraySize;
+    return this._arrayKeys;
+  })();
+}
+const ENTRY_ARRAY_KEYS_DESCRIPTOR = Object.freeze({
+  get: getEntryArrayKeys
+});
+function getEntryUnflattenedArrayKeys() {
+  return (async () => {
+    await this.svComponent.state[this.arrayStateVariable].arraySize;
+    return this._unflattenedArrayKeys;
+  })();
+}
+const ENTRY_UNFLATTENED_ARRAY_KEYS_DESCRIPTOR = Object.freeze({ get: getEntryUnflattenedArrayKeys });
+function getEntryArraySize() {
+  return this.svComponent.state[this.arrayStateVariable].arraySize;
+}
+const ENTRY_ARRAY_SIZE_DESCRIPTOR = Object.freeze({
+  get: getEntryArraySize
+});
+function getEntryArrayEntrySize() {
+  return (async () => {
+    let unflattenedArrayKeys = await this.unflattenedArrayKeys;
+    let arrayEntrySize = [];
+    let subArray = [unflattenedArrayKeys];
+    for (let i2 = 0; i2 < this.numDimensions; i2++) {
+      subArray = subArray[0];
+      arrayEntrySize.push(subArray.length);
+    }
+    arrayEntrySize.reverse();
+    return arrayEntrySize;
+  })();
+}
+const ENTRY_ARRAY_ENTRY_SIZE_DESCRIPTOR = Object.freeze({
+  get: getEntryArrayEntrySize
+});
+function multiDimKeyToIndex(key) {
+  return key.split(",").map((x2) => Number(x2));
+}
+function oneDimKeyToIndex(key) {
+  return Number(key);
+}
+function arrayIndexToKey(index2) {
+  return String(index2);
+}
+function defaultReturnEntryDimensions() {
+  return 0;
+}
+function multiDimSetArrayValue({ value, arrayKey, arraySize: arraySize2, arrayValues = this.arrayValues }) {
+  const component = this.svComponent;
+  const addDiagnostic = component.coreFunctions.addDiagnostic;
+  const numDimensions = this.numDimensions;
+  let index2 = this.keyToIndex(arrayKey);
+  let numDimensionsInArrayKey = index2.length;
+  if (numDimensionsInArrayKey > numDimensions) {
+    addDiagnostic({
+      type: "info",
+      message: "Cannot set array value.  Number of dimensions is too large.",
+      position: component.position,
+      sourceDoc: component.sourceDoc
+    });
+    return { nFailures: 1 };
+  }
+  let arrayValuesDrillDown = arrayValues;
+  let arraySizeDrillDown = arraySize2;
+  for (let indComponent of index2.slice(0, index2.length - 1)) {
+    if (indComponent >= 0 && indComponent < arraySizeDrillDown[0]) {
+      if (!arrayValuesDrillDown[indComponent]) {
+        arrayValuesDrillDown[indComponent] = [];
+      }
+      arrayValuesDrillDown = arrayValuesDrillDown[indComponent];
+      arraySizeDrillDown = arraySizeDrillDown.slice(1);
+    } else {
+      addDiagnostic({
+        type: "info",
+        message: "ignore setting array value out of bounds",
+        position: component.position,
+        sourceDoc: component.sourceDoc
+      });
+      return { nFailures: 1 };
+    }
+  }
+  let nFailures = 0;
+  if (numDimensionsInArrayKey < numDimensions) {
+    let setArrayValuesPiece = function(desiredValue, arrayValuesPiece, arraySizePiece) {
+      if (!Array.isArray(desiredValue)) {
+        addDiagnostic({
+          type: "info",
+          message: "ignoring array values with insufficient dimensions",
+          position: component.position,
+          sourceDoc: component.sourceDoc
+        });
+        return { nFailures: 1 };
+      }
+      let nFailuresSub = 0;
+      let currentSize = arraySizePiece[0];
+      if (desiredValue.length > currentSize) {
+        addDiagnostic({
+          type: "info",
+          message: "ignoring array values out of bounds",
+          position: component.position,
+          sourceDoc: component.sourceDoc
+        });
+        nFailuresSub += desiredValue.length - currentSize;
+        desiredValue = desiredValue.slice(0, currentSize);
+      }
+      if (arraySizePiece.length === 1) {
+        for (let [ind, val] of desiredValue.entries()) {
+          arrayValuesPiece[ind] = val;
+        }
+      } else {
+        for (let [ind, val] of desiredValue.entries()) {
+          if (!arrayValuesPiece[ind]) {
+            arrayValuesPiece[ind] = [];
+          }
+          let result22 = setArrayValuesPiece(
+            val,
+            arrayValuesPiece[ind],
+            arraySizePiece.slice(1)
+          );
+          nFailuresSub += result22.nFailures;
+        }
+      }
+      return { nFailures: nFailuresSub };
+    };
+    let result2 = setArrayValuesPiece(
+      value,
+      arrayValuesDrillDown,
+      arraySizeDrillDown
+    );
+    nFailures += result2.nFailures;
+  } else {
+    arrayValuesDrillDown[index2[index2.length - 1]] = value;
+  }
+  return { nFailures };
+}
+function oneDimSetArrayValue({ value, arrayKey, arraySize: arraySize2, arrayValues = this.arrayValues }) {
+  let ind = this.keyToIndex(arrayKey);
+  if (ind >= 0 && ind < arraySize2[0]) {
+    arrayValues[ind] = value;
+    return { nFailures: 0 };
+  } else {
+    const component = this.svComponent;
+    component.coreFunctions.addDiagnostic({
+      type: "info",
+      message: `Ignoring setting array values out of bounds: ${arrayKey} of ${this.svVarName}`,
+      position: component.position,
+      sourceDoc: component.sourceDoc
+    });
+    return { nFailures: 1 };
+  }
+}
+function multiDimGetArrayValue({ arrayKey, arrayValues = this.arrayValues }) {
+  let index2 = this.keyToIndex(arrayKey);
+  let aVals = arrayValues;
+  for (let indComponent of index2.slice(0, index2.length - 1)) {
+    aVals = aVals[indComponent];
+    if (!aVals) {
+      return void 0;
+    }
+  }
+  return aVals[index2[index2.length - 1]];
+}
+function oneDimGetArrayValue({ arrayKey, arrayValues = this.arrayValues }) {
+  return arrayValues[arrayKey];
+}
+function multiDimGetAllArrayKeys(arraySize2, flatten2 = true, desiredSize) {
+  function prependToAllKeys(keys2, newStuff) {
+    for (let [ind, key] of keys2.entries()) {
+      if (Array.isArray(key)) {
+        prependToAllKeys(key, newStuff);
+      } else {
+        keys2[ind] = newStuff + "," + key;
+      }
+    }
+  }
+  function getAllArrayKeysSub(subArraySize) {
+    if (subArraySize.length === 1) {
+      return Array.from(Array(subArraySize[0]), (_2, i2) => String(i2));
+    } else {
+      let currentSize = subArraySize[0];
+      let subSubKeys = getAllArrayKeysSub(subArraySize.slice(1));
+      let subKeys = [];
+      for (let ind = 0; ind < currentSize; ind++) {
+        if (flatten2) {
+          subKeys.push(...subSubKeys.map((x2) => ind + "," + x2));
+        } else {
+          let newSubSubKeys = deepClone(subSubKeys);
+          prependToAllKeys(newSubSubKeys, ind);
+          subKeys.push(newSubSubKeys);
+        }
+      }
+      return subKeys;
+    }
+  }
+  if (desiredSize) {
+    if (desiredSize.length === 0) {
+      return [];
+    } else {
+      return getAllArrayKeysSub(desiredSize);
+    }
+  } else if (!arraySize2 || arraySize2.length === 0) {
+    return [];
+  } else {
+    return getAllArrayKeysSub(arraySize2);
+  }
+}
+function oneDimGetAllArrayKeys(arraySize2, flatten2, desiredSize) {
+  if (desiredSize) {
+    if (desiredSize.length === 0) {
+      return [];
+    } else {
+      return Array.from(Array(desiredSize[0]), (_2, i2) => String(i2));
+    }
+  } else if (!arraySize2 || arraySize2.length === 0) {
+    return [];
+  } else {
+    return Array.from(Array(arraySize2[0]), (_2, i2) => String(i2));
+  }
+}
+function defaultMultiDimArrayVarNameFromArrayKey(arrayKey) {
+  return this.entryPrefixes[0] + arrayKey.split(",").map((x2) => Number(x2) + 1).join("_");
+}
+function defaultOneDimArrayVarNameFromArrayKey(arrayKey) {
+  return this.entryPrefixes[0] + String(Number(arrayKey) + 1);
+}
+async function multiDimAdjustArrayToNewArraySize() {
+  function resizeSubArray(subArray, subArraySize) {
+    subArray.length = subArraySize[0];
+    if (subArraySize.length > 1) {
+      let subSubArraySize = subArraySize.slice(1);
+      for (let [ind, subSubArray] of subArray.entries()) {
+        if (!subSubArray) {
+          subSubArray = subArray[ind] = [];
+        }
+        resizeSubArray(subSubArray, subSubArraySize);
+      }
+    }
+  }
+  let arraySize2 = await this.arraySize;
+  resizeSubArray(this.arrayValues, arraySize2);
+}
+async function oneDimAdjustArrayToNewArraySize() {
+  let arraySize2 = await this.arraySize;
+  this.arrayValues.length = arraySize2[0];
+}
+function resolveArrayStateVarObj(svObj) {
+  return svObj.isArrayEntry ? svObj.svComponent.state[svObj.arrayStateVariable] : svObj;
+}
+function defaultReturnWrappingComponents(prefix) {
+  return [];
+}
+async function arrayReturnDependencies(args) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const component = arrayStateVarObj.svComponent;
+  const arrayVarName = arrayStateVarObj.svVarName;
+  args.arraySize = await arrayStateVarObj.arraySize;
+  for (let key in args.stateValues) {
+    if (key.slice(0, 8) === "__array_") {
+      delete args.stateValues[key];
+    }
+  }
+  if (args.arrayKeys === void 0) {
+    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  }
+  if (!arrayStateVarObj.dependencyNames) {
+    arrayStateVarObj.dependencyNames = {
+      namesByKey: {},
+      keysByName: {},
+      global: []
+    };
+    if (arrayStateVarObj.additionalStateVariablesDefined) {
+      for (let vName of arrayStateVarObj.additionalStateVariablesDefined) {
+        component.state[vName].dependencyNames = arrayStateVarObj.dependencyNames;
+      }
+    }
+  }
+  let dependencies2 = {};
+  if (arrayStateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
+    const allStateVariablesAffected = [
+      arrayVarName,
+      ...arrayStateVarObj.additionalStateVariablesDefined ?? []
+    ];
+    for (let arrayKey of args.arrayKeys) {
+      for (let vName of allStateVariablesAffected) {
+        let sObj = component.state[vName];
+        dependencies2[vName + "_" + arrayKey] = {
+          dependencyType: "stateVariable",
+          variableName: sObj.arrayVarNameFromArrayKey(arrayKey)
+        };
+      }
+    }
+  } else {
+    let arrayDependencies = arrayStateVarObj.returnArrayDependenciesByKey(args);
+    if (arrayDependencies.globalDependencies) {
+      arrayStateVarObj.dependencyNames.global = Object.keys(
+        arrayDependencies.globalDependencies
+      );
+      Object.assign(dependencies2, arrayDependencies.globalDependencies);
+    }
+    if (!arrayDependencies.dependenciesByKey) {
+      arrayDependencies.dependenciesByKey = {};
+    }
+    for (let arrayKey of args.arrayKeys) {
+      if (!(arrayKey in arrayStateVarObj.dependencyNames.namesByKey)) {
+        args.changedDependency = true;
+      }
+      arrayStateVarObj.dependencyNames.namesByKey[arrayKey] = {};
+      for (let depName in arrayDependencies.dependenciesByKey[arrayKey]) {
+        let extendedDepName = "__" + arrayKey + "_" + depName;
+        dependencies2[extendedDepName] = arrayDependencies.dependenciesByKey[arrayKey][depName];
+        arrayStateVarObj.dependencyNames.namesByKey[arrayKey][depName] = extendedDepName;
+        if (!arrayStateVarObj.dependencyNames.keysByName[extendedDepName]) {
+          arrayStateVarObj.dependencyNames.keysByName[extendedDepName] = [];
+        }
+        if (!arrayStateVarObj.dependencyNames.keysByName[extendedDepName].includes(arrayKey)) {
+          arrayStateVarObj.dependencyNames.keysByName[extendedDepName].push(arrayKey);
+        }
+      }
+    }
+    arrayStateVarObj.dependencyNames.global.push("__array_size");
+  }
+  dependencies2.__array_size = {
+    dependencyType: "stateVariable",
+    variableName: arrayStateVarObj.arraySizeStateVariable
+  };
+  return dependencies2;
+}
+function arrayGetCurrentFreshness({ freshnessInfo, arrayKeys, arraySize: arraySize2 }) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  if (arrayKeys === void 0) {
+    arrayKeys = arrayStateVarObj.getAllArrayKeys(arraySize2);
+  }
+  let freshByKey = freshnessInfo.freshByKey;
+  let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
+  for (let arrayKey of arrayKeys) {
+    if (freshByKey[arrayKey]) {
+      numberFresh += 1;
+    }
+  }
+  if (numberFresh > 0) {
+    if (numberFresh === arrayKeys.length + 1) {
+      return { fresh: { [arrayVarName]: true } };
+    } else {
+      return { partiallyFresh: { [arrayVarName]: numberFresh } };
+    }
+  } else {
+    return { fresh: { [arrayVarName]: false } };
+  }
+}
+function arrayMarkStale({ freshnessInfo, changes, arrayKeys, arraySize: arraySize2 }) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  let result2 = {};
+  if (arrayKeys === void 0) {
+    arrayKeys = arrayStateVarObj.getAllArrayKeys(arraySize2);
+  }
+  if (arrayStateVarObj.markStaleByKey) {
+    result2 = arrayStateVarObj.markStaleByKey({ arrayKeys, changes });
+  }
+  let freshByKey = freshnessInfo.freshByKey;
+  if (changes.__array_size) {
+    freshnessInfo.freshArraySize = false;
+    freshnessInfo.freshByKey = {};
+    result2.fresh = { [arrayVarName]: false };
+    return result2;
+  }
+  if (Object.keys(freshByKey).length === 0) {
+    freshnessInfo.freshByKey = {};
+    if (freshnessInfo.freshArraySize) {
+      result2.partiallyFresh = { [arrayVarName]: 1 };
+      return result2;
+    } else {
+      result2.fresh = { [arrayVarName]: false };
+      return result2;
+    }
+  }
+  for (let changeName in changes) {
+    if (arrayStateVarObj.dependencyNames.global.includes(changeName)) {
+      freshnessInfo.freshByKey = {};
+      if (freshnessInfo.freshArraySize) {
+        result2.partiallyFresh = { [arrayVarName]: 1 };
+        return result2;
+      } else {
+        result2.fresh = { [arrayVarName]: false };
+        return result2;
+      }
+    }
+    if (arrayStateVarObj.basedOnArrayKeyStateVariables && arrayKeys.length > 1) {
+      delete freshByKey[changeName];
+    } else {
+      for (let key of arrayStateVarObj.dependencyNames.keysByName[changeName]) {
+        delete freshByKey[key];
+      }
+    }
+  }
+  let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
+  for (let arrayKey of arrayKeys) {
+    if (freshByKey[arrayKey]) {
+      numberFresh += 1;
+    }
+  }
+  if (numberFresh > 0) {
+    if (numberFresh === arrayKeys.length + 1) {
+      result2.fresh = { [arrayVarName]: true };
+      return result2;
+    } else {
+      result2.partiallyFresh = { [arrayVarName]: numberFresh };
+      return result2;
+    }
+  } else {
+    result2.fresh = { [arrayVarName]: false };
+    return result2;
+  }
+}
+function arrayFreshenOnNoChanges({ arrayKeys, freshnessInfo, arraySize: arraySize2 }) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  let freshByKey = freshnessInfo.freshByKey;
+  if (arrayKeys === void 0) {
+    arrayKeys = arrayStateVarObj.getAllArrayKeys(arraySize2);
+  }
+  for (let arrayKey of arrayKeys) {
+    freshByKey[arrayKey] = true;
+  }
+}
+function extractArrayDependencies(arrayStateVarObj, dependencyValues, arrayKeys, usedDefault) {
+  let globalDependencyValues = {};
+  let globalUsedDefault = {};
+  for (let dependencyName of arrayStateVarObj.dependencyNames.global) {
+    globalDependencyValues[dependencyName] = dependencyValues[dependencyName];
+    globalUsedDefault[dependencyName] = usedDefault[dependencyName];
+  }
+  let dependencyValuesByKey = {};
+  let usedDefaultByKey = {};
+  let foundAllDependencyValuesForKey = {};
+  for (let arrayKey of arrayKeys) {
+    dependencyValuesByKey[arrayKey] = {};
+    usedDefaultByKey[arrayKey] = {};
+    if (arrayKey in arrayStateVarObj.dependencyNames.namesByKey) {
+      foundAllDependencyValuesForKey[arrayKey] = true;
+      for (let dependencyName in arrayStateVarObj.dependencyNames.namesByKey[arrayKey]) {
+        let extendedDepName = arrayStateVarObj.dependencyNames.namesByKey[arrayKey][dependencyName];
+        if (extendedDepName in dependencyValues) {
+          dependencyValuesByKey[arrayKey][dependencyName] = dependencyValues[extendedDepName];
+          usedDefaultByKey[arrayKey][dependencyName] = usedDefault[extendedDepName];
+        } else {
+          foundAllDependencyValuesForKey[arrayKey] = false;
+        }
+      }
+    }
+  }
+  return {
+    globalDependencyValues,
+    globalUsedDefault,
+    dependencyValuesByKey,
+    usedDefaultByKey,
+    foundAllDependencyValuesForKey
+  };
+}
+function arrayDefinition(args) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  const component = arrayStateVarObj.svComponent;
+  if (args.arrayKeys === void 0) {
+    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  }
+  if (arrayStateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
+    return {};
+  } else {
+    let extractedDeps = extractArrayDependencies(
+      arrayStateVarObj,
+      args.dependencyValues,
+      args.arrayKeys,
+      args.usedDefault
+    );
+    let globalDependencyValues = extractedDeps.globalDependencyValues;
+    let globalUsedDefault = extractedDeps.globalUsedDefault;
+    let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
+    let usedDefaultByKey = extractedDeps.usedDefaultByKey;
+    let foundAllDependencyValuesForKey = extractedDeps.foundAllDependencyValuesForKey;
+    delete args.dependencyValues;
+    args.globalDependencyValues = globalDependencyValues;
+    args.globalUsedDefault = globalUsedDefault;
+    args.dependencyValuesByKey = dependencyValuesByKey;
+    args.usedDefaultByKey = usedDefaultByKey;
+    let arrayKeysToRecalculate = [];
+    let freshByKey = args.freshnessInfo.freshByKey;
+    for (let arrayKey of args.arrayKeys) {
+      if (!freshByKey[arrayKey] && foundAllDependencyValuesForKey[arrayKey]) {
+        freshByKey[arrayKey] = true;
+        arrayKeysToRecalculate.push(arrayKey);
+      }
+    }
+    let result2;
+    if (arrayKeysToRecalculate.length === 0) {
+      result2 = {};
+    } else {
+      args.arrayKeys = arrayKeysToRecalculate;
+      if (!arrayStateVarObj.arrayDefinitionByKey) {
+        throw Error(
+          `For ${arrayVarName} of ${component.componentType}, arrayDefinitionByKey must be a function`
+        );
+      }
+      result2 = arrayStateVarObj.arrayDefinitionByKey(args);
+      if (result2.setValue && result2.setValue[arrayVarName]) {
+        for (let arrayKey in result2.setValue[arrayVarName]) {
+          freshByKey[arrayKey] = true;
+        }
+      }
+      if (result2.useEssentialOrDefaultValue && result2.useEssentialOrDefaultValue[arrayVarName]) {
+        for (let arrayKey in result2.useEssentialOrDefaultValue[arrayVarName]) {
+          freshByKey[arrayKey] = true;
+        }
+      }
+    }
+    if (!args.freshnessInfo.freshArraySize) {
+      if (args.changes.__array_size) {
+        result2.arraySizeChanged = [arrayVarName];
+        if (arrayStateVarObj.additionalStateVariablesDefined) {
+          for (let varName of arrayStateVarObj.additionalStateVariablesDefined) {
+            if (component.state[varName].isArray) {
+              result2.arraySizeChanged.push(varName);
+            }
+          }
+        }
+      }
+      args.freshnessInfo.freshArraySize = true;
+    }
+    return result2;
+  }
+}
+function arrayInverseDefinition(args) {
+  const arrayStateVarObj = resolveArrayStateVarObj(this);
+  const arrayVarName = arrayStateVarObj.svVarName;
+  if (!arrayStateVarObj.inverseArrayDefinitionByKey) {
+    return { success: false };
+  }
+  if (args.arrayKeys === void 0) {
+    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  }
+  if (arrayStateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
+    const allStateVariablesAffected = [
+      arrayVarName,
+      ...arrayStateVarObj.additionalStateVariablesDefined ?? []
+    ];
+    let instructions = [];
+    for (let vName of allStateVariablesAffected) {
+      for (let key in args.desiredStateVariableValues[vName]) {
+        let depName = vName + "_" + key;
+        if (depName in args.dependencyValues) {
+          instructions.push({
+            setDependency: depName,
+            desiredValue: args.desiredStateVariableValues[vName][key],
+            treatAsInitialChange: args.initialChange
+          });
+        }
+      }
+    }
+    return {
+      success: true,
+      instructions
+    };
+  } else {
+    let extractedDeps = extractArrayDependencies(
+      arrayStateVarObj,
+      args.dependencyValues,
+      args.arrayKeys,
+      args.usedDefault
+    );
+    let globalDependencyValues = extractedDeps.globalDependencyValues;
+    let globalUsedDefault = extractedDeps.globalUsedDefault;
+    let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
+    let usedDefaultByKey = extractedDeps.usedDefaultByKey;
+    delete args.dependencyValues;
+    args.globalDependencyValues = globalDependencyValues;
+    args.globalUsedDefault = globalUsedDefault;
+    args.dependencyValuesByKey = dependencyValuesByKey;
+    args.usedDefaultByKey = usedDefaultByKey;
+    args.dependencyNamesByKey = arrayStateVarObj.dependencyNames.namesByKey;
+    if (!arrayStateVarObj.allowExtraArrayKeysInInverse) {
+      let newDesiredStateVariableValues = {};
+      for (let vName in args.desiredStateVariableValues) {
+        newDesiredStateVariableValues[vName] = {};
+        for (let key in args.desiredStateVariableValues[vName]) {
+          if (args.arrayKeys.includes(key)) {
+            newDesiredStateVariableValues[vName][key] = args.desiredStateVariableValues[vName][key];
+          }
+        }
+      }
+      args.desiredStateVariableValues = newDesiredStateVariableValues;
+    }
+    let result2 = arrayStateVarObj.inverseArrayDefinitionByKey(args);
+    return result2;
+  }
+}
+function getArrayArraySize() {
+  return (async () => {
+    if (!this.svComponent.state[this.arraySizeStateVariable].initiallyResolved) {
+      return [];
+    }
+    if (this.arraySizeStale) {
+      await this.recalculateArraySizeDependentQuantities();
+    }
+    return await this.svComponent.stateValues[this.arraySizeStateVariable];
+  })();
+}
+const ARRAY_ARRAY_SIZE_DESCRIPTOR = Object.freeze({
+  get: getArrayArraySize
+});
+function normalizeArrayStateVariableDefaults(def, varName) {
+  if (!def.isArray) {
+    return;
+  }
+  if (def.numDimensions === void 0) {
+    def.numDimensions = 1;
+  }
+  if (!def.entryPrefixes) {
+    def.entryPrefixes = [varName];
+  }
+  const multiDim = def.numDimensions > 1;
+  if (!def.keyToIndex) {
+    def.keyToIndex = multiDim ? multiDimKeyToIndex : oneDimKeyToIndex;
+  }
+  if (!def.indexToKey) {
+    def.indexToKey = arrayIndexToKey;
+  }
+  if (!def.getAllArrayKeys) {
+    def.getAllArrayKeys = multiDim ? multiDimGetAllArrayKeys : oneDimGetAllArrayKeys;
+  }
+  if (!def.getArrayKeysFromVarName) {
+    def.getArrayKeysFromVarName = returnDefaultGetArrayKeysFromVarName(
+      def.numDimensions
+    );
+  }
+  if (!def.arrayVarNameFromArrayKey) {
+    def.arrayVarNameFromArrayKey = multiDim ? defaultMultiDimArrayVarNameFromArrayKey : defaultOneDimArrayVarNameFromArrayKey;
+  }
+  if (!def.arrayVarNameFromPropIndex) {
+    def.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(
+      def.numDimensions,
+      def.entryPrefixes[0]
+    );
+  }
+  if (!def.returnEntryDimensions) {
+    def.returnEntryDimensions = defaultReturnEntryDimensions;
+  }
+  if (def.shadowingInstructions && !def.shadowingInstructions.returnWrappingComponents) {
+    def.shadowingInstructions.returnWrappingComponents = defaultReturnWrappingComponents;
+  }
+}
+function arraySizeDefinition({ dependencyValues }) {
+  let arraySize2 = this.svComponent.state[this.arraySizeSourceVarName].returnArraySize({
+    dependencyValues
+  });
+  for (let [ind, value] of arraySize2.entries()) {
+    if (!(Number.isInteger(value) && value >= 0)) {
+      arraySize2[ind] = 0;
+    }
+  }
+  return { setValue: { [this.svVarName]: arraySize2 } };
+}
+function arraySizeMarkStale() {
+  for (let varName of this.arraySizeVarNamesAffected) {
+    this.svComponent.state[varName].arraySizeStale = true;
+  }
+  return {};
+}
+async function arrayRecalculateArraySizeDependentQuantities() {
+  const component = this.svComponent;
+  let newArraySize = await component.stateValues[this.arraySizeStateVariable];
+  if (this.previousArraySize.length !== newArraySize.length || this.previousArraySize.some((v2, i2) => v2 != newArraySize[i2])) {
+    this.previousArraySize = [...newArraySize];
+    let varNamesIncluding = this.varNamesIncludingArrayKeys = {};
+    for (let entryName of this.arrayEntryNames) {
+      let entryStateVarObj = component.state[entryName];
+      let arrayKeys = this.getArrayKeysFromVarName({
+        arrayEntryPrefix: entryStateVarObj.entryPrefix,
+        varEnding: entryStateVarObj.varEnding,
+        arraySize: newArraySize,
+        numDimensions: this.numDimensions
+      });
+      entryStateVarObj._unflattenedArrayKeys = arrayKeys;
+      entryStateVarObj._arrayKeys = flattenDeep(arrayKeys);
+      for (let arrayKey of entryStateVarObj._arrayKeys) {
+        if (!varNamesIncluding[arrayKey]) {
+          varNamesIncluding[arrayKey] = [];
+        }
+        varNamesIncluding[arrayKey].push(entryName);
+      }
+    }
+  }
+  this.arraySizeStale = false;
+}
+async function entryReturnDependencies(args) {
+  const arrayStateVarObj = this.svComponent.state[this.arrayStateVariable];
+  args.arraySize = await this.arraySize;
+  args.arrayKeys = await this.arrayKeys;
+  let dependencies2 = await arrayStateVarObj.returnDependencies(args);
+  let numNames = Object.keys(
+    arrayStateVarObj.dependencyNames.namesByKey
+  ).length;
+  if (this.numberNamesInPreviousReturnDep !== numNames) {
+    args.changedDependency = true;
+  }
+  this.numberNamesInPreviousReturnDep = numNames;
+  return dependencies2;
+}
+async function initializeComponentStateVariables({
+  core: core2,
+  component
+}) {
+  for (let stateVariable in component.state) {
+    if (component.state[stateVariable].isAlias) {
+      if (!component.stateVarAliases) {
+        component.stateVarAliases = {};
+      }
+      component.stateVarAliases[stateVariable] = component.state[stateVariable].targetVariableName;
+      delete component.state[stateVariable];
+    } else {
+      await initializeStateVariable({
+        core: core2,
+        component,
+        stateVariable
+      });
+    }
+  }
+}
+async function initializeStateVariable({
+  core: core2,
+  component,
+  stateVariable,
+  arrayStateVariable,
+  arrayEntryPrefix
+}) {
+  if (!component.state[stateVariable]) {
+    component.state[stateVariable] = {};
+  }
+  let stateVarObj = component.state[stateVariable];
+  stateVarObj.svComponent = component;
+  stateVarObj.svVarName = stateVariable;
+  stateVarObj.isResolved = false;
+  installStaleValueGetter(stateVarObj);
+  if (arrayEntryPrefix !== void 0) {
+    await initializeArrayEntryStateVariable({
+      stateVarObj,
+      arrayStateVariable,
+      arrayEntryPrefix,
+      component,
+      stateVariable
+    });
+  } else if (stateVarObj.isArray) {
+    await initializeArrayStateVariable({
+      core: core2,
+      stateVarObj,
+      component,
+      stateVariable
+    });
+  }
+  if (stateVarObj.triggerActionOnChange) {
+    let componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx];
+    if (!componentTriggers) {
+      componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx] = {};
+    }
+    componentTriggers[stateVariable] = {
+      action: stateVarObj.triggerActionOnChange
+    };
+  }
+}
+async function initializeArrayEntryStateVariable({
+  stateVarObj,
+  arrayStateVariable,
+  arrayEntryPrefix,
+  component,
+  stateVariable
+}) {
+  stateVarObj.isArrayEntry = true;
+  stateVarObj.arrayStateVariable = arrayStateVariable;
+  let arrayStateVarObj = component.state[arrayStateVariable];
+  stateVarObj.definition = arrayStateVarObj.definition;
+  stateVarObj.inverseDefinition = arrayStateVarObj.inverseDefinition;
+  stateVarObj.markStale = arrayStateVarObj.markStale;
+  stateVarObj.freshnessInfo = arrayStateVarObj.freshnessInfo;
+  stateVarObj.getPreviousDependencyValuesForMarkStale = arrayStateVarObj.getPreviousDependencyValuesForMarkStale;
+  stateVarObj.provideEssentialValuesInDefinition = arrayStateVarObj.provideEssentialValuesInDefinition;
+  stateVarObj.providePreviousValuesInDefinition = arrayStateVarObj.providePreviousValuesInDefinition;
+  stateVarObj.isLocation = arrayStateVarObj.isLocation;
+  stateVarObj.numDimensions = arrayStateVarObj.returnEntryDimensions(arrayEntryPrefix);
+  stateVarObj.entryPrefix = arrayEntryPrefix;
+  stateVarObj.varEnding = stateVariable.slice(arrayEntryPrefix.length);
+  if (arrayStateVarObj.createWorkspace) {
+    stateVarObj.createWorkspace = true;
+    stateVarObj.workspace = arrayStateVarObj.workspace;
+  }
+  if (arrayStateVarObj.basedOnArrayKeyStateVariables) {
+    stateVarObj.basedOnArrayKeyStateVariables = true;
+  }
+  if (arrayStateVarObj.additionalStateVariablesDefined) {
+    stateVarObj.additionalStateVariablesDefined = [];
+    let entryPrefixInd = arrayStateVarObj.entryPrefixes.indexOf(arrayEntryPrefix);
+    for (let varName of arrayStateVarObj.additionalStateVariablesDefined) {
+      let sObj = component.state[varName];
+      if (sObj.isArray) {
+        let newArrayEntryPrefix = sObj.entryPrefixes[entryPrefixInd];
+        let arrayEntryVarName = newArrayEntryPrefix + stateVarObj.varEnding;
+        stateVarObj.additionalStateVariablesDefined.push(
+          arrayEntryVarName
+        );
+      } else {
+        stateVarObj.additionalStateVariablesDefined.push(varName);
+      }
+    }
+  }
+  if (arrayStateVarObj.shadowingInstructions) {
+    stateVarObj.shadowingInstructions = {};
+    stateVarObj.wrappingComponents = arrayStateVarObj.shadowingInstructions.returnWrappingComponents(
+      arrayEntryPrefix
+    );
+    if (arrayStateVarObj.shadowingInstructions.attributesToShadow) {
+      stateVarObj.shadowingInstructions.attributesToShadow = arrayStateVarObj.shadowingInstructions.attributesToShadow;
+    }
+    if (arrayStateVarObj.shadowingInstructions.createComponentOfType) {
+      let entryPrefixInd = arrayStateVarObj.entryPrefixes.indexOf(arrayEntryPrefix);
+      if (arrayStateVarObj.shadowingInstructions.createComponentOfType[entryPrefixInd]) {
+        stateVarObj.shadowingInstructions.createComponentOfType = [
+          arrayStateVarObj.shadowingInstructions.createComponentOfType[entryPrefixInd]
+        ];
+      }
+    }
+  }
+  if (arrayStateVarObj.getEntryValues) {
+    stateVarObj.getValueFromArrayValues = entryGetValueViaGetEntryValues;
+  } else {
+    stateVarObj.getValueFromArrayValues = entryGetValueFromArrayValues;
+  }
+  stateVarObj.arraySizeStateVariable = arrayStateVarObj.arraySizeStateVariable;
+  stateVarObj._arrayKeys = [];
+  stateVarObj._unflattenedArrayKeys = [];
+  Object.defineProperty(
+    stateVarObj,
+    "arrayKeys",
+    ENTRY_ARRAY_KEYS_DESCRIPTOR
+  );
+  Object.defineProperty(
+    stateVarObj,
+    "unflattenedArrayKeys",
+    ENTRY_UNFLATTENED_ARRAY_KEYS_DESCRIPTOR
+  );
+  if (component.state[stateVarObj.arraySizeStateVariable].initiallyResolved) {
+    let arraySize2 = await arrayStateVarObj.arraySize;
+    let arrayKeys = arrayStateVarObj.getArrayKeysFromVarName({
+      arrayEntryPrefix: stateVarObj.entryPrefix,
+      varEnding: stateVarObj.varEnding,
+      arraySize: arraySize2,
+      numDimensions: arrayStateVarObj.numDimensions
+    });
+    stateVarObj._unflattenedArrayKeys = arrayKeys;
+    stateVarObj._arrayKeys = flattenDeep(arrayKeys);
+    let varNamesIncluding = arrayStateVarObj.varNamesIncludingArrayKeys;
+    for (let arrayKey of stateVarObj._arrayKeys) {
+      if (!varNamesIncluding[arrayKey]) {
+        varNamesIncluding[arrayKey] = [];
+      }
+      varNamesIncluding[arrayKey].push(stateVariable);
+    }
+  }
+  arrayStateVarObj.arrayEntryNames.push(stateVariable);
+  Object.defineProperty(
+    stateVarObj,
+    "arraySize",
+    ENTRY_ARRAY_SIZE_DESCRIPTOR
+  );
+  Object.defineProperty(
+    stateVarObj,
+    "arrayEntrySize",
+    ENTRY_ARRAY_ENTRY_SIZE_DESCRIPTOR
+  );
+  if (arrayStateVarObj.stateVariablesDeterminingDependencies) {
+    if (!stateVarObj.stateVariablesDeterminingDependencies) {
+      stateVarObj.stateVariablesDeterminingDependencies = [];
+    }
+    for (let varName of arrayStateVarObj.stateVariablesDeterminingDependencies) {
+      if (!stateVarObj.stateVariablesDeterminingDependencies.includes(
+        varName
+      )) {
+        stateVarObj.stateVariablesDeterminingDependencies.push(varName);
+      }
+    }
+  }
+  stateVarObj.returnDependencies = entryReturnDependencies;
+}
+async function initializeArrayStateVariable({
+  core: core2,
+  stateVarObj,
+  component,
+  stateVariable
+}) {
+  stateVarObj.arrayValues = [];
+  if (stateVarObj.numDimensions === void 0) {
+    stateVarObj.numDimensions = 1;
+  }
+  let entryPrefixes = stateVarObj.entryPrefixes;
+  if (!entryPrefixes) {
+    entryPrefixes = stateVarObj.entryPrefixes = [stateVariable];
+  }
+  if (!component.arrayEntryPrefixes) {
+    component.arrayEntryPrefixes = {};
+  }
+  for (let prefix of entryPrefixes) {
+    component.arrayEntryPrefixes[prefix] = stateVariable;
+  }
+  if (stateVarObj.numDimensions > 1) {
+    if (!stateVarObj.keyToIndex) {
+      stateVarObj.keyToIndex = multiDimKeyToIndex;
+    }
+    stateVarObj.setArrayValue = multiDimSetArrayValue;
+    stateVarObj.getArrayValue = multiDimGetArrayValue;
+    if (!stateVarObj.getAllArrayKeys) {
+      stateVarObj.getAllArrayKeys = multiDimGetAllArrayKeys;
+    }
+    if (!stateVarObj.arrayVarNameFromArrayKey) {
+      stateVarObj.arrayVarNameFromArrayKey = defaultMultiDimArrayVarNameFromArrayKey;
+    }
+    if (!stateVarObj.arrayVarNameFromPropIndex) {
+      stateVarObj.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(
+        stateVarObj.numDimensions,
+        entryPrefixes[0]
+      );
+    }
+    stateVarObj.adjustArrayToNewArraySize = multiDimAdjustArrayToNewArraySize;
+  } else {
+    if (!stateVarObj.keyToIndex) {
+      stateVarObj.keyToIndex = oneDimKeyToIndex;
+    }
+    stateVarObj.setArrayValue = oneDimSetArrayValue;
+    stateVarObj.getArrayValue = oneDimGetArrayValue;
+    if (!stateVarObj.getAllArrayKeys) {
+      stateVarObj.getAllArrayKeys = oneDimGetAllArrayKeys;
+    }
+    if (!stateVarObj.arrayVarNameFromArrayKey) {
+      stateVarObj.arrayVarNameFromArrayKey = defaultOneDimArrayVarNameFromArrayKey;
+    }
+    if (!stateVarObj.arrayVarNameFromPropIndex) {
+      stateVarObj.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(1, entryPrefixes[0]);
+    }
+    stateVarObj.adjustArrayToNewArraySize = oneDimAdjustArrayToNewArraySize;
+  }
+  if (!stateVarObj.getArrayKeysFromVarName) {
+    stateVarObj.getArrayKeysFromVarName = returnDefaultGetArrayKeysFromVarName(stateVarObj.numDimensions);
+  }
+  if (!stateVarObj.indexToKey) {
+    stateVarObj.indexToKey = arrayIndexToKey;
+  }
+  if (!stateVarObj.returnEntryDimensions) {
+    stateVarObj.returnEntryDimensions = defaultReturnEntryDimensions;
+  }
+  if (stateVarObj.shadowingInstructions) {
+    if (!stateVarObj.shadowingInstructions.returnWrappingComponents) {
+      stateVarObj.shadowingInstructions.returnWrappingComponents = defaultReturnWrappingComponents;
+    }
+    stateVarObj.wrappingComponents = stateVarObj.shadowingInstructions.returnWrappingComponents();
+  }
+  stateVarObj.usedDefaultByArrayKey = {};
+  stateVarObj.arrayEntryNames = [];
+  stateVarObj.varNamesIncludingArrayKeys = {};
+  stateVarObj.returnDependencies = arrayReturnDependencies;
+  stateVarObj.getCurrentFreshness = arrayGetCurrentFreshness;
+  stateVarObj.markStale = arrayMarkStale;
+  stateVarObj.freshenOnNoChanges = arrayFreshenOnNoChanges;
+  stateVarObj.definition = arrayDefinition;
+  stateVarObj.inverseDefinition = arrayInverseDefinition;
+  await createArraySizeStateVariable({
+    core: core2,
+    stateVarObj,
+    component,
+    stateVariable
+  });
+  stateVarObj.arraySizeStale = true;
+  stateVarObj.previousArraySize = [];
+  Object.defineProperty(
+    stateVarObj,
+    "arraySize",
+    ARRAY_ARRAY_SIZE_DESCRIPTOR
+  );
+  stateVarObj.recalculateArraySizeDependentQuantities = arrayRecalculateArraySizeDependentQuantities;
+  if (!stateVarObj.freshnessInfo) {
+    stateVarObj.freshnessInfo = { freshByKey: {} };
+    if (stateVarObj.additionalStateVariablesDefined) {
+      for (let vName of stateVarObj.additionalStateVariablesDefined) {
+        if (!component.state[vName]) {
+          component.state[vName] = {};
+        }
+        component.state[vName].freshnessInfo = stateVarObj.freshnessInfo;
+      }
+    }
+  }
+}
+async function createArraySizeStateVariable({
+  core: core2,
+  stateVarObj,
+  component,
+  stateVariable
+}) {
+  let allStateVariablesAffected = [stateVariable];
+  if (stateVarObj.additionalStateVariablesDefined) {
+    allStateVariablesAffected.push(
+      ...stateVarObj.additionalStateVariablesDefined
+    );
+  }
+  allStateVariablesAffected.sort();
+  let arraySizeStateVar = `__array_size_` + allStateVariablesAffected.join("_");
+  stateVarObj.arraySizeStateVariable = arraySizeStateVar;
+  if (stateVarObj.stateVariablesDeterminingDependencies) {
+    stateVarObj.stateVariablesDeterminingDependencies.push(
+      arraySizeStateVar
+    );
+  } else {
+    stateVarObj.stateVariablesDeterminingDependencies = [arraySizeStateVar];
+  }
+  if (component.state[arraySizeStateVar]) {
+    if (component.state[arraySizeStateVar].isShadow) {
+      let arraySizeStateVarObj = component.state[arraySizeStateVar];
+      arraySizeStateVarObj.arraySizeVarNamesAffected = allStateVariablesAffected;
+      arraySizeStateVarObj.markStale = arraySizeMarkStale;
+    }
+    return;
+  }
+  component.state[arraySizeStateVar] = {
+    returnDependencies: stateVarObj.returnArraySizeDependencies,
+    definition: arraySizeDefinition,
+    markStale: arraySizeMarkStale,
+    arraySizeVarNamesAffected: allStateVariablesAffected,
+    arraySizeSourceVarName: stateVariable
+  };
+  if (stateVarObj.stateVariablesDeterminingArraySizeDependencies) {
+    component.state[arraySizeStateVar].stateVariablesDeterminingDependencies = stateVarObj.stateVariablesDeterminingArraySizeDependencies;
+  }
+  await initializeStateVariable({
+    core: core2,
+    component,
+    stateVariable: arraySizeStateVar
+  });
+}
+async function arrayEntryNamesFromPropIndex({
+  core: core2,
+  stateVariables,
+  component,
+  propIndex
+}) {
+  let newVarNames = [];
+  for (let varName of stateVariables) {
+    let stateVarObj = component.state[varName];
+    if (!stateVarObj) {
+      if (!core2.checkIfArrayEntry({
+        stateVariable: varName,
+        component
+      }).isArrayEntry) {
+        newVarNames.push(varName);
+        continue;
+      }
+      await core2.createFromArrayEntry({
+        stateVariable: varName,
+        component
+      });
+      stateVarObj = component.state[varName];
+    }
+    let newName;
+    if (stateVarObj.isArray) {
+      newName = stateVarObj.arrayVarNameFromPropIndex(propIndex, varName);
+    } else if (stateVarObj.isArrayEntry) {
+      let arrayStateVarObj = component.state[stateVarObj.arrayStateVariable];
+      newName = arrayStateVarObj.arrayVarNameFromPropIndex(
+        propIndex,
+        varName
+      );
+    } else {
+      core2.addDiagnostic({
+        type: "warning",
+        message: `Cannot get propIndex from ${varName} of ${component.componentIdx} as it is not an array or array entry state variable`,
+        position: component.position,
+        sourceDoc: component.sourceDoc
+      });
+      newName = varName;
+    }
+    if (newName) {
+      newVarNames.push(newName);
+    } else {
+      core2.addDiagnostic({
+        type: "warning",
+        message: `Cannot get propIndex from ${varName} of ${component.componentIdx}`,
+        position: component.position,
+        sourceDoc: component.sourceDoc
+      });
+      newVarNames.push(varName);
+    }
+  }
+  return newVarNames;
+}
 const PRIMITIVE_TO_COMPONENT_TYPE = {
   string: "text",
   stringArray: "textList",
@@ -49638,6 +50893,9 @@ function getClassStateVariableDefinitions(core2, componentClass) {
       core2.numerics
     );
     Object.assign(combined, normalized);
+    for (const varName in combined) {
+      normalizeArrayStateVariableDefaults(combined[varName], varName);
+    }
     combined[SHARED_STATE_VARIABLE_DEFINITIONS] = true;
     entry = { combined, normalized };
     perCore.set(componentClass, entry);
@@ -50693,1159 +51951,6 @@ function validateAttributeValue({
   }
   return { value, diagnostics };
 }
-function renameStateVariable({
-  stateVariableDefinitions,
-  oldName,
-  newName
-}) {
-  let stateVarDef = stateVariableDefinitions[newName] = stateVariableDefinitions[oldName];
-  delete stateVariableDefinitions[oldName];
-  stateVarDef.excludeFromSchema = true;
-  if (stateVarDef.additionalStateVariablesDefined) {
-    let ind = stateVarDef.additionalStateVariablesDefined.indexOf(oldName);
-    if (ind !== -1) {
-      stateVarDef.additionalStateVariablesDefined[ind] = newName;
-    }
-  }
-  let originalDefinition = stateVarDef.definition;
-  let keysInObjects = [
-    "setValue",
-    "useEssentialOrDefaultValue",
-    "setEssentialValue"
-  ];
-  let entriesInArrays = ["noChanges"];
-  stateVarDef.definition = function(args) {
-    let result2 = originalDefinition(args);
-    for (let key of keysInObjects) {
-      if (result2[key] && oldName in result2[key]) {
-        result2[key][newName] = result2[key][oldName];
-        delete result2[key][oldName];
-      }
-    }
-    for (let key of entriesInArrays) {
-      if (result2[key]) {
-        let ind = result2[key].indexOf(oldName);
-        if (ind !== -1) {
-          result2[key][ind] = newName;
-        }
-      }
-    }
-    return result2;
-  };
-  let originalInverseDefinition = stateVarDef.inverseDefinition;
-  if (originalInverseDefinition) {
-    stateVarDef.inverseDefinition = async function(args) {
-      let desiredStateVariableValues = args.desiredStateVariableValues;
-      desiredStateVariableValues[oldName] = desiredStateVariableValues[newName];
-      delete desiredStateVariableValues[newName];
-      let results = await originalInverseDefinition(args);
-      if (results.success) {
-        for (let instruction of results.instructions) {
-          if (instruction.setEssentialValue === oldName) {
-            instruction.setEssentialValue = newName;
-          }
-        }
-      }
-      return results;
-    };
-  }
-}
-function returnDefaultGetArrayKeysFromVarName(numDim) {
-  if (numDim > 1) {
-    return function({
-      arrayEntryPrefix,
-      varEnding,
-      arraySize: arraySize2,
-      numDimensions
-    }) {
-      let indices = varEnding.split("_").map((x2) => Number(x2) - 1);
-      if (indices.length === numDimensions && indices.every((x2, i2) => Number.isInteger(x2) && x2 >= 0)) {
-        if (arraySize2) {
-          if (indices.every((x2, i2) => x2 < arraySize2[i2])) {
-            return [String(indices)];
-          } else {
-            return [];
-          }
-        } else {
-          return [String(indices)];
-        }
-      } else {
-        return [];
-      }
-    };
-  } else {
-    return function({ arrayEntryPrefix, varEnding, arraySize: arraySize2 }) {
-      let index2 = Number(varEnding) - 1;
-      if (Number.isInteger(index2) && index2 >= 0) {
-        if (arraySize2) {
-          if (index2 < arraySize2[0]) {
-            return [String(index2)];
-          } else {
-            return [];
-          }
-        } else {
-          return [String(index2)];
-        }
-      } else {
-        return [];
-      }
-    };
-  }
-}
-function returnDefaultArrayVarNameFromPropIndex(numDim, arrayEntryPrefix) {
-  if (numDim > 1) {
-    return function(propIndex, varName) {
-      return arrayEntryPrefix + [
-        ...propIndex.map((x2) => Math.round(Number(x2))),
-        ...Array(numDim - propIndex.length).fill(1)
-      ].join("_");
-    };
-  } else {
-    return function(propIndex, varName) {
-      return arrayEntryPrefix + propIndex[0];
-    };
-  }
-}
-async function initializeComponentStateVariables({
-  core: core2,
-  component
-}) {
-  for (let stateVariable in component.state) {
-    if (component.state[stateVariable].isAlias) {
-      if (!component.stateVarAliases) {
-        component.stateVarAliases = {};
-      }
-      component.stateVarAliases[stateVariable] = component.state[stateVariable].targetVariableName;
-      delete component.state[stateVariable];
-    } else {
-      await initializeStateVariable({
-        core: core2,
-        component,
-        stateVariable
-      });
-    }
-  }
-}
-async function initializeStateVariable({
-  core: core2,
-  component,
-  stateVariable,
-  arrayStateVariable,
-  arrayEntryPrefix
-}) {
-  let getStateVar = core2.getStateVariableValue;
-  if (!component.state[stateVariable]) {
-    component.state[stateVariable] = {};
-  }
-  let stateVarObj = component.state[stateVariable];
-  stateVarObj.isResolved = false;
-  Object.defineProperty(stateVarObj, "value", {
-    get: () => getStateVar({ component, stateVariable }),
-    configurable: true
-  });
-  if (arrayEntryPrefix !== void 0) {
-    await initializeArrayEntryStateVariable({
-      stateVarObj,
-      arrayStateVariable,
-      arrayEntryPrefix,
-      component,
-      stateVariable
-    });
-  } else if (stateVarObj.isArray) {
-    await initializeArrayStateVariable({
-      core: core2,
-      stateVarObj,
-      component,
-      stateVariable
-    });
-  }
-  if (stateVarObj.triggerActionOnChange) {
-    let componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx];
-    if (!componentTriggers) {
-      componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx] = {};
-    }
-    componentTriggers[stateVariable] = {
-      action: stateVarObj.triggerActionOnChange
-    };
-  }
-}
-async function initializeArrayEntryStateVariable({
-  stateVarObj,
-  arrayStateVariable,
-  arrayEntryPrefix,
-  component,
-  stateVariable
-}) {
-  stateVarObj.isArrayEntry = true;
-  stateVarObj.arrayStateVariable = arrayStateVariable;
-  let arrayStateVarObj = component.state[arrayStateVariable];
-  stateVarObj.definition = arrayStateVarObj.definition;
-  stateVarObj.inverseDefinition = arrayStateVarObj.inverseDefinition;
-  stateVarObj.markStale = arrayStateVarObj.markStale;
-  stateVarObj.freshnessInfo = arrayStateVarObj.freshnessInfo;
-  stateVarObj.getPreviousDependencyValuesForMarkStale = arrayStateVarObj.getPreviousDependencyValuesForMarkStale;
-  stateVarObj.provideEssentialValuesInDefinition = arrayStateVarObj.provideEssentialValuesInDefinition;
-  stateVarObj.providePreviousValuesInDefinition = arrayStateVarObj.providePreviousValuesInDefinition;
-  stateVarObj.isLocation = arrayStateVarObj.isLocation;
-  stateVarObj.numDimensions = arrayStateVarObj.returnEntryDimensions(arrayEntryPrefix);
-  stateVarObj.entryPrefix = arrayEntryPrefix;
-  stateVarObj.varEnding = stateVariable.slice(arrayEntryPrefix.length);
-  if (arrayStateVarObj.createWorkspace) {
-    stateVarObj.createWorkspace = true;
-    stateVarObj.workspace = arrayStateVarObj.workspace;
-  }
-  if (arrayStateVarObj.basedOnArrayKeyStateVariables) {
-    stateVarObj.basedOnArrayKeyStateVariables = true;
-  }
-  if (arrayStateVarObj.additionalStateVariablesDefined) {
-    stateVarObj.additionalStateVariablesDefined = [];
-    let entryPrefixInd = arrayStateVarObj.entryPrefixes.indexOf(arrayEntryPrefix);
-    for (let varName of arrayStateVarObj.additionalStateVariablesDefined) {
-      let sObj = component.state[varName];
-      if (sObj.isArray) {
-        let newArrayEntryPrefix = sObj.entryPrefixes[entryPrefixInd];
-        let arrayEntryVarName = newArrayEntryPrefix + stateVarObj.varEnding;
-        stateVarObj.additionalStateVariablesDefined.push(
-          arrayEntryVarName
-        );
-      } else {
-        stateVarObj.additionalStateVariablesDefined.push(varName);
-      }
-    }
-  }
-  if (arrayStateVarObj.shadowingInstructions) {
-    stateVarObj.shadowingInstructions = {};
-    stateVarObj.wrappingComponents = arrayStateVarObj.shadowingInstructions.returnWrappingComponents(
-      arrayEntryPrefix
-    );
-    if (arrayStateVarObj.shadowingInstructions.attributesToShadow) {
-      stateVarObj.shadowingInstructions.attributesToShadow = arrayStateVarObj.shadowingInstructions.attributesToShadow;
-    }
-    if (arrayStateVarObj.shadowingInstructions.createComponentOfType) {
-      let entryPrefixInd = arrayStateVarObj.entryPrefixes.indexOf(arrayEntryPrefix);
-      if (arrayStateVarObj.shadowingInstructions.createComponentOfType[entryPrefixInd]) {
-        stateVarObj.shadowingInstructions.createComponentOfType = [
-          arrayStateVarObj.shadowingInstructions.createComponentOfType[entryPrefixInd]
-        ];
-      }
-    }
-  }
-  if (arrayStateVarObj.getEntryValues) {
-    stateVarObj.getValueFromArrayValues = async function() {
-      return await arrayStateVarObj.getEntryValues({
-        varName: stateVariable
-      });
-    };
-  } else {
-    stateVarObj.getValueFromArrayValues = async function() {
-      let arrayKeys = await stateVarObj.arrayKeys;
-      if (arrayKeys.length === 0) {
-        return;
-      }
-      let value = [];
-      for (let arrayKey of arrayKeys) {
-        value.push(arrayStateVarObj.getArrayValue({ arrayKey }));
-      }
-      if (value.length === 1) {
-        return value[0];
-      } else {
-        return value;
-      }
-    };
-  }
-  stateVarObj.arraySizeStateVariable = arrayStateVarObj.arraySizeStateVariable;
-  stateVarObj._arrayKeys = [];
-  stateVarObj._unflattenedArrayKeys = [];
-  Object.defineProperty(stateVarObj, "arrayKeys", {
-    get: function() {
-      return (async () => {
-        await arrayStateVarObj.arraySize;
-        return stateVarObj._arrayKeys;
-      })();
-    }
-  });
-  Object.defineProperty(stateVarObj, "unflattenedArrayKeys", {
-    get: function() {
-      return (async () => {
-        await arrayStateVarObj.arraySize;
-        return stateVarObj._unflattenedArrayKeys;
-      })();
-    }
-  });
-  if (component.state[stateVarObj.arraySizeStateVariable].initiallyResolved) {
-    let arraySize2 = await arrayStateVarObj.arraySize;
-    let arrayKeys = arrayStateVarObj.getArrayKeysFromVarName({
-      arrayEntryPrefix: stateVarObj.entryPrefix,
-      varEnding: stateVarObj.varEnding,
-      arraySize: arraySize2,
-      numDimensions: arrayStateVarObj.numDimensions
-    });
-    stateVarObj._unflattenedArrayKeys = arrayKeys;
-    stateVarObj._arrayKeys = flattenDeep(arrayKeys);
-    let varNamesIncluding = arrayStateVarObj.varNamesIncludingArrayKeys;
-    for (let arrayKey of stateVarObj._arrayKeys) {
-      if (!varNamesIncluding[arrayKey]) {
-        varNamesIncluding[arrayKey] = [];
-      }
-      varNamesIncluding[arrayKey].push(stateVariable);
-    }
-  }
-  arrayStateVarObj.arrayEntryNames.push(stateVariable);
-  Object.defineProperty(stateVarObj, "arraySize", {
-    get: () => arrayStateVarObj.arraySize
-  });
-  Object.defineProperty(stateVarObj, "arrayEntrySize", {
-    get: function() {
-      return (async () => {
-        let unflattenedArrayKeys = await stateVarObj.unflattenedArrayKeys;
-        let arrayEntrySize = [];
-        let subArray = [unflattenedArrayKeys];
-        for (let i2 = 0; i2 < stateVarObj.numDimensions; i2++) {
-          subArray = subArray[0];
-          arrayEntrySize.push(subArray.length);
-        }
-        arrayEntrySize.reverse();
-        return arrayEntrySize;
-      })();
-    }
-  });
-  if (arrayStateVarObj.stateVariablesDeterminingDependencies) {
-    if (!stateVarObj.stateVariablesDeterminingDependencies) {
-      stateVarObj.stateVariablesDeterminingDependencies = [];
-    }
-    for (let varName of arrayStateVarObj.stateVariablesDeterminingDependencies) {
-      if (!stateVarObj.stateVariablesDeterminingDependencies.includes(
-        varName
-      )) {
-        stateVarObj.stateVariablesDeterminingDependencies.push(varName);
-      }
-    }
-  }
-  let arrayReturnDependencies = arrayStateVarObj.returnDependencies.bind(arrayStateVarObj);
-  stateVarObj.returnDependencies = async function(args) {
-    args.arraySize = await stateVarObj.arraySize;
-    args.arrayKeys = await stateVarObj.arrayKeys;
-    let dependencies2 = await arrayReturnDependencies(args);
-    let numNames = Object.keys(
-      arrayStateVarObj.dependencyNames.namesByKey
-    ).length;
-    if (stateVarObj.numberNamesInPreviousReturnDep !== numNames) {
-      args.changedDependency = true;
-    }
-    stateVarObj.numberNamesInPreviousReturnDep = numNames;
-    return dependencies2;
-  };
-}
-async function initializeArrayStateVariable({
-  core: core2,
-  stateVarObj,
-  component,
-  stateVariable
-}) {
-  stateVarObj.arrayValues = [];
-  if (stateVarObj.numDimensions === void 0) {
-    stateVarObj.numDimensions = 1;
-  }
-  let entryPrefixes = stateVarObj.entryPrefixes;
-  if (!entryPrefixes) {
-    entryPrefixes = stateVarObj.entryPrefixes = [stateVariable];
-  }
-  if (!component.arrayEntryPrefixes) {
-    component.arrayEntryPrefixes = {};
-  }
-  for (let prefix of entryPrefixes) {
-    component.arrayEntryPrefixes[prefix] = stateVariable;
-  }
-  if (stateVarObj.numDimensions > 1) {
-    stateVarObj.keyToIndex = (key) => key.split(",").map((x2) => Number(x2));
-    stateVarObj.setArrayValue = function({
-      value,
-      arrayKey,
-      arraySize: arraySize2,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      let index2 = stateVarObj.keyToIndex(arrayKey);
-      let numDimensionsInArrayKey = index2.length;
-      if (numDimensionsInArrayKey > stateVarObj.numDimensions) {
-        core2.addDiagnostic({
-          type: "info",
-          message: "Cannot set array value.  Number of dimensions is too large.",
-          position: component.position,
-          sourceDoc: component.sourceDoc
-        });
-        return { nFailures: 1 };
-      }
-      let arrayValuesDrillDown = arrayValues;
-      let arraySizeDrillDown = arraySize2;
-      for (let indComponent of index2.slice(0, index2.length - 1)) {
-        if (indComponent >= 0 && indComponent < arraySizeDrillDown[0]) {
-          if (!arrayValuesDrillDown[indComponent]) {
-            arrayValuesDrillDown[indComponent] = [];
-          }
-          arrayValuesDrillDown = arrayValuesDrillDown[indComponent];
-          arraySizeDrillDown = arraySizeDrillDown.slice(1);
-        } else {
-          core2.addDiagnostic({
-            type: "info",
-            message: "ignore setting array value out of bounds",
-            position: component.position,
-            sourceDoc: component.sourceDoc
-          });
-          return { nFailures: 1 };
-        }
-      }
-      let nFailures = 0;
-      if (numDimensionsInArrayKey < stateVarObj.numDimensions) {
-        let setArrayValuesPiece = function(desiredValue, arrayValuesPiece, arraySizePiece) {
-          if (!Array.isArray(desiredValue)) {
-            core2.addDiagnostic({
-              type: "info",
-              message: "ignoring array values with insufficient dimensions",
-              position: component.position,
-              sourceDoc: component.sourceDoc
-            });
-            return { nFailures: 1 };
-          }
-          let nFailuresSub = 0;
-          let currentSize = arraySizePiece[0];
-          if (desiredValue.length > currentSize) {
-            core2.addDiagnostic({
-              type: "info",
-              message: "ignoring array values out of bounds",
-              position: component.position,
-              sourceDoc: component.sourceDoc
-            });
-            nFailuresSub += desiredValue.length - currentSize;
-            desiredValue = desiredValue.slice(0, currentSize);
-          }
-          if (arraySizePiece.length === 1) {
-            for (let [
-              ind,
-              val
-            ] of desiredValue.entries()) {
-              arrayValuesPiece[ind] = val;
-            }
-          } else {
-            for (let [
-              ind,
-              val
-            ] of desiredValue.entries()) {
-              if (!arrayValuesPiece[ind]) {
-                arrayValuesPiece[ind] = [];
-              }
-              let result22 = setArrayValuesPiece(
-                val,
-                arrayValuesPiece[ind],
-                arraySizePiece.slice(1)
-              );
-              nFailuresSub += result22.nFailures;
-            }
-          }
-          return { nFailures: nFailuresSub };
-        };
-        let result2 = setArrayValuesPiece(
-          value,
-          arrayValuesDrillDown,
-          arraySizeDrillDown
-        );
-        nFailures += result2.nFailures;
-      } else {
-        arrayValuesDrillDown[index2[index2.length - 1]] = value;
-      }
-      return { nFailures };
-    };
-    stateVarObj.getArrayValue = function({
-      arrayKey,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      let index2 = stateVarObj.keyToIndex(arrayKey);
-      let aVals = arrayValues;
-      for (let indComponent of index2.slice(0, index2.length - 1)) {
-        aVals = aVals[indComponent];
-        if (!aVals) {
-          return void 0;
-        }
-      }
-      return aVals[index2[index2.length - 1]];
-    };
-    if (!stateVarObj.getAllArrayKeys) {
-      stateVarObj.getAllArrayKeys = function(arraySize2, flatten2 = true, desiredSize) {
-        function prependToAllKeys(keys2, newStuff) {
-          for (let [ind, key] of keys2.entries()) {
-            if (Array.isArray(key)) {
-              prependToAllKeys(key, newStuff);
-            } else {
-              keys2[ind] = newStuff + "," + key;
-            }
-          }
-        }
-        function getAllArrayKeysSub(subArraySize) {
-          if (subArraySize.length === 1) {
-            return Array.from(
-              Array(subArraySize[0]),
-              (_2, i2) => String(i2)
-            );
-          } else {
-            let currentSize = subArraySize[0];
-            let subSubKeys = getAllArrayKeysSub(
-              subArraySize.slice(1)
-            );
-            let subKeys = [];
-            for (let ind = 0; ind < currentSize; ind++) {
-              if (flatten2) {
-                subKeys.push(
-                  ...subSubKeys.map(
-                    (x2) => ind + "," + x2
-                  )
-                );
-              } else {
-                let newSubSubKeys = deepClone(subSubKeys);
-                prependToAllKeys(newSubSubKeys, ind);
-                subKeys.push(newSubSubKeys);
-              }
-            }
-            return subKeys;
-          }
-        }
-        if (desiredSize) {
-          if (desiredSize.length === 0) {
-            return [];
-          } else {
-            return getAllArrayKeysSub(desiredSize);
-          }
-        } else if (!arraySize2 || arraySize2.length === 0) {
-          return [];
-        } else {
-          return getAllArrayKeysSub(arraySize2);
-        }
-      };
-    }
-    if (!stateVarObj.arrayVarNameFromArrayKey) {
-      stateVarObj.arrayVarNameFromArrayKey = function(arrayKey) {
-        return entryPrefixes[0] + arrayKey.split(",").map((x2) => Number(x2) + 1).join("_");
-      };
-    }
-    if (!stateVarObj.arrayVarNameFromPropIndex) {
-      stateVarObj.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(
-        stateVarObj.numDimensions,
-        entryPrefixes[0]
-      );
-    }
-    stateVarObj.adjustArrayToNewArraySize = async function() {
-      function resizeSubArray(subArray, subArraySize) {
-        subArray.length = subArraySize[0];
-        if (subArraySize.length > 1) {
-          let subSubArraySize = subArraySize.slice(1);
-          for (let [
-            ind,
-            subSubArray
-          ] of subArray.entries()) {
-            if (!subSubArray) {
-              subSubArray = subArray[ind] = [];
-            }
-            resizeSubArray(subSubArray, subSubArraySize);
-          }
-        }
-      }
-      let arraySize2 = await stateVarObj.arraySize;
-      resizeSubArray(stateVarObj.arrayValues, arraySize2);
-    };
-  } else {
-    stateVarObj.keyToIndex = (key) => Number(key);
-    stateVarObj.setArrayValue = function({
-      value,
-      arrayKey,
-      arraySize: arraySize2,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      let ind = stateVarObj.keyToIndex(arrayKey);
-      if (ind >= 0 && ind < arraySize2[0]) {
-        arrayValues[ind] = value;
-        return { nFailures: 0 };
-      } else {
-        core2.addDiagnostic({
-          type: "info",
-          message: `Ignoring setting array values out of bounds: ${arrayKey} of ${stateVariable}`,
-          position: component.position,
-          sourceDoc: component.sourceDoc
-        });
-        return { nFailures: 1 };
-      }
-    };
-    stateVarObj.getArrayValue = function({
-      arrayKey,
-      arrayValues = stateVarObj.arrayValues
-    }) {
-      return arrayValues[arrayKey];
-    };
-    if (!stateVarObj.getAllArrayKeys) {
-      stateVarObj.getAllArrayKeys = function(arraySize2, flatten2, desiredSize) {
-        if (desiredSize) {
-          if (desiredSize.length === 0) {
-            return [];
-          } else {
-            return Array.from(
-              Array(desiredSize[0]),
-              (_2, i2) => String(i2)
-            );
-          }
-        } else if (!arraySize2 || arraySize2.length === 0) {
-          return [];
-        } else {
-          return Array.from(Array(arraySize2[0]), (_2, i2) => String(i2));
-        }
-      };
-    }
-    if (!stateVarObj.arrayVarNameFromArrayKey) {
-      stateVarObj.arrayVarNameFromArrayKey = function(arrayKey) {
-        return entryPrefixes[0] + String(Number(arrayKey) + 1);
-      };
-    }
-    if (!stateVarObj.arrayVarNameFromPropIndex) {
-      stateVarObj.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(1, entryPrefixes[0]);
-    }
-    stateVarObj.adjustArrayToNewArraySize = async function() {
-      let arraySize2 = await stateVarObj.arraySize;
-      stateVarObj.arrayValues.length = arraySize2[0];
-    };
-  }
-  if (!stateVarObj.getArrayKeysFromVarName) {
-    stateVarObj.getArrayKeysFromVarName = returnDefaultGetArrayKeysFromVarName(stateVarObj.numDimensions);
-  }
-  stateVarObj.indexToKey = (index2) => String(index2);
-  if (!stateVarObj.returnEntryDimensions) {
-    stateVarObj.returnEntryDimensions = () => 0;
-  }
-  if (stateVarObj.shadowingInstructions) {
-    if (!stateVarObj.shadowingInstructions.returnWrappingComponents) {
-      stateVarObj.shadowingInstructions.returnWrappingComponents = (prefix) => [];
-    }
-    stateVarObj.wrappingComponents = stateVarObj.shadowingInstructions.returnWrappingComponents();
-  }
-  stateVarObj.usedDefaultByArrayKey = {};
-  stateVarObj.arrayEntryNames = [];
-  stateVarObj.varNamesIncludingArrayKeys = {};
-  let allStateVariablesAffected = [stateVariable];
-  if (stateVarObj.additionalStateVariablesDefined) {
-    allStateVariablesAffected.push(
-      ...stateVarObj.additionalStateVariablesDefined
-    );
-  }
-  stateVarObj.returnDependencies = async function(args) {
-    args.arraySize = await stateVarObj.arraySize;
-    for (let key in args.stateValues) {
-      if (key.slice(0, 8) === "__array_") {
-        delete args.stateValues[key];
-      }
-    }
-    if (args.arrayKeys === void 0) {
-      args.arrayKeys = stateVarObj.getAllArrayKeys(args.arraySize);
-    }
-    if (!stateVarObj.dependencyNames) {
-      stateVarObj.dependencyNames = {
-        namesByKey: {},
-        keysByName: {},
-        global: []
-      };
-      if (stateVarObj.additionalStateVariablesDefined) {
-        for (let vName of stateVarObj.additionalStateVariablesDefined) {
-          component.state[vName].dependencyNames = stateVarObj.dependencyNames;
-        }
-      }
-    }
-    let dependencies2 = {};
-    if (stateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
-      for (let arrayKey of args.arrayKeys) {
-        for (let vName of allStateVariablesAffected) {
-          let sObj = component.state[vName];
-          dependencies2[vName + "_" + arrayKey] = {
-            dependencyType: "stateVariable",
-            variableName: sObj.arrayVarNameFromArrayKey(arrayKey)
-          };
-        }
-      }
-    } else {
-      let arrayDependencies = stateVarObj.returnArrayDependenciesByKey(args);
-      if (arrayDependencies.globalDependencies) {
-        stateVarObj.dependencyNames.global = Object.keys(
-          arrayDependencies.globalDependencies
-        );
-        Object.assign(
-          dependencies2,
-          arrayDependencies.globalDependencies
-        );
-      }
-      if (!arrayDependencies.dependenciesByKey) {
-        arrayDependencies.dependenciesByKey = {};
-      }
-      for (let arrayKey of args.arrayKeys) {
-        if (!(arrayKey in stateVarObj.dependencyNames.namesByKey)) {
-          args.changedDependency = true;
-        }
-        stateVarObj.dependencyNames.namesByKey[arrayKey] = {};
-        for (let depName in arrayDependencies.dependenciesByKey[arrayKey]) {
-          let extendedDepName = "__" + arrayKey + "_" + depName;
-          dependencies2[extendedDepName] = arrayDependencies.dependenciesByKey[arrayKey][depName];
-          stateVarObj.dependencyNames.namesByKey[arrayKey][depName] = extendedDepName;
-          if (!stateVarObj.dependencyNames.keysByName[extendedDepName]) {
-            stateVarObj.dependencyNames.keysByName[extendedDepName] = [];
-          }
-          if (!stateVarObj.dependencyNames.keysByName[extendedDepName].includes(arrayKey)) {
-            stateVarObj.dependencyNames.keysByName[extendedDepName].push(arrayKey);
-          }
-        }
-      }
-      stateVarObj.dependencyNames.global.push("__array_size");
-    }
-    dependencies2.__array_size = {
-      dependencyType: "stateVariable",
-      variableName: stateVarObj.arraySizeStateVariable
-    };
-    return dependencies2;
-  };
-  stateVarObj.getCurrentFreshness = function({
-    freshnessInfo,
-    arrayKeys,
-    arraySize: arraySize2
-  }) {
-    if (arrayKeys === void 0) {
-      arrayKeys = stateVarObj.getAllArrayKeys(arraySize2);
-    }
-    let freshByKey = freshnessInfo.freshByKey;
-    let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
-    for (let arrayKey of arrayKeys) {
-      if (freshByKey[arrayKey]) {
-        numberFresh += 1;
-      }
-    }
-    if (numberFresh > 0) {
-      if (numberFresh === arrayKeys.length + 1) {
-        return { fresh: { [stateVariable]: true } };
-      } else {
-        return { partiallyFresh: { [stateVariable]: numberFresh } };
-      }
-    } else {
-      return { fresh: { [stateVariable]: false } };
-    }
-  };
-  stateVarObj.markStale = function({
-    freshnessInfo,
-    changes,
-    arrayKeys,
-    arraySize: arraySize2
-  }) {
-    let result2 = {};
-    if (arrayKeys === void 0) {
-      arrayKeys = stateVarObj.getAllArrayKeys(arraySize2);
-    }
-    if (stateVarObj.markStaleByKey) {
-      result2 = stateVarObj.markStaleByKey({ arrayKeys, changes });
-    }
-    let freshByKey = freshnessInfo.freshByKey;
-    if (changes.__array_size) {
-      freshnessInfo.freshArraySize = false;
-      freshnessInfo.freshByKey = {};
-      result2.fresh = { [stateVariable]: false };
-      return result2;
-    }
-    if (Object.keys(freshByKey).length === 0) {
-      freshnessInfo.freshByKey = {};
-      if (freshnessInfo.freshArraySize) {
-        result2.partiallyFresh = { [stateVariable]: 1 };
-        return result2;
-      } else {
-        result2.fresh = { [stateVariable]: false };
-        return result2;
-      }
-    }
-    for (let changeName in changes) {
-      if (stateVarObj.dependencyNames.global.includes(changeName)) {
-        freshnessInfo.freshByKey = {};
-        if (freshnessInfo.freshArraySize) {
-          result2.partiallyFresh = { [stateVariable]: 1 };
-          return result2;
-        } else {
-          result2.fresh = { [stateVariable]: false };
-          return result2;
-        }
-      }
-      if (stateVarObj.basedOnArrayKeyStateVariables && arrayKeys.length > 1) {
-        delete freshByKey[changeName];
-      } else {
-        for (let key of stateVarObj.dependencyNames.keysByName[changeName]) {
-          delete freshByKey[key];
-        }
-      }
-    }
-    let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
-    for (let arrayKey of arrayKeys) {
-      if (freshByKey[arrayKey]) {
-        numberFresh += 1;
-      }
-    }
-    if (numberFresh > 0) {
-      if (numberFresh === arrayKeys.length + 1) {
-        result2.fresh = { [stateVariable]: true };
-        return result2;
-      } else {
-        result2.partiallyFresh = { [stateVariable]: numberFresh };
-        return result2;
-      }
-    } else {
-      result2.fresh = { [stateVariable]: false };
-      return result2;
-    }
-  };
-  stateVarObj.freshenOnNoChanges = function({
-    arrayKeys,
-    freshnessInfo,
-    arraySize: arraySize2
-  }) {
-    let freshByKey = freshnessInfo.freshByKey;
-    if (arrayKeys === void 0) {
-      arrayKeys = stateVarObj.getAllArrayKeys(arraySize2);
-    }
-    for (let arrayKey of arrayKeys) {
-      freshByKey[arrayKey] = true;
-    }
-  };
-  function extractArrayDependencies(dependencyValues, arrayKeys, usedDefault) {
-    let globalDependencyValues = {};
-    let globalUsedDefault = {};
-    for (let dependencyName of stateVarObj.dependencyNames.global) {
-      globalDependencyValues[dependencyName] = dependencyValues[dependencyName];
-      globalUsedDefault[dependencyName] = usedDefault[dependencyName];
-    }
-    let dependencyValuesByKey = {};
-    let usedDefaultByKey = {};
-    let foundAllDependencyValuesForKey = {};
-    for (let arrayKey of arrayKeys) {
-      dependencyValuesByKey[arrayKey] = {};
-      usedDefaultByKey[arrayKey] = {};
-      if (arrayKey in stateVarObj.dependencyNames.namesByKey) {
-        foundAllDependencyValuesForKey[arrayKey] = true;
-        for (let dependencyName in stateVarObj.dependencyNames.namesByKey[arrayKey]) {
-          let extendedDepName = stateVarObj.dependencyNames.namesByKey[arrayKey][dependencyName];
-          if (extendedDepName in dependencyValues) {
-            dependencyValuesByKey[arrayKey][dependencyName] = dependencyValues[extendedDepName];
-            usedDefaultByKey[arrayKey][dependencyName] = usedDefault[extendedDepName];
-          } else {
-            foundAllDependencyValuesForKey[arrayKey] = false;
-          }
-        }
-      }
-    }
-    return {
-      globalDependencyValues,
-      globalUsedDefault,
-      dependencyValuesByKey,
-      usedDefaultByKey,
-      foundAllDependencyValuesForKey
-    };
-  }
-  stateVarObj.definition = function(args) {
-    if (args.arrayKeys === void 0) {
-      args.arrayKeys = stateVarObj.getAllArrayKeys(args.arraySize);
-    }
-    if (stateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
-      return {};
-    } else {
-      let extractedDeps = extractArrayDependencies(
-        args.dependencyValues,
-        args.arrayKeys,
-        args.usedDefault
-      );
-      let globalDependencyValues = extractedDeps.globalDependencyValues;
-      let globalUsedDefault = extractedDeps.globalUsedDefault;
-      let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
-      let usedDefaultByKey = extractedDeps.usedDefaultByKey;
-      let foundAllDependencyValuesForKey = extractedDeps.foundAllDependencyValuesForKey;
-      delete args.dependencyValues;
-      args.globalDependencyValues = globalDependencyValues;
-      args.globalUsedDefault = globalUsedDefault;
-      args.dependencyValuesByKey = dependencyValuesByKey;
-      args.usedDefaultByKey = usedDefaultByKey;
-      let arrayKeysToRecalculate = [];
-      let freshByKey = args.freshnessInfo.freshByKey;
-      for (let arrayKey of args.arrayKeys) {
-        if (!freshByKey[arrayKey] && foundAllDependencyValuesForKey[arrayKey]) {
-          freshByKey[arrayKey] = true;
-          arrayKeysToRecalculate.push(arrayKey);
-        }
-      }
-      let result2;
-      if (arrayKeysToRecalculate.length === 0) {
-        result2 = {};
-      } else {
-        args.arrayKeys = arrayKeysToRecalculate;
-        if (!stateVarObj.arrayDefinitionByKey) {
-          throw Error(
-            `For ${stateVariable} of ${component.componentType}, arrayDefinitionByKey must be a function`
-          );
-        }
-        result2 = stateVarObj.arrayDefinitionByKey(args);
-        if (result2.setValue && result2.setValue[stateVariable]) {
-          for (let arrayKey in result2.setValue[stateVariable]) {
-            freshByKey[arrayKey] = true;
-          }
-        }
-        if (result2.useEssentialOrDefaultValue && result2.useEssentialOrDefaultValue[stateVariable]) {
-          for (let arrayKey in result2.useEssentialOrDefaultValue[stateVariable]) {
-            freshByKey[arrayKey] = true;
-          }
-        }
-      }
-      if (!args.freshnessInfo.freshArraySize) {
-        if (args.changes.__array_size) {
-          result2.arraySizeChanged = [stateVariable];
-          if (stateVarObj.additionalStateVariablesDefined) {
-            for (let varName of stateVarObj.additionalStateVariablesDefined) {
-              if (component.state[varName].isArray) {
-                result2.arraySizeChanged.push(varName);
-              }
-            }
-          }
-        }
-        args.freshnessInfo.freshArraySize = true;
-      }
-      return result2;
-    }
-  };
-  stateVarObj.inverseDefinition = function(args) {
-    if (!stateVarObj.inverseArrayDefinitionByKey) {
-      return { success: false };
-    }
-    if (args.arrayKeys === void 0) {
-      args.arrayKeys = stateVarObj.getAllArrayKeys(args.arraySize);
-    }
-    if (stateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
-      let instructions = [];
-      for (let vName of allStateVariablesAffected) {
-        for (let key in args.desiredStateVariableValues[vName]) {
-          let depName = vName + "_" + key;
-          if (depName in args.dependencyValues) {
-            instructions.push({
-              setDependency: depName,
-              desiredValue: args.desiredStateVariableValues[vName][key],
-              treatAsInitialChange: args.initialChange
-            });
-          }
-        }
-      }
-      return {
-        success: true,
-        instructions
-      };
-    } else {
-      let extractedDeps = extractArrayDependencies(
-        args.dependencyValues,
-        args.arrayKeys,
-        args.usedDefault
-      );
-      let globalDependencyValues = extractedDeps.globalDependencyValues;
-      let globalUsedDefault = extractedDeps.globalUsedDefault;
-      let dependencyValuesByKey = extractedDeps.dependencyValuesByKey;
-      let usedDefaultByKey = extractedDeps.usedDefaultByKey;
-      delete args.dependencyValues;
-      args.globalDependencyValues = globalDependencyValues;
-      args.globalUsedDefault = globalUsedDefault;
-      args.dependencyValuesByKey = dependencyValuesByKey;
-      args.usedDefaultByKey = usedDefaultByKey;
-      args.dependencyNamesByKey = stateVarObj.dependencyNames.namesByKey;
-      if (!stateVarObj.allowExtraArrayKeysInInverse) {
-        let newDesiredStateVariableValues = {};
-        for (let vName in args.desiredStateVariableValues) {
-          newDesiredStateVariableValues[vName] = {};
-          for (let key in args.desiredStateVariableValues[vName]) {
-            if (args.arrayKeys.includes(key)) {
-              newDesiredStateVariableValues[vName][key] = args.desiredStateVariableValues[vName][key];
-            }
-          }
-        }
-        args.desiredStateVariableValues = newDesiredStateVariableValues;
-      }
-      let result2 = stateVarObj.inverseArrayDefinitionByKey(args);
-      return result2;
-    }
-  };
-  await createArraySizeStateVariable({
-    core: core2,
-    stateVarObj,
-    component,
-    stateVariable
-  });
-  stateVarObj.arraySizeStale = true;
-  stateVarObj.previousArraySize = [];
-  Object.defineProperty(stateVarObj, "arraySize", {
-    get: function() {
-      return (async () => {
-        if (!component.state[stateVarObj.arraySizeStateVariable].initiallyResolved) {
-          return [];
-        }
-        if (stateVarObj.arraySizeStale) {
-          await stateVarObj.recalculateArraySizeDependentQuantities();
-        }
-        return await component.stateValues[stateVarObj.arraySizeStateVariable];
-      })();
-    }
-  });
-  stateVarObj.recalculateArraySizeDependentQuantities = async function() {
-    let newArraySize = await component.stateValues[stateVarObj.arraySizeStateVariable];
-    if (stateVarObj.previousArraySize.length !== newArraySize.length || stateVarObj.previousArraySize.some(
-      (v2, i2) => v2 != newArraySize[i2]
-    )) {
-      stateVarObj.previousArraySize = [...newArraySize];
-      let varNamesIncluding = stateVarObj.varNamesIncludingArrayKeys = {};
-      for (let entryName of stateVarObj.arrayEntryNames) {
-        let entryStateVarObj = component.state[entryName];
-        let arrayKeys = stateVarObj.getArrayKeysFromVarName({
-          arrayEntryPrefix: entryStateVarObj.entryPrefix,
-          varEnding: entryStateVarObj.varEnding,
-          arraySize: newArraySize,
-          numDimensions: stateVarObj.numDimensions
-        });
-        entryStateVarObj._unflattenedArrayKeys = arrayKeys;
-        entryStateVarObj._arrayKeys = flattenDeep(arrayKeys);
-        for (let arrayKey of entryStateVarObj._arrayKeys) {
-          if (!varNamesIncluding[arrayKey]) {
-            varNamesIncluding[arrayKey] = [];
-          }
-          varNamesIncluding[arrayKey].push(entryName);
-        }
-      }
-    }
-    stateVarObj.arraySizeStale = false;
-  };
-  if (!stateVarObj.freshnessInfo) {
-    stateVarObj.freshnessInfo = { freshByKey: {} };
-    if (stateVarObj.additionalStateVariablesDefined) {
-      for (let vName of stateVarObj.additionalStateVariablesDefined) {
-        if (!component.state[vName]) {
-          component.state[vName] = {};
-        }
-        component.state[vName].freshnessInfo = stateVarObj.freshnessInfo;
-      }
-    }
-  }
-}
-async function createArraySizeStateVariable({
-  core: core2,
-  stateVarObj,
-  component,
-  stateVariable
-}) {
-  let allStateVariablesAffected = [stateVariable];
-  if (stateVarObj.additionalStateVariablesDefined) {
-    allStateVariablesAffected.push(
-      ...stateVarObj.additionalStateVariablesDefined
-    );
-  }
-  allStateVariablesAffected.sort();
-  let arraySizeStateVar = `__array_size_` + allStateVariablesAffected.join("_");
-  stateVarObj.arraySizeStateVariable = arraySizeStateVar;
-  if (stateVarObj.stateVariablesDeterminingDependencies) {
-    stateVarObj.stateVariablesDeterminingDependencies.push(
-      arraySizeStateVar
-    );
-  } else {
-    stateVarObj.stateVariablesDeterminingDependencies = [arraySizeStateVar];
-  }
-  if (component.state[arraySizeStateVar]) {
-    if (component.state[arraySizeStateVar].isShadow) {
-      let arraySizeStateVarObj = component.state[arraySizeStateVar];
-      arraySizeStateVarObj.markStale = function() {
-        for (let varName of allStateVariablesAffected) {
-          component.state[varName].arraySizeStale = true;
-        }
-        return {};
-      };
-    }
-    return;
-  }
-  component.state[arraySizeStateVar] = {
-    returnDependencies: stateVarObj.returnArraySizeDependencies,
-    definition({ dependencyValues }) {
-      let arraySize2 = stateVarObj.returnArraySize({
-        dependencyValues
-      });
-      for (let [ind, value] of arraySize2.entries()) {
-        if (!(Number.isInteger(value) && value >= 0)) {
-          arraySize2[ind] = 0;
-        }
-      }
-      return { setValue: { [arraySizeStateVar]: arraySize2 } };
-    },
-    markStale() {
-      for (let varName of allStateVariablesAffected) {
-        component.state[varName].arraySizeStale = true;
-      }
-      return {};
-    }
-  };
-  if (stateVarObj.stateVariablesDeterminingArraySizeDependencies) {
-    component.state[arraySizeStateVar].stateVariablesDeterminingDependencies = stateVarObj.stateVariablesDeterminingArraySizeDependencies;
-  }
-  await initializeStateVariable({
-    core: core2,
-    component,
-    stateVariable: arraySizeStateVar
-  });
-}
-async function arrayEntryNamesFromPropIndex({
-  core: core2,
-  stateVariables,
-  component,
-  propIndex
-}) {
-  let newVarNames = [];
-  for (let varName of stateVariables) {
-    let stateVarObj = component.state[varName];
-    if (!stateVarObj) {
-      if (!core2.checkIfArrayEntry({
-        stateVariable: varName,
-        component
-      }).isArrayEntry) {
-        newVarNames.push(varName);
-        continue;
-      }
-      await core2.createFromArrayEntry({
-        stateVariable: varName,
-        component
-      });
-      stateVarObj = component.state[varName];
-    }
-    let newName;
-    if (stateVarObj.isArray) {
-      newName = stateVarObj.arrayVarNameFromPropIndex(propIndex, varName);
-    } else if (stateVarObj.isArrayEntry) {
-      let arrayStateVarObj = component.state[stateVarObj.arrayStateVariable];
-      newName = arrayStateVarObj.arrayVarNameFromPropIndex(
-        propIndex,
-        varName
-      );
-    } else {
-      core2.addDiagnostic({
-        type: "warning",
-        message: `Cannot get propIndex from ${varName} of ${component.componentIdx} as it is not an array or array entry state variable`,
-        position: component.position,
-        sourceDoc: component.sourceDoc
-      });
-      newName = varName;
-    }
-    if (newName) {
-      newVarNames.push(newName);
-    } else {
-      core2.addDiagnostic({
-        type: "warning",
-        message: `Cannot get propIndex from ${varName} of ${component.componentIdx}`,
-        position: component.position,
-        sourceDoc: component.sourceDoc
-      });
-      newVarNames.push(varName);
-    }
-  }
-  return newVarNames;
-}
 const EMPTY_SERIALIZED_CHILDREN = Object.freeze([]);
 function ancestorsForChild(parent) {
   return [
@@ -64309,17 +64414,12 @@ class StalenessPropagator {
    * as stale: the next `await stateVarObj.value` will recompute, while
    * `_previousValue` is preserved for change-detection.
    */
-  async _replaceWithStaleGetter(stateVarObj, component, vName) {
+  async _replaceWithStaleGetter(stateVarObj) {
     stateVarObj._previousValue = await stateVarObj.value;
     if (Array.isArray(stateVarObj._previousValue)) {
       stateVarObj._previousValue = [...stateVarObj._previousValue];
     }
-    delete stateVarObj.value;
-    const getStateVar = this.core.getStateVariableValue;
-    Object.defineProperty(stateVarObj, "value", {
-      get: () => getStateVar({ component, stateVariable: vName }),
-      configurable: true
-    });
+    installStaleValueGetter(stateVarObj);
   }
   /**
    * Visit `component` for stale-marking against `varName` plus every
@@ -64444,11 +64544,7 @@ class StalenessPropagator {
       const stateVarObj = allStateVariablesAffectedObj[vName];
       delete stateVarObj.recursiveDependencyValues;
       if (previouslyFreshVars.includes(vName)) {
-        await this._replaceWithStaleGetter(
-          stateVarObj,
-          component,
-          vName
-        );
+        await this._replaceWithStaleGetter(stateVarObj);
       }
     }
     if (freshnessDecreased) {
@@ -67603,7 +67699,13 @@ class Core {
       requestSolutionView: this.requestSolutionView.bind(this),
       requestComponentDoenetML: this.requestComponentDoenetML.bind(this),
       copyToClipboard: this.copyToClipboard.bind(this),
-      navigateToTarget: (args) => navigateToTarget({ core: this, args })
+      navigateToTarget: (args) => navigateToTarget({ core: this, args }),
+      // State-variable runtime plumbing, not component-facing API:
+      // the shared state-variable functions in StateVariableInitializer
+      // reach core through `svComponent.coreFunctions`.
+      getStateVariableValue: this.getStateVariableValue,
+      // bound above
+      addDiagnostic: this.addDiagnostic.bind(this)
     };
     this.updateInfo = {
       componentsToUpdateRenderers: /* @__PURE__ */ new Set(),
@@ -229197,4 +229299,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-BBh2EPqg.js.map
+//# sourceMappingURL=index-D7QB7nkv.js.map