@doenet/v06-to-v07 0.7.21-dev.346 → 0.7.21-dev.347

package/{index-DIXIAZMT.js → index-BdPydNFg.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-A0bbFFmK-Drhbnw70.js").then((n2) => n2.s)).default;
+      const sha256 = (await import("./sha256-C0vj3HDn-DgMb2jlU-CPBnemG6.js").then((n2) => n2.s)).default;
       digest = (data2) => sha256(data2, {
         asBytes: true
       });
@@ -120332,6 +120332,136 @@ class Coords extends MathComponent {
   //   }
   // }
 }
+function buildIgnoredPhrase(ignored) {
+  if (ignored.length === 1) {
+    return `${ignored[0]} is`;
+  } else if (ignored.length === 2) {
+    return `${ignored[0]} and ${ignored[1]} are`;
+  } else {
+    return `${ignored.slice(0, -1).join(", ")}, and ${ignored.slice(-1)} are`;
+  }
+}
+function directionFromSlope(slope) {
+  if (slope === Infinity || slope === -Infinity) {
+    return [0, Math.sign(slope)];
+  }
+  if (!Number.isFinite(slope)) {
+    return null;
+  }
+  let theta = Math.atan(slope);
+  return [Math.cos(theta), Math.sin(theta)];
+}
+function getNumericValue(mathOrNumber) {
+  return mathOrNumber instanceof Context.class ? mathOrNumber.evaluate_to_constant() : Number(mathOrNumber);
+}
+function getNumericEndpointPair(desiredUnconstrainedEndpoints, currentEndpoints, numDimensions = 2, pointInds = [0, 1]) {
+  return pointInds.map(
+    (pointInd) => Array.from({ length: numDimensions }, (_2, dim) => {
+      let key = pointInd + "," + dim;
+      if (key in desiredUnconstrainedEndpoints) {
+        return getNumericValue(desiredUnconstrainedEndpoints[key]);
+      }
+      return currentEndpoints[pointInd][dim].evaluate_to_constant();
+    })
+  );
+}
+function getSlopeAndSignedLength(endpoint1, endpoint2, fallbackSlope) {
+  const dx = endpoint2[0] - endpoint1[0];
+  const dy = endpoint2[1] - endpoint1[1];
+  if (dx === 0 && dy === 0) {
+    return {
+      slope: fallbackSlope,
+      signedLength: 0
+    };
+  }
+  if (dx === 0) {
+    return {
+      slope: dy > 0 ? Infinity : -Infinity,
+      // For vertical segments, canonicalize interactions so slope encodes
+      // up vs down and the defining length stays non-negative.
+      signedLength: Math.abs(dy)
+    };
+  }
+  return {
+    slope: dy / dx,
+    signedLength: Math.hypot(dx, dy) * Math.sign(dx)
+  };
+}
+function getDirectionComponent(dim, dirX, dirY) {
+  let dimNumber = Number(dim);
+  if (dimNumber === 0) {
+    return dirX;
+  }
+  if (dimNumber === 1) {
+    return dirY;
+  }
+  return 0;
+}
+function getConfiguredSlope(globalDependencyValues) {
+  return globalDependencyValues.slopeAttr !== null ? globalDependencyValues.slopeAttr.stateValues.value : globalDependencyValues.essentialSlope;
+}
+function getConfiguredSignedLength(globalDependencyValues) {
+  return globalDependencyValues.lengthAttr !== null ? globalDependencyValues.lengthAttr.stateValues.value : globalDependencyValues.essentialSignedLength;
+}
+function addSlopeAndLengthInstructions({
+  instructions,
+  globalDependencyValues,
+  endpoint1,
+  endpoint2
+}) {
+  const fallbackSlope = getConfiguredSlope(globalDependencyValues);
+  const { slope, signedLength } = getSlopeAndSignedLength(
+    endpoint1,
+    endpoint2,
+    fallbackSlope
+  );
+  if (globalDependencyValues.slopeAttr !== null) {
+    instructions.push({
+      setDependency: "slopeAttr",
+      desiredValue: slope,
+      variableIndex: 0
+    });
+  } else {
+    instructions.push({
+      setDependency: "essentialSlope",
+      desiredValue: slope
+    });
+  }
+  if (globalDependencyValues.lengthAttr !== null) {
+    instructions.push({
+      setDependency: "lengthAttr",
+      desiredValue: signedLength,
+      variableIndex: 0
+    });
+  } else {
+    instructions.push({
+      setDependency: "essentialSignedLength",
+      desiredValue: signedLength
+    });
+  }
+}
+function addMidpointInstructions({
+  instructions,
+  dependencyNamesByKey,
+  midpointCoords
+}) {
+  for (let dim = 0; dim < midpointCoords.length; dim++) {
+    const midpointDependencyName = dependencyNamesByKey["0," + dim]?.midpointCoord;
+    if (midpointDependencyName !== void 0) {
+      instructions.push({
+        setDependency: midpointDependencyName,
+        desiredValue: Context.fromAst(midpointCoords[dim]),
+        variableIndex: 0
+      });
+    }
+  }
+}
+function mergePointCoords(pointCoords, currentPoint, numDimensions) {
+  return Array.from(
+    { length: numDimensions },
+    (_2, dim) => pointCoords[dim] !== void 0 ? pointCoords[dim] : currentPoint[dim]
+  );
+}
 class LineSegment extends GraphicalComponent {
   constructor(args) {
     super(args);
@@ -120365,6 +120495,25 @@ class LineSegment extends GraphicalComponent {
       createComponentOfType: "pointList",
       description: "The two endpoints of the line segment."
     };
+    attributes.midpoint = {
+      createComponentOfType: "point",
+      description: "A reference point on the line segment, located at its midpoint by default. Used with slope/length/midpointOffset to position the segment. When midpointOffset is nonzero, this point is offset from the segment's actual midpoint (given by the midpoint property)."
+    };
+    attributes.slope = {
+      createComponentOfType: "number",
+      description: "The slope of the line segment in the x-y plane."
+    };
+    attributes.length = {
+      createComponentOfType: "number",
+      description: "The signed defining length used with the slope/midpoint parameterization. Negative values flip the relative position of the endpoints."
+    };
+    attributes.midpointOffset = {
+      createComponentOfType: "number",
+      createStateVariable: "midpointOffset",
+      defaultValue: 0,
+      clamp: [-1, 1],
+      description: "Where the point given by the midpoint attribute sits along the segment (requires midpoint to be set): -1=first endpoint, 0=midpoint, 1=second endpoint. Clamped to [-1, 1]."
+    };
     attributes.addControls = {
       description: "Whether to render interactive control handles.",
       createComponentOfType: "text",
@@ -120509,18 +120658,218 @@ class LineSegment extends GraphicalComponent {
           dependencyType: "attributeComponent",
           attributeName: "endpoints",
           variableNames: ["numDimensions"]
+        },
+        midpointAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "midpoint",
+          variableNames: ["numDimensions"]
         }
       }),
       definition: function({ dependencyValues }) {
-        if (dependencyValues.endpointsAttr !== null) {
-          let numDimensions = dependencyValues.endpointsAttr.stateValues.numDimensions;
-          return {
-            setValue: { numDimensions: Math.max(numDimensions, 2) },
-            checkForActualChange: { numDimensions: true }
-          };
-        } else {
-          return { setValue: { numDimensions: 2 } };
+        const endpointsDimensions = dependencyValues.endpointsAttr?.stateValues.numDimensions ?? 0;
+        const midpointDimensions = dependencyValues.midpointAttr?.stateValues.numDimensions ?? 0;
+        return {
+          setValue: {
+            numDimensions: Math.max(
+              endpointsDimensions,
+              midpointDimensions,
+              2
+            )
+          },
+          checkForActualChange: { numDimensions: true }
+        };
+      }
+    };
+    stateVariableDefinitions.numEndpointsSpecified = {
+      returnDependencies: () => ({
+        endpointsAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "endpoints",
+          variableNames: ["numPoints"]
         }
+      }),
+      definition({ dependencyValues }) {
+        if (dependencyValues.endpointsAttr === null) {
+          return { setValue: { numEndpointsSpecified: 0 } };
+        }
+        return {
+          setValue: {
+            numEndpointsSpecified: Math.min(
+              dependencyValues.endpointsAttr.stateValues.numPoints,
+              2
+            )
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.midpointSpecified = {
+      returnDependencies: () => ({
+        midpointAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "midpoint"
+        }
+      }),
+      definition({ dependencyValues }) {
+        return {
+          setValue: {
+            midpointSpecified: dependencyValues.midpointAttr !== null
+          }
+        };
+      }
+    };
+    stateVariableDefinitions.basedOnSlopeOrMidpoint = {
+      stateVariablesDeterminingDependencies: [],
+      returnDependencies: () => ({
+        slopeAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "slope"
+        },
+        lengthAttr: {
+          dependencyType: "attributeComponent",
+          attributeName: "length"
+        },
+        midpointSpecified: {
+          dependencyType: "stateVariable",
+          variableName: "midpointSpecified"
+        },
+        numEndpointsSpecified: {
+          dependencyType: "stateVariable",
+          variableName: "numEndpointsSpecified"
+        },
+        midpointOffset: {
+          dependencyType: "stateVariable",
+          variableName: "midpointOffset"
+        }
+      }),
+      definition({ dependencyValues, usedDefault }) {
+        const anyPositioningAttr = dependencyValues.slopeAttr !== null || dependencyValues.lengthAttr !== null || dependencyValues.midpointSpecified;
+        const basedOnSlopeOrMidpoint = anyPositioningAttr && dependencyValues.numEndpointsSpecified < 2;
+        const result2 = {
+          setValue: {
+            basedOnSlopeOrMidpoint
+          }
+        };
+        if (anyPositioningAttr && !basedOnSlopeOrMidpoint) {
+          const ignored = [];
+          if (dependencyValues.slopeAttr !== null) {
+            ignored.push("slope");
+          }
+          if (dependencyValues.lengthAttr !== null) {
+            ignored.push("length");
+          }
+          if (dependencyValues.midpointSpecified) {
+            ignored.push("midpoint");
+          }
+          if (!usedDefault.midpointOffset) {
+            ignored.push("midpointOffset");
+          }
+          result2.sendDiagnostics = [
+            {
+              type: "info",
+              message: `${buildIgnoredPhrase(ignored)} ignored when two endpoints are specified`
+            }
+          ];
+        } else if (!basedOnSlopeOrMidpoint && !usedDefault.midpointOffset) {
+          result2.sendDiagnostics = [
+            {
+              type: "info",
+              message: "midpointOffset has no effect without a midpoint"
+            }
+          ];
+        }
+        return result2;
+      }
+    };
+    stateVariableDefinitions.essentialSlope = {
+      defaultValue: 0,
+      hasEssential: true,
+      returnDependencies: () => ({}),
+      definition: () => ({
+        useEssentialOrDefaultValue: { essentialSlope: true }
+      }),
+      inverseDefinition({ desiredStateVariableValues }) {
+        return {
+          success: true,
+          instructions: [
+            {
+              setEssentialValue: "essentialSlope",
+              value: desiredStateVariableValues.essentialSlope
+            }
+          ]
+        };
+      }
+    };
+    stateVariableDefinitions.essentialSignedLength = {
+      defaultValue: 1,
+      hasEssential: true,
+      returnDependencies: () => ({}),
+      definition: () => ({
+        useEssentialOrDefaultValue: { essentialSignedLength: true }
+      }),
+      inverseDefinition({ desiredStateVariableValues }) {
+        return {
+          success: true,
+          instructions: [
+            {
+              setEssentialValue: "essentialSignedLength",
+              value: desiredStateVariableValues.essentialSignedLength
+            }
+          ]
+        };
+      }
+    };
+    stateVariableDefinitions.essentialEp1 = {
+      isArray: true,
+      numDimensions: 1,
+      isLocation: true,
+      hasEssential: true,
+      set: convertValueToMathExpression,
+      defaultValueByArrayKey: () => Context.fromAst(0),
+      entryPrefixes: ["essentialEp1X"],
+      getArrayKeysFromVarName({
+        arrayEntryPrefix,
+        varEnding,
+        arraySize: arraySize2
+      }) {
+        let ind = Number(varEnding) - 1;
+        if (!Number.isInteger(ind) || ind < 0) {
+          return [];
+        }
+        if (arraySize2) {
+          return ind < arraySize2[0] ? [String(ind)] : [];
+        }
+        return [String(ind)];
+      },
+      returnArraySizeDependencies: () => ({
+        numDimensions: {
+          dependencyType: "stateVariable",
+          variableName: "numDimensions"
+        }
+      }),
+      returnArraySize({ dependencyValues }) {
+        return [dependencyValues.numDimensions];
+      },
+      returnArrayDependenciesByKey: () => ({}),
+      arrayDefinitionByKey({ arrayKeys }) {
+        let essentialEp1 = {};
+        for (let arrayKey of arrayKeys) {
+          essentialEp1[arrayKey] = true;
+        }
+        return { useEssentialOrDefaultValue: { essentialEp1 } };
+      },
+      inverseArrayDefinitionByKey({ desiredStateVariableValues }) {
+        let instructions = [];
+        for (let arrayKey in desiredStateVariableValues.essentialEp1) {
+          instructions.push({
+            setEssentialValue: "essentialEp1",
+            value: {
+              [arrayKey]: convertValueToMathExpression(
+                desiredStateVariableValues.essentialEp1[arrayKey]
+              )
+            }
+          });
+        }
+        return { success: true, instructions };
       }
     };
     stateVariableDefinitions.unconstrainedEndpoints = {
@@ -120595,75 +120944,485 @@ class LineSegment extends GraphicalComponent {
       returnArraySize({ dependencyValues }) {
         return [2, dependencyValues.numDimensions];
       },
-      returnArrayDependenciesByKey({ arrayKeys }) {
-        let dependenciesByKey = {};
-        for (let arrayKey of arrayKeys) {
-          let [pointInd, dim] = arrayKey.split(",");
-          let varEnding = Number(pointInd) + 1 + "_" + (Number(dim) + 1);
-          dependenciesByKey[arrayKey] = {
-            endpointsAttr: {
-              dependencyType: "attributeComponent",
-              attributeName: "endpoints",
-              variableNames: ["pointX" + varEnding]
+      stateVariablesDeterminingDependencies: [
+        "basedOnSlopeOrMidpoint",
+        "numEndpointsSpecified",
+        "midpointSpecified"
+      ],
+      returnArrayDependenciesByKey({ stateValues, arrayKeys }) {
+        if (!stateValues.basedOnSlopeOrMidpoint) {
+          let dependenciesByKey2 = {};
+          for (let arrayKey of arrayKeys) {
+            let [pointInd, dim] = arrayKey.split(",");
+            let varEnding = Number(pointInd) + 1 + "_" + (Number(dim) + 1);
+            dependenciesByKey2[arrayKey] = {
+              endpointsAttr: {
+                dependencyType: "attributeComponent",
+                attributeName: "endpoints",
+                variableNames: ["pointX" + varEnding]
+              }
+            };
+          }
+          return { dependenciesByKey: dependenciesByKey2 };
+        }
+        let globalDependencies = {
+          basedOnSlopeOrMidpoint: {
+            dependencyType: "stateVariable",
+            variableName: "basedOnSlopeOrMidpoint"
+          },
+          numEndpointsSpecified: {
+            dependencyType: "stateVariable",
+            variableName: "numEndpointsSpecified"
+          },
+          midpointSpecified: {
+            dependencyType: "stateVariable",
+            variableName: "midpointSpecified"
+          },
+          numDimensions: {
+            dependencyType: "stateVariable",
+            variableName: "numDimensions"
+          },
+          slopeAttr: {
+            dependencyType: "attributeComponent",
+            attributeName: "slope",
+            variableNames: ["value"]
+          },
+          lengthAttr: {
+            dependencyType: "attributeComponent",
+            attributeName: "length",
+            variableNames: ["value"]
+          },
+          midpointOffset: {
+            dependencyType: "stateVariable",
+            variableName: "midpointOffset"
+          },
+          essentialSlope: {
+            dependencyType: "stateVariable",
+            variableName: "essentialSlope"
+          },
+          essentialSignedLength: {
+            dependencyType: "stateVariable",
+            variableName: "essentialSignedLength"
+          }
+        };
+        if (stateValues.numEndpointsSpecified === 1) {
+          globalDependencies.ep1FromAttr = {
+            dependencyType: "attributeComponent",
+            attributeName: "endpoints",
+            variableNames: []
+          };
+          let dependenciesByKey2 = {};
+          for (let arrayKey of arrayKeys) {
+            let [pointInd, dim] = arrayKey.split(",");
+            let varEnding = "1_" + (Number(dim) + 1);
+            dependenciesByKey2[arrayKey] = {
+              ep1Coord: {
+                dependencyType: "attributeComponent",
+                attributeName: "endpoints",
+                variableNames: ["pointX" + varEnding]
+              }
+            };
+          }
+          if (stateValues.midpointSpecified) {
+            for (let arrayKey of arrayKeys) {
+              let dim = Number(arrayKey.split(",")[1]);
+              dependenciesByKey2[arrayKey].midpointCoord = {
+                dependencyType: "attributeComponent",
+                attributeName: "midpoint",
+                variableNames: ["x" + (dim + 1)]
+              };
             }
+          }
+          return { globalDependencies, dependenciesByKey: dependenciesByKey2 };
+        }
+        let dependenciesByKey = {};
+        if (stateValues.midpointSpecified) {
+          for (let arrayKey of arrayKeys) {
+            let dim = Number(arrayKey.split(",")[1]);
+            dependenciesByKey[arrayKey] = {
+              midpointCoord: {
+                dependencyType: "attributeComponent",
+                attributeName: "midpoint",
+                variableNames: ["x" + (dim + 1)]
+              }
+            };
+          }
+        } else {
+          globalDependencies.essentialEp1 = {
+            dependencyType: "stateVariable",
+            variableName: "essentialEp1"
           };
+          for (let arrayKey of arrayKeys) {
+            dependenciesByKey[arrayKey] = {};
+          }
+          return { globalDependencies, dependenciesByKey };
         }
-        return { dependenciesByKey };
+        return { globalDependencies, dependenciesByKey };
       },
-      arrayDefinitionByKey({ dependencyValuesByKey, arrayKeys }) {
+      arrayDefinitionByKey({
+        globalDependencyValues,
+        globalUsedDefault,
+        dependencyValuesByKey,
+        arrayKeys
+      }) {
+        if (!globalDependencyValues?.basedOnSlopeOrMidpoint) {
+          let unconstrainedEndpoints2 = {};
+          let essentialUnconstrainedEndpoints = {};
+          for (let arrayKey of arrayKeys) {
+            let [pointInd, dim] = arrayKey.split(",");
+            let varEnding = Number(pointInd) + 1 + "_" + (Number(dim) + 1);
+            if (dependencyValuesByKey[arrayKey].endpointsAttr !== null && dependencyValuesByKey[arrayKey].endpointsAttr.stateValues["pointX" + varEnding]) {
+              unconstrainedEndpoints2[arrayKey] = dependencyValuesByKey[arrayKey].endpointsAttr.stateValues["pointX" + varEnding];
+            } else {
+              essentialUnconstrainedEndpoints[arrayKey] = true;
+            }
+          }
+          let result22 = {};
+          if (Object.keys(unconstrainedEndpoints2).length > 0) {
+            result22.setValue = { unconstrainedEndpoints: unconstrainedEndpoints2 };
+          }
+          if (Object.keys(essentialUnconstrainedEndpoints).length > 0) {
+            result22.useEssentialOrDefaultValue = {
+              unconstrainedEndpoints: essentialUnconstrainedEndpoints
+            };
+          }
+          return result22;
+        }
+        const g2 = globalDependencyValues;
+        const gUsedDefault = globalUsedDefault;
+        let sendDiagnostics = [];
+        if (g2.numEndpointsSpecified === 1 && g2.midpointSpecified) {
+          if (g2.slopeAttr !== null || g2.lengthAttr !== null) {
+            const ignored = [];
+            if (g2.slopeAttr !== null) {
+              ignored.push("slope");
+            }
+            if (g2.lengthAttr !== null) {
+              ignored.push("length");
+            }
+            sendDiagnostics.push({
+              type: "info",
+              message: `${buildIgnoredPhrase(ignored)} ignored when an endpoint and a midpoint are both specified`
+            });
+          }
+        } else if (!g2.midpointSpecified && !gUsedDefault.midpointOffset) {
+          sendDiagnostics.push({
+            type: "info",
+            message: "midpointOffset has no effect without a midpoint"
+          });
+        }
         let unconstrainedEndpoints = {};
-        let essentialUnconstrainedEndpoints = {};
-        for (let arrayKey of arrayKeys) {
-          let [pointInd, dim] = arrayKey.split(",");
-          let varEnding = Number(pointInd) + 1 + "_" + (Number(dim) + 1);
-          if (dependencyValuesByKey[arrayKey].endpointsAttr !== null && dependencyValuesByKey[arrayKey].endpointsAttr.stateValues["pointX" + varEnding]) {
-            unconstrainedEndpoints[arrayKey] = dependencyValuesByKey[arrayKey].endpointsAttr.stateValues["pointX" + varEnding];
+        if (g2.numEndpointsSpecified === 1 && g2.midpointSpecified) {
+          const tT = (1 + g2.midpointOffset) / 2;
+          for (let arrayKey of arrayKeys) {
+            let [pointInd, dim] = arrayKey.split(",");
+            let varEnding = "1_" + (Number(dim) + 1);
+            let ep1Coord = dependencyValuesByKey[arrayKey].ep1Coord?.stateValues["pointX" + varEnding];
+            if (pointInd === "0") {
+              unconstrainedEndpoints[arrayKey] = ep1Coord ?? Context.fromAst("＿");
+              continue;
+            }
+            let midpointVal = dependencyValuesByKey[arrayKey].midpointCoord?.stateValues["x" + (Number(dim) + 1)];
+            if (tT === 0 || !ep1Coord || !midpointVal) {
+              unconstrainedEndpoints[arrayKey] = Context.fromAst("＿");
+              continue;
+            }
+            let invT = 1 / tT;
+            unconstrainedEndpoints[arrayKey] = Context.fromAst([
+              "+",
+              ["*", 1 - invT, ep1Coord.tree],
+              ["*", invT, midpointVal.tree]
+            ]).simplify();
+          }
+        } else {
+          const slope = getConfiguredSlope(g2);
+          const signedLength = getConfiguredSignedLength(g2);
+          const direction = directionFromSlope(slope);
+          if (direction === null) {
+            for (let arrayKey of arrayKeys) {
+              unconstrainedEndpoints[arrayKey] = Context.fromAst("＿");
+            }
+            let result22 = { setValue: { unconstrainedEndpoints } };
+            if (sendDiagnostics.length > 0) {
+              result22.sendDiagnostics = sendDiagnostics;
+            }
+            return result22;
+          }
+          const [dirX, dirY] = direction;
+          if (g2.numEndpointsSpecified === 1 && !g2.midpointSpecified) {
+            for (let arrayKey of arrayKeys) {
+              let [pointInd, dim] = arrayKey.split(",");
+              let varEnding = "1_" + (Number(dim) + 1);
+              let ep1Coord = dependencyValuesByKey[arrayKey].ep1Coord.stateValues["pointX" + varEnding];
+              if (!ep1Coord) {
+                unconstrainedEndpoints[arrayKey] = Context.fromAst("＿");
+                continue;
+              }
+              if (pointInd === "0") {
+                unconstrainedEndpoints[arrayKey] = ep1Coord;
+              } else {
+                let delta = signedLength * getDirectionComponent(dim, dirX, dirY);
+                unconstrainedEndpoints[arrayKey] = Context.fromAst(["+", ep1Coord.tree, delta]).simplify();
+              }
+            }
+          } else if (g2.midpointSpecified) {
+            const po2 = g2.midpointOffset;
+            for (let arrayKey of arrayKeys) {
+              let [pointInd, dim] = arrayKey.split(",");
+              let midpointCoordVal = dependencyValuesByKey[arrayKey].midpointCoord?.stateValues["x" + (Number(dim) + 1)];
+              if (!midpointCoordVal) {
+                unconstrainedEndpoints[arrayKey] = Context.fromAst("＿");
+                continue;
+              }
+              let dir = getDirectionComponent(dim, dirX, dirY);
+              if (pointInd === "0") {
+                let coeff = (1 + po2) / 2 * signedLength * dir;
+                unconstrainedEndpoints[arrayKey] = Context.fromAst([
+                  "+",
+                  midpointCoordVal.tree,
+                  -coeff
+                ]).simplify();
+              } else {
+                let coeff = (1 - po2) / 2 * signedLength * dir;
+                unconstrainedEndpoints[arrayKey] = Context.fromAst([
+                  "+",
+                  midpointCoordVal.tree,
+                  coeff
+                ]).simplify();
+              }
+            }
           } else {
-            essentialUnconstrainedEndpoints[arrayKey] = true;
+            let ep1 = g2.essentialEp1 ?? [
+              Context.fromAst(0),
+              Context.fromAst(0)
+            ];
+            for (let arrayKey of arrayKeys) {
+              let [pointInd, dim] = arrayKey.split(",");
+              let ep1Coord = ep1[Number(dim)] ?? Context.fromAst(0);
+              if (pointInd === "0") {
+                unconstrainedEndpoints[arrayKey] = ep1Coord;
+              } else {
+                let dir = getDirectionComponent(
+                  dim,
+                  dirX,
+                  dirY
+                );
+                let delta = signedLength * dir;
+                unconstrainedEndpoints[arrayKey] = Context.fromAst(["+", ep1Coord.tree, delta]).simplify();
+              }
+            }
           }
         }
-        let result2 = {};
-        if (Object.keys(unconstrainedEndpoints).length > 0) {
-          result2.setValue = { unconstrainedEndpoints };
-        }
-        if (Object.keys(essentialUnconstrainedEndpoints).length > 0) {
-          result2.useEssentialOrDefaultValue = {
-            unconstrainedEndpoints: essentialUnconstrainedEndpoints
-          };
+        let result2 = { setValue: { unconstrainedEndpoints } };
+        if (sendDiagnostics.length > 0) {
+          result2.sendDiagnostics = sendDiagnostics;
         }
         return result2;
       },
       async inverseArrayDefinitionByKey({
         desiredStateVariableValues,
+        globalDependencyValues,
         dependencyValuesByKey,
         dependencyNamesByKey,
         initialChange,
-        stateValues
+        stateValues,
+        workspace,
+        arraySize: arraySize2
       }) {
+        if (!globalDependencyValues?.basedOnSlopeOrMidpoint) {
+          let instructions2 = [];
+          for (let arrayKey in desiredStateVariableValues.unconstrainedEndpoints) {
+            let [pointInd, dim] = arrayKey.split(",");
+            let varEnding = Number(pointInd) + 1 + "_" + (Number(dim) + 1);
+            if (dependencyValuesByKey[arrayKey].endpointsAttr !== null && dependencyValuesByKey[arrayKey].endpointsAttr.stateValues["pointX" + varEnding]) {
+              instructions2.push({
+                setDependency: dependencyNamesByKey[arrayKey].endpointsAttr,
+                desiredValue: desiredStateVariableValues.unconstrainedEndpoints[arrayKey],
+                childIndex: 0,
+                variableIndex: 0
+              });
+            } else {
+              instructions2.push({
+                setEssentialValue: "unconstrainedEndpoints",
+                value: {
+                  [arrayKey]: desiredStateVariableValues.unconstrainedEndpoints[arrayKey]
+                }
+              });
+            }
+          }
+          return { success: true, instructions: instructions2 };
+        }
+        const g2 = globalDependencyValues;
+        const numDim = g2.numDimensions ?? 2;
+        workspace ??= {};
+        Object.assign(
+          workspace,
+          desiredStateVariableValues.unconstrainedEndpoints
+        );
+        const desiredUnconstrainedEndpoints = workspace;
+        const desiredKeys = Object.keys(desiredUnconstrainedEndpoints);
+        const onlyEp1Desired = desiredKeys.every(
+          (k2) => k2.startsWith("0,")
+        );
+        const onlyEp2Desired = desiredKeys.every(
+          (k2) => k2.startsWith("1,")
+        );
         let instructions = [];
-        for (let arrayKey in desiredStateVariableValues.unconstrainedEndpoints) {
-          let [pointInd, dim] = arrayKey.split(",");
-          let varEnding = Number(pointInd) + 1 + "_" + (Number(dim) + 1);
-          if (dependencyValuesByKey[arrayKey].endpointsAttr !== null && dependencyValuesByKey[arrayKey].endpointsAttr.stateValues["pointX" + varEnding]) {
-            instructions.push({
-              setDependency: dependencyNamesByKey[arrayKey].endpointsAttr,
-              desiredValue: desiredStateVariableValues.unconstrainedEndpoints[arrayKey],
-              childIndex: 0,
-              variableIndex: 0
-            });
-          } else {
-            instructions.push({
-              setEssentialValue: "unconstrainedEndpoints",
-              value: {
-                [arrayKey]: desiredStateVariableValues.unconstrainedEndpoints[arrayKey]
+        const numEndpointsSpecified = g2.numEndpointsSpecified;
+        const midpointSpecified = g2.midpointSpecified;
+        if (numEndpointsSpecified === 1 && midpointSpecified) {
+          const tT = (1 + g2.midpointOffset) / 2;
+          if (tT === 0) {
+            if (!onlyEp1Desired) {
+              return { success: false };
+            }
+            for (let arrayKey of desiredKeys) {
+              instructions.push({
+                setDependency: dependencyNamesByKey[arrayKey].ep1Coord,
+                desiredValue: desiredUnconstrainedEndpoints[arrayKey],
+                variableIndex: 0
+              });
+            }
+            return { success: true, instructions };
+          }
+          let currentEndpoints = await stateValues.endpoints;
+          let [ep1Num, ep2Num] = getNumericEndpointPair(
+            desiredUnconstrainedEndpoints,
+            currentEndpoints,
+            numDim
+          );
+          if (!ep1Num.every(Number.isFinite) || !ep2Num.every(Number.isFinite)) {
+            return { success: false };
+          }
+          for (let arrayKey of desiredKeys) {
+            let [pointInd] = arrayKey.split(",").map(Number);
+            if (pointInd === 0) {
+              instructions.push({
+                setDependency: dependencyNamesByKey[arrayKey].ep1Coord,
+                desiredValue: desiredUnconstrainedEndpoints[arrayKey],
+                variableIndex: 0
+              });
+            }
+          }
+          const M_new = ep1Num.map(
+            (value, dim) => value + tT * (ep2Num[dim] - value)
+          );
+          addMidpointInstructions({
+            instructions,
+            dependencyNamesByKey,
+            midpointCoords: M_new
+          });
+          return { success: true, instructions };
+        }
+        if (numEndpointsSpecified === 1 && !midpointSpecified) {
+          if (!onlyEp2Desired) {
+            for (let arrayKey of desiredKeys) {
+              let [pointInd] = arrayKey.split(",").map(Number);
+              if (pointInd === 0) {
+                instructions.push({
+                  setDependency: dependencyNamesByKey[arrayKey].ep1Coord,
+                  desiredValue: desiredUnconstrainedEndpoints[arrayKey],
+                  variableIndex: 0
+                });
               }
+            }
+          }
+          if (!onlyEp1Desired) {
+            let currentEndpoints = await stateValues.endpoints;
+            let [ep1Num, ep2Num] = getNumericEndpointPair(
+              desiredUnconstrainedEndpoints,
+              currentEndpoints
+            );
+            if (ep1Num.every(Number.isFinite) && ep2Num.every(Number.isFinite)) {
+              addSlopeAndLengthInstructions({
+                instructions,
+                globalDependencyValues: g2,
+                endpoint1: ep1Num,
+                endpoint2: ep2Num
+              });
+            }
+          }
+        } else if (midpointSpecified) {
+          const po2 = g2.midpointOffset;
+          const tT = (1 + po2) / 2;
+          let T_new;
+          if (onlyEp1Desired) {
+            const slope = getConfiguredSlope(g2);
+            const L2 = getConfiguredSignedLength(g2);
+            const direction = directionFromSlope(slope);
+            if (direction === null) {
+              return { success: false };
+            }
+            const [dirX2, dirY2] = direction;
+            let currentEndpoints = await stateValues.endpoints;
+            const [ep1Desired] = getNumericEndpointPair(
+              desiredUnconstrainedEndpoints,
+              currentEndpoints,
+              numDim,
+              [0]
+            );
+            T_new = ep1Desired.map(
+              (value, dim) => value + tT * L2 * getDirectionComponent(dim, dirX2, dirY2)
+            );
+            if (!T_new.every(Number.isFinite)) {
+              return { success: false };
+            }
+          } else {
+            let currentEndpoints = await stateValues.endpoints;
+            let [ep1Num, ep2Num] = getNumericEndpointPair(
+              desiredUnconstrainedEndpoints,
+              currentEndpoints,
+              numDim
+            );
+            if (!ep1Num.every(Number.isFinite) || !ep2Num.every(Number.isFinite)) {
+              return { success: false };
+            }
+            T_new = ep1Num.map(
+              (value, dim) => value + tT * (ep2Num[dim] - value)
+            );
+            addSlopeAndLengthInstructions({
+              instructions,
+              globalDependencyValues: g2,
+              endpoint1: ep1Num,
+              endpoint2: ep2Num
             });
           }
+          addMidpointInstructions({
+            instructions,
+            dependencyNamesByKey,
+            midpointCoords: T_new
+          });
+        } else {
+          if (!onlyEp2Desired) {
+            for (let arrayKey of desiredKeys) {
+              let [pointInd, dim] = arrayKey.split(",").map(Number);
+              if (pointInd === 0) {
+                instructions.push({
+                  setDependency: "essentialEp1",
+                  desiredValue: {
+                    [String(dim)]: desiredUnconstrainedEndpoints[arrayKey]
+                  }
+                });
+              }
+            }
+          }
+          if (!onlyEp1Desired) {
+            let currentEndpoints = await stateValues.endpoints;
+            let [ep1Num, ep2Num] = getNumericEndpointPair(
+              desiredUnconstrainedEndpoints,
+              currentEndpoints
+            );
+            if (ep1Num.every(Number.isFinite) && ep2Num.every(Number.isFinite)) {
+              addSlopeAndLengthInstructions({
+                instructions,
+                globalDependencyValues: g2,
+                endpoint1: ep1Num,
+                endpoint2: ep2Num
+              });
+            }
+          }
         }
-        return {
-          success: true,
-          instructions
-        };
+        return { success: true, instructions };
       }
     };
     stateVariableDefinitions.haveConstrainedEndpoints = {
@@ -120954,7 +121713,7 @@ class LineSegment extends GraphicalComponent {
       }
     };
     stateVariableDefinitions.length = {
-      description: "The length of the line segment.",
+      description: "The Euclidean length of the line segment (always non-negative).",
       public: true,
       isLocation: true,
       shadowingInstructions: {
@@ -121215,7 +121974,7 @@ class LineSegment extends GraphicalComponent {
       }
     };
     stateVariableDefinitions.slope = {
-      description: "The slope of the line segment (2D only).",
+      description: "The slope of the line segment in the x-y plane; returns NaN when the segment is not 2D.",
       public: true,
       isLocation: true,
       shadowingInstructions: {
@@ -121223,9 +121982,9 @@ class LineSegment extends GraphicalComponent {
         addAttributeComponentsShadowingStateVariables: returnNumberDisplayAttributeComponentShadowing()
       },
       returnDependencies: () => ({
-        numericalEndpoints: {
+        endpoints: {
           dependencyType: "stateVariable",
-          variableName: "numericalEndpoints"
+          variableName: "endpoints"
         },
         numDimensions: {
           dependencyType: "stateVariable",
@@ -121236,9 +121995,206 @@ class LineSegment extends GraphicalComponent {
         if (dependencyValues.numDimensions !== 2) {
           return { setValue: { slope: NaN } };
         }
-        let ps = dependencyValues.numericalEndpoints;
-        let slope = (ps[1][1] - ps[0][1]) / (ps[1][0] - ps[0][0]);
+        let ep = dependencyValues.endpoints;
+        let A1 = ep[0][0].evaluate_to_constant();
+        let A2 = ep[0][1].evaluate_to_constant();
+        let B1 = ep[1][0].evaluate_to_constant();
+        let B2 = ep[1][1].evaluate_to_constant();
+        let slope = (B2 - A2) / (B1 - A1);
         return { setValue: { slope } };
+      },
+      inverseDefinition({
+        desiredStateVariableValues,
+        dependencyValues
+      }) {
+        if (dependencyValues.numDimensions !== 2) {
+          return { success: false };
+        }
+        let ep = dependencyValues.endpoints;
+        let A1 = ep[0][0].evaluate_to_constant();
+        let A2 = ep[0][1].evaluate_to_constant();
+        let B1 = ep[1][0].evaluate_to_constant();
+        let B2 = ep[1][1].evaluate_to_constant();
+        if (!Number.isFinite(A1) || !Number.isFinite(A2) || !Number.isFinite(B1) || !Number.isFinite(B2)) {
+          return { success: false };
+        }
+        let cx = (A1 + B1) / 2;
+        let cy = (A2 + B2) / 2;
+        let L2 = Math.sqrt((B1 - A1) ** 2 + (B2 - A2) ** 2);
+        if (L2 === 0) {
+          return { success: false };
+        }
+        let m2 = desiredStateVariableValues.slope;
+        if (m2 instanceof Context.class) {
+          m2 = m2.evaluate_to_constant();
+        }
+        if (Number.isNaN(m2)) {
+          return { success: false };
+        }
+        const direction = directionFromSlope(m2);
+        if (direction === null) {
+          return { success: false };
+        }
+        let [dirX, dirY] = direction;
+        let currentDirX = (B1 - A1) / L2;
+        let currentDirY = (B2 - A2) / L2;
+        if (Number.isFinite(m2) && currentDirX * dirX + currentDirY * dirY < 0) {
+          dirX = -dirX;
+          dirY = -dirY;
+        }
+        let half = L2 / 2;
+        let newEp1 = [
+          Context.fromAst(cx - half * dirX),
+          Context.fromAst(cy - half * dirY)
+        ];
+        let newEp2 = [
+          Context.fromAst(cx + half * dirX),
+          Context.fromAst(cy + half * dirY)
+        ];
+        return {
+          success: true,
+          instructions: [
+            {
+              setDependency: "endpoints",
+              desiredValue: [newEp1, newEp2]
+            }
+          ]
+        };
+      }
+    };
+    stateVariableDefinitions.midpoint = {
+      description: "The midpoint of the line segment, i.e. the average of its endpoints. When the midpoint attribute is set together with a nonzero midpointOffset, this actual midpoint differs from the point given by the midpoint attribute.",
+      public: true,
+      isLocation: true,
+      shadowingInstructions: {
+        createComponentOfType: "math",
+        addAttributeComponentsShadowingStateVariables: returnNumberDisplayAttributeComponentShadowing(),
+        returnWrappingComponents(prefix) {
+          if (prefix === "midpointX") {
+            return [];
+          } else {
+            return [
+              [
+                "point",
+                {
+                  componentType: "mathList",
+                  isAttributeNamed: "xs"
+                }
+              ]
+            ];
+          }
+        }
+      },
+      isArray: true,
+      numDimensions: 1,
+      indexAliases: [["x", "y", "z"]],
+      entryPrefixes: ["midpointX"],
+      returnEntryDimensions: () => 0,
+      getArrayKeysFromVarName({
+        arrayEntryPrefix,
+        varEnding,
+        arraySize: arraySize2
+      }) {
+        let ind = Number(varEnding) - 1;
+        if (!Number.isInteger(ind) || ind < 0) {
+          return [];
+        }
+        if (arraySize2) {
+          return ind < arraySize2[0] ? [String(ind)] : [];
+        }
+        return [String(ind)];
+      },
+      arrayVarNameFromPropIndex(propIndex, varName) {
+        if (varName === "midpoint") {
+          return "midpointX" + propIndex[0];
+        }
+        return null;
+      },
+      returnArraySizeDependencies: () => ({
+        numDimensions: {
+          dependencyType: "stateVariable",
+          variableName: "numDimensions"
+        }
+      }),
+      returnArraySize({ dependencyValues }) {
+        return [dependencyValues.numDimensions];
+      },
+      returnArrayDependenciesByKey() {
+        return {
+          globalDependencies: {
+            endpoints: {
+              dependencyType: "stateVariable",
+              variableName: "endpoints"
+            },
+            numDimensions: {
+              dependencyType: "stateVariable",
+              variableName: "numDimensions"
+            }
+          }
+        };
+      },
+      arrayDefinitionByKey({ globalDependencyValues, arrayKeys }) {
+        let midpoint = {};
+        let ep1 = globalDependencyValues.endpoints[0];
+        let ep2 = globalDependencyValues.endpoints[1];
+        for (let arrayKey of arrayKeys) {
+          let dim = Number(arrayKey);
+          let v1 = ep1[dim].evaluate_to_constant();
+          let v2 = ep2[dim].evaluate_to_constant();
+          if (Number.isFinite(v1) && Number.isFinite(v2)) {
+            midpoint[arrayKey] = Context.fromAst((v1 + v2) / 2);
+          } else {
+            midpoint[arrayKey] = Context.fromAst([
+              "/",
+              ["+", ep1[dim].tree, ep2[dim].tree],
+              2
+            ]);
+          }
+        }
+        return { setValue: { midpoint } };
+      },
+      inverseArrayDefinitionByKey({
+        desiredStateVariableValues,
+        globalDependencyValues
+      }) {
+        let ep1 = globalDependencyValues.endpoints[0];
+        let ep2 = globalDependencyValues.endpoints[1];
+        let desiredEndpoints = {};
+        for (let dimString in desiredStateVariableValues.midpoint) {
+          let d2 = Number(dimString);
+          let currentMidpoint = Context.fromAst([
+            "/",
+            ["+", ep1[d2].tree, ep2[d2].tree],
+            2
+          ]);
+          let desiredMidpoint = convertValueToMathExpression(
+            desiredStateVariableValues.midpoint[dimString]
+          );
+          let delta = Context.fromAst([
+            "+",
+            desiredMidpoint.tree,
+            ["-", currentMidpoint.tree]
+          ]);
+          desiredEndpoints["0," + d2] = Context.fromAst([
+            "+",
+            ep1[d2].tree,
+            delta.tree
+          ]);
+          desiredEndpoints["1," + d2] = Context.fromAst([
+            "+",
+            ep2[d2].tree,
+            delta.tree
+          ]);
+        }
+        return {
+          success: true,
+          instructions: [
+            {
+              setDependency: "endpoints",
+              desiredValue: desiredEndpoints
+            }
+          ]
+        };
       }
     };
     return stateVariableDefinitions;
@@ -121253,8 +122209,10 @@ class LineSegment extends GraphicalComponent {
     }
   ];
   async moveLineSegmentSinglePoint({
+    coords,
     x: x2,
     y: y2,
+    z: z2,
     pointRole,
     transient,
     skippable,
@@ -121263,15 +122221,19 @@ class LineSegment extends GraphicalComponent {
     sourceInformation = {},
     skipRendererUpdate = false
   }) {
-    if (!Number.isFinite(x2) || !Number.isFinite(y2)) {
+    let pointCoords = coords ?? [x2, y2];
+    if (coords === void 0 && z2 !== void 0) {
+      pointCoords.push(z2);
+    }
+    if (pointCoords.length < 2 || !Number.isFinite(pointCoords[0]) || !Number.isFinite(pointCoords[1]) || pointCoords.slice(2).some((coord) => coord !== void 0 && !Number.isFinite(coord))) {
       console.warn(
-        `Invalid endpoint coordinates for line segment move: x=${x2}, y=${y2}`
+        `Invalid endpoint coordinates for line segment move: ${pointCoords.join(", ")}`
       );
       return;
     }
     if (pointRole === "endpoint1") {
       return await this.moveLineSegment({
-        point1coords: [x2, y2],
+        point1coords: pointCoords,
         transient,
         skippable,
         actionId,
@@ -121281,7 +122243,7 @@ class LineSegment extends GraphicalComponent {
       });
     } else if (pointRole === "endpoint2") {
       return await this.moveLineSegment({
-        point2coords: [x2, y2],
+        point2coords: pointCoords,
         transient,
         skippable,
         actionId,
@@ -121316,14 +122278,39 @@ class LineSegment extends GraphicalComponent {
         return;
       }
     }
+    const numDimensions = await this.stateValues.numDimensions;
+    let numericalEndpoints = await this.stateValues.numericalEndpoints;
+    if (point1coords !== void 0) {
+      point1coords = mergePointCoords(
+        point1coords,
+        numericalEndpoints[0],
+        numDimensions
+      );
+    }
+    if (point2coords !== void 0) {
+      point2coords = mergePointCoords(
+        point2coords,
+        numericalEndpoints[1],
+        numDimensions
+      );
+    }
+    if (await this.stateValues.basedOnSlopeOrMidpoint) {
+      if (point1coords !== void 0 && point2coords === void 0) {
+        point2coords = numericalEndpoints[1];
+      } else if (point2coords !== void 0 && point1coords === void 0) {
+        point1coords = numericalEndpoints[0];
+      }
+    }
     let newComponents = {};
     if (point1coords !== void 0) {
-      newComponents["0,0"] = Context.fromAst(point1coords[0]);
-      newComponents["0,1"] = Context.fromAst(point1coords[1]);
+      for (let dim = 0; dim < numDimensions; dim++) {
+        newComponents[`0,${dim}`] = Context.fromAst(point1coords[dim]);
+      }
     }
     if (point2coords !== void 0) {
-      newComponents["1,0"] = Context.fromAst(point2coords[0]);
-      newComponents["1,1"] = Context.fromAst(point2coords[1]);
+      for (let dim = 0; dim < numDimensions; dim++) {
+        newComponents[`1,${dim}`] = Context.fromAst(point2coords[dim]);
+      }
     }
     if (transient) {
       await this.coreFunctions.performUpdate({
@@ -121397,12 +122384,11 @@ class LineSegment extends GraphicalComponent {
         }
         let newPointComponents = {};
         for (let ind in newNumericalPoints) {
-          newPointComponents[ind + ",0"] = Context.fromAst(
-            newNumericalPoints[ind][0]
-          );
-          newPointComponents[ind + ",1"] = Context.fromAst(
-            newNumericalPoints[ind][1]
-          );
+          for (let dim = 0; dim < numDimensions; dim++) {
+            newPointComponents[`${ind},${dim}`] = Context.fromAst(
+              newNumericalPoints[ind][dim]
+            );
+          }
         }
         let newInstructions = [
           {
@@ -229508,4 +230494,4 @@ export {
   getDefaultExportFromCjs as g,
   updateSyntaxFromV06toV07 as u
 };
-//# sourceMappingURL=index-DIXIAZMT.js.map
+//# sourceMappingURL=index-BdPydNFg.js.map