oasis-editor 0.0.21 → 0.0.22

package/dist/{index-BmpiQ2A0.js → index-N6EX-tEW.js}

@@ -2438,7 +2438,7 @@ function OasisEditorAppLazy(props = {}) {
     onCleanup(() => {
       cancelled = true;
     });
-    import("./OasisEditorApp-D-O4XHvu.js").then((m) => {
+    import("./OasisEditorApp-BD3WQQO5.js").then((m) => {
       cancelled = true;
       setProgress(1);
       setTimeout(() => setApp(() => m.OasisEditorApp), 180);
@@ -14805,52 +14805,199 @@ function drawTable(ctx, table, tableSegment, state, originX, originY, contentWid
     });
   }
 }
-const KAPPA = 0.5522847498307936;
-function getPresetPathSegments(preset, x, y, width, height) {
-  const right = x + width;
-  const bottom = y + height;
-  const cx = x + width / 2;
-  const cy = y + height / 2;
-  switch (preset) {
-    case "roundRect":
-      return roundRectSegments(
-        x,
-        y,
-        width,
-        height,
-        Math.min(width, height) * 0.1
-      );
-    case "ellipse":
-      return ellipseSegments(cx, cy, width / 2, height / 2);
-    case "triangle":
-      return polygon([
-        [cx, y],
-        [right, bottom],
-        [x, bottom]
-      ]);
-    case "rtTriangle":
-      return polygon([
-        [x, y],
-        [x, bottom],
-        [right, bottom]
-      ]);
-    case "diamond":
-      return polygon([
-        [cx, y],
-        [right, cy],
-        [cx, bottom],
-        [x, cy]
-      ]);
-    case "rect":
-    default:
-      return polygon([
-        [x, y],
-        [right, y],
-        [right, bottom],
-        [x, bottom]
-      ]);
-  }
+const SUPPORTED_PRESET_GEOMETRIES = /* @__PURE__ */ new Set([
+  "accentBorderCallout1",
+  "accentBorderCallout2",
+  "accentBorderCallout3",
+  "accentCallout1",
+  "accentCallout2",
+  "accentCallout3",
+  "actionButtonBackPrevious",
+  "actionButtonBeginning",
+  "actionButtonBlank",
+  "actionButtonDocument",
+  "actionButtonEnd",
+  "actionButtonForwardNext",
+  "actionButtonHelp",
+  "actionButtonHome",
+  "actionButtonInformation",
+  "actionButtonMovie",
+  "actionButtonReturn",
+  "actionButtonSound",
+  "arc",
+  "bentArrow",
+  "bentConnector2",
+  "bentConnector3",
+  "bentConnector4",
+  "bentConnector5",
+  "bentUpArrow",
+  "bevel",
+  "blockArc",
+  "borderCallout1",
+  "borderCallout2",
+  "borderCallout3",
+  "bracePair",
+  "bracketPair",
+  "callout1",
+  "callout2",
+  "callout3",
+  "can",
+  "chartPlus",
+  "chartStar",
+  "chartX",
+  "chevron",
+  "chord",
+  "circularArrow",
+  "cloud",
+  "cloudCallout",
+  "corner",
+  "cornerTabs",
+  "cube",
+  "curvedConnector2",
+  "curvedConnector3",
+  "curvedConnector4",
+  "curvedConnector5",
+  "curvedDownArrow",
+  "curvedLeftArrow",
+  "curvedRightArrow",
+  "curvedUpArrow",
+  "decagon",
+  "diagStripe",
+  "diamond",
+  "dodecagon",
+  "donut",
+  "doubleWave",
+  "downArrow",
+  "downArrowCallout",
+  "ellipse",
+  "ellipseRibbon",
+  "ellipseRibbon2",
+  "flowChartAlternateProcess",
+  "flowChartCollate",
+  "flowChartConnector",
+  "flowChartDecision",
+  "flowChartDelay",
+  "flowChartDisplay",
+  "flowChartDocument",
+  "flowChartExtract",
+  "flowChartInputOutput",
+  "flowChartInternalStorage",
+  "flowChartMagneticDisk",
+  "flowChartMagneticDrum",
+  "flowChartMagneticTape",
+  "flowChartManualInput",
+  "flowChartManualOperation",
+  "flowChartMerge",
+  "flowChartMultidocument",
+  "flowChartOfflineStorage",
+  "flowChartOffpageConnector",
+  "flowChartOnlineStorage",
+  "flowChartOr",
+  "flowChartPredefinedProcess",
+  "flowChartPreparation",
+  "flowChartProcess",
+  "flowChartPunchedCard",
+  "flowChartPunchedTape",
+  "flowChartSort",
+  "flowChartSummingJunction",
+  "flowChartTerminator",
+  "foldedCorner",
+  "frame",
+  "funnel",
+  "gear6",
+  "gear9",
+  "halfFrame",
+  "heart",
+  "heptagon",
+  "hexagon",
+  "homePlate",
+  "horizontalScroll",
+  "irregularSeal1",
+  "irregularSeal2",
+  "leftArrow",
+  "leftArrowCallout",
+  "leftBrace",
+  "leftBracket",
+  "leftCircularArrow",
+  "leftRightArrow",
+  "leftRightArrowCallout",
+  "leftRightCircularArrow",
+  "leftRightRibbon",
+  "leftRightUpArrow",
+  "leftUpArrow",
+  "lightningBolt",
+  "line",
+  "lineInv",
+  "mathDivide",
+  "mathEqual",
+  "mathMinus",
+  "mathMultiply",
+  "mathNotEqual",
+  "mathPlus",
+  "moon",
+  "nonIsoscelesTrapezoid",
+  "noSmoking",
+  "notchedRightArrow",
+  "octagon",
+  "parallelogram",
+  "pentagon",
+  "pie",
+  "pieWedge",
+  "plaque",
+  "plaqueTabs",
+  "plus",
+  "quadArrow",
+  "quadArrowCallout",
+  "rect",
+  "ribbon",
+  "ribbon2",
+  "rightArrow",
+  "rightArrowCallout",
+  "rightBrace",
+  "rightBracket",
+  "round1Rect",
+  "round2DiagRect",
+  "round2SameRect",
+  "roundRect",
+  "rtTriangle",
+  "smileyFace",
+  "snip1Rect",
+  "snip2DiagRect",
+  "snip2SameRect",
+  "snipRoundRect",
+  "squareTabs",
+  "star10",
+  "star12",
+  "star16",
+  "star24",
+  "star32",
+  "star4",
+  "star5",
+  "star6",
+  "star7",
+  "star8",
+  "straightConnector1",
+  "stripedRightArrow",
+  "sun",
+  "swooshArrow",
+  "teardrop",
+  "trapezoid",
+  "triangle",
+  "upArrow",
+  "upArrowCallout",
+  "upDownArrow",
+  "upDownArrowCallout",
+  "uturnArrow",
+  "verticalScroll",
+  "wave",
+  "wedgeEllipseCallout",
+  "wedgeRectCallout",
+  "wedgeRoundRectCallout"
+]);
+function isPresetGeometrySupported(preset) {
+  return Boolean(preset && SUPPORTED_PRESET_GEOMETRIES.has(preset));
 }
+const KAPPA = 0.5522847498307936;
 function polygon(points) {
   const segments = [];
   points.forEach(([px, py], index) => {
@@ -14861,6 +15008,14 @@ function polygon(points) {
   segments.push({ type: "close" });
   return segments;
 }
+function rectSegments(x, y, width, height) {
+  return polygon([
+    [x, y],
+    [x + width, y],
+    [x + width, y + height],
+    [x, y + height]
+  ]);
+}
 function ellipseSegments(cx, cy, rx, ry) {
   const ox = rx * KAPPA;
   const oy = ry * KAPPA;
@@ -14905,6 +15060,50 @@ function ellipseSegments(cx, cy, rx, ry) {
     { type: "close" }
   ];
 }
+function pointOnEllipse(cx, cy, rx, ry, degrees) {
+  const radians = degrees * Math.PI / 180;
+  return [cx + Math.cos(radians) * rx, cy + Math.sin(radians) * ry];
+}
+function arcSegments(cx, cy, rx, ry, start, end) {
+  const steps = Math.max(4, Math.ceil(Math.abs(end - start) / 30));
+  const points = Array.from(
+    { length: steps + 1 },
+    (_, index) => pointOnEllipse(cx, cy, rx, ry, start + (end - start) * index / steps)
+  );
+  return points.map(
+    ([px, py], index) => index === 0 ? { type: "move", x: px, y: py } : { type: "line", x: px, y: py }
+  );
+}
+function pieSegments(cx, cy, rx, ry, start, end) {
+  return [
+    { type: "move", x: cx, y: cy },
+    ...arcSegments(cx, cy, rx, ry, start, end).slice(1),
+    { type: "close" }
+  ];
+}
+function regularPolygon(cx, cy, rx, ry, sides, startDegrees) {
+  const points = Array.from(
+    { length: sides },
+    (_, index) => pointOnEllipse(cx, cy, rx, ry, startDegrees + 360 * index / sides)
+  );
+  return polygon(points);
+}
+function starPointCount(preset) {
+  return Number.parseInt(preset.replace("star", ""), 10);
+}
+function starSegments(cx, cy, rx, ry, points, innerRatio = 0.45) {
+  const vertices = Array.from({ length: points * 2 }, (_, index) => {
+    const radius = index % 2 === 0 ? 1 : innerRatio;
+    return pointOnEllipse(
+      cx,
+      cy,
+      rx * radius,
+      ry * radius,
+      -90 + 180 * index / points
+    );
+  });
+  return polygon(vertices);
+}
 function roundRectSegments(x, y, width, height, radius) {
   const r = Math.min(radius, width / 2, height / 2);
   const right = x + width;
@@ -14947,6 +15146,1163 @@ function roundRectSegments(x, y, width, height, radius) {
     { type: "close" }
   ];
 }
+function mixedRectSegments(x, y, width, height, tl, tr, br, bl) {
+  return snipRoundRectLikeSegments(x, y, width, height, {
+    tlRound: tl,
+    trRound: tr,
+    brRound: br,
+    blRound: bl
+  });
+}
+function snipRoundRectSegments(x, y, width, height) {
+  return snipRoundRectLikeSegments(x, y, width, height, {
+    tlSnip: true,
+    brRound: true
+  });
+}
+function snipRectSegments(x, y, width, height, tl, tr, br, bl) {
+  return snipRoundRectLikeSegments(x, y, width, height, {
+    tlSnip: tl,
+    trSnip: tr,
+    brSnip: br,
+    blSnip: bl
+  });
+}
+function snipRoundRectLikeSegments(x, y, width, height, corners) {
+  const r = Math.min(width, height) * 0.16;
+  const right = x + width;
+  const bottom = y + height;
+  const points = [
+    [x + (corners.tlSnip || corners.tlRound ? r : 0), y],
+    [right - (corners.trSnip || corners.trRound ? r : 0), y],
+    [right, y + (corners.trSnip || corners.trRound ? r : 0)],
+    [right, bottom - (corners.brSnip || corners.brRound ? r : 0)],
+    [right - (corners.brSnip || corners.brRound ? r : 0), bottom],
+    [x + (corners.blSnip || corners.blRound ? r : 0), bottom],
+    [x, bottom - (corners.blSnip || corners.blRound ? r : 0)],
+    [x, y + (corners.tlSnip || corners.tlRound ? r : 0)]
+  ];
+  return polygon(points);
+}
+function arrowSegments(key, x, y, width, height) {
+  const right = x + width;
+  const bottom = y + height;
+  const cx = x + width / 2;
+  const cy = y + height / 2;
+  if (key === "upDownArrow")
+    return polygon([
+      [cx, y],
+      [right, y + height * 0.28],
+      [x + width * 0.62, y + height * 0.28],
+      [x + width * 0.62, y + height * 0.72],
+      [right, y + height * 0.72],
+      [cx, bottom],
+      [x, y + height * 0.72],
+      [x + width * 0.38, y + height * 0.72],
+      [x + width * 0.38, y + height * 0.28],
+      [x, y + height * 0.28]
+    ]);
+  if (key === "leftRightArrow" || key === "leftRightUpArrow")
+    return polygon([
+      [x, cy],
+      [x + width * 0.24, y],
+      [x + width * 0.24, y + height * 0.32],
+      [x + width * 0.76, y + height * 0.32],
+      [x + width * 0.76, y],
+      [right, cy],
+      [x + width * 0.76, bottom],
+      [x + width * 0.76, y + height * 0.68],
+      [x + width * 0.24, y + height * 0.68],
+      [x + width * 0.24, bottom]
+    ]);
+  if (key === "quadArrow")
+    return starSegments(cx, cy, width * 0.5, height * 0.5, 4, 0.38);
+  if (key === "leftArrow" || key === "leftCircularArrow")
+    return polygon([
+      [x, cy],
+      [x + width * 0.38, y],
+      [x + width * 0.38, y + height * 0.28],
+      [right, y + height * 0.28],
+      [right, y + height * 0.72],
+      [x + width * 0.38, y + height * 0.72],
+      [x + width * 0.38, bottom]
+    ]);
+  if (key === "upArrow" || key === "bentUpArrow" || key === "curvedUpArrow")
+    return polygon([
+      [cx, y],
+      [right, y + height * 0.38],
+      [x + width * 0.68, y + height * 0.38],
+      [x + width * 0.68, bottom],
+      [x + width * 0.32, bottom],
+      [x + width * 0.32, y + height * 0.38],
+      [x, y + height * 0.38]
+    ]);
+  if (key === "downArrow" || key === "curvedDownArrow")
+    return polygon([
+      [x + width * 0.32, y],
+      [x + width * 0.68, y],
+      [x + width * 0.68, y + height * 0.62],
+      [right, y + height * 0.62],
+      [cx, bottom],
+      [x, y + height * 0.62],
+      [x + width * 0.32, y + height * 0.62]
+    ]);
+  if (key === "circularArrow" || key === "leftRightCircularArrow")
+    return blockArcSegments(cx, cy, width / 2, height / 2);
+  if (key === "uturnArrow")
+    return polygon([
+      [x + width * 0.2, bottom],
+      [x + width * 0.2, y + height * 0.35],
+      [x + width * 0.62, y + height * 0.35],
+      [x + width * 0.62, y],
+      [right, y + height * 0.5],
+      [x + width * 0.62, bottom],
+      [x + width * 0.62, y + height * 0.65],
+      [x + width * 0.38, y + height * 0.65],
+      [x + width * 0.38, bottom]
+    ]);
+  if (key === "notchedRightArrow")
+    return polygon([
+      [x, y],
+      [right - width * 0.28, y],
+      [right, cy],
+      [right - width * 0.28, bottom],
+      [x, bottom],
+      [x + width * 0.18, cy]
+    ]);
+  if (key === "stripedRightArrow")
+    return polygon([
+      [x + width * 0.16, y],
+      [right - width * 0.28, y],
+      [right, cy],
+      [right - width * 0.28, bottom],
+      [x + width * 0.16, bottom],
+      [x + width * 0.34, cy]
+    ]);
+  return polygon([
+    [x, y + height * 0.28],
+    [right - width * 0.38, y + height * 0.28],
+    [right - width * 0.38, y],
+    [right, cy],
+    [right - width * 0.38, bottom],
+    [right - width * 0.38, y + height * 0.72],
+    [x, y + height * 0.72]
+  ]);
+}
+function calloutSegments(key, x, y, width, height) {
+  if (key.startsWith("wedgeEllipse")) {
+    return [
+      ...ellipseSegments(
+        x + width / 2,
+        y + height / 2,
+        width / 2,
+        height * 0.42
+      ),
+      { type: "move", x: x + width * 0.55, y: y + height * 0.82 },
+      { type: "line", x: x + width * 0.24, y: y + height },
+      { type: "line", x: x + width * 0.45, y: y + height * 0.75 }
+    ];
+  }
+  const r = key.startsWith("wedgeRound") ? Math.min(width, height) * 0.08 : 0;
+  const body = r > 0 ? roundRectSegments(x, y, width, height * 0.82, r) : rectSegments(x, y, width, height * 0.82);
+  return [
+    ...body,
+    { type: "move", x: x + width * 0.58, y: y + height * 0.82 },
+    { type: "line", x: x + width * 0.26, y: y + height },
+    { type: "line", x: x + width * 0.44, y: y + height * 0.82 },
+    { type: "close" }
+  ];
+}
+function connectorSegments(key, x, y, width, height) {
+  const right = x + width;
+  const bottom = y + height;
+  if (key.startsWith("curved")) {
+    return [
+      { type: "move", x, y },
+      {
+        type: "cubic",
+        x1: x + width * 0.7,
+        y1: y,
+        x2: x + width * 0.3,
+        y2: bottom,
+        x: right,
+        y: bottom
+      }
+    ];
+  }
+  if (key === "bentConnector2")
+    return [
+      { type: "move", x, y },
+      { type: "line", x: right, y: bottom }
+    ];
+  if (key === "bentConnector3")
+    return [
+      { type: "move", x, y },
+      { type: "line", x: right, y },
+      { type: "line", x: right, y: bottom }
+    ];
+  if (key === "bentConnector4")
+    return [
+      { type: "move", x, y },
+      { type: "line", x: x + width * 0.5, y },
+      { type: "line", x: x + width * 0.5, y: bottom },
+      { type: "line", x: right, y: bottom }
+    ];
+  if (key === "bentConnector5")
+    return [
+      { type: "move", x, y },
+      { type: "line", x: x + width * 0.34, y },
+      { type: "line", x: x + width * 0.34, y: bottom },
+      { type: "line", x: x + width * 0.66, y: bottom },
+      { type: "line", x: x + width * 0.66, y },
+      { type: "line", x: right, y }
+    ];
+  return [
+    { type: "move", x, y },
+    { type: "line", x: right, y: bottom }
+  ];
+}
+function flowChartSegments(key, x, y, width, height, resolvePreset) {
+  if (key.includes("Decision"))
+    return resolvePreset("diamond", x, y, width, height);
+  if (key.includes("Connector") || key.includes("SummingJunction") || key.includes("Or")) {
+    return ellipseSegments(
+      x + width / 2,
+      y + height / 2,
+      width / 2,
+      height / 2
+    );
+  }
+  if (key.includes("Terminator")) {
+    return roundRectSegments(
+      x,
+      y,
+      width,
+      height,
+      Math.min(width, height) * 0.28
+    );
+  }
+  if (key.includes("Delay")) {
+    return [
+      ...rectSegments(x, y, width * 0.65, height).slice(0, -1),
+      ...arcSegments(
+        x + width * 0.65,
+        y + height / 2,
+        width * 0.35,
+        height / 2,
+        -90,
+        90
+      ),
+      { type: "close" }
+    ];
+  }
+  if (key.includes("Document")) return waveBottomRect(x, y, width, height);
+  if (key.includes("Data") || key.includes("InputOutput") || key.includes("ManualInput")) {
+    return resolvePreset("parallelogram", x, y, width, height);
+  }
+  if (key.includes("Preparation")) {
+    return resolvePreset("hexagon", x, y, width, height);
+  }
+  if (key.includes("OffpageConnector")) {
+    return resolvePreset("homePlate", x, y, width, height);
+  }
+  if (key.includes("PunchedCard")) {
+    return snipRectSegments(x, y, width, height, true, false, false, false);
+  }
+  if (key.includes("Magnetic")) return canSegments(x, y, width, height);
+  if (key.includes("Collate")) {
+    return polygon([
+      [x, y],
+      [x + width, y],
+      [x, y + height],
+      [x + width, y + height]
+    ]);
+  }
+  if (key.includes("Sort"))
+    return resolvePreset("diamond", x, y, width, height);
+  return rectSegments(x, y, width, height);
+}
+function actionButtonSegments(key, x, y, width, height, resolvePreset) {
+  const base = roundRectSegments(
+    x,
+    y,
+    width,
+    height,
+    Math.min(width, height) * 0.08
+  );
+  if (key === "actionButtonBlank") return base;
+  return [...base, ...symbolSegments(key, x, y, width, height, resolvePreset)];
+}
+function symbolSegments(key, x, y, width, height, resolvePreset) {
+  const cx = x + width / 2;
+  const cy = y + height / 2;
+  if (key.includes("Home"))
+    return polygon([
+      [cx, y + height * 0.25],
+      [x + width * 0.72, cy],
+      [x + width * 0.72, y + height * 0.75],
+      [x + width * 0.28, y + height * 0.75],
+      [x + width * 0.28, cy]
+    ]);
+  if (key.includes("Help")) {
+    return ellipseSegments(cx, cy, width * 0.12, height * 0.12);
+  }
+  if (key.includes("Information")) {
+    return rectSegments(
+      cx - width * 0.04,
+      y + height * 0.34,
+      width * 0.08,
+      height * 0.38
+    );
+  }
+  if (key.includes("Sound"))
+    return polygon([
+      [x + width * 0.3, cy],
+      [x + width * 0.45, y + height * 0.35],
+      [x + width * 0.45, y + height * 0.65]
+    ]);
+  if (key.includes("Back") || key.includes("Beginning") || key.includes("Return")) {
+    return resolvePreset(
+      "leftArrow",
+      x + width * 0.28,
+      y + height * 0.3,
+      width * 0.45,
+      height * 0.4
+    );
+  }
+  return resolvePreset(
+    "rightArrow",
+    x + width * 0.28,
+    y + height * 0.3,
+    width * 0.45,
+    height * 0.4
+  );
+}
+function blockArcSegments(cx, cy, rx, ry) {
+  const outer = arcSegments(cx, cy, rx, ry, -45, 250);
+  const inner = arcSegments(cx, cy, rx * 0.58, ry * 0.58, 250, -45).reverse();
+  return [...outer, ...inner.slice(1), { type: "close" }];
+}
+function plusSegments(x, y, width, height) {
+  return polygon([
+    [x + width * 0.38, y],
+    [x + width * 0.62, y],
+    [x + width * 0.62, y + height * 0.38],
+    [x + width, y + height * 0.38],
+    [x + width, y + height * 0.62],
+    [x + width * 0.62, y + height * 0.62],
+    [x + width * 0.62, y + height],
+    [x + width * 0.38, y + height],
+    [x + width * 0.38, y + height * 0.62],
+    [x, y + height * 0.62],
+    [x, y + height * 0.38],
+    [x + width * 0.38, y + height * 0.38]
+  ]);
+}
+function xSegments(x, y, width, height) {
+  return polygon([
+    [x + width * 0.18, y],
+    [x + width * 0.5, y + height * 0.32],
+    [x + width * 0.82, y],
+    [x + width, y + height * 0.18],
+    [x + width * 0.68, y + height * 0.5],
+    [x + width, y + height * 0.82],
+    [x + width * 0.82, y + height],
+    [x + width * 0.5, y + height * 0.68],
+    [x + width * 0.18, y + height],
+    [x, y + height * 0.82],
+    [x + width * 0.32, y + height * 0.5],
+    [x, y + height * 0.18]
+  ]);
+}
+function mathDivideSegments(x, y, width, height) {
+  return [
+    ...ellipseSegments(
+      x + width / 2,
+      y + height * 0.22,
+      width * 0.07,
+      height * 0.07
+    ),
+    ...rectSegments(
+      x + width * 0.18,
+      y + height * 0.46,
+      width * 0.64,
+      height * 0.08
+    ),
+    ...ellipseSegments(
+      x + width / 2,
+      y + height * 0.78,
+      width * 0.07,
+      height * 0.07
+    )
+  ];
+}
+function mathEqualSegments(x, y, width, height) {
+  return [
+    ...rectSegments(x, y + height * 0.3, width, height * 0.12),
+    ...rectSegments(x, y + height * 0.58, width, height * 0.12)
+  ];
+}
+function mathNotEqualSegments(x, y, width, height) {
+  return [
+    ...mathEqualSegments(x, y, width, height),
+    ...polygon([
+      [x + width * 0.62, y],
+      [x + width * 0.74, y],
+      [x + width * 0.38, y + height],
+      [x + width * 0.26, y + height]
+    ])
+  ];
+}
+function heartSegments(x, y, width, height) {
+  const cx = x + width / 2;
+  return [
+    { type: "move", x: cx, y: y + height * 0.9 },
+    {
+      type: "cubic",
+      x1: x - width * 0.12,
+      y1: y + height * 0.45,
+      x2: x + width * 0.08,
+      y2: y,
+      x: cx,
+      y: y + height * 0.28
+    },
+    {
+      type: "cubic",
+      x1: x + width * 0.92,
+      y1: y,
+      x2: x + width * 1.12,
+      y2: y + height * 0.45,
+      x: cx,
+      y: y + height * 0.9
+    },
+    { type: "close" }
+  ];
+}
+function cloudSegments(x, y, width, height) {
+  return [
+    ...ellipseSegments(
+      x + width * 0.28,
+      y + height * 0.58,
+      width * 0.24,
+      height * 0.23
+    ),
+    ...ellipseSegments(
+      x + width * 0.48,
+      y + height * 0.42,
+      width * 0.28,
+      height * 0.28
+    ),
+    ...ellipseSegments(
+      x + width * 0.7,
+      y + height * 0.58,
+      width * 0.25,
+      height * 0.24
+    )
+  ];
+}
+function moonSegments(x, y, width, height) {
+  return [
+    { type: "move", x: x + width * 0.68, y },
+    {
+      type: "cubic",
+      x1: x + width * 0.22,
+      y1: y + height * 0.06,
+      x2: x + width * 0.18,
+      y2: y + height * 0.94,
+      x: x + width * 0.68,
+      y: y + height
+    },
+    {
+      type: "cubic",
+      x1: x + width * 0.42,
+      y1: y + height * 0.72,
+      x2: x + width * 0.42,
+      y2: y + height * 0.28,
+      x: x + width * 0.68,
+      y
+    },
+    { type: "close" }
+  ];
+}
+function smileySegments(x, y, width, height) {
+  return [
+    ...ellipseSegments(x + width / 2, y + height / 2, width / 2, height / 2),
+    ...ellipseSegments(
+      x + width * 0.35,
+      y + height * 0.38,
+      width * 0.05,
+      height * 0.05
+    ),
+    ...ellipseSegments(
+      x + width * 0.65,
+      y + height * 0.38,
+      width * 0.05,
+      height * 0.05
+    ),
+    ...arcSegments(
+      x + width / 2,
+      y + height * 0.52,
+      width * 0.24,
+      height * 0.18,
+      20,
+      160
+    )
+  ];
+}
+function teardropSegments(x, y, width, height) {
+  return [
+    { type: "move", x: x + width * 0.55, y },
+    {
+      type: "cubic",
+      x1: x + width,
+      y1: y + height * 0.22,
+      x2: x + width * 0.95,
+      y2: y + height,
+      x: x + width * 0.35,
+      y: y + height
+    },
+    {
+      type: "cubic",
+      x1: x - width * 0.1,
+      y1: y + height * 0.66,
+      x2: x + width * 0.16,
+      y2: y + height * 0.12,
+      x: x + width * 0.55,
+      y
+    },
+    { type: "close" }
+  ];
+}
+function noSmokingSegments(x, y, width, height) {
+  return [
+    ...ellipseSegments(x + width / 2, y + height / 2, width / 2, height / 2),
+    ...polygon([
+      [x + width * 0.18, y + height * 0.1],
+      [x + width * 0.28, y],
+      [x + width * 0.82, y + height * 0.9],
+      [x + width * 0.72, y + height]
+    ])
+  ];
+}
+function donutSegments(cx, cy, rx, ry) {
+  return [
+    ...ellipseSegments(cx, cy, rx, ry),
+    ...ellipseSegments(cx, cy, rx * 0.52, ry * 0.52)
+  ];
+}
+function canSegments(x, y, width, height) {
+  return [
+    ...rectSegments(x, y + height * 0.14, width, height * 0.72),
+    ...ellipseSegments(
+      x + width / 2,
+      y + height * 0.14,
+      width / 2,
+      height * 0.14
+    ),
+    ...arcSegments(
+      x + width / 2,
+      y + height * 0.86,
+      width / 2,
+      height * 0.14,
+      0,
+      180
+    )
+  ];
+}
+function cubeSegments(x, y, width, height) {
+  return polygon([
+    [x + width * 0.22, y],
+    [x + width, y],
+    [x + width, y + height * 0.78],
+    [x + width * 0.78, y + height],
+    [x, y + height],
+    [x, y + height * 0.22]
+  ]);
+}
+function bevelSegments(x, y, width, height) {
+  const inset = Math.min(width, height) * 0.16;
+  return polygon([
+    [x + inset, y],
+    [x + width - inset, y],
+    [x + width, y + inset],
+    [x + width, y + height - inset],
+    [x + width - inset, y + height],
+    [x + inset, y + height],
+    [x, y + height - inset],
+    [x, y + inset]
+  ]);
+}
+function foldedCornerSegments(x, y, width, height) {
+  return polygon([
+    [x, y],
+    [x + width * 0.78, y],
+    [x + width, y + height * 0.22],
+    [x + width, y + height],
+    [x, y + height]
+  ]);
+}
+function frameSegments(x, y, width, height) {
+  return [
+    ...rectSegments(x, y, width, height),
+    ...rectSegments(
+      x + width * 0.18,
+      y + height * 0.18,
+      width * 0.64,
+      height * 0.64
+    )
+  ];
+}
+function halfFrameSegments(x, y, width, height) {
+  return polygon([
+    [x, y],
+    [x + width, y],
+    [x + width, y + height * 0.22],
+    [x + width * 0.22, y + height * 0.22],
+    [x + width * 0.22, y + height],
+    [x, y + height]
+  ]);
+}
+function cornerSegments(x, y, width, height) {
+  return polygon([
+    [x, y],
+    [x + width, y],
+    [x + width, y + height * 0.22],
+    [x + width * 0.22, y + height * 0.22],
+    [x + width * 0.22, y + height],
+    [x, y + height]
+  ]);
+}
+function plaqueSegments(x, y, width, height) {
+  return polygon([
+    [x + width * 0.18, y],
+    [x + width * 0.82, y],
+    [x + width, y + height * 0.18],
+    [x + width, y + height * 0.82],
+    [x + width * 0.82, y + height],
+    [x + width * 0.18, y + height],
+    [x, y + height * 0.82],
+    [x, y + height * 0.18]
+  ]);
+}
+function tabbedRectSegments(key, x, y, width, height) {
+  const tab = Math.min(width, height) * 0.18;
+  if (key === "cornerTabs")
+    return polygon([
+      [x, y + tab],
+      [x + tab, y + tab],
+      [x + tab, y],
+      [x + width - tab, y],
+      [x + width - tab, y + tab],
+      [x + width, y + tab],
+      [x + width, y + height - tab],
+      [x + width - tab, y + height - tab],
+      [x + width - tab, y + height],
+      [x + tab, y + height],
+      [x + tab, y + height - tab],
+      [x, y + height - tab]
+    ]);
+  if (key === "plaqueTabs")
+    return polygon([
+      [x, y + tab],
+      [x + width * 0.35, y + tab],
+      [x + width * 0.35, y],
+      [x + width * 0.65, y],
+      [x + width * 0.65, y + tab],
+      [x + width, y + tab],
+      [x + width, y + height - tab],
+      [x + width * 0.65, y + height - tab],
+      [x + width * 0.65, y + height],
+      [x + width * 0.35, y + height],
+      [x + width * 0.35, y + height - tab],
+      [x, y + height - tab]
+    ]);
+  return polygon([
+    [x + tab, y],
+    [x + width - tab, y],
+    [x + width - tab, y + tab],
+    [x + width, y + tab],
+    [x + width, y + height - tab],
+    [x + width - tab, y + height - tab],
+    [x + width - tab, y + height],
+    [x + tab, y + height],
+    [x + tab, y + height - tab],
+    [x, y + height - tab],
+    [x, y + tab],
+    [x + tab, y + tab]
+  ]);
+}
+function braceSegments(key, x, y, width, height) {
+  if (key === "rightBrace")
+    return [
+      { type: "move", x, y },
+      {
+        type: "cubic",
+        x1: x + width,
+        y1: y,
+        x2: x,
+        y2: y + height * 0.5,
+        x: x + width,
+        y: y + height * 0.5
+      },
+      {
+        type: "cubic",
+        x1: x,
+        y1: y + height * 0.5,
+        x2: x + width,
+        y2: y + height,
+        x,
+        y: y + height
+      }
+    ];
+  if (key === "bracePair")
+    return [
+      ...braceSegments("leftBrace", x, y, width * 0.45, height),
+      ...braceSegments("rightBrace", x + width * 0.55, y, width * 0.45, height)
+    ];
+  return [
+    { type: "move", x: x + width, y },
+    {
+      type: "cubic",
+      x1: x,
+      y1: y,
+      x2: x + width,
+      y2: y + height * 0.5,
+      x,
+      y: y + height * 0.5
+    },
+    {
+      type: "cubic",
+      x1: x + width,
+      y1: y + height * 0.5,
+      x2: x,
+      y2: y + height,
+      x: x + width,
+      y: y + height
+    }
+  ];
+}
+function bracketSegments(key, x, y, width, height) {
+  if (key === "rightBracket")
+    return [
+      { type: "move", x, y },
+      { type: "line", x: x + width, y },
+      { type: "line", x: x + width, y: y + height },
+      { type: "line", x, y: y + height }
+    ];
+  if (key === "bracketPair")
+    return [
+      ...bracketSegments("leftBracket", x, y, width * 0.45, height),
+      ...bracketSegments(
+        "rightBracket",
+        x + width * 0.55,
+        y,
+        width * 0.45,
+        height
+      )
+    ];
+  return [
+    { type: "move", x: x + width, y },
+    { type: "line", x, y },
+    { type: "line", x, y: y + height },
+    { type: "line", x: x + width, y: y + height }
+  ];
+}
+function ribbonSegments(key, x, y, width, height) {
+  const mid = y + height * 0.5;
+  if (key.includes("Ellipse"))
+    return [
+      ...ellipseSegments(x + width / 2, mid, width * 0.42, height * 0.28),
+      ...polygon([
+        [x, mid],
+        [x + width * 0.18, y + height * 0.3],
+        [x + width * 0.18, y + height * 0.7]
+      ]),
+      ...polygon([
+        [x + width, mid],
+        [x + width * 0.82, y + height * 0.3],
+        [x + width * 0.82, y + height * 0.7]
+      ])
+    ];
+  return polygon([
+    [x, y + height * 0.25],
+    [x + width, y + height * 0.25],
+    [x + width * 0.82, mid],
+    [x + width, y + height * 0.75],
+    [x, y + height * 0.75],
+    [x + width * 0.18, mid]
+  ]);
+}
+function scrollSegments(key, x, y, width, height) {
+  if (key === "horizontalScroll")
+    return [
+      ...rectSegments(
+        x + width * 0.1,
+        y + height * 0.2,
+        width * 0.8,
+        height * 0.6
+      ),
+      ...ellipseSegments(
+        x + width * 0.1,
+        y + height * 0.5,
+        width * 0.1,
+        height * 0.3
+      ),
+      ...ellipseSegments(
+        x + width * 0.9,
+        y + height * 0.5,
+        width * 0.1,
+        height * 0.3
+      )
+    ];
+  return [
+    ...rectSegments(
+      x + width * 0.2,
+      y + height * 0.1,
+      width * 0.6,
+      height * 0.8
+    ),
+    ...ellipseSegments(
+      x + width * 0.5,
+      y + height * 0.1,
+      width * 0.3,
+      height * 0.1
+    ),
+    ...ellipseSegments(
+      x + width * 0.5,
+      y + height * 0.9,
+      width * 0.3,
+      height * 0.1
+    )
+  ];
+}
+function waveSegments(key, x, y, width, height) {
+  const first = [
+    { type: "move", x, y: y + height * 0.5 },
+    {
+      type: "cubic",
+      x1: x + width * 0.25,
+      y1: y,
+      x2: x + width * 0.25,
+      y2: y + height,
+      x: x + width * 0.5,
+      y: y + height * 0.5
+    },
+    {
+      type: "cubic",
+      x1: x + width * 0.75,
+      y1: y,
+      x2: x + width * 0.75,
+      y2: y + height,
+      x: x + width,
+      y: y + height * 0.5
+    }
+  ];
+  return key === "doubleWave" ? [
+    ...first,
+    ...first.map(
+      (segment) => "y" in segment ? { ...segment, y: segment.y + height * 0.18 } : segment
+    )
+  ] : first;
+}
+function waveBottomRect(x, y, width, height) {
+  return [
+    { type: "move", x, y },
+    { type: "line", x: x + width, y },
+    { type: "line", x: x + width, y: y + height * 0.82 },
+    {
+      type: "cubic",
+      x1: x + width * 0.75,
+      y1: y + height,
+      x2: x + width * 0.25,
+      y2: y + height * 0.64,
+      x,
+      y: y + height * 0.82
+    },
+    { type: "close" }
+  ];
+}
+function resolvePresetPathSegments(preset, x, y, width, height) {
+  const right = x + width;
+  const bottom = y + height;
+  const cx = x + width / 2;
+  const cy = y + height / 2;
+  if (/Connector\d$/.test(preset) || preset === "straightConnector1") {
+    return connectorSegments(preset, x, y, width, height);
+  }
+  if (/Callout\d$/.test(preset) || /Callout$/.test(preset)) {
+    return calloutSegments(preset, x, y, width, height);
+  }
+  if (/Arrow/.test(preset) || preset === "swooshArrow") {
+    return arrowSegments(preset, x, y, width, height);
+  }
+  if (/^star\d+$/.test(preset)) {
+    return starSegments(
+      cx,
+      cy,
+      width * 0.48,
+      height * 0.48,
+      starPointCount(preset)
+    );
+  }
+  if (/^flowChart/.test(preset)) {
+    return flowChartSegments(
+      preset,
+      x,
+      y,
+      width,
+      height,
+      resolvePresetPathSegments
+    );
+  }
+  if (/^actionButton/.test(preset)) {
+    return actionButtonSegments(
+      preset,
+      x,
+      y,
+      width,
+      height,
+      resolvePresetPathSegments
+    );
+  }
+  switch (preset) {
+    case "line":
+      return [
+        { type: "move", x, y },
+        { type: "line", x: right, y: bottom }
+      ];
+    case "lineInv":
+      return [
+        { type: "move", x, y: bottom },
+        { type: "line", x: right, y }
+      ];
+    case "arc":
+      return arcSegments(cx, cy, width / 2, height / 2, 200, 340);
+    case "blockArc":
+      return blockArcSegments(cx, cy, width / 2, height / 2);
+    case "chord":
+      return [
+        ...arcSegments(cx, cy, width / 2, height / 2, 210, 330),
+        { type: "close" }
+      ];
+    case "pie":
+      return pieSegments(cx, cy, width / 2, height / 2, -90, 45);
+    case "pieWedge":
+      return pieSegments(cx, cy, width / 2, height / 2, -35, 55);
+    case "roundRect":
+      return roundRectSegments(
+        x,
+        y,
+        width,
+        height,
+        Math.min(width, height) * 0.12
+      );
+    case "round1Rect":
+      return mixedRectSegments(x, y, width, height, true, false, false, false);
+    case "round2SameRect":
+      return mixedRectSegments(x, y, width, height, true, false, true, false);
+    case "round2DiagRect":
+      return mixedRectSegments(x, y, width, height, true, false, false, true);
+    case "snipRoundRect":
+      return snipRoundRectSegments(x, y, width, height);
+    case "snip1Rect":
+      return snipRectSegments(x, y, width, height, true, false, false, false);
+    case "snip2SameRect":
+      return snipRectSegments(x, y, width, height, true, true, false, false);
+    case "snip2DiagRect":
+      return snipRectSegments(x, y, width, height, true, false, true, false);
+    case "ellipse":
+      return ellipseSegments(cx, cy, width / 2, height / 2);
+    case "triangle":
+      return polygon([
+        [cx, y],
+        [right, bottom],
+        [x, bottom]
+      ]);
+    case "rtTriangle":
+      return polygon([
+        [x, y],
+        [x, bottom],
+        [right, bottom]
+      ]);
+    case "diamond":
+      return polygon([
+        [cx, y],
+        [right, cy],
+        [cx, bottom],
+        [x, cy]
+      ]);
+    case "parallelogram":
+      return polygon([
+        [x + width * 0.22, y],
+        [right, y],
+        [right - width * 0.22, bottom],
+        [x, bottom]
+      ]);
+    case "trapezoid":
+      return polygon([
+        [x + width * 0.2, y],
+        [right - width * 0.2, y],
+        [right, bottom],
+        [x, bottom]
+      ]);
+    case "nonIsoscelesTrapezoid":
+      return polygon([
+        [x + width * 0.08, y],
+        [right - width * 0.28, y],
+        [right, bottom],
+        [x, bottom]
+      ]);
+    case "pentagon":
+      return regularPolygon(cx, cy, width * 0.48, height * 0.48, 5, -90);
+    case "hexagon":
+      return regularPolygon(cx, cy, width * 0.48, height * 0.48, 6, 0);
+    case "heptagon":
+      return regularPolygon(cx, cy, width * 0.48, height * 0.48, 7, -90);
+    case "octagon":
+      return regularPolygon(cx, cy, width * 0.48, height * 0.48, 8, 22.5);
+    case "decagon":
+      return regularPolygon(cx, cy, width * 0.48, height * 0.48, 10, -90);
+    case "dodecagon":
+      return regularPolygon(cx, cy, width * 0.48, height * 0.48, 12, -90);
+    case "homePlate":
+      return polygon([
+        [x, y],
+        [right - width * 0.22, y],
+        [right, cy],
+        [right - width * 0.22, bottom],
+        [x, bottom]
+      ]);
+    case "chevron":
+      return polygon([
+        [x, y],
+        [right - width * 0.28, y],
+        [right, cy],
+        [right - width * 0.28, bottom],
+        [x, bottom],
+        [x + width * 0.28, cy]
+      ]);
+    case "heart":
+      return heartSegments(x, y, width, height);
+    case "cloud":
+      return cloudSegments(x, y, width, height);
+    case "sun":
+      return starSegments(cx, cy, width * 0.48, height * 0.48, 16, 0.72);
+    case "moon":
+      return moonSegments(x, y, width, height);
+    case "smileyFace":
+      return smileySegments(x, y, width, height);
+    case "lightningBolt":
+      return polygon([
+        [x + width * 0.58, y],
+        [x + width * 0.28, y + height * 0.44],
+        [x + width * 0.48, y + height * 0.44],
+        [x + width * 0.36, bottom],
+        [x + width * 0.74, y + height * 0.36],
+        [x + width * 0.52, y + height * 0.36]
+      ]);
+    case "teardrop":
+      return teardropSegments(x, y, width, height);
+    case "noSmoking":
+      return noSmokingSegments(x, y, width, height);
+    case "donut":
+      return donutSegments(cx, cy, width / 2, height / 2);
+    case "can":
+      return canSegments(x, y, width, height);
+    case "cube":
+      return cubeSegments(x, y, width, height);
+    case "bevel":
+      return bevelSegments(x, y, width, height);
+    case "foldedCorner":
+      return foldedCornerSegments(x, y, width, height);
+    case "frame":
+      return frameSegments(x, y, width, height);
+    case "halfFrame":
+      return halfFrameSegments(x, y, width, height);
+    case "corner":
+      return cornerSegments(x, y, width, height);
+    case "diagStripe":
+      return polygon([
+        [x + width * 0.25, y],
+        [right, y],
+        [right - width * 0.25, bottom],
+        [x, bottom]
+      ]);
+    case "plaque":
+      return plaqueSegments(x, y, width, height);
+    case "plaqueTabs":
+    case "squareTabs":
+    case "cornerTabs":
+      return tabbedRectSegments(preset, x, y, width, height);
+    case "irregularSeal1":
+      return starSegments(cx, cy, width * 0.48, height * 0.48, 18, 0.78);
+    case "irregularSeal2":
+      return starSegments(cx, cy, width * 0.48, height * 0.48, 14, 0.68);
+    case "gear6":
+      return starSegments(cx, cy, width * 0.48, height * 0.48, 12, 0.76);
+    case "gear9":
+      return starSegments(cx, cy, width * 0.48, height * 0.48, 18, 0.76);
+    case "funnel":
+      return polygon([
+        [x, y],
+        [right, y],
+        [x + width * 0.6, y + height * 0.56],
+        [x + width * 0.6, bottom],
+        [x + width * 0.4, bottom],
+        [x + width * 0.4, y + height * 0.56]
+      ]);
+    case "leftBrace":
+    case "rightBrace":
+    case "bracePair":
+      return braceSegments(preset, x, y, width, height);
+    case "leftBracket":
+    case "rightBracket":
+    case "bracketPair":
+      return bracketSegments(preset, x, y, width, height);
+    case "mathPlus":
+      return plusSegments(x, y, width, height);
+    case "mathMinus":
+      return polygon([
+        [x, y + height * 0.42],
+        [right, y + height * 0.42],
+        [right, y + height * 0.58],
+        [x, y + height * 0.58]
+      ]);
+    case "mathMultiply":
+      return xSegments(x, y, width, height);
+    case "mathDivide":
+      return mathDivideSegments(x, y, width, height);
+    case "mathEqual":
+      return mathEqualSegments(x, y, width, height);
+    case "mathNotEqual":
+      return mathNotEqualSegments(x, y, width, height);
+    case "chartPlus":
+      return plusSegments(x, y, width, height);
+    case "chartX":
+      return xSegments(x, y, width, height);
+    case "chartStar":
+      return starSegments(cx, cy, width * 0.48, height * 0.48, 5);
+    case "ribbon":
+    case "ribbon2":
+    case "ellipseRibbon":
+    case "ellipseRibbon2":
+    case "leftRightRibbon":
+      return ribbonSegments(preset, x, y, width, height);
+    case "verticalScroll":
+    case "horizontalScroll":
+      return scrollSegments(preset, x, y, width, height);
+    case "wave":
+    case "doubleWave":
+      return waveSegments(preset, x, y, width, height);
+    case "rect":
+    default:
+      return rectSegments(x, y, width, height);
+  }
+}
+function getPresetPathSegments(preset, x, y, width, height) {
+  const key = isPresetGeometrySupported(preset) ? preset : "rect";
+  return resolvePresetPathSegments(key, x, y, width, height);
+}
 function buildPresetPath(preset, x, y, width, height) {
   const path = new Path2D();
   for (const segment of getPresetPathSegments(preset, x, y, width, height)) {
@@ -32066,10 +33422,6 @@ async function parseTextBox(drawing, parseNestedBlocks) {
   if (!wsp) {
     return void 0;
   }
-  const txbxContent = findElementDeep(wsp, "txbxContent");
-  if (!txbxContent) {
-    return void 0;
-  }
   const container = findDrawingContainer(drawing);
   const drawingBox = (container == null ? void 0 : container.element) ?? drawing;
   const extent = findElementDeep(drawingBox, "extent");
@@ -32079,7 +33431,8 @@ async function parseTextBox(drawing, parseNestedBlocks) {
   const name = docPr ? getAttributeValue(docPr, "name") : null;
   const alt = docPr ? getAttributeValue(docPr, "descr") ?? getAttributeValue(docPr, "title") : null;
   const floating = (container == null ? void 0 : container.kind) === "anchor" ? parseFloatingLayout(container.element) : void 0;
-  const blocks = parseNestedBlocks ? await parseNestedBlocks(txbxContent) : [];
+  const txbxContent = findElementDeep(wsp, "txbxContent");
+  const blocks = txbxContent && parseNestedBlocks ? await parseNestedBlocks(txbxContent) : [];
   const shape = parseTextBoxShape(wsp);
   const body = parseTextBoxBody(wsp);
   const rotation = parseTextBoxRotation(wsp);
@@ -34437,7 +35790,7 @@ function importDocxInWorker(buffer, options = {}) {
     const worker = new Worker(
       new URL(
         /* @vite-ignore */
-        "" + new URL("assets/importDocxWorker-D4P4_drI.js", import.meta.url).href,
+        "" + new URL("assets/importDocxWorker-DcrboJNQ.js", import.meta.url).href,
         import.meta.url
       ),
       {