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

package/{index-CyEKEyxP.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-BN2lLQ1h-1QSWShIW.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,1088 +49611,6 @@ function recursivelyReplaceCompositesWithReplacements({
     unexpandedCompositesNotReady
   };
 }
-const PRIMITIVE_TO_COMPONENT_TYPE = {
-  string: "text",
-  stringArray: "textList",
-  numberArray: "numberList"
-};
-const SHARED_STATE_VARIABLE_DEFINITIONS = /* @__PURE__ */ Symbol(
-  "sharedStateVariableDefinitions"
-);
-const classStateVariableDefinitionsCache = /* @__PURE__ */ new WeakMap();
-function getClassStateVariableDefinitions(core2, componentClass) {
-  let perCore = classStateVariableDefinitionsCache.get(core2);
-  if (!perCore) {
-    perCore = /* @__PURE__ */ new Map();
-    classStateVariableDefinitionsCache.set(core2, perCore);
-  }
-  let entry = perCore.get(componentClass);
-  if (!entry) {
-    const combined = {};
-    createAttributeStateVariableDefinitions({
-      core: core2,
-      stateVariableDefinitions: combined,
-      componentClass
-    });
-    const normalized = componentClass.returnNormalizedStateVariableDefinitions(
-      core2.numerics
-    );
-    Object.assign(combined, normalized);
-    combined[SHARED_STATE_VARIABLE_DEFINITIONS] = true;
-    entry = { combined, normalized };
-    perCore.set(componentClass, entry);
-  }
-  return entry;
-}
-function cloneStateVariableDefinition(def) {
-  const clone2 = Object.assign({}, def);
-  if (clone2.shadowingInstructions) {
-    clone2.shadowingInstructions = Object.assign(
-      {},
-      clone2.shadowingInstructions
-    );
-  }
-  if (clone2.additionalStateVariablesDefined) {
-    clone2.additionalStateVariablesDefined = [
-      ...clone2.additionalStateVariablesDefined
-    ];
-  }
-  if (clone2.stateVariablesDeterminingDependencies) {
-    clone2.stateVariablesDeterminingDependencies = [
-      ...clone2.stateVariablesDeterminingDependencies
-    ];
-  }
-  return clone2;
-}
-async function createStateVariableDefinitions({
-  core: core2,
-  componentClass,
-  prescribedDependencies,
-  componentIdx
-}) {
-  let redefineDependencies;
-  if (prescribedDependencies) {
-    for (const idxStr in prescribedDependencies) {
-      const idx = Number(idxStr);
-      let depArray = prescribedDependencies[idx];
-      for (let dep of depArray) {
-        if (dep.dependencyType === "referenceShadow") {
-          if (idx === componentIdx) {
-            throw Error(
-              `Circular dependency involving ${componentIdx}.`
-            );
-          }
-          redefineDependencies = {
-            linkSource: "referenceShadow",
-            targetIdx: idx,
-            compositeIdx: dep.compositeIdx,
-            propVariable: dep.propVariable,
-            fromImplicitProp: dep.fromImplicitProp,
-            arrayStateVariable: dep.arrayStateVariable,
-            arrayKey: dep.arrayKey,
-            ignorePrimaryStateVariable: dep.ignorePrimaryStateVariable,
-            substituteForPrimaryStateVariable: dep.substituteForPrimaryStateVariable,
-            firstLevelReplacement: dep.firstLevelReplacement,
-            additionalStateVariableShadowing: dep.additionalStateVariableShadowing
-          };
-        } else if (dep.dependencyType === "adapter") {
-          redefineDependencies = {
-            linkSource: "adapter",
-            adapterTargetIdentity: dep.adapterTargetIdentity,
-            adapterVariable: dep.adapterVariable,
-            substituteForPrimaryStateVariable: dep.substituteForPrimaryStateVariable,
-            stateVariablesToShadow: dep.stateVariablesToShadow
-          };
-        }
-      }
-    }
-  }
-  const classDefinitions = getClassStateVariableDefinitions(
-    core2,
-    componentClass
-  );
-  if (!redefineDependencies) {
-    return classDefinitions.combined;
-  }
-  let stateVariableDefinitions = {};
-  for (const varName in classDefinitions.normalized) {
-    stateVariableDefinitions[varName] = cloneStateVariableDefinition(
-      classDefinitions.normalized[varName]
-    );
-  }
-  if (redefineDependencies.linkSource === "adapter") {
-    createAdapterStateVariableDefinitions({
-      core: core2,
-      redefineDependencies,
-      stateVariableDefinitions,
-      componentClass
-    });
-  } else {
-    await createReferenceShadowStateVariableDefinitions({
-      core: core2,
-      redefineDependencies,
-      stateVariableDefinitions,
-      componentClass
-    });
-  }
-  return stateVariableDefinitions;
-}
-function createAttributeStateVariableDefinitions({
-  core: core2,
-  componentClass,
-  stateVariableDefinitions
-}) {
-  let attributes = preprocessAttributesObject(
-    componentClass.createAttributesObject()
-  );
-  for (let attrName in attributes) {
-    let attributeSpecification = attributes[attrName];
-    if (!attributeSpecification.createStateVariable) {
-      continue;
-    }
-    let varName = attributeSpecification.createStateVariable;
-    let stateVarDef = stateVariableDefinitions[varName] = {
-      isAttribute: true,
-      hasEssential: true,
-      provideEssentialValuesInDefinition: true
-    };
-    if (attributeSpecification.public) {
-      _setShadowingInstructionsFromAttribute(
-        stateVarDef,
-        attributeSpecification
-      );
-    }
-    let stateVariableForAttributeValue = _resolveAttributeValueVariable(
-      core2,
-      attributeSpecification,
-      attrName,
-      componentClass
-    );
-    stateVarDef.returnDependencies = function() {
-      return {
-        ..._buildAttributeFallbackDependencies(attributeSpecification),
-        ..._buildAttributeValueDependency(
-          attributeSpecification,
-          attrName,
-          stateVariableForAttributeValue
-        )
-      };
-    };
-    const { definition, inverseDefinition } = _buildAttributeDerivedDefinitions({
-      varName,
-      stateVariableForAttributeValue,
-      attributeSpecification,
-      attrName
-    });
-    stateVarDef.definition = definition;
-    if (!attributeSpecification.noInverse) {
-      stateVarDef.inverseDefinition = inverseDefinition;
-    }
-    _copyPassthroughAttributes(stateVarDef, attributeSpecification, {
-      includeTriggerActionOnChange: true
-    });
-  }
-}
-function createAdapterStateVariableDefinitions({
-  core: core2,
-  redefineDependencies,
-  stateVariableDefinitions,
-  componentClass
-}) {
-  let adapterTargetComponent = core2._components[redefineDependencies.adapterTargetIdentity.componentIdx];
-  let attributes = preprocessAttributesObject(
-    componentClass.createAttributesObject()
-  );
-  for (let attrName in attributes) {
-    let attributeSpecification = attributes[attrName];
-    if (!attributeSpecification.createStateVariable) {
-      continue;
-    }
-    let varName = attributeSpecification.createStateVariable;
-    let stateVarDef = stateVariableDefinitions[varName] = {
-      isAttribute: true,
-      hasEssential: true
-    };
-    if (attributeSpecification.public) {
-      _setShadowingInstructionsFromAttribute(
-        stateVarDef,
-        attributeSpecification
-      );
-    }
-    if (varName in adapterTargetComponent.state) {
-      stateVarDef.returnDependencies = () => ({
-        adapterTargetVariable: {
-          dependencyType: "stateVariable",
-          componentIdx: redefineDependencies.adapterTargetIdentity.componentIdx,
-          variableName: varName
-        }
-      });
-    } else {
-      stateVarDef.returnDependencies = () => ({});
-    }
-    stateVarDef.definition = function({ dependencyValues, usedDefault }) {
-      if (dependencyValues.adapterTargetVariable === void 0 || usedDefault.adapterTargetVariable) {
-        return {
-          useEssentialOrDefaultValue: {
-            [varName]: true
-          },
-          checkForActualChange: { [varName]: true }
-        };
-      } else {
-        return {
-          setValue: {
-            [varName]: dependencyValues.adapterTargetVariable
-          },
-          checkForActualChange: { [varName]: true }
-        };
-      }
-    };
-    if (!attributeSpecification.noInverse) {
-      stateVarDef.inverseDefinition = async function({
-        desiredStateVariableValues,
-        dependencyValues
-      }) {
-        if (dependencyValues.adapterTargetVariable === void 0) {
-          return {
-            success: true,
-            instructions: [
-              {
-                setEssentialValue: varName,
-                value: desiredStateVariableValues[varName]
-              }
-            ]
-          };
-        } else {
-          return {
-            success: true,
-            instructions: [
-              {
-                setDependency: "adapterTargetVariable",
-                desiredValue: desiredStateVariableValues[varName]
-              }
-            ]
-          };
-        }
-      };
-    }
-    _copyPassthroughAttributes(stateVarDef, attributeSpecification);
-  }
-  const { name: primaryStateVariableForDefinition, stateDef } = _resolvePrimaryStateVariableForDefinition({
-    redefineDependencies,
-    componentClass,
-    stateVariableDefinitions,
-    throwIfMissing: false
-  });
-  stateDef.isShadow = true;
-  stateDef.returnDependencies = () => ({
-    adapterTargetVariable: {
-      dependencyType: "stateVariable",
-      componentIdx: redefineDependencies.adapterTargetIdentity.componentIdx,
-      variableName: redefineDependencies.adapterVariable
-    }
-  });
-  if (stateDef.set) {
-    stateDef.definition = function({ dependencyValues }) {
-      return {
-        setValue: {
-          [primaryStateVariableForDefinition]: stateDef.set(
-            dependencyValues.adapterTargetVariable
-          )
-        }
-      };
-    };
-  } else {
-    stateDef.definition = function({ dependencyValues }) {
-      return {
-        setValue: {
-          [primaryStateVariableForDefinition]: dependencyValues.adapterTargetVariable
-        }
-      };
-    };
-  }
-  stateDef.inverseDefinition = function({ desiredStateVariableValues }) {
-    return {
-      success: true,
-      instructions: [
-        {
-          setDependency: "adapterTargetVariable",
-          desiredValue: desiredStateVariableValues[primaryStateVariableForDefinition]
-        }
-      ]
-    };
-  };
-  if (redefineDependencies.stateVariablesToShadow) {
-    modifyStateDefsToBeShadows({
-      stateVariablesToShadow: redefineDependencies.stateVariablesToShadow,
-      stateVariableDefinitions,
-      targetComponent: adapterTargetComponent
-    });
-  }
-}
-async function createReferenceShadowStateVariableDefinitions({
-  core: core2,
-  redefineDependencies,
-  stateVariableDefinitions,
-  componentClass
-}) {
-  let targetComponent = core2._components[redefineDependencies.targetIdx];
-  if (redefineDependencies.propVariable) {
-    if (!targetComponent.state[redefineDependencies.propVariable] && core2.checkIfArrayEntry({
-      stateVariable: redefineDependencies.propVariable,
-      component: targetComponent
-    }).isArrayEntry) {
-      await core2.createFromArrayEntry({
-        stateVariable: redefineDependencies.propVariable,
-        component: targetComponent
-      });
-    }
-  }
-  let attributes = preprocessAttributesObject(
-    componentClass.createAttributesObject()
-  );
-  for (let attrName in attributes) {
-    let attributeSpecification = attributes[attrName];
-    let varName = attributeSpecification.createStateVariable;
-    if (!varName) {
-      continue;
-    }
-    let stateVarDef = stateVariableDefinitions[varName] = {
-      isAttribute: true,
-      hasEssential: true,
-      provideEssentialValuesInDefinition: true
-    };
-    !attributeSpecification.createComponentOfType;
-    if (attributeSpecification.public) {
-      _setShadowingInstructionsFromAttribute(
-        stateVarDef,
-        attributeSpecification
-      );
-    }
-    let stateVariableForAttributeValue = _resolveAttributeValueVariable(
-      core2,
-      attributeSpecification,
-      attrName,
-      componentClass
-    );
-    const thisDependencies = {
-      ..._buildAttributeValueDependency(
-        attributeSpecification,
-        attrName,
-        stateVariableForAttributeValue
-      ),
-      ..._buildAttributeFallbackDependencies(attributeSpecification)
-    };
-    stateVarDef.returnDependencies = () => thisDependencies;
-    const { definition, inverseDefinition } = _buildAttributeDerivedDefinitions({
-      varName,
-      stateVariableForAttributeValue,
-      attributeSpecification,
-      attrName
-    });
-    stateVarDef.definition = definition;
-    if (!attributeSpecification.noInverse) {
-      stateVarDef.inverseDefinition = inverseDefinition;
-    }
-    _copyPassthroughAttributes(stateVarDef, attributeSpecification);
-  }
-  if (redefineDependencies.propVariable) {
-    if (!redefineDependencies.ignorePrimaryStateVariable) {
-      const { name: primaryStateVariableForDefinition, stateDef } = _resolvePrimaryStateVariableForDefinition({
-        redefineDependencies,
-        componentClass,
-        stateVariableDefinitions,
-        throwIfMissing: true
-      });
-      stateDef.isShadow = true;
-      stateDef.returnDependencies = () => ({
-        targetVariable: {
-          dependencyType: "stateVariable",
-          componentIdx: targetComponent.componentIdx,
-          variableName: redefineDependencies.propVariable
-        }
-      });
-      let setDefault = false;
-      if (targetComponent.state[redefineDependencies.propVariable].defaultValue !== void 0) {
-        stateDef.defaultValue = targetComponent.state[redefineDependencies.propVariable].defaultValue;
-        if (stateDef.set) {
-          stateDef.defaultValue = stateDef.set(stateDef.defaultValue);
-        }
-        stateDef.hasEssential = true;
-        setDefault = true;
-      }
-      let targetVariableIsArray = targetComponent.state[redefineDependencies.propVariable].isArray;
-      if (stateDef.set) {
-        stateDef.definition = function({
-          dependencyValues,
-          usedDefault
-        }) {
-          let targetVariable = dependencyValues.targetVariable;
-          if (targetVariable === void 0 || targetVariableIsArray && targetVariable.length === 0) {
-            return {
-              useEssentialOrDefaultValue: {
-                [primaryStateVariableForDefinition]: true
-              }
-            };
-          }
-          let valueFromTarget = stateDef.set(targetVariable);
-          if (setDefault && usedDefault.targetVariable) {
-            return {
-              useEssentialOrDefaultValue: {
-                [primaryStateVariableForDefinition]: {
-                  defaultValue: valueFromTarget
-                }
-              }
-            };
-          }
-          return {
-            setValue: {
-              [primaryStateVariableForDefinition]: valueFromTarget
-            }
-          };
-        };
-      } else {
-        stateDef.definition = function({
-          dependencyValues,
-          usedDefault
-        }) {
-          let targetVariable = dependencyValues.targetVariable;
-          if (targetVariable === void 0 || targetVariableIsArray && targetVariable.length === 0) {
-            return {
-              useEssentialOrDefaultValue: {
-                [primaryStateVariableForDefinition]: true
-              }
-            };
-          }
-          if (setDefault && usedDefault.targetVariable) {
-            return {
-              useEssentialOrDefaultValue: {
-                [primaryStateVariableForDefinition]: {
-                  defaultValue: targetVariable
-                }
-              }
-            };
-          }
-          return {
-            setValue: {
-              [primaryStateVariableForDefinition]: targetVariable
-            }
-          };
-        };
-      }
-      stateDef.inverseDefinition = function({
-        desiredStateVariableValues
-      }) {
-        return {
-          success: true,
-          instructions: [
-            {
-              setDependency: "targetVariable",
-              desiredValue: desiredStateVariableValues[primaryStateVariableForDefinition]
-            }
-          ]
-        };
-      };
-    }
-    let shadowStandardVariables = false;
-    let stateVariablesToShadow2 = [];
-    if (targetComponent.constructor.implicitPropReturnsSameType) {
-      if (redefineDependencies.fromImplicitProp) {
-        shadowStandardVariables = true;
-      }
-      for (let varName in targetComponent.state) {
-        let stateObj = targetComponent.state[varName];
-        if (stateObj.shadowVariable || stateObj.isShadow) {
-          stateVariablesToShadow2.push(varName);
-        }
-      }
-    }
-    if (redefineDependencies.additionalStateVariableShadowing) {
-      let differentStateVariablesInTarget = Array(
-        stateVariablesToShadow2.length
-      );
-      for (let varName in redefineDependencies.additionalStateVariableShadowing) {
-        if (!stateVariablesToShadow2.includes(varName)) {
-          stateVariablesToShadow2.push(varName);
-          differentStateVariablesInTarget.push(
-            redefineDependencies.additionalStateVariableShadowing[varName].stateVariableToShadow
-          );
-        }
-      }
-      modifyStateDefsToBeShadows({
-        stateVariablesToShadow: stateVariablesToShadow2,
-        stateVariableDefinitions,
-        targetComponent,
-        differentStateVariablesInTarget
-      });
-    } else if (shadowStandardVariables) {
-      modifyStateDefsToBeShadows({
-        stateVariablesToShadow: stateVariablesToShadow2,
-        stateVariableDefinitions,
-        targetComponent
-      });
-    }
-    return;
-  }
-  let foundReadyToExpandWhenResolved = false;
-  if ("readyToExpandWhenResolved" in stateVariableDefinitions) {
-    foundReadyToExpandWhenResolved = true;
-    let stateDef = stateVariableDefinitions.readyToExpandWhenResolved;
-    let originalReturnDependencies = stateDef.returnDependencies.bind(stateDef);
-    let originalDefinition = stateDef.definition;
-    stateDef.returnDependencies = function(args) {
-      let dependencies2 = originalReturnDependencies(args);
-      dependencies2.targetReadyToExpandWhenResolved = {
-        dependencyType: "stateVariable",
-        componentIdx: targetComponent.componentIdx,
-        variableName: "readyToExpandWhenResolved"
-      };
-      return dependencies2;
-    };
-    stateDef.definition = function(args) {
-      let result2 = originalDefinition(args);
-      if (result2.setValue && result2.setValue.readyToExpandWhenResolved) {
-        if (!args.dependencyValues.targetReadyToExpandWhenResolved) {
-          result2.setValue.readyToExpandWhenResolved = false;
-        }
-      }
-      return result2;
-    };
-  }
-  let stateVariablesToShadow = [];
-  for (let varName in targetComponent.state) {
-    let stateObj = targetComponent.state[varName];
-    if (stateObj.shadowVariable || stateObj.isShadow) {
-      stateVariablesToShadow.push(varName);
-    }
-  }
-  modifyStateDefsToBeShadows({
-    stateVariablesToShadow,
-    stateVariableDefinitions,
-    foundReadyToExpandWhenResolved,
-    targetComponent
-  });
-}
-function shadowReturnDependencies(args) {
-  let dependencies2 = Object.assign(
-    {},
-    this.shadowOriginalReturnDependencies?.(args)
-  );
-  dependencies2.targetVariable = {
-    dependencyType: "stateVariable",
-    componentIdx: this.shadowOfComponentIdx,
-    variableName: this.shadowVarNameInTarget
-  };
-  if (this.shadowCopyComponentType) {
-    dependencies2.targetVariableComponentType = {
-      dependencyType: "stateVariableComponentType",
-      componentIdx: this.shadowOfComponentIdx,
-      variableName: this.shadowVarNameInTarget
-    };
-  }
-  return dependencies2;
-}
-function shadowDefinition({ dependencyValues, usedDefault }) {
-  const varName = this.shadowVarName;
-  let result2 = {};
-  if ("targetVariableComponentType" in dependencyValues) {
-    result2.setCreateComponentOfType = {
-      [varName]: dependencyValues.targetVariableComponentType
-    };
-  }
-  if (usedDefault.targetVariable && "defaultValue" in this && this.hasEssential) {
-    result2.useEssentialOrDefaultValue = {
-      [varName]: {
-        defaultValue: dependencyValues.targetVariable
-      }
-    };
-  } else {
-    result2.setValue = {
-      [varName]: dependencyValues.targetVariable
-    };
-  }
-  return result2;
-}
-function shadowInverseDefinition({ desiredStateVariableValues }) {
-  return {
-    success: true,
-    instructions: [
-      {
-        setDependency: "targetVariable",
-        desiredValue: desiredStateVariableValues[this.shadowVarName],
-        shadowedVariable: true
-      }
-    ]
-  };
-}
-function shadowReturnArrayDependenciesByKey({ arrayKeys }) {
-  let dependenciesByKey = {};
-  for (let key of arrayKeys) {
-    dependenciesByKey[key] = {
-      targetVariable: {
-        dependencyType: "stateVariable",
-        componentIdx: this.shadowOfComponentIdx,
-        variableName: this.shadowOverrideVarName || this.arrayVarNameFromArrayKey(key)
-      }
-    };
-  }
-  let globalDependencies = {};
-  if (this.shadowCopyComponentType) {
-    globalDependencies.targetVariableComponentType = {
-      dependencyType: "stateVariableComponentType",
-      componentIdx: this.shadowOfComponentIdx,
-      variableName: this.shadowVarName
-    };
-  }
-  if (this.inverseShadowToSetEntireArray) {
-    globalDependencies.targetArray = {
-      dependencyType: "stateVariable",
-      componentIdx: this.shadowOfComponentIdx,
-      variableName: this.shadowVarName
-    };
-  }
-  return { globalDependencies, dependenciesByKey };
-}
-function shadowArrayDefinitionByKey({ globalDependencyValues, dependencyValuesByKey, arrayKeys }) {
-  const varName = this.shadowVarName;
-  let newEntries = {};
-  for (let arrayKey of arrayKeys) {
-    if ("targetVariable" in dependencyValuesByKey[arrayKey]) {
-      newEntries[arrayKey] = dependencyValuesByKey[arrayKey].targetVariable;
-    } else {
-      newEntries[arrayKey] = this.defaultValueByArrayKey?.(arrayKey);
-    }
-  }
-  let result2 = {
-    setValue: { [varName]: newEntries }
-  };
-  if ("targetVariableComponentType" in globalDependencyValues) {
-    result2.setCreateComponentOfType = {
-      [varName]: globalDependencyValues.targetVariableComponentType
-    };
-  }
-  return result2;
-}
-function shadowInverseArrayDefinitionByKey({
-  desiredStateVariableValues,
-  dependencyValuesByKey,
-  dependencyNamesByKey,
-  arraySize: arraySize2,
-  initialChange
-}) {
-  const varName = this.shadowVarName;
-  if (this.inverseShadowToSetEntireArray) {
-    return {
-      success: true,
-      instructions: [
-        {
-          setDependency: "targetArray",
-          desiredValue: desiredStateVariableValues[varName],
-          treatAsInitialChange: initialChange
-        }
-      ]
-    };
-  }
-  let instructions = [];
-  for (let key in desiredStateVariableValues[varName]) {
-    if (!dependencyValuesByKey[key]) {
-      continue;
-    }
-    instructions.push({
-      setDependency: dependencyNamesByKey[key].targetVariable,
-      desiredValue: desiredStateVariableValues[varName][key],
-      shadowedVariable: true
-    });
-  }
-  return {
-    success: true,
-    instructions
-  };
-}
-function modifyStateDefsToBeShadows({
-  stateVariablesToShadow,
-  stateVariableDefinitions,
-  foundReadyToExpandWhenResolved,
-  targetComponent,
-  differentStateVariablesInTarget = []
-}) {
-  let deleteStateVariablesFromDefinition = {};
-  for (let [varInd, varName] of stateVariablesToShadow.entries()) {
-    let stateDef = stateVariableDefinitions[varName];
-    if (stateDef === void 0) {
-      if (varName.slice(0, 8) === "__array_") {
-        stateDef = stateVariableDefinitions[varName] = {};
-      } else {
-        continue;
-      }
-    }
-    stateDef.isShadow = true;
-    if (stateDef.additionalStateVariablesDefined) {
-      for (let varName2 of stateDef.additionalStateVariablesDefined) {
-        if (!stateVariablesToShadow.includes(varName2)) {
-          if (!deleteStateVariablesFromDefinition[varName2]) {
-            deleteStateVariablesFromDefinition[varName2] = [];
-          }
-          deleteStateVariablesFromDefinition[varName2].push(varName);
-        }
-      }
-    }
-    delete stateDef.additionalStateVariablesDefined;
-    if (!foundReadyToExpandWhenResolved) {
-      delete stateDef.stateVariablesDeterminingDependencies;
-    }
-    let copyComponentType = stateDef.public && stateDef.shadowingInstructions.hasVariableComponentType;
-    stateDef.shadowOfComponentIdx = targetComponent.componentIdx;
-    stateDef.shadowVarName = varName;
-    stateDef.shadowCopyComponentType = copyComponentType;
-    if (stateDef.isArray) {
-      stateDef.shadowOverrideVarName = differentStateVariablesInTarget[varInd];
-      stateDef.returnArrayDependenciesByKey = shadowReturnArrayDependenciesByKey;
-      stateDef.arrayDefinitionByKey = shadowArrayDefinitionByKey;
-      stateDef.inverseArrayDefinitionByKey = shadowInverseArrayDefinitionByKey;
-    } else {
-      if (foundReadyToExpandWhenResolved) {
-        stateDef.shadowOriginalReturnDependencies = stateDef.returnDependencies.bind(stateDef);
-      }
-      stateDef.shadowVarNameInTarget = differentStateVariablesInTarget[varInd] || varName;
-      stateDef.returnDependencies = shadowReturnDependencies;
-      stateDef.definition = shadowDefinition;
-      stateDef.excludeDependencyValuesInInverseDefinition = true;
-      stateDef.inverseDefinition = shadowInverseDefinition;
-    }
-  }
-  for (let varName in deleteStateVariablesFromDefinition) {
-    modifyStateDefToDeleteVariableReferences({
-      varNamesToDelete: deleteStateVariablesFromDefinition[varName],
-      stateDef: stateVariableDefinitions[varName]
-    });
-  }
-}
-function modifyStateDefToDeleteVariableReferences({
-  varNamesToDelete,
-  stateDef
-}) {
-  for (let varName2 of varNamesToDelete) {
-    let ind = stateDef.additionalStateVariablesDefined.indexOf(varName2);
-    stateDef.additionalStateVariablesDefined.splice(ind, 1);
-  }
-  let originalDefinition = stateDef.definition;
-  stateDef.definition = function(args) {
-    let results = originalDefinition(args);
-    for (let key in results) {
-      if (Array.isArray(results[key])) {
-        for (let varName2 of varNamesToDelete) {
-          let ind = results[key].indexOf(varName2);
-          if (ind !== -1) {
-            results[key].splice(ind, 1);
-          }
-        }
-      } else {
-        for (let varName2 of varNamesToDelete) {
-          delete results[key][varName2];
-        }
-      }
-    }
-    return results;
-  };
-}
-function _buildAttributeValueDependency(attributeSpecification, attrName, stateVariableForAttributeValue) {
-  if (attributeSpecification.createPrimitiveOfType) {
-    return {
-      attributePrimitive: {
-        dependencyType: "attributePrimitive",
-        attributeName: attrName
-      }
-    };
-  } else if (attributeSpecification.createReferences) {
-    return {
-      attributeRefResolutions: {
-        dependencyType: "attributeRefResolutions",
-        attributeName: attrName
-      }
-    };
-  } else {
-    return {
-      attributeComponent: {
-        dependencyType: "attributeComponent",
-        attributeName: attrName,
-        variableNames: [stateVariableForAttributeValue]
-      }
-    };
-  }
-}
-function _buildAttributeFallbackDependencies(attributeSpecification) {
-  const deps = {};
-  if (attributeSpecification.fallBackToParentStateVariable) {
-    deps.parentValue = {
-      dependencyType: "parentStateVariable",
-      variableName: attributeSpecification.fallBackToParentStateVariable
-    };
-  }
-  if (attributeSpecification.fallBackToSourceCompositeStateVariable) {
-    deps.sourceCompositeValue = {
-      dependencyType: "sourceCompositeStateVariable",
-      variableName: attributeSpecification.fallBackToSourceCompositeStateVariable
-    };
-  }
-  return deps;
-}
-function _resolvePrimaryStateVariableForDefinition({
-  redefineDependencies,
-  componentClass,
-  stateVariableDefinitions,
-  throwIfMissing
-}) {
-  let name2 = "value";
-  if (redefineDependencies.substituteForPrimaryStateVariable) {
-    name2 = redefineDependencies.substituteForPrimaryStateVariable;
-  } else if (componentClass.primaryStateVariableForDefinition) {
-    name2 = componentClass.primaryStateVariableForDefinition;
-  }
-  const stateDef = stateVariableDefinitions[name2];
-  if (throwIfMissing && !stateDef) {
-    if (redefineDependencies.substituteForPrimaryStateVariable) {
-      throw Error(
-        `Invalid public state variable of componentType ${componentClass.componentType}: substituteForPrimaryStateVariable ${redefineDependencies.substituteForPrimaryStateVariable} does not exist`
-      );
-    } else {
-      throw Error(
-        `Cannot have a public state variable with componentType ${componentClass.componentType} as the class doesn't have a primary state variable for definition`
-      );
-    }
-  }
-  return { name: name2, stateDef };
-}
-function _setShadowingInstructionsFromAttribute(stateVarDef, attributeSpecification) {
-  stateVarDef.public = true;
-  stateVarDef.shadowingInstructions = {};
-  if (attributeSpecification.createPrimitiveOfType) {
-    const primitive = attributeSpecification.createPrimitiveOfType;
-    stateVarDef.shadowingInstructions.createComponentOfType = PRIMITIVE_TO_COMPONENT_TYPE[primitive] ?? primitive;
-  } else if (attributeSpecification.createReferences) {
-    throw Error(
-      "Cannot make a public state variable from an attribute with createReferences"
-    );
-  } else {
-    stateVarDef.shadowingInstructions.createComponentOfType = attributeSpecification.createComponentOfType;
-  }
-}
-function _resolveAttributeValueVariable(core2, attributeSpecification, attrName, componentClass) {
-  if (!attributeSpecification.createComponentOfType) {
-    return void 0;
-  }
-  const attributeClass = core2.componentInfoObjects.allComponentClasses[attributeSpecification.createComponentOfType];
-  if (!attributeClass) {
-    throw Error(
-      `Component type ${attributeSpecification.createComponentOfType} does not exist so cannot create state variable for attribute ${attrName} of componentType ${componentClass.componentType}.`
-    );
-  }
-  let stateVariableForAttributeValue = attributeSpecification.componentStateVariableForAttributeValue;
-  if (stateVariableForAttributeValue === void 0) {
-    stateVariableForAttributeValue = attributeClass.stateVariableToBeShadowed;
-    if (stateVariableForAttributeValue === void 0) {
-      stateVariableForAttributeValue = "value";
-    }
-  }
-  return stateVariableForAttributeValue;
-}
-function _copyPassthroughAttributes(stateVarDef, attributeSpecification, { includeTriggerActionOnChange = false } = {}) {
-  const attributesToCopy = [
-    "forRenderer",
-    "defaultValue",
-    "propagateToProps",
-    ...includeTriggerActionOnChange ? ["triggerActionOnChange"] : [],
-    "ignoreFixed",
-    "isLocation",
-    "essentialVarName"
-  ];
-  for (const attrName2 of attributesToCopy) {
-    if (attrName2 in attributeSpecification) {
-      stateVarDef[attrName2] = attributeSpecification[attrName2];
-    }
-  }
-}
-function _buildAttributeDerivedDefinitions({
-  varName,
-  stateVariableForAttributeValue,
-  attributeSpecification,
-  attrName
-}) {
-  const definition = function({
-    dependencyValues,
-    usedDefault,
-    essentialValues
-  }) {
-    let attributeValue;
-    if (dependencyValues.attributeComponent) {
-      attributeValue = dependencyValues.attributeComponent.stateValues[stateVariableForAttributeValue];
-    } else if (dependencyValues.attributePrimitive != null) {
-      attributeValue = dependencyValues.attributePrimitive;
-    } else if (dependencyValues.attributeRefResolutions != null && !usedDefault.attributeRefResolutions) {
-      attributeValue = dependencyValues.attributeRefResolutions;
-    } else {
-      let haveSourceCompositeValue = dependencyValues.sourceCompositeValue != null;
-      if (haveSourceCompositeValue && !usedDefault.sourceCompositeValue && essentialValues[varName] === void 0) {
-        return {
-          setValue: {
-            [varName]: dependencyValues.sourceCompositeValue
-          },
-          checkForActualChange: { [varName]: true }
-        };
-      } else {
-        let haveParentValue = dependencyValues.parentValue != null;
-        if (haveParentValue && !usedDefault.parentValue && essentialValues[varName] === void 0) {
-          return {
-            setValue: {
-              [varName]: dependencyValues.parentValue
-            },
-            checkForActualChange: { [varName]: true }
-          };
-        } else {
-          return {
-            useEssentialOrDefaultValue: {
-              [varName]: true
-            },
-            checkForActualChange: { [varName]: true }
-          };
-        }
-      }
-    }
-    const res = validateAttributeValue({
-      value: attributeValue,
-      attributeSpecification,
-      attribute: attrName
-    });
-    return {
-      setValue: { [varName]: res.value },
-      checkForActualChange: { [varName]: true },
-      sendDiagnostics: res.diagnostics
-    };
-  };
-  const inverseDefinition = async function({
-    desiredStateVariableValues,
-    dependencyValues,
-    usedDefault,
-    essentialValues
-  }) {
-    if (!dependencyValues.attributeComponent) {
-      if (dependencyValues.attributePrimitive != null) {
-        return { success: false };
-      }
-      if (dependencyValues.attributeRefResolutions != null) {
-        return { success: false };
-      }
-      let haveSourceCompositeValue = dependencyValues.sourceCompositeValue != null;
-      if (haveSourceCompositeValue && !usedDefault.sourceCompositeValue && essentialValues[varName] === void 0) {
-        return {
-          success: true,
-          instructions: [
-            {
-              setDependency: "sourceCompositeValue",
-              desiredValue: desiredStateVariableValues[varName]
-            }
-          ]
-        };
-      } else {
-        let haveParentValue = dependencyValues.parentValue != null;
-        if (haveParentValue && !usedDefault.parentValue && essentialValues[varName] === void 0) {
-          return {
-            success: true,
-            instructions: [
-              {
-                setDependency: "parentValue",
-                desiredValue: desiredStateVariableValues[varName]
-              }
-            ]
-          };
-        } else {
-          const res = validateAttributeValue({
-            value: desiredStateVariableValues[varName],
-            attributeSpecification,
-            attribute: attrName
-          });
-          return {
-            success: true,
-            instructions: [
-              {
-                setEssentialValue: varName,
-                value: res.value
-              }
-            ],
-            sendDiagnostics: res.diagnostics
-          };
-        }
-      }
-    }
-    return {
-      success: true,
-      instructions: [
-        {
-          setDependency: "attributeComponent",
-          desiredValue: desiredStateVariableValues[varName],
-          variableIndex: 0
-        }
-      ]
-    };
-  };
-  return { definition, inverseDefinition };
-}
-function validateAttributeValue({
-  value,
-  attributeSpecification,
-  attribute
-}) {
-  let diagnostics = [];
-  const valueOrig = value;
-  if (attributeSpecification.transformNonFiniteTo !== void 0 && !Number.isFinite(value)) {
-    value = attributeSpecification.transformNonFiniteTo;
-  }
-  if (attributeSpecification.validValues && Array.isArray(value)) {
-    const res = validateListItemsAgainstValidValues({
-      items: value,
-      validValues: attributeSpecification.validValues,
-      toLowerCase: attributeSpecification.toLowerCase,
-      attribute
-    });
-    diagnostics.push(...res.diagnostics);
-    return { value: res.value, diagnostics };
-  }
-  if (attributeSpecification.toLowerCase) {
-    value = value.toLowerCase();
-  }
-  if (attributeSpecification.trim || attributeSpecification.validValues) {
-    value = value.trim();
-  }
-  if (attributeSpecification.validValues) {
-    const allowed = attributeSpecification.validValues.map((v2) => v2.value);
-    if (!allowed.includes(value)) {
-      let defaultValue = attributeSpecification.defaultValue;
-      if (defaultValue === void 0) {
-        if (attributeSpecification.createPrimitiveOfType) {
-          defaultValue = attributeSpecification.defaultPrimitiveValue;
-        }
-        if (defaultValue === void 0) {
-          throw Error(
-            "Invalid attribute specification: no default value specified"
-          );
-        }
-      }
-      diagnostics.push({
-        message: `Invalid value \`${valueOrig}\` for attribute \`${attribute}\`, using value \`${defaultValue}\``,
-        type: "info"
-      });
-      value = defaultValue;
-    }
-  } else if (attributeSpecification.clamp) {
-    if (value < attributeSpecification.clamp[0]) {
-      value = attributeSpecification.clamp[0];
-    } else if (value > attributeSpecification.clamp[1]) {
-      value = attributeSpecification.clamp[1];
-    } else if (!Number.isFinite(value)) {
-      value = attributeSpecification.defaultValue;
-    }
-  }
-  return { value, diagnostics };
-}
 function renameStateVariable({
   stateVariableDefinitions,
   oldName,
@@ -50750,46 +49668,52 @@ function renameStateVariable({
     };
   }
 }
-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)];
-        }
+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({ 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)];
-        }
+    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) {
@@ -51005,895 +49929,2027 @@ function multiDimGetArrayValue({ arrayKey, arrayValues = this.arrayValues }) {
       return void 0;
     }
   }
-  return aVals[index2[index2.length - 1]];
-}
-function oneDimGetArrayValue({ arrayKey, arrayValues = this.arrayValues }) {
-  return arrayValues[arrayKey];
+  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
+    };
+  }
 }
-function multiDimGetAllArrayKeys(arraySize2, flatten2 = true, desiredSize) {
-  function prependToAllKeys(keys2, newStuff) {
-    for (let [ind, key] of keys2.entries()) {
-      if (Array.isArray(key)) {
-        prependToAllKeys(key, newStuff);
+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 {
-        keys2[ind] = newStuff + "," + key;
+        stateVarObj.additionalStateVariablesDefined.push(varName);
       }
     }
   }
-  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);
-        }
+  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]
+        ];
       }
-      return subKeys;
     }
   }
-  if (desiredSize) {
-    if (desiredSize.length === 0) {
-      return [];
-    } else {
-      return getAllArrayKeysSub(desiredSize);
-    }
-  } else if (!arraySize2 || arraySize2.length === 0) {
-    return [];
+  if (arrayStateVarObj.getEntryValues) {
+    stateVarObj.getValueFromArrayValues = entryGetValueViaGetEntryValues;
   } else {
-    return getAllArrayKeysSub(arraySize2);
+    stateVarObj.getValueFromArrayValues = entryGetValueFromArrayValues;
   }
-}
-function oneDimGetAllArrayKeys(arraySize2, flatten2, desiredSize) {
-  if (desiredSize) {
-    if (desiredSize.length === 0) {
-      return [];
-    } else {
-      return Array.from(Array(desiredSize[0]), (_2, i2) => String(i2));
+  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);
     }
-  } 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);
+  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);
       }
     }
   }
-  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 [];
+  stateVarObj.returnDependencies = entryReturnDependencies;
 }
-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];
-    }
+async function initializeArrayStateVariable({
+  core: core2,
+  stateVarObj,
+  component,
+  stateVariable
+}) {
+  stateVarObj.arrayValues = [];
+  if (stateVarObj.numDimensions === void 0) {
+    stateVarObj.numDimensions = 1;
   }
-  if (args.arrayKeys === void 0) {
-    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  let entryPrefixes = stateVarObj.entryPrefixes;
+  if (!entryPrefixes) {
+    entryPrefixes = stateVarObj.entryPrefixes = [stateVariable];
   }
-  if (!arrayStateVarObj.dependencyNames) {
-    arrayStateVarObj.dependencyNames = {
-      namesByKey: {},
-      keysByName: {},
-      global: []
-    };
-    if (arrayStateVarObj.additionalStateVariablesDefined) {
-      for (let vName of arrayStateVarObj.additionalStateVariablesDefined) {
-        component.state[vName].dependencyNames = arrayStateVarObj.dependencyNames;
-      }
-    }
+  if (!component.arrayEntryPrefixes) {
+    component.arrayEntryPrefixes = {};
   }
-  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)
-        };
-      }
+  for (let prefix of entryPrefixes) {
+    component.arrayEntryPrefixes[prefix] = stateVariable;
+  }
+  if (stateVarObj.numDimensions > 1) {
+    if (!stateVarObj.keyToIndex) {
+      stateVarObj.keyToIndex = multiDimKeyToIndex;
     }
-  } else {
-    let arrayDependencies = arrayStateVarObj.returnArrayDependenciesByKey(args);
-    if (arrayDependencies.globalDependencies) {
-      arrayStateVarObj.dependencyNames.global = Object.keys(
-        arrayDependencies.globalDependencies
+    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]
       );
-      Object.assign(dependencies2, arrayDependencies.globalDependencies);
     }
-    if (!arrayDependencies.dependenciesByKey) {
-      arrayDependencies.dependenciesByKey = {};
+    stateVarObj.adjustArrayToNewArraySize = multiDimAdjustArrayToNewArraySize;
+  } else {
+    if (!stateVarObj.keyToIndex) {
+      stateVarObj.keyToIndex = oneDimKeyToIndex;
     }
-    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);
-        }
-      }
+    stateVarObj.setArrayValue = oneDimSetArrayValue;
+    stateVarObj.getArrayValue = oneDimGetArrayValue;
+    if (!stateVarObj.getAllArrayKeys) {
+      stateVarObj.getAllArrayKeys = oneDimGetAllArrayKeys;
     }
-    arrayStateVarObj.dependencyNames.global.push("__array_size");
+    if (!stateVarObj.arrayVarNameFromArrayKey) {
+      stateVarObj.arrayVarNameFromArrayKey = defaultOneDimArrayVarNameFromArrayKey;
+    }
+    if (!stateVarObj.arrayVarNameFromPropIndex) {
+      stateVarObj.arrayVarNameFromPropIndex = returnDefaultArrayVarNameFromPropIndex(1, entryPrefixes[0]);
+    }
+    stateVarObj.adjustArrayToNewArraySize = oneDimAdjustArrayToNewArraySize;
   }
-  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);
+  if (!stateVarObj.getArrayKeysFromVarName) {
+    stateVarObj.getArrayKeysFromVarName = returnDefaultGetArrayKeysFromVarName(stateVarObj.numDimensions);
   }
-  let freshByKey = freshnessInfo.freshByKey;
-  let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
-  for (let arrayKey of arrayKeys) {
-    if (freshByKey[arrayKey]) {
-      numberFresh += 1;
+  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();
   }
-  if (numberFresh > 0) {
-    if (numberFresh === arrayKeys.length + 1) {
-      return { fresh: { [arrayVarName]: true } };
-    } else {
-      return { partiallyFresh: { [arrayVarName]: numberFresh } };
+  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;
+      }
     }
-  } 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 });
+async function createArraySizeStateVariable({
+  core: core2,
+  stateVarObj,
+  component,
+  stateVariable
+}) {
+  let allStateVariablesAffected = [stateVariable];
+  if (stateVarObj.additionalStateVariablesDefined) {
+    allStateVariablesAffected.push(
+      ...stateVarObj.additionalStateVariablesDefined
+    );
   }
-  let freshByKey = freshnessInfo.freshByKey;
-  if (changes.__array_size) {
-    freshnessInfo.freshArraySize = false;
-    freshnessInfo.freshByKey = {};
-    result2.fresh = { [arrayVarName]: false };
-    return result2;
+  allStateVariablesAffected.sort();
+  let arraySizeStateVar = `__array_size_` + allStateVariablesAffected.join("_");
+  stateVarObj.arraySizeStateVariable = arraySizeStateVar;
+  if (stateVarObj.stateVariablesDeterminingDependencies) {
+    stateVarObj.stateVariablesDeterminingDependencies.push(
+      arraySizeStateVar
+    );
+  } else {
+    stateVarObj.stateVariablesDeterminingDependencies = [arraySizeStateVar];
   }
-  if (Object.keys(freshByKey).length === 0) {
-    freshnessInfo.freshByKey = {};
-    if (freshnessInfo.freshArraySize) {
-      result2.partiallyFresh = { [arrayVarName]: 1 };
-      return result2;
-    } else {
-      result2.fresh = { [arrayVarName]: false };
-      return result2;
+  if (component.state[arraySizeStateVar]) {
+    if (component.state[arraySizeStateVar].isShadow) {
+      let arraySizeStateVarObj = component.state[arraySizeStateVar];
+      arraySizeStateVarObj.arraySizeVarNamesAffected = allStateVariablesAffected;
+      arraySizeStateVarObj.markStale = arraySizeMarkStale;
     }
+    return;
   }
-  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;
+  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];
     }
-    if (arrayStateVarObj.basedOnArrayKeyStateVariables && arrayKeys.length > 1) {
-      delete freshByKey[changeName];
+    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 {
-      for (let key of arrayStateVarObj.dependencyNames.keysByName[changeName]) {
-        delete freshByKey[key];
-      }
+      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;
     }
-  }
-  let numberFresh = freshnessInfo.freshArraySize ? 1 : 0;
-  for (let arrayKey of arrayKeys) {
-    if (freshByKey[arrayKey]) {
-      numberFresh += 1;
+    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);
     }
   }
-  if (numberFresh > 0) {
-    if (numberFresh === arrayKeys.length + 1) {
-      result2.fresh = { [arrayVarName]: true };
-      return result2;
-    } else {
-      result2.partiallyFresh = { [arrayVarName]: numberFresh };
-      return result2;
+  return newVarNames;
+}
+const PRIMITIVE_TO_COMPONENT_TYPE = {
+  string: "text",
+  stringArray: "textList",
+  numberArray: "numberList"
+};
+const SHARED_STATE_VARIABLE_DEFINITIONS = /* @__PURE__ */ Symbol(
+  "sharedStateVariableDefinitions"
+);
+const classStateVariableDefinitionsCache = /* @__PURE__ */ new WeakMap();
+function getClassStateVariableDefinitions(core2, componentClass) {
+  let perCore = classStateVariableDefinitionsCache.get(core2);
+  if (!perCore) {
+    perCore = /* @__PURE__ */ new Map();
+    classStateVariableDefinitionsCache.set(core2, perCore);
+  }
+  let entry = perCore.get(componentClass);
+  if (!entry) {
+    const combined = {};
+    createAttributeStateVariableDefinitions({
+      core: core2,
+      stateVariableDefinitions: combined,
+      componentClass
+    });
+    const normalized = componentClass.returnNormalizedStateVariableDefinitions(
+      core2.numerics
+    );
+    Object.assign(combined, normalized);
+    for (const varName in combined) {
+      normalizeArrayStateVariableDefaults(combined[varName], varName);
     }
-  } else {
-    result2.fresh = { [arrayVarName]: false };
-    return result2;
+    combined[SHARED_STATE_VARIABLE_DEFINITIONS] = true;
+    entry = { combined, normalized };
+    perCore.set(componentClass, entry);
   }
+  return entry;
 }
-function arrayFreshenOnNoChanges({ arrayKeys, freshnessInfo, arraySize: arraySize2 }) {
-  const arrayStateVarObj = resolveArrayStateVarObj(this);
-  let freshByKey = freshnessInfo.freshByKey;
-  if (arrayKeys === void 0) {
-    arrayKeys = arrayStateVarObj.getAllArrayKeys(arraySize2);
+function cloneStateVariableDefinition(def) {
+  const clone2 = Object.assign({}, def);
+  if (clone2.shadowingInstructions) {
+    clone2.shadowingInstructions = Object.assign(
+      {},
+      clone2.shadowingInstructions
+    );
   }
-  for (let arrayKey of arrayKeys) {
-    freshByKey[arrayKey] = true;
+  if (clone2.additionalStateVariablesDefined) {
+    clone2.additionalStateVariablesDefined = [
+      ...clone2.additionalStateVariablesDefined
+    ];
+  }
+  if (clone2.stateVariablesDeterminingDependencies) {
+    clone2.stateVariablesDeterminingDependencies = [
+      ...clone2.stateVariablesDeterminingDependencies
+    ];
   }
+  return clone2;
 }
-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];
+async function createStateVariableDefinitions({
+  core: core2,
+  componentClass,
+  prescribedDependencies,
+  componentIdx
+}) {
+  let redefineDependencies;
+  if (prescribedDependencies) {
+    for (const idxStr in prescribedDependencies) {
+      const idx = Number(idxStr);
+      let depArray = prescribedDependencies[idx];
+      for (let dep of depArray) {
+        if (dep.dependencyType === "referenceShadow") {
+          if (idx === componentIdx) {
+            throw Error(
+              `Circular dependency involving ${componentIdx}.`
+            );
+          }
+          redefineDependencies = {
+            linkSource: "referenceShadow",
+            targetIdx: idx,
+            compositeIdx: dep.compositeIdx,
+            propVariable: dep.propVariable,
+            fromImplicitProp: dep.fromImplicitProp,
+            arrayStateVariable: dep.arrayStateVariable,
+            arrayKey: dep.arrayKey,
+            ignorePrimaryStateVariable: dep.ignorePrimaryStateVariable,
+            substituteForPrimaryStateVariable: dep.substituteForPrimaryStateVariable,
+            firstLevelReplacement: dep.firstLevelReplacement,
+            additionalStateVariableShadowing: dep.additionalStateVariableShadowing
+          };
+        } else if (dep.dependencyType === "adapter") {
+          redefineDependencies = {
+            linkSource: "adapter",
+            adapterTargetIdentity: dep.adapterTargetIdentity,
+            adapterVariable: dep.adapterVariable,
+            substituteForPrimaryStateVariable: dep.substituteForPrimaryStateVariable,
+            stateVariablesToShadow: dep.stateVariablesToShadow
+          };
+        }
+      }
+    }
   }
-  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;
+  const classDefinitions = getClassStateVariableDefinitions(
+    core2,
+    componentClass
+  );
+  if (!redefineDependencies) {
+    return classDefinitions.combined;
+  }
+  let stateVariableDefinitions = {};
+  for (const varName in classDefinitions.normalized) {
+    stateVariableDefinitions[varName] = cloneStateVariableDefinition(
+      classDefinitions.normalized[varName]
+    );
+  }
+  if (redefineDependencies.linkSource === "adapter") {
+    createAdapterStateVariableDefinitions({
+      core: core2,
+      redefineDependencies,
+      stateVariableDefinitions,
+      componentClass
+    });
+  } else {
+    await createReferenceShadowStateVariableDefinitions({
+      core: core2,
+      redefineDependencies,
+      stateVariableDefinitions,
+      componentClass
+    });
+  }
+  return stateVariableDefinitions;
+}
+function createAttributeStateVariableDefinitions({
+  core: core2,
+  componentClass,
+  stateVariableDefinitions
+}) {
+  let attributes = preprocessAttributesObject(
+    componentClass.createAttributesObject()
+  );
+  for (let attrName in attributes) {
+    let attributeSpecification = attributes[attrName];
+    if (!attributeSpecification.createStateVariable) {
+      continue;
+    }
+    let varName = attributeSpecification.createStateVariable;
+    let stateVarDef = stateVariableDefinitions[varName] = {
+      isAttribute: true,
+      hasEssential: true,
+      provideEssentialValuesInDefinition: true
+    };
+    if (attributeSpecification.public) {
+      _setShadowingInstructionsFromAttribute(
+        stateVarDef,
+        attributeSpecification
+      );
+    }
+    let stateVariableForAttributeValue = _resolveAttributeValueVariable(
+      core2,
+      attributeSpecification,
+      attrName,
+      componentClass
+    );
+    stateVarDef.returnDependencies = function() {
+      return {
+        ..._buildAttributeFallbackDependencies(attributeSpecification),
+        ..._buildAttributeValueDependency(
+          attributeSpecification,
+          attrName,
+          stateVariableForAttributeValue
+        )
+      };
+    };
+    const { definition, inverseDefinition } = _buildAttributeDerivedDefinitions({
+      varName,
+      stateVariableForAttributeValue,
+      attributeSpecification,
+      attrName
+    });
+    stateVarDef.definition = definition;
+    if (!attributeSpecification.noInverse) {
+      stateVarDef.inverseDefinition = inverseDefinition;
+    }
+    _copyPassthroughAttributes(stateVarDef, attributeSpecification, {
+      includeTriggerActionOnChange: true
+    });
+  }
+}
+function createAdapterStateVariableDefinitions({
+  core: core2,
+  redefineDependencies,
+  stateVariableDefinitions,
+  componentClass
+}) {
+  let adapterTargetComponent = core2._components[redefineDependencies.adapterTargetIdentity.componentIdx];
+  let attributes = preprocessAttributesObject(
+    componentClass.createAttributesObject()
+  );
+  for (let attrName in attributes) {
+    let attributeSpecification = attributes[attrName];
+    if (!attributeSpecification.createStateVariable) {
+      continue;
+    }
+    let varName = attributeSpecification.createStateVariable;
+    let stateVarDef = stateVariableDefinitions[varName] = {
+      isAttribute: true,
+      hasEssential: true
+    };
+    if (attributeSpecification.public) {
+      _setShadowingInstructionsFromAttribute(
+        stateVarDef,
+        attributeSpecification
+      );
+    }
+    if (varName in adapterTargetComponent.state) {
+      stateVarDef.returnDependencies = () => ({
+        adapterTargetVariable: {
+          dependencyType: "stateVariable",
+          componentIdx: redefineDependencies.adapterTargetIdentity.componentIdx,
+          variableName: varName
         }
+      });
+    } else {
+      stateVarDef.returnDependencies = () => ({});
+    }
+    stateVarDef.definition = function({ dependencyValues, usedDefault }) {
+      if (dependencyValues.adapterTargetVariable === void 0 || usedDefault.adapterTargetVariable) {
+        return {
+          useEssentialOrDefaultValue: {
+            [varName]: true
+          },
+          checkForActualChange: { [varName]: true }
+        };
+      } else {
+        return {
+          setValue: {
+            [varName]: dependencyValues.adapterTargetVariable
+          },
+          checkForActualChange: { [varName]: true }
+        };
       }
+    };
+    if (!attributeSpecification.noInverse) {
+      stateVarDef.inverseDefinition = async function({
+        desiredStateVariableValues,
+        dependencyValues
+      }) {
+        if (dependencyValues.adapterTargetVariable === void 0) {
+          return {
+            success: true,
+            instructions: [
+              {
+                setEssentialValue: varName,
+                value: desiredStateVariableValues[varName]
+              }
+            ]
+          };
+        } else {
+          return {
+            success: true,
+            instructions: [
+              {
+                setDependency: "adapterTargetVariable",
+                desiredValue: desiredStateVariableValues[varName]
+              }
+            ]
+          };
+        }
+      };
     }
+    _copyPassthroughAttributes(stateVarDef, attributeSpecification);
   }
-  return {
-    globalDependencyValues,
-    globalUsedDefault,
-    dependencyValuesByKey,
-    usedDefaultByKey,
-    foundAllDependencyValuesForKey
+  const { name: primaryStateVariableForDefinition, stateDef } = _resolvePrimaryStateVariableForDefinition({
+    redefineDependencies,
+    componentClass,
+    stateVariableDefinitions,
+    throwIfMissing: false
+  });
+  stateDef.isShadow = true;
+  stateDef.returnDependencies = () => ({
+    adapterTargetVariable: {
+      dependencyType: "stateVariable",
+      componentIdx: redefineDependencies.adapterTargetIdentity.componentIdx,
+      variableName: redefineDependencies.adapterVariable
+    }
+  });
+  if (stateDef.set) {
+    stateDef.definition = function({ dependencyValues }) {
+      return {
+        setValue: {
+          [primaryStateVariableForDefinition]: stateDef.set(
+            dependencyValues.adapterTargetVariable
+          )
+        }
+      };
+    };
+  } else {
+    stateDef.definition = function({ dependencyValues }) {
+      return {
+        setValue: {
+          [primaryStateVariableForDefinition]: dependencyValues.adapterTargetVariable
+        }
+      };
+    };
+  }
+  stateDef.inverseDefinition = function({ desiredStateVariableValues }) {
+    return {
+      success: true,
+      instructions: [
+        {
+          setDependency: "adapterTargetVariable",
+          desiredValue: desiredStateVariableValues[primaryStateVariableForDefinition]
+        }
+      ]
+    };
   };
+  if (redefineDependencies.stateVariablesToShadow) {
+    modifyStateDefsToBeShadows({
+      stateVariablesToShadow: redefineDependencies.stateVariablesToShadow,
+      stateVariableDefinitions,
+      targetComponent: adapterTargetComponent
+    });
+  }
 }
-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);
+async function createReferenceShadowStateVariableDefinitions({
+  core: core2,
+  redefineDependencies,
+  stateVariableDefinitions,
+  componentClass
+}) {
+  let targetComponent = core2._components[redefineDependencies.targetIdx];
+  if (redefineDependencies.propVariable) {
+    if (!targetComponent.state[redefineDependencies.propVariable] && core2.checkIfArrayEntry({
+      stateVariable: redefineDependencies.propVariable,
+      component: targetComponent
+    }).isArrayEntry) {
+      await core2.createFromArrayEntry({
+        stateVariable: redefineDependencies.propVariable,
+        component: targetComponent
+      });
+    }
   }
-  if (arrayStateVarObj.basedOnArrayKeyStateVariables && args.arrayKeys.length > 1) {
-    return {};
-  } else {
-    let extractedDeps = extractArrayDependencies(
-      arrayStateVarObj,
-      args.dependencyValues,
-      args.arrayKeys,
-      args.usedDefault
+  let attributes = preprocessAttributesObject(
+    componentClass.createAttributesObject()
+  );
+  for (let attrName in attributes) {
+    let attributeSpecification = attributes[attrName];
+    let varName = attributeSpecification.createStateVariable;
+    if (!varName) {
+      continue;
+    }
+    let stateVarDef = stateVariableDefinitions[varName] = {
+      isAttribute: true,
+      hasEssential: true,
+      provideEssentialValuesInDefinition: true
+    };
+    !attributeSpecification.createComponentOfType;
+    if (attributeSpecification.public) {
+      _setShadowingInstructionsFromAttribute(
+        stateVarDef,
+        attributeSpecification
+      );
+    }
+    let stateVariableForAttributeValue = _resolveAttributeValueVariable(
+      core2,
+      attributeSpecification,
+      attrName,
+      componentClass
     );
-    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);
+    const thisDependencies = {
+      ..._buildAttributeValueDependency(
+        attributeSpecification,
+        attrName,
+        stateVariableForAttributeValue
+      ),
+      ..._buildAttributeFallbackDependencies(attributeSpecification)
+    };
+    stateVarDef.returnDependencies = () => thisDependencies;
+    const { definition, inverseDefinition } = _buildAttributeDerivedDefinitions({
+      varName,
+      stateVariableForAttributeValue,
+      attributeSpecification,
+      attrName
+    });
+    stateVarDef.definition = definition;
+    if (!attributeSpecification.noInverse) {
+      stateVarDef.inverseDefinition = inverseDefinition;
+    }
+    _copyPassthroughAttributes(stateVarDef, attributeSpecification);
+  }
+  if (redefineDependencies.propVariable) {
+    if (!redefineDependencies.ignorePrimaryStateVariable) {
+      const { name: primaryStateVariableForDefinition, stateDef } = _resolvePrimaryStateVariableForDefinition({
+        redefineDependencies,
+        componentClass,
+        stateVariableDefinitions,
+        throwIfMissing: true
+      });
+      stateDef.isShadow = true;
+      stateDef.returnDependencies = () => ({
+        targetVariable: {
+          dependencyType: "stateVariable",
+          componentIdx: targetComponent.componentIdx,
+          variableName: redefineDependencies.propVariable
+        }
+      });
+      let setDefault = false;
+      if (targetComponent.state[redefineDependencies.propVariable].defaultValue !== void 0) {
+        stateDef.defaultValue = targetComponent.state[redefineDependencies.propVariable].defaultValue;
+        if (stateDef.set) {
+          stateDef.defaultValue = stateDef.set(stateDef.defaultValue);
+        }
+        stateDef.hasEssential = true;
+        setDefault = true;
+      }
+      let targetVariableIsArray = targetComponent.state[redefineDependencies.propVariable].isArray;
+      if (stateDef.set) {
+        stateDef.definition = function({
+          dependencyValues,
+          usedDefault
+        }) {
+          let targetVariable = dependencyValues.targetVariable;
+          if (targetVariable === void 0 || targetVariableIsArray && targetVariable.length === 0) {
+            return {
+              useEssentialOrDefaultValue: {
+                [primaryStateVariableForDefinition]: true
+              }
+            };
+          }
+          let valueFromTarget = stateDef.set(targetVariable);
+          if (setDefault && usedDefault.targetVariable) {
+            return {
+              useEssentialOrDefaultValue: {
+                [primaryStateVariableForDefinition]: {
+                  defaultValue: valueFromTarget
+                }
+              }
+            };
+          }
+          return {
+            setValue: {
+              [primaryStateVariableForDefinition]: valueFromTarget
+            }
+          };
+        };
+      } else {
+        stateDef.definition = function({
+          dependencyValues,
+          usedDefault
+        }) {
+          let targetVariable = dependencyValues.targetVariable;
+          if (targetVariable === void 0 || targetVariableIsArray && targetVariable.length === 0) {
+            return {
+              useEssentialOrDefaultValue: {
+                [primaryStateVariableForDefinition]: true
+              }
+            };
+          }
+          if (setDefault && usedDefault.targetVariable) {
+            return {
+              useEssentialOrDefaultValue: {
+                [primaryStateVariableForDefinition]: {
+                  defaultValue: targetVariable
+                }
+              }
+            };
+          }
+          return {
+            setValue: {
+              [primaryStateVariableForDefinition]: targetVariable
+            }
+          };
+        };
       }
+      stateDef.inverseDefinition = function({
+        desiredStateVariableValues
+      }) {
+        return {
+          success: true,
+          instructions: [
+            {
+              setDependency: "targetVariable",
+              desiredValue: desiredStateVariableValues[primaryStateVariableForDefinition]
+            }
+          ]
+        };
+      };
     }
-    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`
-        );
+    let shadowStandardVariables = false;
+    let stateVariablesToShadow2 = [];
+    if (targetComponent.constructor.implicitPropReturnsSameType) {
+      if (redefineDependencies.fromImplicitProp) {
+        shadowStandardVariables = true;
       }
-      result2 = arrayStateVarObj.arrayDefinitionByKey(args);
-      if (result2.setValue && result2.setValue[arrayVarName]) {
-        for (let arrayKey in result2.setValue[arrayVarName]) {
-          freshByKey[arrayKey] = true;
+      for (let varName in targetComponent.state) {
+        let stateObj = targetComponent.state[varName];
+        if (stateObj.shadowVariable || stateObj.isShadow) {
+          stateVariablesToShadow2.push(varName);
         }
       }
-      if (result2.useEssentialOrDefaultValue && result2.useEssentialOrDefaultValue[arrayVarName]) {
-        for (let arrayKey in result2.useEssentialOrDefaultValue[arrayVarName]) {
-          freshByKey[arrayKey] = true;
+    }
+    if (redefineDependencies.additionalStateVariableShadowing) {
+      let differentStateVariablesInTarget = Array(
+        stateVariablesToShadow2.length
+      );
+      for (let varName in redefineDependencies.additionalStateVariableShadowing) {
+        if (!stateVariablesToShadow2.includes(varName)) {
+          stateVariablesToShadow2.push(varName);
+          differentStateVariablesInTarget.push(
+            redefineDependencies.additionalStateVariableShadowing[varName].stateVariableToShadow
+          );
         }
       }
+      modifyStateDefsToBeShadows({
+        stateVariablesToShadow: stateVariablesToShadow2,
+        stateVariableDefinitions,
+        targetComponent,
+        differentStateVariablesInTarget
+      });
+    } else if (shadowStandardVariables) {
+      modifyStateDefsToBeShadows({
+        stateVariablesToShadow: stateVariablesToShadow2,
+        stateVariableDefinitions,
+        targetComponent
+      });
     }
-    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);
-            }
-          }
+    return;
+  }
+  let foundReadyToExpandWhenResolved = false;
+  if ("readyToExpandWhenResolved" in stateVariableDefinitions) {
+    foundReadyToExpandWhenResolved = true;
+    let stateDef = stateVariableDefinitions.readyToExpandWhenResolved;
+    let originalReturnDependencies = stateDef.returnDependencies.bind(stateDef);
+    let originalDefinition = stateDef.definition;
+    stateDef.returnDependencies = function(args) {
+      let dependencies2 = originalReturnDependencies(args);
+      dependencies2.targetReadyToExpandWhenResolved = {
+        dependencyType: "stateVariable",
+        componentIdx: targetComponent.componentIdx,
+        variableName: "readyToExpandWhenResolved"
+      };
+      return dependencies2;
+    };
+    stateDef.definition = function(args) {
+      let result2 = originalDefinition(args);
+      if (result2.setValue && result2.setValue.readyToExpandWhenResolved) {
+        if (!args.dependencyValues.targetReadyToExpandWhenResolved) {
+          result2.setValue.readyToExpandWhenResolved = false;
         }
       }
-      args.freshnessInfo.freshArraySize = true;
+      return result2;
+    };
+  }
+  let stateVariablesToShadow = [];
+  for (let varName in targetComponent.state) {
+    let stateObj = targetComponent.state[varName];
+    if (stateObj.shadowVariable || stateObj.isShadow) {
+      stateVariablesToShadow.push(varName);
     }
-    return result2;
   }
+  modifyStateDefsToBeShadows({
+    stateVariablesToShadow,
+    stateVariableDefinitions,
+    foundReadyToExpandWhenResolved,
+    targetComponent
+  });
 }
-function arrayInverseDefinition(args) {
-  const arrayStateVarObj = resolveArrayStateVarObj(this);
-  const arrayVarName = arrayStateVarObj.svVarName;
-  if (!arrayStateVarObj.inverseArrayDefinitionByKey) {
-    return { success: false };
+function shadowReturnDependencies(args) {
+  let dependencies2 = Object.assign(
+    {},
+    this.shadowOriginalReturnDependencies?.(args)
+  );
+  dependencies2.targetVariable = {
+    dependencyType: "stateVariable",
+    componentIdx: this.shadowOfComponentIdx,
+    variableName: this.shadowVarNameInTarget
+  };
+  if (this.shadowCopyComponentType) {
+    dependencies2.targetVariableComponentType = {
+      dependencyType: "stateVariableComponentType",
+      componentIdx: this.shadowOfComponentIdx,
+      variableName: this.shadowVarNameInTarget
+    };
   }
-  if (args.arrayKeys === void 0) {
-    args.arrayKeys = arrayStateVarObj.getAllArrayKeys(args.arraySize);
+  return dependencies2;
+}
+function shadowDefinition({ dependencyValues, usedDefault }) {
+  const varName = this.shadowVarName;
+  let result2 = {};
+  if ("targetVariableComponentType" in dependencyValues) {
+    result2.setCreateComponentOfType = {
+      [varName]: dependencyValues.targetVariableComponentType
+    };
   }
-  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
-          });
-        }
+  if (usedDefault.targetVariable && "defaultValue" in this && this.hasEssential) {
+    result2.useEssentialOrDefaultValue = {
+      [varName]: {
+        defaultValue: dependencyValues.targetVariable
       }
-    }
-    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 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;
-    }
+    result2.setValue = {
+      [varName]: dependencyValues.targetVariable
+    };
   }
-  return { setValue: { [this.svVarName]: arraySize2 } };
+  return result2;
 }
-function arraySizeMarkStale() {
-  for (let varName of this.arraySizeVarNamesAffected) {
-    this.svComponent.state[varName].arraySizeStale = true;
-  }
-  return {};
+function shadowInverseDefinition({ desiredStateVariableValues }) {
+  return {
+    success: true,
+    instructions: [
+      {
+        setDependency: "targetVariable",
+        desiredValue: desiredStateVariableValues[this.shadowVarName],
+        shadowedVariable: true
+      }
+    ]
+  };
 }
-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);
+function shadowReturnArrayDependenciesByKey({ arrayKeys }) {
+  let dependenciesByKey = {};
+  for (let key of arrayKeys) {
+    dependenciesByKey[key] = {
+      targetVariable: {
+        dependencyType: "stateVariable",
+        componentIdx: this.shadowOfComponentIdx,
+        variableName: this.shadowOverrideVarName || this.arrayVarNameFromArrayKey(key)
       }
-    }
+    };
   }
-  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;
+  let globalDependencies = {};
+  if (this.shadowCopyComponentType) {
+    globalDependencies.targetVariableComponentType = {
+      dependencyType: "stateVariableComponentType",
+      componentIdx: this.shadowOfComponentIdx,
+      variableName: this.shadowVarName
+    };
   }
-  this.numberNamesInPreviousReturnDep = numNames;
-  return dependencies2;
+  if (this.inverseShadowToSetEntireArray) {
+    globalDependencies.targetArray = {
+      dependencyType: "stateVariable",
+      componentIdx: this.shadowOfComponentIdx,
+      variableName: this.shadowVarName
+    };
+  }
+  return { globalDependencies, dependenciesByKey };
 }
-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];
+function shadowArrayDefinitionByKey({ globalDependencyValues, dependencyValuesByKey, arrayKeys }) {
+  const varName = this.shadowVarName;
+  let newEntries = {};
+  for (let arrayKey of arrayKeys) {
+    if ("targetVariable" in dependencyValuesByKey[arrayKey]) {
+      newEntries[arrayKey] = dependencyValuesByKey[arrayKey].targetVariable;
     } else {
-      await initializeStateVariable({
-        core: core2,
-        component,
-        stateVariable
-      });
+      newEntries[arrayKey] = this.defaultValueByArrayKey?.(arrayKey);
     }
   }
+  let result2 = {
+    setValue: { [varName]: newEntries }
+  };
+  if ("targetVariableComponentType" in globalDependencyValues) {
+    result2.setCreateComponentOfType = {
+      [varName]: globalDependencyValues.targetVariableComponentType
+    };
+  }
+  return result2;
 }
-async function initializeStateVariable({
-  core: core2,
-  component,
-  stateVariable,
-  arrayStateVariable,
-  arrayEntryPrefix
+function shadowInverseArrayDefinitionByKey({
+  desiredStateVariableValues,
+  dependencyValuesByKey,
+  dependencyNamesByKey,
+  arraySize: arraySize2,
+  initialChange
 }) {
-  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
-    });
+  const varName = this.shadowVarName;
+  if (this.inverseShadowToSetEntireArray) {
+    return {
+      success: true,
+      instructions: [
+        {
+          setDependency: "targetArray",
+          desiredValue: desiredStateVariableValues[varName],
+          treatAsInitialChange: initialChange
+        }
+      ]
+    };
   }
-  if (stateVarObj.triggerActionOnChange) {
-    let componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx];
-    if (!componentTriggers) {
-      componentTriggers = core2.stateVariableChangeTriggers[component.componentIdx] = {};
+  let instructions = [];
+  for (let key in desiredStateVariableValues[varName]) {
+    if (!dependencyValuesByKey[key]) {
+      continue;
     }
-    componentTriggers[stateVariable] = {
-      action: stateVarObj.triggerActionOnChange
-    };
+    instructions.push({
+      setDependency: dependencyNamesByKey[key].targetVariable,
+      desiredValue: desiredStateVariableValues[varName][key],
+      shadowedVariable: true
+    });
   }
+  return {
+    success: true,
+    instructions
+  };
 }
-async function initializeArrayEntryStateVariable({
-  stateVarObj,
-  arrayStateVariable,
-  arrayEntryPrefix,
-  component,
-  stateVariable
+function modifyStateDefsToBeShadows({
+  stateVariablesToShadow,
+  stateVariableDefinitions,
+  foundReadyToExpandWhenResolved,
+  targetComponent,
+  differentStateVariablesInTarget = []
 }) {
-  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
-        );
+  let deleteStateVariablesFromDefinition = {};
+  for (let [varInd, varName] of stateVariablesToShadow.entries()) {
+    let stateDef = stateVariableDefinitions[varName];
+    if (stateDef === void 0) {
+      if (varName.slice(0, 8) === "__array_") {
+        stateDef = stateVariableDefinitions[varName] = {};
       } else {
-        stateVarObj.additionalStateVariablesDefined.push(varName);
+        continue;
       }
     }
-  }
-  if (arrayStateVarObj.shadowingInstructions) {
-    stateVarObj.shadowingInstructions = {};
-    stateVarObj.wrappingComponents = arrayStateVarObj.shadowingInstructions.returnWrappingComponents(
-      arrayEntryPrefix
-    );
-    if (arrayStateVarObj.shadowingInstructions.attributesToShadow) {
-      stateVarObj.shadowingInstructions.attributesToShadow = arrayStateVarObj.shadowingInstructions.attributesToShadow;
+    stateDef.isShadow = true;
+    if (stateDef.additionalStateVariablesDefined) {
+      for (let varName2 of stateDef.additionalStateVariablesDefined) {
+        if (!stateVariablesToShadow.includes(varName2)) {
+          if (!deleteStateVariablesFromDefinition[varName2]) {
+            deleteStateVariablesFromDefinition[varName2] = [];
+          }
+          deleteStateVariablesFromDefinition[varName2].push(varName);
+        }
+      }
     }
-    if (arrayStateVarObj.shadowingInstructions.createComponentOfType) {
-      let entryPrefixInd = arrayStateVarObj.entryPrefixes.indexOf(arrayEntryPrefix);
-      if (arrayStateVarObj.shadowingInstructions.createComponentOfType[entryPrefixInd]) {
-        stateVarObj.shadowingInstructions.createComponentOfType = [
-          arrayStateVarObj.shadowingInstructions.createComponentOfType[entryPrefixInd]
-        ];
+    delete stateDef.additionalStateVariablesDefined;
+    if (!foundReadyToExpandWhenResolved) {
+      delete stateDef.stateVariablesDeterminingDependencies;
+    }
+    let copyComponentType = stateDef.public && stateDef.shadowingInstructions.hasVariableComponentType;
+    stateDef.shadowOfComponentIdx = targetComponent.componentIdx;
+    stateDef.shadowVarName = varName;
+    stateDef.shadowCopyComponentType = copyComponentType;
+    if (stateDef.isArray) {
+      stateDef.shadowOverrideVarName = differentStateVariablesInTarget[varInd];
+      stateDef.returnArrayDependenciesByKey = shadowReturnArrayDependenciesByKey;
+      stateDef.arrayDefinitionByKey = shadowArrayDefinitionByKey;
+      stateDef.inverseArrayDefinitionByKey = shadowInverseArrayDefinitionByKey;
+    } else {
+      if (foundReadyToExpandWhenResolved) {
+        stateDef.shadowOriginalReturnDependencies = stateDef.returnDependencies.bind(stateDef);
       }
+      stateDef.shadowVarNameInTarget = differentStateVariablesInTarget[varInd] || varName;
+      stateDef.returnDependencies = shadowReturnDependencies;
+      stateDef.definition = shadowDefinition;
+      stateDef.excludeDependencyValuesInInverseDefinition = true;
+      stateDef.inverseDefinition = shadowInverseDefinition;
     }
   }
-  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
+  for (let varName in deleteStateVariablesFromDefinition) {
+    modifyStateDefToDeleteVariableReferences({
+      varNamesToDelete: deleteStateVariablesFromDefinition[varName],
+      stateDef: stateVariableDefinitions[varName]
     });
-    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);
+}
+function modifyStateDefToDeleteVariableReferences({
+  varNamesToDelete,
+  stateDef
+}) {
+  for (let varName2 of varNamesToDelete) {
+    let ind = stateDef.additionalStateVariablesDefined.indexOf(varName2);
+    stateDef.additionalStateVariablesDefined.splice(ind, 1);
+  }
+  let originalDefinition = stateDef.definition;
+  stateDef.definition = function(args) {
+    let results = originalDefinition(args);
+    for (let key in results) {
+      if (Array.isArray(results[key])) {
+        for (let varName2 of varNamesToDelete) {
+          let ind = results[key].indexOf(varName2);
+          if (ind !== -1) {
+            results[key].splice(ind, 1);
+          }
+        }
+      } else {
+        for (let varName2 of varNamesToDelete) {
+          delete results[key][varName2];
+        }
       }
     }
-  }
-  stateVarObj.returnDependencies = entryReturnDependencies;
+    return results;
+  };
 }
-async function initializeArrayStateVariable({
-  core: core2,
-  stateVarObj,
-  component,
-  stateVariable
-}) {
-  stateVarObj.arrayValues = [];
-  if (stateVarObj.numDimensions === void 0) {
-    stateVarObj.numDimensions = 1;
+function _buildAttributeValueDependency(attributeSpecification, attrName, stateVariableForAttributeValue) {
+  if (attributeSpecification.createPrimitiveOfType) {
+    return {
+      attributePrimitive: {
+        dependencyType: "attributePrimitive",
+        attributeName: attrName
+      }
+    };
+  } else if (attributeSpecification.createReferences) {
+    return {
+      attributeRefResolutions: {
+        dependencyType: "attributeRefResolutions",
+        attributeName: attrName
+      }
+    };
+  } else {
+    return {
+      attributeComponent: {
+        dependencyType: "attributeComponent",
+        attributeName: attrName,
+        variableNames: [stateVariableForAttributeValue]
+      }
+    };
   }
-  let entryPrefixes = stateVarObj.entryPrefixes;
-  if (!entryPrefixes) {
-    entryPrefixes = stateVarObj.entryPrefixes = [stateVariable];
+}
+function _buildAttributeFallbackDependencies(attributeSpecification) {
+  const deps = {};
+  if (attributeSpecification.fallBackToParentStateVariable) {
+    deps.parentValue = {
+      dependencyType: "parentStateVariable",
+      variableName: attributeSpecification.fallBackToParentStateVariable
+    };
   }
-  if (!component.arrayEntryPrefixes) {
-    component.arrayEntryPrefixes = {};
+  if (attributeSpecification.fallBackToSourceCompositeStateVariable) {
+    deps.sourceCompositeValue = {
+      dependencyType: "sourceCompositeStateVariable",
+      variableName: attributeSpecification.fallBackToSourceCompositeStateVariable
+    };
   }
-  for (let prefix of entryPrefixes) {
-    component.arrayEntryPrefixes[prefix] = stateVariable;
+  return deps;
+}
+function _resolvePrimaryStateVariableForDefinition({
+  redefineDependencies,
+  componentClass,
+  stateVariableDefinitions,
+  throwIfMissing
+}) {
+  let name2 = "value";
+  if (redefineDependencies.substituteForPrimaryStateVariable) {
+    name2 = redefineDependencies.substituteForPrimaryStateVariable;
+  } else if (componentClass.primaryStateVariableForDefinition) {
+    name2 = componentClass.primaryStateVariableForDefinition;
   }
-  if (stateVarObj.numDimensions > 1) {
-    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]
+  const stateDef = stateVariableDefinitions[name2];
+  if (throwIfMissing && !stateDef) {
+    if (redefineDependencies.substituteForPrimaryStateVariable) {
+      throw Error(
+        `Invalid public state variable of componentType ${componentClass.componentType}: substituteForPrimaryStateVariable ${redefineDependencies.substituteForPrimaryStateVariable} does not exist`
+      );
+    } else {
+      throw Error(
+        `Cannot have a public state variable with componentType ${componentClass.componentType} as the class doesn't have a primary state variable for definition`
       );
     }
-    stateVarObj.adjustArrayToNewArraySize = multiDimAdjustArrayToNewArraySize;
+  }
+  return { name: name2, stateDef };
+}
+function _setShadowingInstructionsFromAttribute(stateVarDef, attributeSpecification) {
+  stateVarDef.public = true;
+  stateVarDef.shadowingInstructions = {};
+  if (attributeSpecification.createPrimitiveOfType) {
+    const primitive = attributeSpecification.createPrimitiveOfType;
+    stateVarDef.shadowingInstructions.createComponentOfType = PRIMITIVE_TO_COMPONENT_TYPE[primitive] ?? primitive;
+  } else if (attributeSpecification.createReferences) {
+    throw Error(
+      "Cannot make a public state variable from an attribute with createReferences"
+    );
   } else {
-    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;
+    stateVarDef.shadowingInstructions.createComponentOfType = attributeSpecification.createComponentOfType;
   }
-  if (!stateVarObj.getArrayKeysFromVarName) {
-    stateVarObj.getArrayKeysFromVarName = returnDefaultGetArrayKeysFromVarName(stateVarObj.numDimensions);
+}
+function _resolveAttributeValueVariable(core2, attributeSpecification, attrName, componentClass) {
+  if (!attributeSpecification.createComponentOfType) {
+    return void 0;
   }
-  stateVarObj.indexToKey = arrayIndexToKey;
-  if (!stateVarObj.returnEntryDimensions) {
-    stateVarObj.returnEntryDimensions = defaultReturnEntryDimensions;
+  const attributeClass = core2.componentInfoObjects.allComponentClasses[attributeSpecification.createComponentOfType];
+  if (!attributeClass) {
+    throw Error(
+      `Component type ${attributeSpecification.createComponentOfType} does not exist so cannot create state variable for attribute ${attrName} of componentType ${componentClass.componentType}.`
+    );
   }
-  if (stateVarObj.shadowingInstructions) {
-    if (!stateVarObj.shadowingInstructions.returnWrappingComponents) {
-      stateVarObj.shadowingInstructions.returnWrappingComponents = defaultReturnWrappingComponents;
+  let stateVariableForAttributeValue = attributeSpecification.componentStateVariableForAttributeValue;
+  if (stateVariableForAttributeValue === void 0) {
+    stateVariableForAttributeValue = attributeClass.stateVariableToBeShadowed;
+    if (stateVariableForAttributeValue === void 0) {
+      stateVariableForAttributeValue = "value";
     }
-    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] = {};
+  return stateVariableForAttributeValue;
+}
+function _copyPassthroughAttributes(stateVarDef, attributeSpecification, { includeTriggerActionOnChange = false } = {}) {
+  const attributesToCopy = [
+    "forRenderer",
+    "defaultValue",
+    "propagateToProps",
+    ...includeTriggerActionOnChange ? ["triggerActionOnChange"] : [],
+    "ignoreFixed",
+    "isLocation",
+    "essentialVarName"
+  ];
+  for (const attrName2 of attributesToCopy) {
+    if (attrName2 in attributeSpecification) {
+      stateVarDef[attrName2] = attributeSpecification[attrName2];
+    }
+  }
+}
+function _buildAttributeDerivedDefinitions({
+  varName,
+  stateVariableForAttributeValue,
+  attributeSpecification,
+  attrName
+}) {
+  const definition = function({
+    dependencyValues,
+    usedDefault,
+    essentialValues
+  }) {
+    let attributeValue;
+    if (dependencyValues.attributeComponent) {
+      attributeValue = dependencyValues.attributeComponent.stateValues[stateVariableForAttributeValue];
+    } else if (dependencyValues.attributePrimitive != null) {
+      attributeValue = dependencyValues.attributePrimitive;
+    } else if (dependencyValues.attributeRefResolutions != null && !usedDefault.attributeRefResolutions) {
+      attributeValue = dependencyValues.attributeRefResolutions;
+    } else {
+      let haveSourceCompositeValue = dependencyValues.sourceCompositeValue != null;
+      if (haveSourceCompositeValue && !usedDefault.sourceCompositeValue && essentialValues[varName] === void 0) {
+        return {
+          setValue: {
+            [varName]: dependencyValues.sourceCompositeValue
+          },
+          checkForActualChange: { [varName]: true }
+        };
+      } else {
+        let haveParentValue = dependencyValues.parentValue != null;
+        if (haveParentValue && !usedDefault.parentValue && essentialValues[varName] === void 0) {
+          return {
+            setValue: {
+              [varName]: dependencyValues.parentValue
+            },
+            checkForActualChange: { [varName]: true }
+          };
+        } else {
+          return {
+            useEssentialOrDefaultValue: {
+              [varName]: true
+            },
+            checkForActualChange: { [varName]: true }
+          };
         }
-        component.state[vName].freshnessInfo = stateVarObj.freshnessInfo;
       }
     }
-  }
+    const res = validateAttributeValue({
+      value: attributeValue,
+      attributeSpecification,
+      attribute: attrName
+    });
+    return {
+      setValue: { [varName]: res.value },
+      checkForActualChange: { [varName]: true },
+      sendDiagnostics: res.diagnostics
+    };
+  };
+  const inverseDefinition = async function({
+    desiredStateVariableValues,
+    dependencyValues,
+    usedDefault,
+    essentialValues
+  }) {
+    if (!dependencyValues.attributeComponent) {
+      if (dependencyValues.attributePrimitive != null) {
+        return { success: false };
+      }
+      if (dependencyValues.attributeRefResolutions != null) {
+        return { success: false };
+      }
+      let haveSourceCompositeValue = dependencyValues.sourceCompositeValue != null;
+      if (haveSourceCompositeValue && !usedDefault.sourceCompositeValue && essentialValues[varName] === void 0) {
+        return {
+          success: true,
+          instructions: [
+            {
+              setDependency: "sourceCompositeValue",
+              desiredValue: desiredStateVariableValues[varName]
+            }
+          ]
+        };
+      } else {
+        let haveParentValue = dependencyValues.parentValue != null;
+        if (haveParentValue && !usedDefault.parentValue && essentialValues[varName] === void 0) {
+          return {
+            success: true,
+            instructions: [
+              {
+                setDependency: "parentValue",
+                desiredValue: desiredStateVariableValues[varName]
+              }
+            ]
+          };
+        } else {
+          const res = validateAttributeValue({
+            value: desiredStateVariableValues[varName],
+            attributeSpecification,
+            attribute: attrName
+          });
+          return {
+            success: true,
+            instructions: [
+              {
+                setEssentialValue: varName,
+                value: res.value
+              }
+            ],
+            sendDiagnostics: res.diagnostics
+          };
+        }
+      }
+    }
+    return {
+      success: true,
+      instructions: [
+        {
+          setDependency: "attributeComponent",
+          desiredValue: desiredStateVariableValues[varName],
+          variableIndex: 0
+        }
+      ]
+    };
+  };
+  return { definition, inverseDefinition };
 }
-async function createArraySizeStateVariable({
-  core: core2,
-  stateVarObj,
-  component,
-  stateVariable
+function validateAttributeValue({
+  value,
+  attributeSpecification,
+  attribute
 }) {
-  let allStateVariablesAffected = [stateVariable];
-  if (stateVarObj.additionalStateVariablesDefined) {
-    allStateVariablesAffected.push(
-      ...stateVarObj.additionalStateVariablesDefined
-    );
+  let diagnostics = [];
+  const valueOrig = value;
+  if (attributeSpecification.transformNonFiniteTo !== void 0 && !Number.isFinite(value)) {
+    value = attributeSpecification.transformNonFiniteTo;
   }
-  allStateVariablesAffected.sort();
-  let arraySizeStateVar = `__array_size_` + allStateVariablesAffected.join("_");
-  stateVarObj.arraySizeStateVariable = arraySizeStateVar;
-  if (stateVarObj.stateVariablesDeterminingDependencies) {
-    stateVarObj.stateVariablesDeterminingDependencies.push(
-      arraySizeStateVar
-    );
-  } else {
-    stateVarObj.stateVariablesDeterminingDependencies = [arraySizeStateVar];
+  if (attributeSpecification.validValues && Array.isArray(value)) {
+    const res = validateListItemsAgainstValidValues({
+      items: value,
+      validValues: attributeSpecification.validValues,
+      toLowerCase: attributeSpecification.toLowerCase,
+      attribute
+    });
+    diagnostics.push(...res.diagnostics);
+    return { value: res.value, diagnostics };
   }
-  if (component.state[arraySizeStateVar]) {
-    if (component.state[arraySizeStateVar].isShadow) {
-      let arraySizeStateVarObj = component.state[arraySizeStateVar];
-      arraySizeStateVarObj.arraySizeVarNamesAffected = allStateVariablesAffected;
-      arraySizeStateVarObj.markStale = arraySizeMarkStale;
-    }
-    return;
+  if (attributeSpecification.toLowerCase) {
+    value = value.toLowerCase();
   }
-  component.state[arraySizeStateVar] = {
-    returnDependencies: stateVarObj.returnArraySizeDependencies,
-    definition: arraySizeDefinition,
-    markStale: arraySizeMarkStale,
-    arraySizeVarNamesAffected: allStateVariablesAffected,
-    arraySizeSourceVarName: stateVariable
-  };
-  if (stateVarObj.stateVariablesDeterminingArraySizeDependencies) {
-    component.state[arraySizeStateVar].stateVariablesDeterminingDependencies = stateVarObj.stateVariablesDeterminingArraySizeDependencies;
+  if (attributeSpecification.trim || attributeSpecification.validValues) {
+    value = value.trim();
   }
-  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;
+  if (attributeSpecification.validValues) {
+    const allowed = attributeSpecification.validValues.map((v2) => v2.value);
+    if (!allowed.includes(value)) {
+      let defaultValue = attributeSpecification.defaultValue;
+      if (defaultValue === void 0) {
+        if (attributeSpecification.createPrimitiveOfType) {
+          defaultValue = attributeSpecification.defaultPrimitiveValue;
+        }
+        if (defaultValue === void 0) {
+          throw Error(
+            "Invalid attribute specification: no default value specified"
+          );
+        }
       }
-      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
+      diagnostics.push({
+        message: `Invalid value \`${valueOrig}\` for attribute \`${attribute}\`, using value \`${defaultValue}\``,
+        type: "info"
       });
-      newName = varName;
+      value = defaultValue;
     }
-    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);
+  } else if (attributeSpecification.clamp) {
+    if (value < attributeSpecification.clamp[0]) {
+      value = attributeSpecification.clamp[0];
+    } else if (value > attributeSpecification.clamp[1]) {
+      value = attributeSpecification.clamp[1];
+    } else if (!Number.isFinite(value)) {
+      value = attributeSpecification.defaultValue;
     }
   }
-  return newVarNames;
+  return { value, diagnostics };
 }
 const EMPTY_SERIALIZED_CHILDREN = Object.freeze([]);
 function ancestorsForChild(parent) {
@@ -229243,4 +229299,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-CyEKEyxP.js.map
+//# sourceMappingURL=index-D7QB7nkv.js.map