@bigbluebutton/tldraw 2.0.0-alpha.19

package/dist-esm/lib/shapes/shared/freehand/setStrokePointRadii.mjs

@@ -0,0 +1,81 @@
+import { EASINGS } from "@bigbluebutton/editor";
+const { min } = Math;
+const RATE_OF_PRESSURE_CHANGE = 0.275;
+function setStrokePointRadii(strokePoints, options) {
+  const {
+    size = 16,
+    thinning = 0.5,
+    simulatePressure = true,
+    easing = (t) => t,
+    start = {},
+    end = {}
+  } = options;
+  const { easing: taperStartEase = EASINGS.easeOutQuad } = start;
+  const { easing: taperEndEase = EASINGS.easeOutCubic } = end;
+  const totalLength = strokePoints[strokePoints.length - 1].runningLength;
+  let firstRadius;
+  let prevPressure = strokePoints[0].pressure;
+  let strokePoint;
+  if (!simulatePressure && totalLength < size) {
+    const max = strokePoints.reduce((max2, curr) => Math.max(max2, curr.pressure), 0.5);
+    strokePoints.forEach((sp) => {
+      sp.pressure = max;
+      sp.radius = size * easing(0.5 - thinning * (0.5 - sp.pressure));
+    });
+    return strokePoints;
+  } else {
+    let p;
+    for (let i = 0, n = strokePoints.length; i < n; i++) {
+      strokePoint = strokePoints[i];
+      if (strokePoint.runningLength > size * 5)
+        break;
+      const sp = min(1, strokePoint.distance / size);
+      if (simulatePressure) {
+        const rp = min(1, 1 - sp);
+        p = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE));
+      } else {
+        p = min(1, prevPressure + (strokePoint.pressure - prevPressure) * 0.5);
+      }
+      prevPressure = prevPressure + (p - prevPressure) * 0.5;
+    }
+    for (let i = 0; i < strokePoints.length; i++) {
+      strokePoint = strokePoints[i];
+      if (thinning) {
+        let { pressure } = strokePoint;
+        const sp = min(1, strokePoint.distance / size);
+        if (simulatePressure) {
+          const rp = min(1, 1 - sp);
+          pressure = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE));
+        } else {
+          pressure = min(
+            1,
+            prevPressure + (pressure - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE)
+          );
+        }
+        strokePoint.radius = size * easing(0.5 - thinning * (0.5 - pressure));
+        prevPressure = pressure;
+      } else {
+        strokePoint.radius = size / 2;
+      }
+      if (firstRadius === void 0) {
+        firstRadius = strokePoint.radius;
+      }
+    }
+  }
+  const taperStart = start.taper === false ? 0 : start.taper === true ? Math.max(size, totalLength) : start.taper;
+  const taperEnd = end.taper === false ? 0 : end.taper === true ? Math.max(size, totalLength) : end.taper;
+  if (taperStart || taperEnd) {
+    for (let i = 0; i < strokePoints.length; i++) {
+      strokePoint = strokePoints[i];
+      const { runningLength } = strokePoint;
+      const ts = runningLength < taperStart ? taperStartEase(runningLength / taperStart) : 1;
+      const te = totalLength - runningLength < taperEnd ? taperEndEase((totalLength - runningLength) / taperEnd) : 1;
+      strokePoint.radius = Math.max(0.01, strokePoint.radius * Math.min(ts, te));
+    }
+  }
+  return strokePoints;
+}
+export {
+  setStrokePointRadii
+};
+//# sourceMappingURL=setStrokePointRadii.mjs.map

package/dist-esm/lib/shapes/shared/freehand/setStrokePointRadii.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/setStrokePointRadii.ts"],
+  "sourcesContent": ["import { EASINGS } from '@bigbluebutton/editor'\nimport { StrokeOptions, StrokePoint } from './types'\n\nconst { min } = Math\n\n// This is the rate of change for simulated pressure. It could be an option.\nconst RATE_OF_PRESSURE_CHANGE = 0.275\n\n/** @public */\nexport function setStrokePointRadii(strokePoints: StrokePoint[], options: StrokeOptions) {\n\tconst {\n\t\tsize = 16,\n\t\tthinning = 0.5,\n\t\tsimulatePressure = true,\n\t\teasing = (t) => t,\n\t\tstart = {},\n\t\tend = {},\n\t} = options\n\n\tconst { easing: taperStartEase = EASINGS.easeOutQuad } = start\n\tconst { easing: taperEndEase = EASINGS.easeOutCubic } = end\n\n\tconst totalLength = strokePoints[strokePoints.length - 1].runningLength\n\n\tlet firstRadius: number | undefined\n\tlet prevPressure = strokePoints[0].pressure\n\tlet strokePoint: StrokePoint\n\n\tif (!simulatePressure && totalLength < size) {\n\t\tconst max = strokePoints.reduce((max, curr) => Math.max(max, curr.pressure), 0.5)\n\t\tstrokePoints.forEach((sp) => {\n\t\t\tsp.pressure = max\n\t\t\tsp.radius = size * easing(0.5 - thinning * (0.5 - sp.pressure))\n\t\t})\n\t\treturn strokePoints\n\t} else {\n\t\t// Calculate initial pressure based on the average of the first\n\t\t// n number of points. This prevents \"dots\" at the start of the\n\t\t// line. Drawn lines almost always start slow!\n\t\tlet p: number\n\t\tfor (let i = 0, n = strokePoints.length; i < n; i++) {\n\t\t\tstrokePoint = strokePoints[i]\n\t\t\tif (strokePoint.runningLength > size * 5) break\n\t\t\tconst sp = min(1, strokePoint.distance / size)\n\t\t\tif (simulatePressure) {\n\t\t\t\tconst rp = min(1, 1 - sp)\n\t\t\t\tp = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE))\n\t\t\t} else {\n\t\t\t\tp = min(1, prevPressure + (strokePoint.pressure - prevPressure) * 0.5)\n\t\t\t}\n\t\t\tprevPressure = prevPressure + (p - prevPressure) * 0.5\n\t\t}\n\n\t\t// Now calculate pressure and radius for each point\n\t\tfor (let i = 0; i < strokePoints.length; i++) {\n\t\t\tstrokePoint = strokePoints[i]\n\t\t\tif (thinning) {\n\t\t\t\tlet { pressure } = strokePoint\n\t\t\t\tconst sp = min(1, strokePoint.distance / size)\n\t\t\t\tif (simulatePressure) {\n\t\t\t\t\t// If we're simulating pressure, then do so based on the distance\n\t\t\t\t\t// between the current point and the previous point, and the size\n\t\t\t\t\t// of the stroke.\n\t\t\t\t\tconst rp = min(1, 1 - sp)\n\t\t\t\t\tpressure = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE))\n\t\t\t\t} else {\n\t\t\t\t\t// Otherwise, use the input pressure slightly smoothed based on the\n\t\t\t\t\t// distance between the current point and the previous point.\n\t\t\t\t\tpressure = min(\n\t\t\t\t\t\t1,\n\t\t\t\t\t\tprevPressure + (pressure - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE)\n\t\t\t\t\t)\n\t\t\t\t}\n\n\t\t\t\tstrokePoint.radius = size * easing(0.5 - thinning * (0.5 - pressure))\n\n\t\t\t\tprevPressure = pressure\n\t\t\t} else {\n\t\t\t\tstrokePoint.radius = size / 2\n\t\t\t}\n\n\t\t\tif (firstRadius === undefined) {\n\t\t\t\tfirstRadius = strokePoint.radius\n\t\t\t}\n\t\t}\n\t}\n\n\tconst taperStart =\n\t\tstart.taper === false\n\t\t\t? 0\n\t\t\t: start.taper === true\n\t\t\t? Math.max(size, totalLength)\n\t\t\t: (start.taper as number)\n\n\tconst taperEnd =\n\t\tend.taper === false\n\t\t\t? 0\n\t\t\t: end.taper === true\n\t\t\t? Math.max(size, totalLength)\n\t\t\t: (end.taper as number)\n\n\tif (taperStart || taperEnd) {\n\t\tfor (let i = 0; i < strokePoints.length; i++) {\n\t\t\tstrokePoint = strokePoints[i]\n\t\t\t/*\n\t\t\t\tApply tapering\n\n\t\t\t\tIf the current length is within the taper distance at either the\n\t\t\t\tstart or the end, calculate the taper strengths. Apply the smaller \n\t\t\t\tof the two taper strengths to the radius.\n\t\t\t*/\n\n\t\t\tconst { runningLength } = strokePoint\n\n\t\t\tconst ts = runningLength < taperStart ? taperStartEase(runningLength / taperStart) : 1\n\n\t\t\tconst te =\n\t\t\t\ttotalLength - runningLength < taperEnd\n\t\t\t\t\t? taperEndEase((totalLength - runningLength) / taperEnd)\n\t\t\t\t\t: 1\n\n\t\t\tstrokePoint.radius = Math.max(0.01, strokePoint.radius * Math.min(ts, te))\n\t\t}\n\t}\n\n\treturn strokePoints\n}\n"],
+  "mappings": "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",
+  "names": ["max"]
+}

package/dist-esm/lib/shapes/shared/freehand/svg.mjs

@@ -0,0 +1,36 @@
+import { average, precise } from "@bigbluebutton/editor";
+function getSvgPathFromStrokePoints(points, closed = false) {
+  const len = points.length;
+  if (len < 2) {
+    return "";
+  }
+  let a = points[0].point;
+  let b = points[1].point;
+  if (len === 2) {
+    return `M${precise(a)}L${precise(b)}`;
+  }
+  let result = "";
+  for (let i = 2, max = len - 1; i < max; i++) {
+    a = points[i].point;
+    b = points[i + 1].point;
+    result += average(a, b);
+  }
+  if (closed) {
+    return `M${average(points[0].point, points[1].point)}Q${precise(points[1].point)}${average(
+      points[1].point,
+      points[2].point
+    )}T${result}${average(points[len - 1].point, points[0].point)}${average(
+      points[0].point,
+      points[1].point
+    )}Z`;
+  } else {
+    return `M${precise(points[0].point)}Q${precise(points[1].point)}${average(
+      points[1].point,
+      points[2].point
+    )}${points.length > 3 ? "T" : ""}${result}L${precise(points[len - 1].point)}`;
+  }
+}
+export {
+  getSvgPathFromStrokePoints
+};
+//# sourceMappingURL=svg.mjs.map

package/dist-esm/lib/shapes/shared/freehand/svg.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/svg.ts"],
+  "sourcesContent": ["import { average, precise } from '@bigbluebutton/editor'\nimport { StrokePoint } from './types'\n\n/**\n * Turn an array of stroke points into a path of quadradic curves.\n *\n * @param points - The stroke points returned from perfect-freehand\n * @param closed - Whether the shape is closed\n */\nexport function getSvgPathFromStrokePoints(points: StrokePoint[], closed = false): string {\n\tconst len = points.length\n\n\tif (len < 2) {\n\t\treturn ''\n\t}\n\n\tlet a = points[0].point\n\tlet b = points[1].point\n\n\tif (len === 2) {\n\t\treturn `M${precise(a)}L${precise(b)}`\n\t}\n\n\tlet result = ''\n\n\tfor (let i = 2, max = len - 1; i < max; i++) {\n\t\ta = points[i].point\n\t\tb = points[i + 1].point\n\t\tresult += average(a, b)\n\t}\n\n\tif (closed) {\n\t\t// If closed, draw a curve from the last point to the first\n\t\treturn `M${average(points[0].point, points[1].point)}Q${precise(points[1].point)}${average(\n\t\t\tpoints[1].point,\n\t\t\tpoints[2].point\n\t\t)}T${result}${average(points[len - 1].point, points[0].point)}${average(\n\t\t\tpoints[0].point,\n\t\t\tpoints[1].point\n\t\t)}Z`\n\t} else {\n\t\t// If not closed, draw a curve starting at the first point and\n\t\t// ending at the midpoint of the last and second-last point, then\n\t\t// complete the curve with a line segment to the last point.\n\t\treturn `M${precise(points[0].point)}Q${precise(points[1].point)}${average(\n\t\t\tpoints[1].point,\n\t\t\tpoints[2].point\n\t\t)}${points.length > 3 ? 'T' : ''}${result}L${precise(points[len - 1].point)}`\n\t}\n}\n"],
+  "mappings": "AAAA,SAAS,SAAS,eAAe;AAS1B,SAAS,2BAA2B,QAAuB,SAAS,OAAe;AACzF,QAAM,MAAM,OAAO;AAEnB,MAAI,MAAM,GAAG;AACZ,WAAO;AAAA,EACR;AAEA,MAAI,IAAI,OAAO,CAAC,EAAE;AAClB,MAAI,IAAI,OAAO,CAAC,EAAE;AAElB,MAAI,QAAQ,GAAG;AACd,WAAO,IAAI,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC;AAAA,EACpC;AAEA,MAAI,SAAS;AAEb,WAAS,IAAI,GAAG,MAAM,MAAM,GAAG,IAAI,KAAK,KAAK;AAC5C,QAAI,OAAO,CAAC,EAAE;AACd,QAAI,OAAO,IAAI,CAAC,EAAE;AAClB,cAAU,QAAQ,GAAG,CAAC;AAAA,EACvB;AAEA,MAAI,QAAQ;AAEX,WAAO,IAAI,QAAQ,OAAO,CAAC,EAAE,OAAO,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG;AAAA,MAClF,OAAO,CAAC,EAAE;AAAA,MACV,OAAO,CAAC,EAAE;AAAA,IACX,CAAC,IAAI,MAAM,GAAG,QAAQ,OAAO,MAAM,CAAC,EAAE,OAAO,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG;AAAA,MAC/D,OAAO,CAAC,EAAE;AAAA,MACV,OAAO,CAAC,EAAE;AAAA,IACX,CAAC;AAAA,EACF,OAAO;AAIN,WAAO,IAAI,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,IAAI,QAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,GAAG;AAAA,MACjE,OAAO,CAAC,EAAE;AAAA,MACV,OAAO,CAAC,EAAE;AAAA,IACX,CAAC,GAAG,OAAO,SAAS,IAAI,MAAM,EAAE,GAAG,MAAM,IAAI,QAAQ,OAAO,MAAM,CAAC,EAAE,KAAK,CAAC;AAAA,EAC5E;AACD;",
+  "names": []
+}

package/dist-esm/lib/shapes/shared/freehand/svgInk.mjs

@@ -0,0 +1,150 @@
+import {
+  Vec2d,
+  assert,
+  average,
+  precise,
+  shortAngleDist,
+  toDomPrecision
+} from "@bigbluebutton/editor";
+import { getStrokeOutlineTracks } from "./getStrokeOutlinePoints.mjs";
+import { getStrokePoints } from "./getStrokePoints.mjs";
+import { setStrokePointRadii } from "./setStrokePointRadii.mjs";
+function svgInk(rawInputPoints, options = {}) {
+  const { start = {}, end = {} } = options;
+  const { cap: capStart = true } = start;
+  const { cap: capEnd = true } = end;
+  assert(!start.taper && !end.taper, "cap taper not supported here");
+  assert(!start.easing && !end.easing, "cap easing not supported here");
+  assert(capStart && capEnd, "cap must be true");
+  const points = getStrokePoints(rawInputPoints, options);
+  setStrokePointRadii(points, options);
+  const partitions = partitionAtElbows(points);
+  let svg = "";
+  for (const partition of partitions) {
+    svg += renderPartition(partition, options);
+  }
+  return svg;
+}
+function partitionAtElbows(points) {
+  if (points.length <= 2)
+    return [points];
+  const result = [];
+  let currentPartition = [points[0]];
+  for (let i = 1; i < points.length - 1; i++) {
+    const prevPoint = points[i - 1];
+    const thisPoint = points[i];
+    const nextPoint = points[i + 1];
+    const prevAngle = Vec2d.Angle(prevPoint.point, thisPoint.point);
+    const nextAngle = Vec2d.Angle(thisPoint.point, nextPoint.point);
+    const acuteness = Math.abs(shortAngleDist(prevAngle, nextAngle)) / Math.PI;
+    if (acuteness > 0.8) {
+      const elbowPoint = {
+        ...thisPoint,
+        point: thisPoint.input
+      };
+      currentPartition.push(elbowPoint);
+      result.push(cleanUpPartition(currentPartition));
+      currentPartition = [elbowPoint];
+      continue;
+    }
+    currentPartition.push(thisPoint);
+    if (acuteness < 0.25) {
+      continue;
+    }
+    const avgRadius = (prevPoint.radius + thisPoint.radius + nextPoint.radius) / 3;
+    const incomingNormalizedDist = Vec2d.Dist(prevPoint.point, thisPoint.point) / avgRadius;
+    const outgoingNormalizedDist = Vec2d.Dist(thisPoint.point, nextPoint.point) / avgRadius;
+    const angularDist = incomingNormalizedDist + outgoingNormalizedDist;
+    if (angularDist < 1.5) {
+      currentPartition.push(thisPoint);
+      result.push(cleanUpPartition(currentPartition));
+      currentPartition = [thisPoint];
+      continue;
+    }
+  }
+  currentPartition.push(points[points.length - 1]);
+  result.push(cleanUpPartition(currentPartition));
+  return result;
+}
+function cleanUpPartition(partition) {
+  const startPoint = partition[0];
+  while (partition.length > 2) {
+    const nextPoint = partition[1];
+    const dist = Vec2d.Dist(startPoint.point, nextPoint.point);
+    const avgRadius = (startPoint.radius + nextPoint.radius) / 2;
+    if (dist < avgRadius * 0.5) {
+      partition.splice(1, 1);
+    } else {
+      break;
+    }
+  }
+  const endPoint = partition[partition.length - 1];
+  while (partition.length > 2) {
+    const prevPoint = partition[partition.length - 2];
+    const dist = Vec2d.Dist(endPoint.point, prevPoint.point);
+    const avgRadius = (endPoint.radius + prevPoint.radius) / 2;
+    if (dist < avgRadius * 0.5) {
+      partition.splice(partition.length - 2, 1);
+    } else {
+      break;
+    }
+  }
+  if (partition.length > 1) {
+    partition[0] = {
+      ...partition[0],
+      vector: Vec2d.FromAngle(Vec2d.Angle(partition[1].point, partition[0].point))
+    };
+    partition[partition.length - 1] = {
+      ...partition[partition.length - 1],
+      vector: Vec2d.FromAngle(
+        Vec2d.Angle(partition[partition.length - 1].point, partition[partition.length - 2].point)
+      )
+    };
+  }
+  return partition;
+}
+function circlePath(cx, cy, r) {
+  return "M " + cx + " " + cy + " m -" + r + ", 0 a " + r + "," + r + " 0 1,1 " + r * 2 + ",0 a " + r + "," + r + " 0 1,1 -" + r * 2 + ",0";
+}
+function renderPartition(strokePoints, options = {}) {
+  if (strokePoints.length === 0)
+    return "";
+  if (strokePoints.length === 1) {
+    return circlePath(strokePoints[0].point.x, strokePoints[0].point.y, strokePoints[0].radius);
+  }
+  const { left, right } = getStrokeOutlineTracks(strokePoints, options);
+  right.reverse();
+  let svg = `M${precise(left[0])}T`;
+  for (let i = 1; i < left.length; i++) {
+    svg += average(left[i - 1], left[i]);
+  }
+  {
+    const point = strokePoints[strokePoints.length - 1];
+    const radius = point.radius;
+    const direction = point.vector.clone().per().neg();
+    const arcStart = Vec2d.Add(point.point, Vec2d.Mul(direction, radius));
+    const arcEnd = Vec2d.Add(point.point, Vec2d.Mul(direction, -radius));
+    svg += `${precise(arcStart)}A${toDomPrecision(radius)},${toDomPrecision(
+      radius
+    )} 0 0 1 ${precise(arcEnd)}T`;
+  }
+  for (let i = 1; i < right.length; i++) {
+    svg += average(right[i - 1], right[i]);
+  }
+  {
+    const point = strokePoints[0];
+    const radius = point.radius;
+    const direction = point.vector.clone().per();
+    const arcStart = Vec2d.Add(point.point, Vec2d.Mul(direction, radius));
+    const arcEnd = Vec2d.Add(point.point, Vec2d.Mul(direction, -radius));
+    svg += `${precise(arcStart)}A${toDomPrecision(radius)},${toDomPrecision(
+      radius
+    )} 0 0 1 ${precise(arcEnd)}Z`;
+  }
+  return svg;
+}
+export {
+  renderPartition,
+  svgInk
+};
+//# sourceMappingURL=svgInk.mjs.map

package/dist-esm/lib/shapes/shared/freehand/svgInk.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/svgInk.ts"],
+  "sourcesContent": ["import {\n\tVec2d,\n\tVecLike,\n\tassert,\n\taverage,\n\tprecise,\n\tshortAngleDist,\n\ttoDomPrecision,\n} from '@bigbluebutton/editor'\nimport { getStrokeOutlineTracks } from './getStrokeOutlinePoints'\nimport { getStrokePoints } from './getStrokePoints'\nimport { setStrokePointRadii } from './setStrokePointRadii'\nimport { StrokeOptions, StrokePoint } from './types'\n\nexport function svgInk(rawInputPoints: VecLike[], options: StrokeOptions = {}) {\n\tconst { start = {}, end = {} } = options\n\tconst { cap: capStart = true } = start\n\tconst { cap: capEnd = true } = end\n\tassert(!start.taper && !end.taper, 'cap taper not supported here')\n\tassert(!start.easing && !end.easing, 'cap easing not supported here')\n\tassert(capStart && capEnd, 'cap must be true')\n\n\tconst points = getStrokePoints(rawInputPoints, options)\n\tsetStrokePointRadii(points, options)\n\tconst partitions = partitionAtElbows(points)\n\tlet svg = ''\n\tfor (const partition of partitions) {\n\t\tsvg += renderPartition(partition, options)\n\t}\n\n\treturn svg\n}\n\nfunction partitionAtElbows(points: StrokePoint[]): StrokePoint[][] {\n\tif (points.length <= 2) return [points]\n\n\tconst result: StrokePoint[][] = []\n\tlet currentPartition: StrokePoint[] = [points[0]]\n\tfor (let i = 1; i < points.length - 1; i++) {\n\t\tconst prevPoint = points[i - 1]\n\t\tconst thisPoint = points[i]\n\t\tconst nextPoint = points[i + 1]\n\t\tconst prevAngle = Vec2d.Angle(prevPoint.point, thisPoint.point)\n\t\tconst nextAngle = Vec2d.Angle(thisPoint.point, nextPoint.point)\n\t\t// acuteness is a normalized representation of how acute the angle is.\n\t\t// 1 is an infinitely thin wedge\n\t\t// 0 is a straight line\n\t\tconst acuteness = Math.abs(shortAngleDist(prevAngle, nextAngle)) / Math.PI\n\t\tif (acuteness > 0.8) {\n\t\t\t// always treat such acute angles as elbows\n\t\t\t// and use the extended .input point as the elbow point for swooshiness in fast zaggy lines\n\t\t\tconst elbowPoint = {\n\t\t\t\t...thisPoint,\n\t\t\t\tpoint: thisPoint.input,\n\t\t\t}\n\t\t\tcurrentPartition.push(elbowPoint)\n\t\t\tresult.push(cleanUpPartition(currentPartition))\n\t\t\tcurrentPartition = [elbowPoint]\n\t\t\tcontinue\n\t\t}\n\t\tcurrentPartition.push(thisPoint)\n\t\tif (acuteness < 0.25) {\n\t\t\t// this is not an elbow, bail out\n\t\t\tcontinue\n\t\t}\n\t\t// so now we have a reasonably acute angle but it might not be an elbow if it's far\n\t\t// away from it's neighbors\n\t\tconst avgRadius = (prevPoint.radius + thisPoint.radius + nextPoint.radius) / 3\n\t\tconst incomingNormalizedDist = Vec2d.Dist(prevPoint.point, thisPoint.point) / avgRadius\n\t\tconst outgoingNormalizedDist = Vec2d.Dist(thisPoint.point, nextPoint.point) / avgRadius\n\t\t// angular dist is a normalized representation of how far away the point is from it's neighbors\n\t\t// (normalized by the radius)\n\t\tconst angularDist = incomingNormalizedDist + outgoingNormalizedDist\n\t\tif (angularDist < 1.5) {\n\t\t\t// if this point is kinda close to its neighbors and it has a reasonably\n\t\t\t// acute angle, it's probably a hard elbow\n\t\t\tcurrentPartition.push(thisPoint)\n\t\t\tresult.push(cleanUpPartition(currentPartition))\n\t\t\tcurrentPartition = [thisPoint]\n\t\t\tcontinue\n\t\t}\n\t}\n\tcurrentPartition.push(points[points.length - 1])\n\tresult.push(cleanUpPartition(currentPartition))\n\n\treturn result\n}\n\nfunction cleanUpPartition(partition: StrokePoint[]) {\n\t// clean up start of partition (remove points that are too close to the start)\n\tconst startPoint = partition[0]\n\twhile (partition.length > 2) {\n\t\tconst nextPoint = partition[1]\n\t\tconst dist = Vec2d.Dist(startPoint.point, nextPoint.point)\n\t\tconst avgRadius = (startPoint.radius + nextPoint.radius) / 2\n\t\tif (dist < avgRadius * 0.5) {\n\t\t\tpartition.splice(1, 1)\n\t\t} else {\n\t\t\tbreak\n\t\t}\n\t}\n\t// clean up end of partition in the same fashion\n\tconst endPoint = partition[partition.length - 1]\n\twhile (partition.length > 2) {\n\t\tconst prevPoint = partition[partition.length - 2]\n\t\tconst dist = Vec2d.Dist(endPoint.point, prevPoint.point)\n\t\tconst avgRadius = (endPoint.radius + prevPoint.radius) / 2\n\t\tif (dist < avgRadius * 0.5) {\n\t\t\tpartition.splice(partition.length - 2, 1)\n\t\t} else {\n\t\t\tbreak\n\t\t}\n\t}\n\t// now readjust the cap point vectors to point to their nearest neighbors\n\tif (partition.length > 1) {\n\t\tpartition[0] = {\n\t\t\t...partition[0],\n\t\t\tvector: Vec2d.FromAngle(Vec2d.Angle(partition[1].point, partition[0].point)),\n\t\t}\n\t\tpartition[partition.length - 1] = {\n\t\t\t...partition[partition.length - 1],\n\t\t\tvector: Vec2d.FromAngle(\n\t\t\t\tVec2d.Angle(partition[partition.length - 1].point, partition[partition.length - 2].point)\n\t\t\t),\n\t\t}\n\t}\n\treturn partition\n}\n\nfunction circlePath(cx: number, cy: number, r: number) {\n\treturn (\n\t\t'M ' +\n\t\tcx +\n\t\t' ' +\n\t\tcy +\n\t\t' m -' +\n\t\tr +\n\t\t', 0 a ' +\n\t\tr +\n\t\t',' +\n\t\tr +\n\t\t' 0 1,1 ' +\n\t\tr * 2 +\n\t\t',0 a ' +\n\t\tr +\n\t\t',' +\n\t\tr +\n\t\t' 0 1,1 -' +\n\t\tr * 2 +\n\t\t',0'\n\t)\n}\n\nexport function renderPartition(strokePoints: StrokePoint[], options: StrokeOptions = {}): string {\n\tif (strokePoints.length === 0) return ''\n\tif (strokePoints.length === 1) {\n\t\treturn circlePath(strokePoints[0].point.x, strokePoints[0].point.y, strokePoints[0].radius)\n\t}\n\n\tconst { left, right } = getStrokeOutlineTracks(strokePoints, options)\n\tright.reverse()\n\tlet svg = `M${precise(left[0])}T`\n\n\t// draw left track\n\tfor (let i = 1; i < left.length; i++) {\n\t\tsvg += average(left[i - 1], left[i])\n\t}\n\t// draw end cap arc\n\t{\n\t\tconst point = strokePoints[strokePoints.length - 1]\n\t\tconst radius = point.radius\n\t\tconst direction = point.vector.clone().per().neg()\n\t\tconst arcStart = Vec2d.Add(point.point, Vec2d.Mul(direction, radius))\n\t\tconst arcEnd = Vec2d.Add(point.point, Vec2d.Mul(direction, -radius))\n\t\tsvg += `${precise(arcStart)}A${toDomPrecision(radius)},${toDomPrecision(\n\t\t\tradius\n\t\t)} 0 0 1 ${precise(arcEnd)}T`\n\t}\n\t// draw right track\n\tfor (let i = 1; i < right.length; i++) {\n\t\tsvg += average(right[i - 1], right[i])\n\t}\n\t// draw start cap arc\n\t{\n\t\tconst point = strokePoints[0]\n\t\tconst radius = point.radius\n\t\tconst direction = point.vector.clone().per()\n\t\tconst arcStart = Vec2d.Add(point.point, Vec2d.Mul(direction, radius))\n\t\tconst arcEnd = Vec2d.Add(point.point, Vec2d.Mul(direction, -radius))\n\t\tsvg += `${precise(arcStart)}A${toDomPrecision(radius)},${toDomPrecision(\n\t\t\tradius\n\t\t)} 0 0 1 ${precise(arcEnd)}Z`\n\t}\n\treturn svg\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist-esm/lib/shapes/shared/freehand/types.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=types.mjs.map

package/dist-esm/lib/shapes/shared/freehand/types.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist-esm/lib/shapes/shared/getBrowserCanvasMaxSize.mjs

@@ -0,0 +1,22 @@
+import canvasSize from "canvas-size";
+let maxSizePromise = null;
+function getBrowserCanvasMaxSize() {
+  if (!maxSizePromise) {
+    maxSizePromise = calculateBrowserCanvasMaxSize();
+  }
+  return maxSizePromise;
+}
+async function calculateBrowserCanvasMaxSize() {
+  const maxWidth = await canvasSize.maxWidth({ usePromise: true });
+  const maxHeight = await canvasSize.maxHeight({ usePromise: true });
+  const maxArea = await canvasSize.maxArea({ usePromise: true });
+  return {
+    maxWidth: maxWidth.width,
+    maxHeight: maxHeight.height,
+    maxArea: maxArea.width * maxArea.height
+  };
+}
+export {
+  getBrowserCanvasMaxSize
+};
+//# sourceMappingURL=getBrowserCanvasMaxSize.mjs.map

package/dist-esm/lib/shapes/shared/getBrowserCanvasMaxSize.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/shapes/shared/getBrowserCanvasMaxSize.tsx"],
+  "sourcesContent": ["import canvasSize from 'canvas-size'\n\nexport type CanvasMaxSize = {\n\tmaxWidth: number\n\tmaxHeight: number\n\tmaxArea: number\n}\n\nlet maxSizePromise: Promise<CanvasMaxSize> | null = null\n\nexport function getBrowserCanvasMaxSize() {\n\tif (!maxSizePromise) {\n\t\tmaxSizePromise = calculateBrowserCanvasMaxSize()\n\t}\n\n\treturn maxSizePromise\n}\n\nasync function calculateBrowserCanvasMaxSize(): Promise<CanvasMaxSize> {\n\tconst maxWidth = await canvasSize.maxWidth({ usePromise: true })\n\tconst maxHeight = await canvasSize.maxHeight({ usePromise: true })\n\tconst maxArea = await canvasSize.maxArea({ usePromise: true })\n\treturn {\n\t\tmaxWidth: maxWidth.width,\n\t\tmaxHeight: maxHeight.height,\n\t\tmaxArea: maxArea.width * maxArea.height,\n\t}\n}\n"],
+  "mappings": "AAAA,OAAO,gBAAgB;AAQvB,IAAI,iBAAgD;AAE7C,SAAS,0BAA0B;AACzC,MAAI,CAAC,gBAAgB;AACpB,qBAAiB,8BAA8B;AAAA,EAChD;AAEA,SAAO;AACR;AAEA,eAAe,gCAAwD;AACtE,QAAM,WAAW,MAAM,WAAW,SAAS,EAAE,YAAY,KAAK,CAAC;AAC/D,QAAM,YAAY,MAAM,WAAW,UAAU,EAAE,YAAY,KAAK,CAAC;AACjE,QAAM,UAAU,MAAM,WAAW,QAAQ,EAAE,YAAY,KAAK,CAAC;AAC7D,SAAO;AAAA,IACN,UAAU,SAAS;AAAA,IACnB,WAAW,UAAU;AAAA,IACrB,SAAS,QAAQ,QAAQ,QAAQ;AAAA,EAClC;AACD;",
+  "names": []
+}

package/dist-esm/lib/shapes/shared/getPerfectDashProps.mjs

@@ -0,0 +1,76 @@
+function getPerfectDashProps(totalLength, strokeWidth, opts = {}) {
+  const {
+    closed = false,
+    snap = 1,
+    start = "outset",
+    end = "outset",
+    lengthRatio = 2,
+    style = "dashed"
+  } = opts;
+  let dashLength = 0;
+  let dashCount = 0;
+  let ratio = 1;
+  let gapLength = 0;
+  let strokeDashoffset = 0;
+  switch (style) {
+    case "dashed": {
+      ratio = 1;
+      dashLength = Math.min(strokeWidth * lengthRatio, totalLength / 4);
+      break;
+    }
+    case "dotted": {
+      ratio = 100;
+      dashLength = strokeWidth / ratio;
+      break;
+    }
+    default: {
+      return {
+        strokeDasharray: "none",
+        strokeDashoffset: "none"
+      };
+    }
+  }
+  if (!closed) {
+    if (start === "outset") {
+      totalLength += dashLength / 2;
+      strokeDashoffset += dashLength / 2;
+    } else if (start === "skip") {
+      totalLength -= dashLength;
+      strokeDashoffset -= dashLength;
+    }
+    if (end === "outset") {
+      totalLength += dashLength / 2;
+    } else if (end === "skip") {
+      totalLength -= dashLength;
+    }
+  }
+  dashCount = Math.floor(totalLength / dashLength / (2 * ratio));
+  dashCount -= dashCount % snap;
+  if (dashCount < 3 && style === "dashed") {
+    if (totalLength / strokeWidth < 5) {
+      dashLength = totalLength;
+      dashCount = 1;
+      gapLength = 0;
+    } else {
+      dashLength = totalLength * 0.333;
+      gapLength = totalLength * 0.333;
+    }
+  } else {
+    dashCount = Math.max(dashCount, 3);
+    dashLength = totalLength / dashCount / (2 * ratio);
+    if (closed) {
+      strokeDashoffset = dashLength / 2;
+      gapLength = (totalLength - dashCount * dashLength) / dashCount;
+    } else {
+      gapLength = (totalLength - dashCount * dashLength) / Math.max(1, dashCount - 1);
+    }
+  }
+  return {
+    strokeDasharray: [dashLength, gapLength].join(" "),
+    strokeDashoffset: strokeDashoffset.toString()
+  };
+}
+export {
+  getPerfectDashProps
+};
+//# sourceMappingURL=getPerfectDashProps.mjs.map

package/dist-esm/lib/shapes/shared/getPerfectDashProps.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/shapes/shared/getPerfectDashProps.ts"],
+  "sourcesContent": ["import { TLDefaultDashStyle } from '@bigbluebutton/editor'\n\nexport function getPerfectDashProps(\n\ttotalLength: number,\n\tstrokeWidth: number,\n\topts = {} as Partial<{\n\t\tstyle: TLDefaultDashStyle\n\t\tsnap: number\n\t\tend: 'skip' | 'outset' | 'none'\n\t\tstart: 'skip' | 'outset' | 'none'\n\t\tlengthRatio: number\n\t\tclosed: boolean\n\t}>\n): {\n\tstrokeDasharray: string\n\tstrokeDashoffset: string\n} {\n\tconst {\n\t\tclosed = false,\n\t\tsnap = 1,\n\t\tstart = 'outset',\n\t\tend = 'outset',\n\t\tlengthRatio = 2,\n\t\tstyle = 'dashed',\n\t} = opts\n\n\tlet dashLength = 0\n\tlet dashCount = 0\n\tlet ratio = 1\n\tlet gapLength = 0\n\tlet strokeDashoffset = 0\n\n\tswitch (style) {\n\t\tcase 'dashed': {\n\t\t\tratio = 1\n\t\t\tdashLength = Math.min(strokeWidth * lengthRatio, totalLength / 4)\n\t\t\tbreak\n\t\t}\n\t\tcase 'dotted': {\n\t\t\tratio = 100\n\t\t\tdashLength = strokeWidth / ratio\n\t\t\tbreak\n\t\t}\n\t\tdefault: {\n\t\t\treturn {\n\t\t\t\tstrokeDasharray: 'none',\n\t\t\t\tstrokeDashoffset: 'none',\n\t\t\t}\n\t\t}\n\t}\n\n\tif (!closed) {\n\t\tif (start === 'outset') {\n\t\t\ttotalLength += dashLength / 2\n\t\t\tstrokeDashoffset += dashLength / 2\n\t\t} else if (start === 'skip') {\n\t\t\ttotalLength -= dashLength\n\t\t\tstrokeDashoffset -= dashLength\n\t\t}\n\n\t\tif (end === 'outset') {\n\t\t\ttotalLength += dashLength / 2\n\t\t} else if (end === 'skip') {\n\t\t\ttotalLength -= dashLength\n\t\t}\n\t}\n\n\tdashCount = Math.floor(totalLength / dashLength / (2 * ratio))\n\tdashCount -= dashCount % snap\n\n\tif (dashCount < 3 && style === 'dashed') {\n\t\tif (totalLength / strokeWidth < 5) {\n\t\t\tdashLength = totalLength\n\t\t\tdashCount = 1\n\t\t\tgapLength = 0\n\t\t} else {\n\t\t\tdashLength = totalLength * 0.333\n\t\t\tgapLength = totalLength * 0.333\n\t\t}\n\t} else {\n\t\tdashCount = Math.max(dashCount, 3)\n\t\tdashLength = totalLength / dashCount / (2 * ratio)\n\n\t\tif (closed) {\n\t\t\tstrokeDashoffset = dashLength / 2\n\t\t\tgapLength = (totalLength - dashCount * dashLength) / dashCount\n\t\t} else {\n\t\t\tgapLength = (totalLength - dashCount * dashLength) / Math.max(1, dashCount - 1)\n\t\t}\n\t}\n\n\treturn {\n\t\tstrokeDasharray: [dashLength, gapLength].join(' '),\n\t\tstrokeDashoffset: strokeDashoffset.toString(),\n\t}\n}\n"],
+  "mappings": "AAEO,SAAS,oBACf,aACA,aACA,OAAO,CAAC,GAWP;AACD,QAAM;AAAA,IACL,SAAS;AAAA,IACT,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,MAAM;AAAA,IACN,cAAc;AAAA,IACd,QAAQ;AAAA,EACT,IAAI;AAEJ,MAAI,aAAa;AACjB,MAAI,YAAY;AAChB,MAAI,QAAQ;AACZ,MAAI,YAAY;AAChB,MAAI,mBAAmB;AAEvB,UAAQ,OAAO;AAAA,IACd,KAAK,UAAU;AACd,cAAQ;AACR,mBAAa,KAAK,IAAI,cAAc,aAAa,cAAc,CAAC;AAChE;AAAA,IACD;AAAA,IACA,KAAK,UAAU;AACd,cAAQ;AACR,mBAAa,cAAc;AAC3B;AAAA,IACD;AAAA,IACA,SAAS;AACR,aAAO;AAAA,QACN,iBAAiB;AAAA,QACjB,kBAAkB;AAAA,MACnB;AAAA,IACD;AAAA,EACD;AAEA,MAAI,CAAC,QAAQ;AACZ,QAAI,UAAU,UAAU;AACvB,qBAAe,aAAa;AAC5B,0BAAoB,aAAa;AAAA,IAClC,WAAW,UAAU,QAAQ;AAC5B,qBAAe;AACf,0BAAoB;AAAA,IACrB;AAEA,QAAI,QAAQ,UAAU;AACrB,qBAAe,aAAa;AAAA,IAC7B,WAAW,QAAQ,QAAQ;AAC1B,qBAAe;AAAA,IAChB;AAAA,EACD;AAEA,cAAY,KAAK,MAAM,cAAc,cAAc,IAAI,MAAM;AAC7D,eAAa,YAAY;AAEzB,MAAI,YAAY,KAAK,UAAU,UAAU;AACxC,QAAI,cAAc,cAAc,GAAG;AAClC,mBAAa;AACb,kBAAY;AACZ,kBAAY;AAAA,IACb,OAAO;AACN,mBAAa,cAAc;AAC3B,kBAAY,cAAc;AAAA,IAC3B;AAAA,EACD,OAAO;AACN,gBAAY,KAAK,IAAI,WAAW,CAAC;AACjC,iBAAa,cAAc,aAAa,IAAI;AAE5C,QAAI,QAAQ;AACX,yBAAmB,aAAa;AAChC,mBAAa,cAAc,YAAY,cAAc;AAAA,IACtD,OAAO;AACN,mBAAa,cAAc,YAAY,cAAc,KAAK,IAAI,GAAG,YAAY,CAAC;AAAA,IAC/E;AAAA,EACD;AAEA,SAAO;AAAA,IACN,iBAAiB,CAAC,YAAY,SAAS,EAAE,KAAK,GAAG;AAAA,IACjD,kBAAkB,iBAAiB,SAAS;AAAA,EAC7C;AACD;",
+  "names": []
+}

package/dist-esm/lib/shapes/shared/getTextLabelSvgElement.mjs

@@ -0,0 +1,36 @@
+import { createTextSvgElementFromSpans } from "./createTextSvgElementFromSpans.mjs";
+import { LABEL_FONT_SIZES, TEXT_PROPS } from "./default-shape-constants.mjs";
+import { getLegacyOffsetX } from "./legacyProps.mjs";
+function getTextLabelSvgElement({
+  bounds,
+  editor,
+  font,
+  shape
+}) {
+  const padding = 16;
+  const opts = {
+    fontSize: LABEL_FONT_SIZES[shape.props.size],
+    fontFamily: font,
+    textAlign: shape.props.align,
+    verticalTextAlign: shape.props.verticalAlign,
+    width: Math.ceil(bounds.width),
+    height: Math.ceil(bounds.height),
+    padding: 16,
+    lineHeight: TEXT_PROPS.lineHeight,
+    fontStyle: "normal",
+    fontWeight: "normal",
+    overflow: "wrap",
+    offsetX: 0
+  };
+  const spans = editor.textMeasure.measureTextSpans(shape.props.text, opts);
+  const offsetX = getLegacyOffsetX(shape.props.align, padding, spans, bounds.width);
+  if (offsetX) {
+    opts.offsetX = offsetX;
+  }
+  const textElm = createTextSvgElementFromSpans(editor, spans, opts);
+  return textElm;
+}
+export {
+  getTextLabelSvgElement
+};
+//# sourceMappingURL=getTextLabelSvgElement.mjs.map

package/dist-esm/lib/shapes/shared/getTextLabelSvgElement.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/shapes/shared/getTextLabelSvgElement.ts"],
+  "sourcesContent": ["import { Box2d, Editor, TLGeoShape, TLNoteShape } from '@bigbluebutton/editor'\nimport { createTextSvgElementFromSpans } from './createTextSvgElementFromSpans'\nimport { LABEL_FONT_SIZES, TEXT_PROPS } from './default-shape-constants'\nimport { getLegacyOffsetX } from './legacyProps'\n\nexport function getTextLabelSvgElement({\n\tbounds,\n\teditor,\n\tfont,\n\tshape,\n}: {\n\tbounds: Box2d\n\teditor: Editor\n\tfont: string\n\tshape: TLGeoShape | TLNoteShape\n}) {\n\tconst padding = 16\n\n\tconst opts = {\n\t\tfontSize: LABEL_FONT_SIZES[shape.props.size],\n\t\tfontFamily: font,\n\t\ttextAlign: shape.props.align,\n\t\tverticalTextAlign: shape.props.verticalAlign,\n\t\twidth: Math.ceil(bounds.width),\n\t\theight: Math.ceil(bounds.height),\n\t\tpadding: 16,\n\t\tlineHeight: TEXT_PROPS.lineHeight,\n\t\tfontStyle: 'normal',\n\t\tfontWeight: 'normal',\n\t\toverflow: 'wrap' as const,\n\t\toffsetX: 0,\n\t}\n\n\tconst spans = editor.textMeasure.measureTextSpans(shape.props.text, opts)\n\tconst offsetX = getLegacyOffsetX(shape.props.align, padding, spans, bounds.width)\n\tif (offsetX) {\n\t\topts.offsetX = offsetX\n\t}\n\n\tconst textElm = createTextSvgElementFromSpans(editor, spans, opts)\n\treturn textElm\n}\n"],
+  "mappings": "AACA,SAAS,qCAAqC;AAC9C,SAAS,kBAAkB,kBAAkB;AAC7C,SAAS,wBAAwB;AAE1B,SAAS,uBAAuB;AAAA,EACtC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD,GAKG;AACF,QAAM,UAAU;AAEhB,QAAM,OAAO;AAAA,IACZ,UAAU,iBAAiB,MAAM,MAAM,IAAI;AAAA,IAC3C,YAAY;AAAA,IACZ,WAAW,MAAM,MAAM;AAAA,IACvB,mBAAmB,MAAM,MAAM;AAAA,IAC/B,OAAO,KAAK,KAAK,OAAO,KAAK;AAAA,IAC7B,QAAQ,KAAK,KAAK,OAAO,MAAM;AAAA,IAC/B,SAAS;AAAA,IACT,YAAY,WAAW;AAAA,IACvB,WAAW;AAAA,IACX,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,SAAS;AAAA,EACV;AAEA,QAAM,QAAQ,OAAO,YAAY,iBAAiB,MAAM,MAAM,MAAM,IAAI;AACxE,QAAM,UAAU,iBAAiB,MAAM,MAAM,OAAO,SAAS,OAAO,OAAO,KAAK;AAChF,MAAI,SAAS;AACZ,SAAK,UAAU;AAAA,EAChB;AAEA,QAAM,UAAU,8BAA8B,QAAQ,OAAO,IAAI;AACjE,SAAO;AACR;",
+  "names": []
+}

package/dist-esm/lib/shapes/shared/legacyProps.mjs

@@ -0,0 +1,22 @@
+import { Box2d } from "@bigbluebutton/editor";
+function getLegacyOffsetX(align, padding, spans, totalWidth) {
+  if ((align === "start-legacy" || align === "end-legacy") && spans.length !== 0) {
+    const spansBounds = Box2d.From(spans[0].box);
+    for (const { box } of spans) {
+      spansBounds.union(box);
+    }
+    if (align === "start-legacy") {
+      return (totalWidth - 2 * padding - spansBounds.width) / 2;
+    } else if (align === "end-legacy") {
+      return -(totalWidth - 2 * padding - spansBounds.width) / 2;
+    }
+  }
+}
+function isLegacyAlign(align) {
+  return align === "start-legacy" || align === "middle-legacy" || align === "end-legacy";
+}
+export {
+  getLegacyOffsetX,
+  isLegacyAlign
+};
+//# sourceMappingURL=legacyProps.mjs.map

package/dist-esm/lib/shapes/shared/legacyProps.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/lib/shapes/shared/legacyProps.ts"],
+  "sourcesContent": ["import { Box2d, Box2dModel, TLDefaultHorizontalAlignStyle } from '@bigbluebutton/editor'\n\nexport function getLegacyOffsetX(\n\talign: TLDefaultHorizontalAlignStyle | string,\n\tpadding: number,\n\tspans: { text: string; box: Box2dModel }[],\n\ttotalWidth: number\n): number | undefined {\n\tif ((align === 'start-legacy' || align === 'end-legacy') && spans.length !== 0) {\n\t\tconst spansBounds = Box2d.From(spans[0].box)\n\t\tfor (const { box } of spans) {\n\t\t\tspansBounds.union(box)\n\t\t}\n\t\tif (align === 'start-legacy') {\n\t\t\treturn (totalWidth - 2 * padding - spansBounds.width) / 2\n\t\t} else if (align === 'end-legacy') {\n\t\t\treturn -(totalWidth - 2 * padding - spansBounds.width) / 2\n\t\t}\n\t}\n}\n\n// sneaky TLDefaultHorizontalAlignStyle for legacies\nexport function isLegacyAlign(align: TLDefaultHorizontalAlignStyle | string): boolean {\n\treturn align === 'start-legacy' || align === 'middle-legacy' || align === 'end-legacy'\n}\n"],
+  "mappings": "AAAA,SAAS,aAAwD;AAE1D,SAAS,iBACf,OACA,SACA,OACA,YACqB;AACrB,OAAK,UAAU,kBAAkB,UAAU,iBAAiB,MAAM,WAAW,GAAG;AAC/E,UAAM,cAAc,MAAM,KAAK,MAAM,CAAC,EAAE,GAAG;AAC3C,eAAW,EAAE,IAAI,KAAK,OAAO;AAC5B,kBAAY,MAAM,GAAG;AAAA,IACtB;AACA,QAAI,UAAU,gBAAgB;AAC7B,cAAQ,aAAa,IAAI,UAAU,YAAY,SAAS;AAAA,IACzD,WAAW,UAAU,cAAc;AAClC,aAAO,EAAE,aAAa,IAAI,UAAU,YAAY,SAAS;AAAA,IAC1D;AAAA,EACD;AACD;AAGO,SAAS,cAAc,OAAwD;AACrF,SAAO,UAAU,kBAAkB,UAAU,mBAAmB,UAAU;AAC3E;",
+  "names": []
+}

package/dist-esm/lib/shapes/shared/polygon-helpers.mjs

@@ -0,0 +1,96 @@
+import { Vec2d, toDomPrecision } from "@bigbluebutton/editor";
+function precise(A) {
+  return `${toDomPrecision(A.x)},${toDomPrecision(A.y)} `;
+}
+function rng(seed = "") {
+  let x = 0;
+  let y = 0;
+  let z = 0;
+  let w = 0;
+  function next() {
+    const t = x ^ x << 11;
+    x = y;
+    y = z;
+    z = w;
+    w ^= (w >>> 19 ^ t ^ t >>> 8) >>> 0;
+    return w / 4294967296 * 2;
+  }
+  for (let k = 0; k < seed.length + 64; k++) {
+    x ^= seed.charCodeAt(k) | 0;
+    next();
+  }
+  return next;
+}
+function getRoundedInkyPolygonPath(points) {
+  let polylineA = `M`;
+  const len = points.length;
+  let p0;
+  let p1;
+  let p2;
+  for (let i = 0, n = len; i < n; i += 3) {
+    p0 = points[i];
+    p1 = points[i + 1];
+    p2 = points[i + 2];
+    polylineA += `${precise(p0)}L${precise(p1)}Q${precise(p2)}`;
+  }
+  polylineA += `${precise(points[0])}`;
+  return polylineA;
+}
+function getRoundedPolygonPoints(id, outline, offset, roundness, passes) {
+  const results = [];
+  const random = rng(id);
+  let p0 = outline[0];
+  let p1;
+  const len = outline.length;
+  for (let i = 0, n = len * passes; i < n; i++) {
+    p1 = Vec2d.AddXY(outline[(i + 1) % len], random() * offset, random() * offset);
+    const delta = Vec2d.Sub(p1, p0);
+    const distance = Vec2d.Len(delta);
+    const vector = Vec2d.Div(delta, distance).mul(Math.min(distance / 4, roundness));
+    results.push(Vec2d.Add(p0, vector), Vec2d.Add(p1, vector.neg()), p1);
+    p0 = p1;
+  }
+  return results;
+}
+function getDrawLinePathData(id, outline, strokeWidth) {
+  let innerPathData = `M ${precise(outline[0])}L`;
+  let outerPathData2 = `M ${precise(outline[0])}L`;
+  const offset = strokeWidth / 3;
+  const roundness = strokeWidth * 2;
+  const random = rng(id);
+  let p0 = outline[0];
+  let p1;
+  let s0 = outline[0];
+  let s1;
+  const len = outline.length;
+  for (let i = 0, n = len - 1; i < n; i++) {
+    p1 = outline[i + 1];
+    s1 = Vec2d.AddXY(outline[i + 1], random() * offset, random() * offset);
+    const delta = Vec2d.Sub(p1, p0);
+    const distance = Vec2d.Len(delta);
+    const vector = Vec2d.Div(delta, distance).mul(Math.min(distance / 4, roundness));
+    const q0 = Vec2d.Add(p0, vector);
+    const q1 = Vec2d.Add(p1, vector.neg());
+    const sDelta = Vec2d.Sub(s1, s0);
+    const sDistance = Vec2d.Len(sDelta);
+    const sVector = Vec2d.Div(sDelta, sDistance).mul(Math.min(sDistance / 4, roundness));
+    const sq0 = Vec2d.Add(s0, sVector);
+    const sq1 = Vec2d.Add(s1, sVector.neg());
+    if (i === n - 1) {
+      innerPathData += `${precise(q0)}L ${precise(p1)}`;
+      outerPathData2 += `${precise(sq0)}L ${precise(s1)}`;
+    } else {
+      innerPathData += `${precise(q0)}L ${precise(q1)}Q ${precise(p1)}`;
+      outerPathData2 += `${precise(sq0)}L ${precise(sq1)}Q ${precise(s1)}`;
+      p0 = p1;
+      s0 = s1;
+    }
+  }
+  return [innerPathData, innerPathData + outerPathData2];
+}
+export {
+  getDrawLinePathData,
+  getRoundedInkyPolygonPath,
+  getRoundedPolygonPoints
+};
+//# sourceMappingURL=polygon-helpers.mjs.map