@bigbluebutton/tldraw 2.0.0-alpha.19

package/dist-cjs/lib/shapes/shared/freehand/getStrokeOutlinePoints.js

@@ -0,0 +1,175 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getStrokeOutlinePoints_exports = {};
+__export(getStrokeOutlinePoints_exports, {
+  getStrokeOutlinePoints: () => getStrokeOutlinePoints,
+  getStrokeOutlineTracks: () => getStrokeOutlineTracks
+});
+module.exports = __toCommonJS(getStrokeOutlinePoints_exports);
+var import_editor = require("@bigbluebutton/editor");
+const { PI } = Math;
+const FIXED_PI = PI + 1e-4;
+function getStrokeOutlineTracks(strokePoints, options = {}) {
+  const { size = 16, smoothing = 0.5 } = options;
+  if (strokePoints.length === 0 || size <= 0) {
+    return { left: [], right: [] };
+  }
+  const firstStrokePoint = strokePoints[0];
+  const lastStrokePoint = strokePoints[strokePoints.length - 1];
+  const totalLength = lastStrokePoint.runningLength;
+  const minDistance = Math.pow(size * smoothing, 2);
+  const leftPts = [];
+  const rightPts = [];
+  let prevVector = strokePoints[0].vector;
+  let pl = strokePoints[0].point;
+  let pr = pl;
+  let tl = pl;
+  let tr = pr;
+  let isPrevPointSharpCorner = false;
+  let strokePoint;
+  for (let i = 0; i < strokePoints.length; i++) {
+    strokePoint = strokePoints[i];
+    const { point, vector } = strokePoints[i];
+    const prevDpr = strokePoint.vector.dpr(prevVector);
+    const nextVector = (i < strokePoints.length - 1 ? strokePoints[i + 1] : strokePoints[i]).vector;
+    const nextDpr = i < strokePoints.length - 1 ? nextVector.dpr(strokePoint.vector) : 1;
+    const isPointSharpCorner = prevDpr < 0 && !isPrevPointSharpCorner;
+    const isNextPointSharpCorner = nextDpr !== null && nextDpr < 0.2;
+    if (isPointSharpCorner || isNextPointSharpCorner) {
+      if (nextDpr > -0.62 && totalLength - strokePoint.runningLength > strokePoint.radius) {
+        const offset2 = prevVector.clone().mul(strokePoint.radius);
+        const cpr = prevVector.clone().cpr(nextVector);
+        if (cpr < 0) {
+          tl = import_editor.Vec2d.Add(point, offset2);
+          tr = import_editor.Vec2d.Sub(point, offset2);
+        } else {
+          tl = import_editor.Vec2d.Sub(point, offset2);
+          tr = import_editor.Vec2d.Add(point, offset2);
+        }
+        leftPts.push(tl);
+        rightPts.push(tr);
+      } else {
+        const offset2 = prevVector.clone().mul(strokePoint.radius).per();
+        const start = import_editor.Vec2d.Sub(strokePoint.input, offset2);
+        for (let step = 1 / 13, t = 0; t < 1; t += step) {
+          tl = import_editor.Vec2d.RotWith(start, strokePoint.input, FIXED_PI * t);
+          leftPts.push(tl);
+          tr = import_editor.Vec2d.RotWith(start, strokePoint.input, FIXED_PI + FIXED_PI * -t);
+          rightPts.push(tr);
+        }
+      }
+      pl = tl;
+      pr = tr;
+      if (isNextPointSharpCorner) {
+        isPrevPointSharpCorner = true;
+      }
+      continue;
+    }
+    isPrevPointSharpCorner = false;
+    if (strokePoint === firstStrokePoint || strokePoint === lastStrokePoint) {
+      const offset2 = import_editor.Vec2d.Per(vector).mul(strokePoint.radius);
+      leftPts.push(import_editor.Vec2d.Sub(point, offset2));
+      rightPts.push(import_editor.Vec2d.Add(point, offset2));
+      continue;
+    }
+    const offset = import_editor.Vec2d.Lrp(nextVector, vector, nextDpr).per().mul(strokePoint.radius);
+    tl = import_editor.Vec2d.Sub(point, offset);
+    if (i <= 1 || import_editor.Vec2d.Dist2(pl, tl) > minDistance) {
+      leftPts.push(tl);
+      pl = tl;
+    }
+    tr = import_editor.Vec2d.Add(point, offset);
+    if (i <= 1 || import_editor.Vec2d.Dist2(pr, tr) > minDistance) {
+      rightPts.push(tr);
+      pr = tr;
+    }
+    prevVector = vector;
+    continue;
+  }
+  return {
+    left: leftPts,
+    right: rightPts
+  };
+}
+function getStrokeOutlinePoints(strokePoints, options = {}) {
+  const { size = 16, start = {}, end = {}, last: isComplete = false } = options;
+  const { cap: capStart = true } = start;
+  const { cap: capEnd = true } = end;
+  if (strokePoints.length === 0 || size <= 0) {
+    return [];
+  }
+  const firstStrokePoint = strokePoints[0];
+  const lastStrokePoint = strokePoints[strokePoints.length - 1];
+  const totalLength = lastStrokePoint.runningLength;
+  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;
+  const { left: leftPts, right: rightPts } = getStrokeOutlineTracks(strokePoints, options);
+  const firstPoint = firstStrokePoint.point;
+  const lastPoint = strokePoints.length > 1 ? strokePoints[strokePoints.length - 1].point : import_editor.Vec2d.AddXY(firstStrokePoint.point, 1, 1);
+  if (strokePoints.length === 1) {
+    if (!(taperStart || taperEnd) || isComplete) {
+      const start2 = import_editor.Vec2d.Add(
+        firstPoint,
+        import_editor.Vec2d.Sub(firstPoint, lastPoint).uni().per().mul(-firstStrokePoint.radius)
+      );
+      const dotPts = [];
+      for (let step = 1 / 13, t = step; t <= 1; t += step) {
+        dotPts.push(import_editor.Vec2d.RotWith(start2, firstPoint, FIXED_PI * 2 * t));
+      }
+      return dotPts;
+    }
+  }
+  const startCap = [];
+  if (taperStart || taperEnd && strokePoints.length === 1) {
+  } else if (capStart) {
+    for (let step = 1 / 8, t = step; t <= 1; t += step) {
+      const pt = import_editor.Vec2d.RotWith(rightPts[0], firstPoint, FIXED_PI * t);
+      startCap.push(pt);
+    }
+  } else {
+    const cornersVector = import_editor.Vec2d.Sub(leftPts[0], rightPts[0]);
+    const offsetA = import_editor.Vec2d.Mul(cornersVector, 0.5);
+    const offsetB = import_editor.Vec2d.Mul(cornersVector, 0.51);
+    startCap.push(
+      import_editor.Vec2d.Sub(firstPoint, offsetA),
+      import_editor.Vec2d.Sub(firstPoint, offsetB),
+      import_editor.Vec2d.Add(firstPoint, offsetB),
+      import_editor.Vec2d.Add(firstPoint, offsetA)
+    );
+  }
+  const endCap = [];
+  const direction = lastStrokePoint.vector.clone().per().neg();
+  if (taperEnd || taperStart && strokePoints.length === 1) {
+    endCap.push(lastPoint);
+  } else if (capEnd) {
+    const start2 = import_editor.Vec2d.Add(lastPoint, import_editor.Vec2d.Mul(direction, lastStrokePoint.radius));
+    for (let step = 1 / 29, t = step; t < 1; t += step) {
+      endCap.push(import_editor.Vec2d.RotWith(start2, lastPoint, FIXED_PI * 3 * t));
+    }
+  } else {
+    endCap.push(
+      import_editor.Vec2d.Add(lastPoint, import_editor.Vec2d.Mul(direction, lastStrokePoint.radius)),
+      import_editor.Vec2d.Add(lastPoint, import_editor.Vec2d.Mul(direction, lastStrokePoint.radius * 0.99)),
+      import_editor.Vec2d.Sub(lastPoint, import_editor.Vec2d.Mul(direction, lastStrokePoint.radius * 0.99)),
+      import_editor.Vec2d.Sub(lastPoint, import_editor.Vec2d.Mul(direction, lastStrokePoint.radius))
+    );
+  }
+  return leftPts.concat(endCap, rightPts.reverse(), startCap);
+}
+//# sourceMappingURL=getStrokeOutlinePoints.js.map

package/dist-cjs/lib/shapes/shared/freehand/getStrokeOutlinePoints.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/getStrokeOutlinePoints.ts"],
+  "sourcesContent": ["import { Vec2d } from '@bigbluebutton/editor'\nimport type { StrokeOptions, StrokePoint } from './types'\n\nconst { PI } = Math\n\n// Browser strokes seem to be off if PI is regular, a tiny offset seems to fix it\nconst FIXED_PI = PI + 0.0001\n\n/**\n * @internal\n */\nexport function getStrokeOutlineTracks(\n\tstrokePoints: StrokePoint[],\n\toptions: StrokeOptions = {}\n): { left: Vec2d[]; right: Vec2d[] } {\n\tconst { size = 16, smoothing = 0.5 } = options\n\n\t// We can't do anything with an empty array or a stroke with negative size.\n\tif (strokePoints.length === 0 || size <= 0) {\n\t\treturn { left: [], right: [] }\n\t}\n\n\tconst firstStrokePoint = strokePoints[0]\n\tconst lastStrokePoint = strokePoints[strokePoints.length - 1]\n\n\t// The total length of the line\n\tconst totalLength = lastStrokePoint.runningLength\n\n\t// The minimum allowed distance between points (squared)\n\tconst minDistance = Math.pow(size * smoothing, 2)\n\n\t// Our collected left and right points\n\tconst leftPts: Vec2d[] = []\n\tconst rightPts: Vec2d[] = []\n\n\t// Previous vector\n\tlet prevVector = strokePoints[0].vector\n\n\t// Previous left and right points\n\tlet pl = strokePoints[0].point\n\tlet pr = pl\n\n\t// Temporary left and right points\n\tlet tl = pl\n\tlet tr = pr\n\n\t// Keep track of whether the previous point is a sharp corner\n\t// ... so that we don't detect the same corner twice\n\tlet isPrevPointSharpCorner = false\n\n\t/*\n    Find the outline's left and right points\n\n    Iterating through the points and populate the rightPts and leftPts arrays,\n    skipping the first and last pointsm, which will get caps later on.\n  */\n\n\tlet strokePoint: StrokePoint\n\n\tfor (let i = 0; i < strokePoints.length; i++) {\n\t\tstrokePoint = strokePoints[i]\n\t\tconst { point, vector } = strokePoints[i]\n\n\t\t/*\n      Handle sharp corners\n\n      Find the difference (dot product) between the current and next vector.\n      If the next vector is at more than a right angle to the current vector,\n      draw a cap at the current point.\n    */\n\n\t\tconst prevDpr = strokePoint.vector.dpr(prevVector)\n\t\tconst nextVector = (i < strokePoints.length - 1 ? strokePoints[i + 1] : strokePoints[i]).vector\n\t\tconst nextDpr = i < strokePoints.length - 1 ? nextVector.dpr(strokePoint.vector) : 1\n\n\t\tconst isPointSharpCorner = prevDpr < 0 && !isPrevPointSharpCorner\n\t\tconst isNextPointSharpCorner = nextDpr !== null && nextDpr < 0.2\n\n\t\tif (isPointSharpCorner || isNextPointSharpCorner) {\n\t\t\t// It's a sharp corner. Draw a rounded cap and move on to the next point\n\t\t\t// Considering saving these and drawing them later? So that we can avoid\n\t\t\t// crossing future points.\n\n\t\t\tif (nextDpr > -0.62 && totalLength - strokePoint.runningLength > strokePoint.radius) {\n\t\t\t\t// Draw a \"soft\" corner\n\t\t\t\tconst offset = prevVector.clone().mul(strokePoint.radius)\n\t\t\t\tconst cpr = prevVector.clone().cpr(nextVector)\n\n\t\t\t\tif (cpr < 0) {\n\t\t\t\t\ttl = Vec2d.Add(point, offset)\n\t\t\t\t\ttr = Vec2d.Sub(point, offset)\n\t\t\t\t} else {\n\t\t\t\t\ttl = Vec2d.Sub(point, offset)\n\t\t\t\t\ttr = Vec2d.Add(point, offset)\n\t\t\t\t}\n\n\t\t\t\tleftPts.push(tl)\n\t\t\t\trightPts.push(tr)\n\t\t\t} else {\n\t\t\t\t// Draw a \"sharp\" corner\n\t\t\t\tconst offset = prevVector.clone().mul(strokePoint.radius).per()\n\t\t\t\tconst start = Vec2d.Sub(strokePoint.input, offset)\n\n\t\t\t\tfor (let step = 1 / 13, t = 0; t < 1; t += step) {\n\t\t\t\t\ttl = Vec2d.RotWith(start, strokePoint.input, FIXED_PI * t)\n\t\t\t\t\tleftPts.push(tl)\n\n\t\t\t\t\ttr = Vec2d.RotWith(start, strokePoint.input, FIXED_PI + FIXED_PI * -t)\n\t\t\t\t\trightPts.push(tr)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tpl = tl\n\t\t\tpr = tr\n\n\t\t\tif (isNextPointSharpCorner) {\n\t\t\t\tisPrevPointSharpCorner = true\n\t\t\t}\n\n\t\t\tcontinue\n\t\t}\n\n\t\tisPrevPointSharpCorner = false\n\n\t\tif (strokePoint === firstStrokePoint || strokePoint === lastStrokePoint) {\n\t\t\tconst offset = Vec2d.Per(vector).mul(strokePoint.radius)\n\t\t\tleftPts.push(Vec2d.Sub(point, offset))\n\t\t\trightPts.push(Vec2d.Add(point, offset))\n\n\t\t\tcontinue\n\t\t}\n\n\t\t/* \n      Add regular points\n\n      Project points to either side of the current point, using the\n      calculated size as a distance. If a point's distance to the \n      previous point on that side greater than the minimum distance\n      (or if the corner is kinda sharp), add the points to the side's\n      points array.\n    */\n\n\t\tconst offset = Vec2d.Lrp(nextVector, vector, nextDpr).per().mul(strokePoint.radius)\n\n\t\ttl = Vec2d.Sub(point, offset)\n\n\t\tif (i <= 1 || Vec2d.Dist2(pl, tl) > minDistance) {\n\t\t\tleftPts.push(tl)\n\t\t\tpl = tl\n\t\t}\n\n\t\ttr = Vec2d.Add(point, offset)\n\n\t\tif (i <= 1 || Vec2d.Dist2(pr, tr) > minDistance) {\n\t\t\trightPts.push(tr)\n\t\t\tpr = tr\n\t\t}\n\n\t\t// Set variables for next iteration\n\t\tprevVector = vector\n\n\t\tcontinue\n\t}\n\n\t/*\n    Return the points in the correct winding order: begin on the left side, then \n    continue around the end cap, then come back along the right side, and finally \n    complete the start cap.\n  */\n\n\treturn {\n\t\tleft: leftPts,\n\t\tright: rightPts,\n\t}\n}\n\n/**\n * ## getStrokeOutlinePoints\n *\n * Get an array of points (as `[x, y]`) representing the outline of a stroke.\n *\n * @param points - An array of StrokePoints as returned from `getStrokePoints`.\n * @param options - An object with options.\n * @public\n */\nexport function getStrokeOutlinePoints(\n\tstrokePoints: StrokePoint[],\n\toptions: StrokeOptions = {}\n): Vec2d[] {\n\tconst { size = 16, start = {}, end = {}, last: isComplete = false } = options\n\n\tconst { cap: capStart = true } = start\n\tconst { cap: capEnd = true } = end\n\n\t// We can't do anything with an empty array or a stroke with negative size.\n\tif (strokePoints.length === 0 || size <= 0) {\n\t\treturn []\n\t}\n\n\tconst firstStrokePoint = strokePoints[0]\n\tconst lastStrokePoint = strokePoints[strokePoints.length - 1]\n\n\t// The total length of the line\n\tconst totalLength = lastStrokePoint.runningLength\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\t// The minimum allowed distance between points (squared)\n\t// Our collected left and right points\n\tconst { left: leftPts, right: rightPts } = getStrokeOutlineTracks(strokePoints, options)\n\n\t/*\n    Drawing caps\n    \n    Now that we have our points on either side of the line, we need to\n    draw caps at the start and end. Tapered lines don't have caps, but\n    may have dots for very short lines.\n  */\n\n\tconst firstPoint = firstStrokePoint.point\n\n\tconst lastPoint =\n\t\tstrokePoints.length > 1\n\t\t\t? strokePoints[strokePoints.length - 1].point\n\t\t\t: Vec2d.AddXY(firstStrokePoint.point, 1, 1)\n\n\t/* \n    Draw a dot for very short or completed strokes\n    \n    If the line is too short to gather left or right points and if the line is\n    not tapered on either side, draw a dot. If the line is tapered, then only\n    draw a dot if the line is both very short and complete. If we draw a dot,\n    we can just return those points.\n  */\n\n\tif (strokePoints.length === 1) {\n\t\tif (!(taperStart || taperEnd) || isComplete) {\n\t\t\tconst start = Vec2d.Add(\n\t\t\t\tfirstPoint,\n\t\t\t\tVec2d.Sub(firstPoint, lastPoint).uni().per().mul(-firstStrokePoint.radius)\n\t\t\t)\n\t\t\tconst dotPts: Vec2d[] = []\n\t\t\tfor (let step = 1 / 13, t = step; t <= 1; t += step) {\n\t\t\t\tdotPts.push(Vec2d.RotWith(start, firstPoint, FIXED_PI * 2 * t))\n\t\t\t}\n\t\t\treturn dotPts\n\t\t}\n\t}\n\n\t/*\n    Draw a start cap\n\n    Unless the line has a tapered start, or unless the line has a tapered end\n    and the line is very short, draw a start cap around the first point. Use\n    the distance between the second left and right point for the cap's radius.\n    Finally remove the first left and right points. :psyduck:\n  */\n\n\tconst startCap: Vec2d[] = []\n\tif (taperStart || (taperEnd && strokePoints.length === 1)) {\n\t\t// The start point is tapered, noop\n\t} else if (capStart) {\n\t\t// Draw the round cap - add thirteen points rotating the right point around the start point to the left point\n\t\tfor (let step = 1 / 8, t = step; t <= 1; t += step) {\n\t\t\tconst pt = Vec2d.RotWith(rightPts[0], firstPoint, FIXED_PI * t)\n\t\t\tstartCap.push(pt)\n\t\t}\n\t} else {\n\t\t// Draw the flat cap - add a point to the left and right of the start point\n\t\tconst cornersVector = Vec2d.Sub(leftPts[0], rightPts[0])\n\t\tconst offsetA = Vec2d.Mul(cornersVector, 0.5)\n\t\tconst offsetB = Vec2d.Mul(cornersVector, 0.51)\n\n\t\tstartCap.push(\n\t\t\tVec2d.Sub(firstPoint, offsetA),\n\t\t\tVec2d.Sub(firstPoint, offsetB),\n\t\t\tVec2d.Add(firstPoint, offsetB),\n\t\t\tVec2d.Add(firstPoint, offsetA)\n\t\t)\n\t}\n\n\t/*\n    Draw an end cap\n\n    If the line does not have a tapered end, and unless the line has a tapered\n    start and the line is very short, draw a cap around the last point. Finally,\n    remove the last left and right points. Otherwise, add the last point. Note\n    that This cap is a full-turn-and-a-half: this prevents incorrect caps on\n    sharp end turns.\n  */\n\n\tconst endCap: Vec2d[] = []\n\tconst direction = lastStrokePoint.vector.clone().per().neg()\n\n\tif (taperEnd || (taperStart && strokePoints.length === 1)) {\n\t\t// Tapered end - push the last point to the line\n\t\tendCap.push(lastPoint)\n\t} else if (capEnd) {\n\t\t// Draw the round end cap\n\t\tconst start = Vec2d.Add(lastPoint, Vec2d.Mul(direction, lastStrokePoint.radius))\n\t\tfor (let step = 1 / 29, t = step; t < 1; t += step) {\n\t\t\tendCap.push(Vec2d.RotWith(start, lastPoint, FIXED_PI * 3 * t))\n\t\t}\n\t} else {\n\t\t// Draw the flat end cap\n\t\tendCap.push(\n\t\t\tVec2d.Add(lastPoint, Vec2d.Mul(direction, lastStrokePoint.radius)),\n\t\t\tVec2d.Add(lastPoint, Vec2d.Mul(direction, lastStrokePoint.radius * 0.99)),\n\t\t\tVec2d.Sub(lastPoint, Vec2d.Mul(direction, lastStrokePoint.radius * 0.99)),\n\t\t\tVec2d.Sub(lastPoint, Vec2d.Mul(direction, lastStrokePoint.radius))\n\t\t)\n\t}\n\n\t/*\n    Return the points in the correct winding order: begin on the left side, then \n    continue around the end cap, then come back along the right side, and finally \n    complete the start cap.\n  */\n\n\treturn leftPts.concat(endCap, rightPts.reverse(), startCap)\n}\n"],
+  "mappings": "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",
+  "names": ["offset", "start"]
+}

package/dist-cjs/lib/shapes/shared/freehand/getStrokePoints.js

@@ -0,0 +1,144 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getStrokePoints_exports = {};
+__export(getStrokePoints_exports, {
+  getStrokePoints: () => getStrokePoints
+});
+module.exports = __toCommonJS(getStrokePoints_exports);
+var import_editor = require("@bigbluebutton/editor");
+const MIN_START_PRESSURE = 0.025;
+const MIN_END_PRESSURE = 0.01;
+function getStrokePoints(rawInputPoints, options = {}) {
+  const { streamline = 0.5, size = 16, simulatePressure = false } = options;
+  if (rawInputPoints.length === 0)
+    return [];
+  const t = 0.15 + (1 - streamline) * 0.85;
+  let pts = rawInputPoints.map(import_editor.Vec2d.From);
+  let pointsRemovedFromNearEnd = 0;
+  if (!simulatePressure) {
+    let pt2 = pts[0];
+    while (pt2) {
+      if (pt2.z >= MIN_START_PRESSURE)
+        break;
+      pts.shift();
+      pt2 = pts[0];
+    }
+  }
+  if (!simulatePressure) {
+    let pt2 = pts[pts.length - 1];
+    while (pt2) {
+      if (pt2.z >= MIN_END_PRESSURE)
+        break;
+      pts.pop();
+      pt2 = pts[pts.length - 1];
+    }
+  }
+  if (pts.length === 0)
+    return [
+      {
+        point: import_editor.Vec2d.From(rawInputPoints[0]),
+        input: import_editor.Vec2d.From(rawInputPoints[0]),
+        pressure: simulatePressure ? 0.5 : 0.15,
+        vector: new import_editor.Vec2d(1, 1),
+        distance: 0,
+        runningLength: 0,
+        radius: 1
+      }
+    ];
+  let pt = pts[1];
+  while (pt) {
+    if (import_editor.Vec2d.Dist(pt, pts[0]) > size / 3)
+      break;
+    pts[0].z = Math.max(pts[0].z, pt.z);
+    pts.splice(1, 1);
+    pt = pts[1];
+  }
+  const last = pts.pop();
+  pt = pts[pts.length - 1];
+  while (pt) {
+    if (import_editor.Vec2d.Dist(pt, last) > size / 3)
+      break;
+    pts.pop();
+    pt = pts[pts.length - 1];
+    pointsRemovedFromNearEnd++;
+  }
+  pts.push(last);
+  const isComplete = options.last || !options.simulatePressure || pts.length > 1 && import_editor.Vec2d.Dist(pts[pts.length - 1], pts[pts.length - 2]) < size || pointsRemovedFromNearEnd > 0;
+  if (pts.length === 2 && options.simulatePressure) {
+    const last2 = pts[1];
+    pts = pts.slice(0, -1);
+    for (let i = 1; i < 5; i++) {
+      const next = import_editor.Vec2d.Lrp(pts[0], last2, i / 4);
+      next.z = (pts[0].z + (last2.z - pts[0].z)) * i / 4;
+      pts.push(next);
+    }
+  }
+  const strokePoints = [
+    {
+      point: pts[0],
+      input: pts[0],
+      pressure: simulatePressure ? 0.5 : pts[0].z,
+      vector: new import_editor.Vec2d(1, 1),
+      distance: 0,
+      runningLength: 0,
+      radius: 1
+    }
+  ];
+  let totalLength = 0;
+  let prev = strokePoints[0];
+  let point, distance;
+  if (isComplete && streamline > 0) {
+    pts.push(pts[pts.length - 1].clone());
+  }
+  for (let i = 1, n = pts.length; i < n; i++) {
+    point = !t || options.last && i === n - 1 ? pts[i].clone() : pts[i].clone().lrp(prev.point, 1 - t);
+    if (prev.point.equals(point))
+      continue;
+    distance = import_editor.Vec2d.Dist(point, prev.point);
+    totalLength += distance;
+    if (i < 4 && totalLength < size) {
+      continue;
+    }
+    prev = {
+      input: pts[i],
+      // The adjusted point
+      point,
+      // The input pressure (or .5 if not specified)
+      pressure: simulatePressure ? 0.5 : pts[i].z,
+      // The vector from the current point to the previous point
+      vector: import_editor.Vec2d.Sub(prev.point, point).uni(),
+      // The distance between the current point and the previous point
+      distance,
+      // The total distance so far
+      runningLength: totalLength,
+      // The stroke point's radius
+      radius: 1
+    };
+    strokePoints.push(prev);
+  }
+  if (strokePoints[1]?.vector) {
+    strokePoints[0].vector = strokePoints[1].vector.clone();
+  }
+  if (totalLength < 1) {
+    const maxPressureAmongPoints = Math.max(0.5, ...strokePoints.map((s) => s.pressure));
+    strokePoints.forEach((s) => s.pressure = maxPressureAmongPoints);
+  }
+  return strokePoints;
+}
+//# sourceMappingURL=getStrokePoints.js.map

package/dist-cjs/lib/shapes/shared/freehand/getStrokePoints.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/getStrokePoints.ts"],
+  "sourcesContent": ["import { Vec2d, VecLike } from '@bigbluebutton/editor'\nimport type { StrokeOptions, StrokePoint } from './types'\n\nconst MIN_START_PRESSURE = 0.025\nconst MIN_END_PRESSURE = 0.01\n\n/**\n * ## getStrokePoints\n *\n * Get an array of points as objects with an adjusted point, pressure, vector, distance, and\n * runningLength.\n *\n * @param points - An array of points (as `[x, y, pressure]` or `{x, y, pressure}`). Pressure is\n *   optional in both cases.\n * @param options - An object with options.\n * @public\n */\nexport function getStrokePoints(\n\trawInputPoints: VecLike[],\n\toptions: StrokeOptions = {}\n): StrokePoint[] {\n\tconst { streamline = 0.5, size = 16, simulatePressure = false } = options\n\n\t// If we don't have any points, return an empty array.\n\tif (rawInputPoints.length === 0) return []\n\n\t// Find the interpolation level between points.\n\tconst t = 0.15 + (1 - streamline) * 0.85\n\n\t// Whatever the input is, make sure that the points are in number[][].\n\tlet pts = rawInputPoints.map(Vec2d.From)\n\n\tlet pointsRemovedFromNearEnd = 0\n\n\tif (!simulatePressure) {\n\t\t// Strip low pressure points from the start of the array.\n\t\tlet pt = pts[0]\n\t\twhile (pt) {\n\t\t\tif (pt.z >= MIN_START_PRESSURE) break\n\t\t\tpts.shift()\n\t\t\tpt = pts[0]\n\t\t}\n\t}\n\n\tif (!simulatePressure) {\n\t\t// Strip low pressure points from the end of the array.\n\t\tlet pt = pts[pts.length - 1]\n\t\twhile (pt) {\n\t\t\tif (pt.z >= MIN_END_PRESSURE) break\n\t\t\tpts.pop()\n\t\t\tpt = pts[pts.length - 1]\n\t\t}\n\t}\n\n\tif (pts.length === 0)\n\t\treturn [\n\t\t\t{\n\t\t\t\tpoint: Vec2d.From(rawInputPoints[0]),\n\t\t\t\tinput: Vec2d.From(rawInputPoints[0]),\n\t\t\t\tpressure: simulatePressure ? 0.5 : 0.15,\n\t\t\t\tvector: new Vec2d(1, 1),\n\t\t\t\tdistance: 0,\n\t\t\t\trunningLength: 0,\n\t\t\t\tradius: 1,\n\t\t\t},\n\t\t]\n\n\t// Strip points that are too close to the first point.\n\tlet pt = pts[1]\n\twhile (pt) {\n\t\tif (Vec2d.Dist(pt, pts[0]) > size / 3) break\n\t\tpts[0].z = Math.max(pts[0].z, pt.z) // Use maximum pressure\n\t\tpts.splice(1, 1)\n\t\tpt = pts[1]\n\t}\n\n\t// Strip points that are too close to the last point.\n\tconst last = pts.pop()!\n\tpt = pts[pts.length - 1]\n\twhile (pt) {\n\t\tif (Vec2d.Dist(pt, last) > size / 3) break\n\t\tpts.pop()\n\t\tpt = pts[pts.length - 1]\n\t\tpointsRemovedFromNearEnd++\n\t}\n\tpts.push(last)\n\n\tconst isComplete =\n\t\toptions.last ||\n\t\t!options.simulatePressure ||\n\t\t(pts.length > 1 && Vec2d.Dist(pts[pts.length - 1], pts[pts.length - 2]) < size) ||\n\t\tpointsRemovedFromNearEnd > 0\n\n\t// Add extra points between the two, to help avoid \"dash\" lines\n\t// for strokes with tapered start and ends. Don't mutate the\n\t// input array!\n\tif (pts.length === 2 && options.simulatePressure) {\n\t\tconst last = pts[1]\n\t\tpts = pts.slice(0, -1)\n\t\tfor (let i = 1; i < 5; i++) {\n\t\t\tconst next = Vec2d.Lrp(pts[0], last, i / 4)\n\t\t\tnext.z = ((pts[0].z + (last.z - pts[0].z)) * i) / 4\n\t\t\tpts.push(next)\n\t\t}\n\t}\n\n\t// The strokePoints array will hold the points for the stroke.\n\t// Start it out with the first point, which needs no adjustment.\n\tconst strokePoints: StrokePoint[] = [\n\t\t{\n\t\t\tpoint: pts[0],\n\t\t\tinput: pts[0],\n\t\t\tpressure: simulatePressure ? 0.5 : pts[0].z,\n\t\t\tvector: new Vec2d(1, 1),\n\t\t\tdistance: 0,\n\t\t\trunningLength: 0,\n\t\t\tradius: 1,\n\t\t},\n\t]\n\n\t// We use the totalLength to keep track of the total distance\n\tlet totalLength = 0\n\n\t// We're set this to the latest point, so we can use it to calculate\n\t// the distance and vector of the next point.\n\tlet prev = strokePoints[0]\n\n\t// Iterate through all of the points, creating StrokePoints.\n\tlet point: Vec2d, distance: number\n\n\tif (isComplete && streamline > 0) {\n\t\tpts.push(pts[pts.length - 1].clone())\n\t}\n\n\tfor (let i = 1, n = pts.length; i < n; i++) {\n\t\tpoint =\n\t\t\t!t || (options.last && i === n - 1) ? pts[i].clone() : pts[i].clone().lrp(prev.point, 1 - t)\n\n\t\t// If the new point is the same as the previous point, skip ahead.\n\t\tif (prev.point.equals(point)) continue\n\n\t\t// How far is the new point from the previous point?\n\t\tdistance = Vec2d.Dist(point, prev.point)\n\n\t\t// Add this distance to the total \"running length\" of the line.\n\t\ttotalLength += distance\n\n\t\t// At the start of the line, we wait until the new point is a\n\t\t// certain distance away from the original point, to avoid noise\n\n\t\tif (i < 4 && totalLength < size) {\n\t\t\tcontinue\n\t\t}\n\n\t\t// Create a new strokepoint (it will be the new \"previous\" one).\n\t\tprev = {\n\t\t\tinput: pts[i],\n\t\t\t// The adjusted point\n\t\t\tpoint,\n\t\t\t// The input pressure (or .5 if not specified)\n\t\t\tpressure: simulatePressure ? 0.5 : pts[i].z,\n\t\t\t// The vector from the current point to the previous point\n\t\t\tvector: Vec2d.Sub(prev.point, point).uni(),\n\t\t\t// The distance between the current point and the previous point\n\t\t\tdistance,\n\t\t\t// The total distance so far\n\t\t\trunningLength: totalLength,\n\t\t\t// The stroke point's radius\n\t\t\tradius: 1,\n\t\t}\n\n\t\t// Push it to the strokePoints array.\n\t\tstrokePoints.push(prev)\n\t}\n\n\t// Set the vector of the first point to be the same as the second point.\n\tif (strokePoints[1]?.vector) {\n\t\tstrokePoints[0].vector = strokePoints[1].vector.clone()\n\t}\n\n\tif (totalLength < 1) {\n\t\tconst maxPressureAmongPoints = Math.max(0.5, ...strokePoints.map((s) => s.pressure))\n\t\tstrokePoints.forEach((s) => (s.pressure = maxPressureAmongPoints))\n\t}\n\n\treturn strokePoints\n}\n"],
+  "mappings": "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",
+  "names": ["pt", "last"]
+}

package/dist-cjs/lib/shapes/shared/freehand/getStrokeRadius.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getStrokeRadius_exports = {};
+__export(getStrokeRadius_exports, {
+  getStrokeRadius: () => getStrokeRadius
+});
+module.exports = __toCommonJS(getStrokeRadius_exports);
+function getStrokeRadius(size, thinning, pressure, easing = (t) => t) {
+  return size * easing(0.5 - thinning * (0.5 - pressure));
+}
+//# sourceMappingURL=getStrokeRadius.js.map

package/dist-cjs/lib/shapes/shared/freehand/getStrokeRadius.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/getStrokeRadius.ts"],
+  "sourcesContent": ["/**\n * Compute a radius based on the pressure.\n *\n * @internal\n */\nexport function getStrokeRadius(\n\tsize: number,\n\tthinning: number,\n\tpressure: number,\n\teasing: (t: number) => number = (t) => t\n) {\n\treturn size * easing(0.5 - thinning * (0.5 - pressure))\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKO,SAAS,gBACf,MACA,UACA,UACA,SAAgC,CAAC,MAAM,GACtC;AACD,SAAO,OAAO,OAAO,MAAM,YAAY,MAAM,SAAS;AACvD;",
+  "names": []
+}

package/dist-cjs/lib/shapes/shared/freehand/setStrokePointRadii.js

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var setStrokePointRadii_exports = {};
+__export(setStrokePointRadii_exports, {
+  setStrokePointRadii: () => setStrokePointRadii
+});
+module.exports = __toCommonJS(setStrokePointRadii_exports);
+var import_editor = require("@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 = import_editor.EASINGS.easeOutQuad } = start;
+  const { easing: taperEndEase = import_editor.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;
+}
+//# sourceMappingURL=setStrokePointRadii.js.map

package/dist-cjs/lib/shapes/shared/freehand/setStrokePointRadii.js.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-cjs/lib/shapes/shared/freehand/svg.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var svg_exports = {};
+__export(svg_exports, {
+  getSvgPathFromStrokePoints: () => getSvgPathFromStrokePoints
+});
+module.exports = __toCommonJS(svg_exports);
+var import_editor = require("@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${(0, import_editor.precise)(a)}L${(0, import_editor.precise)(b)}`;
+  }
+  let result = "";
+  for (let i = 2, max = len - 1; i < max; i++) {
+    a = points[i].point;
+    b = points[i + 1].point;
+    result += (0, import_editor.average)(a, b);
+  }
+  if (closed) {
+    return `M${(0, import_editor.average)(points[0].point, points[1].point)}Q${(0, import_editor.precise)(points[1].point)}${(0, import_editor.average)(
+      points[1].point,
+      points[2].point
+    )}T${result}${(0, import_editor.average)(points[len - 1].point, points[0].point)}${(0, import_editor.average)(
+      points[0].point,
+      points[1].point
+    )}Z`;
+  } else {
+    return `M${(0, import_editor.precise)(points[0].point)}Q${(0, import_editor.precise)(points[1].point)}${(0, import_editor.average)(
+      points[1].point,
+      points[2].point
+    )}${points.length > 3 ? "T" : ""}${result}L${(0, import_editor.precise)(points[len - 1].point)}`;
+  }
+}
+//# sourceMappingURL=svg.js.map

package/dist-cjs/lib/shapes/shared/freehand/svg.js.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;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAiC;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,QAAI,uBAAQ,CAAC,CAAC,QAAI,uBAAQ,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,kBAAU,uBAAQ,GAAG,CAAC;AAAA,EACvB;AAEA,MAAI,QAAQ;AAEX,WAAO,QAAI,uBAAQ,OAAO,CAAC,EAAE,OAAO,OAAO,CAAC,EAAE,KAAK,CAAC,QAAI,uBAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,OAAG;AAAA,MAClF,OAAO,CAAC,EAAE;AAAA,MACV,OAAO,CAAC,EAAE;AAAA,IACX,CAAC,IAAI,MAAM,OAAG,uBAAQ,OAAO,MAAM,CAAC,EAAE,OAAO,OAAO,CAAC,EAAE,KAAK,CAAC,OAAG;AAAA,MAC/D,OAAO,CAAC,EAAE;AAAA,MACV,OAAO,CAAC,EAAE;AAAA,IACX,CAAC;AAAA,EACF,OAAO;AAIN,WAAO,QAAI,uBAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,QAAI,uBAAQ,OAAO,CAAC,EAAE,KAAK,CAAC,OAAG;AAAA,MACjE,OAAO,CAAC,EAAE;AAAA,MACV,OAAO,CAAC,EAAE;AAAA,IACX,CAAC,GAAG,OAAO,SAAS,IAAI,MAAM,EAAE,GAAG,MAAM,QAAI,uBAAQ,OAAO,MAAM,CAAC,EAAE,KAAK,CAAC;AAAA,EAC5E;AACD;",
+  "names": []
+}