tldraw 5.2.0-next.e2b8d10bf10e → 5.2.0

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

@@ -0,0 +1,404 @@
+const MIN_PRESSURE = 0.025;
+const RATE_OF_PRESSURE_CHANGE = 0.275;
+const easeOutQuad = (t) => t * (2 - t);
+const easeOutCubic = (t) => --t * t * t + 1;
+const { min } = Math;
+let pointCapacity = 256;
+let pointX = new Float64Array(pointCapacity);
+let pointY = new Float64Array(pointCapacity);
+let inputX = new Float64Array(pointCapacity);
+let inputY = new Float64Array(pointCapacity);
+let inputZ = new Float64Array(pointCapacity);
+let pressures = new Float64Array(pointCapacity);
+let distances = new Float64Array(pointCapacity);
+let runningLengths = new Float64Array(pointCapacity);
+let radii = new Float64Array(pointCapacity);
+let pointCount = 0;
+function ensurePointCapacity(n) {
+  if (n <= pointCapacity) return;
+  while (pointCapacity < n) pointCapacity *= 2;
+  pointX = new Float64Array(pointCapacity);
+  pointY = new Float64Array(pointCapacity);
+  inputX = new Float64Array(pointCapacity);
+  inputY = new Float64Array(pointCapacity);
+  inputZ = new Float64Array(pointCapacity);
+  pressures = new Float64Array(pointCapacity);
+  distances = new Float64Array(pointCapacity);
+  runningLengths = new Float64Array(pointCapacity);
+  radii = new Float64Array(pointCapacity);
+}
+let stageCapacity = 256;
+let stageX = new Float64Array(stageCapacity);
+let stageY = new Float64Array(stageCapacity);
+let stageZ = new Float64Array(stageCapacity);
+function ensureStageCapacity(n) {
+  if (n <= stageCapacity) return;
+  while (stageCapacity < n) stageCapacity *= 2;
+  stageX = new Float64Array(stageCapacity);
+  stageY = new Float64Array(stageCapacity);
+  stageZ = new Float64Array(stageCapacity);
+}
+function zOf(p, clampZ) {
+  const z = p.z === void 0 ? 1 : p.z;
+  return clampZ && z < MIN_PRESSURE ? MIN_PRESSURE : z;
+}
+function ingest(rawInputPoints, options = {}) {
+  const { streamline = 0.5, size = 16, simulatePressure = false } = options;
+  pointCount = 0;
+  const rawLen = rawInputPoints.length;
+  if (rawLen === 0) return;
+  const t = 0.15 + (1 - streamline) * 0.85;
+  ensureStageCapacity(rawLen + 8);
+  ensurePointCapacity(rawLen + 8);
+  const stX = stageX;
+  const stY = stageY;
+  const stZ = stageZ;
+  const minDist2 = (size / 3) ** 2;
+  const clampZ = !simulatePressure;
+  const first = rawInputPoints[0];
+  let firstZ = zOf(first, clampZ);
+  let startIdx = 1;
+  while (startIdx < rawLen) {
+    const pt = rawInputPoints[startIdx];
+    const dx = pt.x - first.x;
+    const dy = pt.y - first.y;
+    if (dx * dx + dy * dy > minDist2) break;
+    firstZ = Math.max(firstZ, zOf(pt, clampZ));
+    startIdx++;
+  }
+  stX[0] = first.x;
+  stY[0] = first.y;
+  stZ[0] = firstZ;
+  let m = 1;
+  for (let i = startIdx; i < rawLen; i++) {
+    const pt = rawInputPoints[i];
+    stX[m] = pt.x;
+    stY[m] = pt.y;
+    stZ[m] = zOf(pt, clampZ);
+    m++;
+  }
+  let pointsRemovedFromNearEnd = 0;
+  if (m > 1) {
+    const lastX = stX[m - 1];
+    const lastY = stY[m - 1];
+    let j = m - 2;
+    while (j >= 0) {
+      const dx = stX[j] - lastX;
+      const dy = stY[j] - lastY;
+      if (dx * dx + dy * dy > minDist2) break;
+      j--;
+      pointsRemovedFromNearEnd++;
+    }
+    if (j < m - 2) {
+      stX[j + 1] = lastX;
+      stY[j + 1] = lastY;
+      stZ[j + 1] = stZ[m - 1];
+      m = j + 2;
+    }
+  }
+  const isComplete = options.last || !options.simulatePressure || m > 1 && (stX[m - 1] - stX[m - 2]) * (stX[m - 1] - stX[m - 2]) + (stY[m - 1] - stY[m - 2]) * (stY[m - 1] - stY[m - 2]) < size ** 2 || pointsRemovedFromNearEnd > 0;
+  if (m === 2 && options.simulatePressure) {
+    const x0 = stX[0];
+    const y0 = stY[0];
+    const z0 = stZ[0];
+    const x1 = stX[1];
+    const y1 = stY[1];
+    const z1 = stZ[1];
+    for (let i = 1; i < 5; i++) {
+      const u2 = i / 4;
+      stX[i] = x0 + (x1 - x0) * u2;
+      stY[i] = y0 + (y1 - y0) * u2;
+      stZ[i] = (z0 + (z1 - z0)) * i / 4;
+    }
+    m = 5;
+  }
+  const ptX = pointX;
+  const ptY = pointY;
+  const inX = inputX;
+  const inY = inputY;
+  const inZ = inputZ;
+  const press = pressures;
+  const dists = distances;
+  const runs = runningLengths;
+  const rads = radii;
+  ptX[0] = stX[0];
+  ptY[0] = stY[0];
+  inX[0] = stX[0];
+  inY[0] = stY[0];
+  inZ[0] = stZ[0];
+  press[0] = simulatePressure ? 0.5 : stZ[0];
+  dists[0] = 0;
+  runs[0] = 0;
+  rads[0] = 1;
+  let count = 1;
+  if (isComplete && streamline > 0) {
+    stX[m] = stX[m - 1];
+    stY[m] = stY[m - 1];
+    stZ[m] = stZ[m - 1];
+    m++;
+  }
+  let totalLength = 0;
+  let prevX = stX[0];
+  let prevY = stY[0];
+  const u = 1 - t;
+  const isLast = options.last;
+  for (let i = 1; i < m; i++) {
+    let x, y;
+    if (!t || isLast && i === m - 1) {
+      x = stX[i];
+      y = stY[i];
+    } else {
+      x = stX[i] + (prevX - stX[i]) * u;
+      y = stY[i] + (prevY - stY[i]) * u;
+    }
+    if (Math.abs(prevX - x) < 1e-4 && Math.abs(prevY - y) < 1e-4) continue;
+    const distance = ((y - prevY) ** 2 + (x - prevX) ** 2) ** 0.5;
+    totalLength += distance;
+    if (i < 4 && totalLength < size) continue;
+    ptX[count] = x;
+    ptY[count] = y;
+    inX[count] = stX[i];
+    inY[count] = stY[i];
+    inZ[count] = stZ[i];
+    press[count] = simulatePressure ? 0.5 : stZ[i];
+    dists[count] = distance;
+    runs[count] = totalLength;
+    rads[count] = 1;
+    count++;
+    prevX = x;
+    prevY = y;
+  }
+  if (totalLength < 1) {
+    let max = 0.5;
+    for (let i = 0; i < count; i++) max = Math.max(max, press[i]);
+    for (let i = 0; i < count; i++) press[i] = max;
+  }
+  pointCount = count;
+}
+function resolveTaper(taper, size, totalLength) {
+  if (!taper) return 0;
+  return taper === true ? Math.max(size, totalLength) : taper;
+}
+function computeRadii(options) {
+  const {
+    size = 16,
+    thinning = 0.5,
+    simulatePressure = true,
+    easing = (t) => t,
+    start = {},
+    end = {}
+  } = options;
+  const { easing: taperStartEase = easeOutQuad } = start;
+  const { easing: taperEndEase = easeOutCubic } = end;
+  const n = pointCount;
+  const press = pressures;
+  const dists = distances;
+  const runs = runningLengths;
+  const rads = radii;
+  const totalLength = runs[n - 1];
+  if (!simulatePressure && totalLength < size) {
+    let max = 0.5;
+    for (let i = 0; i < n; i++) max = Math.max(max, press[i]);
+    for (let i = 0; i < n; i++) {
+      press[i] = max;
+      rads[i] = size * easing(0.5 - thinning * (0.5 - max));
+    }
+    return;
+  }
+  let prevPressure = press[0];
+  for (let i = 0; i < n; i++) {
+    if (runs[i] > size * 5) break;
+    const sp = min(1, dists[i] / size);
+    let p;
+    if (simulatePressure) {
+      const rp = min(1, 1 - sp);
+      p = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE));
+    } else {
+      p = min(1, prevPressure + (press[i] - prevPressure) * 0.5);
+    }
+    prevPressure = prevPressure + (p - prevPressure) * 0.5;
+  }
+  const taperStart = resolveTaper(start.taper, size, totalLength);
+  const taperEnd = resolveTaper(end.taper, size, totalLength);
+  const hasTaper = taperStart || taperEnd;
+  for (let i = 0; i < n; i++) {
+    let radius;
+    if (thinning) {
+      let pressure = press[i];
+      const sp = min(1, dists[i] / 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));
+      }
+      radius = size * easing(0.5 - thinning * (0.5 - pressure));
+      prevPressure = pressure;
+    } else {
+      radius = size / 2;
+    }
+    if (hasTaper) {
+      const runningLength = runs[i];
+      const ts = runningLength < taperStart ? taperStartEase(runningLength / taperStart) : 1;
+      const te = totalLength - runningLength < taperEnd ? taperEndEase((totalLength - runningLength) / taperEnd) : 1;
+      radius = Math.max(0.01, radius * Math.min(ts, te));
+    }
+    rads[i] = radius;
+  }
+}
+let srcCapacity = 256;
+let srcX = new Float64Array(srcCapacity);
+let srcY = new Float64Array(srcCapacity);
+let srcZ = new Float64Array(srcCapacity);
+let srcInputX = new Float64Array(srcCapacity);
+let srcInputY = new Float64Array(srcCapacity);
+let srcRadius = new Float64Array(srcCapacity);
+let srcRunningLength = new Float64Array(srcCapacity);
+let srcIsCap = new Uint8Array(srcCapacity);
+let srcCount = 0;
+function ensureSrcCapacity(n) {
+  if (n <= srcCapacity) return;
+  while (srcCapacity < n) srcCapacity *= 2;
+  srcX = new Float64Array(srcCapacity);
+  srcY = new Float64Array(srcCapacity);
+  srcZ = new Float64Array(srcCapacity);
+  srcInputX = new Float64Array(srcCapacity);
+  srcInputY = new Float64Array(srcCapacity);
+  srcRadius = new Float64Array(srcCapacity);
+  srcRunningLength = new Float64Array(srcCapacity);
+  srcIsCap = new Uint8Array(srcCapacity);
+}
+function loadSrcFromStrokePoints(strokePoints) {
+  const n = strokePoints.length;
+  ensureSrcCapacity(n);
+  const sx = srcX;
+  const sy = srcY;
+  const sz = srcZ;
+  const six = srcInputX;
+  const siy = srcInputY;
+  const sr = srcRadius;
+  const srl = srcRunningLength;
+  const scap = srcIsCap;
+  const first = strokePoints[0];
+  const last = strokePoints[n - 1];
+  for (let i = 0; i < n; i++) {
+    const sp = strokePoints[i];
+    const point = sp.point;
+    const input = sp.input;
+    sx[i] = point.x;
+    sy[i] = point.y;
+    sz[i] = point.z;
+    six[i] = input.x;
+    siy[i] = input.y;
+    sr[i] = sp.radius;
+    srl[i] = sp.runningLength;
+    scap[i] = sp === first || sp === last ? 1 : 0;
+  }
+  srcCount = n;
+}
+function loadSrcFromPipeline() {
+  const n = pointCount;
+  ensureSrcCapacity(n);
+  const sx = srcX;
+  const sy = srcY;
+  const sz = srcZ;
+  const six = srcInputX;
+  const siy = srcInputY;
+  const sr = srcRadius;
+  const srl = srcRunningLength;
+  const scap = srcIsCap;
+  const ptX = pointX;
+  const ptY = pointY;
+  const inX = inputX;
+  const inY = inputY;
+  const inZ = inputZ;
+  const runs = runningLengths;
+  const rads = radii;
+  for (let i = 0; i < n; i++) {
+    sx[i] = ptX[i];
+    sy[i] = ptY[i];
+    sz[i] = inZ[i];
+    six[i] = inX[i];
+    siy[i] = inY[i];
+    sr[i] = rads[i];
+    srl[i] = runs[i];
+    scap[i] = i === 0 || i === n - 1 ? 1 : 0;
+  }
+  srcCount = n;
+}
+function loadSrcPartition(a, aElbow, innerStart, innerEnd, b, bElbow, dupQuirk) {
+  ensureSrcCapacity(innerEnd - innerStart + 3);
+  const sx = srcX;
+  const sy = srcY;
+  const sz = srcZ;
+  const six = srcInputX;
+  const siy = srcInputY;
+  const sr = srcRadius;
+  const srl = srcRunningLength;
+  const scap = srcIsCap;
+  const ptX = pointX;
+  const ptY = pointY;
+  const inX = inputX;
+  const inY = inputY;
+  const inZ = inputZ;
+  const runs = runningLengths;
+  const rads = radii;
+  sx[0] = aElbow ? inX[a] : ptX[a];
+  sy[0] = aElbow ? inY[a] : ptY[a];
+  sz[0] = inZ[a];
+  six[0] = inX[a];
+  siy[0] = inY[a];
+  sr[0] = rads[a];
+  srl[0] = runs[a];
+  scap[0] = 1;
+  let w = 1;
+  for (let i = innerStart; i <= innerEnd; i++) {
+    sx[w] = ptX[i];
+    sy[w] = ptY[i];
+    sz[w] = inZ[i];
+    six[w] = inX[i];
+    siy[w] = inY[i];
+    sr[w] = rads[i];
+    srl[w] = runs[i];
+    scap[w] = 0;
+    w++;
+  }
+  if (dupQuirk) scap[w - 1] = 1;
+  sx[w] = bElbow ? inX[b] : ptX[b];
+  sy[w] = bElbow ? inY[b] : ptY[b];
+  sz[w] = inZ[b];
+  six[w] = inX[b];
+  siy[w] = inY[b];
+  sr[w] = rads[b];
+  srl[w] = runs[b];
+  scap[w] = 1;
+  srcCount = w + 1;
+}
+export {
+  computeRadii,
+  distances,
+  ingest,
+  inputX,
+  inputY,
+  inputZ,
+  loadSrcFromPipeline,
+  loadSrcFromStrokePoints,
+  loadSrcPartition,
+  pointCount,
+  pointX,
+  pointY,
+  pressures,
+  radii,
+  resolveTaper,
+  runningLengths,
+  srcCount,
+  srcInputX,
+  srcInputY,
+  srcIsCap,
+  srcRadius,
+  srcRunningLength,
+  srcX,
+  srcY,
+  srcZ
+};
+//# sourceMappingURL=core.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/core.ts"],
+  "sourcesContent": ["import { VecLike } from '@tldraw/editor'\nimport type { StrokeOptions, StrokePoint } from './types'\n\n// The stroke pipeline's internal representation: one module-level set of reusable\n// struct-of-arrays buffers instead of per-point objects. Like fmt.ts's byte buffer, the\n// buffers are non-reentrant: each public entry point fully consumes them before returning,\n// and the next call overwrites them.\n//\n// A stroke point's vector is not stored; it is derived on the fly from consecutive points\n// (the unit vector pointing back at the predecessor). A point's distance is stored rather\n// than derived from running lengths because `runningLength[i] - runningLength[i - 1]` is\n// not bit-identical to the accumulated distance in floating point.\n//\n// Hot loops capture the array bindings into locals: the arrays never grow mid-fill\n// (capacity is ensured up front), and locals avoid re-reading the module binding on\n// every access.\n\nconst MIN_PRESSURE = 0.025\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// Default taper easings, mirroring `EASINGS.easeOutQuad` and `EASINGS.easeOutCubic`\n// from `@tldraw/editor`.\nconst easeOutQuad = (t: number) => t * (2 - t)\nconst easeOutCubic = (t: number) => --t * t * t + 1\n\nconst { min } = Math\n\n// ---------------------------------------------------------------------------------\n// Pipeline buffers: one slot per stroke point, filled by `ingest`, radii filled in by\n// `computeRadii`. Callers ensure capacity before filling, so growth never copies.\n// ---------------------------------------------------------------------------------\n\nlet pointCapacity = 256\n/** Streamlined (smoothed) point coordinates. */\nexport let pointX = new Float64Array(pointCapacity)\nexport let pointY = new Float64Array(pointCapacity)\n/** The original input coordinates (used for elbows and sharp corners). */\nexport let inputX = new Float64Array(pointCapacity)\nexport let inputY = new Float64Array(pointCapacity)\n/** The input z (pressure channel) after clamping; kept for materializing StrokePoints. */\nexport let inputZ = new Float64Array(pointCapacity)\nexport let pressures = new Float64Array(pointCapacity)\nexport let distances = new Float64Array(pointCapacity)\nexport let runningLengths = new Float64Array(pointCapacity)\nexport let radii = new Float64Array(pointCapacity)\nexport let pointCount = 0\n\nfunction ensurePointCapacity(n: number) {\n\tif (n <= pointCapacity) return\n\twhile (pointCapacity < n) pointCapacity *= 2\n\tpointX = new Float64Array(pointCapacity)\n\tpointY = new Float64Array(pointCapacity)\n\tinputX = new Float64Array(pointCapacity)\n\tinputY = new Float64Array(pointCapacity)\n\tinputZ = new Float64Array(pointCapacity)\n\tpressures = new Float64Array(pointCapacity)\n\tdistances = new Float64Array(pointCapacity)\n\trunningLengths = new Float64Array(pointCapacity)\n\tradii = new Float64Array(pointCapacity)\n}\n\n// Staging buffers for the effective input sequence in `ingest` (after stripping\n// near-start/near-end points, the two-point interpolation, and the duplicated last\n// point) \u2014 replaces the cloned `pts` array of the object pipeline.\nlet stageCapacity = 256\nlet stageX = new Float64Array(stageCapacity)\nlet stageY = new Float64Array(stageCapacity)\nlet stageZ = new Float64Array(stageCapacity)\n\nfunction ensureStageCapacity(n: number) {\n\tif (n <= stageCapacity) return\n\twhile (stageCapacity < n) stageCapacity *= 2\n\tstageX = new Float64Array(stageCapacity)\n\tstageY = new Float64Array(stageCapacity)\n\tstageZ = new Float64Array(stageCapacity)\n}\n\n/** The z of a raw input point as `Vec.From` plus the pressure clamp would produce it. */\nfunction zOf(p: VecLike, clampZ: boolean): number {\n\tconst z = p.z === undefined ? 1 : p.z\n\t// Some pens or OSes report z=0 even while the pen is touching, so we clamp rather\n\t// than strip to avoid removing real input.\n\treturn clampZ && z < MIN_PRESSURE ? MIN_PRESSURE : z\n}\n\n/**\n * Phase 1: ingest and streamline raw input points straight into the pipeline buffers.\n * Mirrors what getStrokePoints used to do with per-point objects, keeping every\n * order-sensitive step: the pressure clamp, near-start/near-end stripping, the two-point\n * simulated-pressure interpolation, the early-noise skip, and the short-stroke pressure\n * fixup.\n *\n * @internal\n */\nexport function ingest(rawInputPoints: VecLike[], options: StrokeOptions = {}): void {\n\tconst { streamline = 0.5, size = 16, simulatePressure = false } = options\n\n\tpointCount = 0\n\tconst rawLen = rawInputPoints.length\n\tif (rawLen === 0) return\n\n\t// Find the interpolation level between points.\n\tconst t = 0.15 + (1 - streamline) * 0.85\n\n\tensureStageCapacity(rawLen + 8)\n\tensurePointCapacity(rawLen + 8)\n\n\tconst stX = stageX\n\tconst stY = stageY\n\tconst stZ = stageZ\n\n\tconst minDist2 = (size / 3) ** 2\n\tconst clampZ = !simulatePressure\n\n\t// Strip points that are too close to the first point, accumulating the maximum\n\t// pressure among them into the first point.\n\tconst first = rawInputPoints[0]\n\tlet firstZ = zOf(first, clampZ)\n\tlet startIdx = 1\n\twhile (startIdx < rawLen) {\n\t\tconst pt = rawInputPoints[startIdx]\n\t\tconst dx = pt.x - first.x\n\t\tconst dy = pt.y - first.y\n\t\tif (dx * dx + dy * dy > minDist2) break\n\t\tfirstZ = Math.max(firstZ, zOf(pt, clampZ))\n\t\tstartIdx++\n\t}\n\n\t// Stage the surviving points.\n\tstX[0] = first.x\n\tstY[0] = first.y\n\tstZ[0] = firstZ\n\tlet m = 1\n\tfor (let i = startIdx; i < rawLen; i++) {\n\t\tconst pt = rawInputPoints[i]\n\t\tstX[m] = pt.x\n\t\tstY[m] = pt.y\n\t\tstZ[m] = zOf(pt, clampZ)\n\t\tm++\n\t}\n\n\t// Strip points that are too close to the last point. This can consume the whole\n\t// sequence, leaving just the last point.\n\tlet pointsRemovedFromNearEnd = 0\n\tif (m > 1) {\n\t\tconst lastX = stX[m - 1]\n\t\tconst lastY = stY[m - 1]\n\t\tlet j = m - 2\n\t\twhile (j >= 0) {\n\t\t\tconst dx = stX[j] - lastX\n\t\t\tconst dy = stY[j] - lastY\n\t\t\tif (dx * dx + dy * dy > minDist2) break\n\t\t\tj--\n\t\t\tpointsRemovedFromNearEnd++\n\t\t}\n\t\tif (j < m - 2) {\n\t\t\tstX[j + 1] = lastX\n\t\t\tstY[j + 1] = lastY\n\t\t\tstZ[j + 1] = stZ[m - 1]\n\t\t\tm = j + 2\n\t\t}\n\t}\n\n\tconst isComplete =\n\t\toptions.last ||\n\t\t!options.simulatePressure ||\n\t\t(m > 1 &&\n\t\t\t(stX[m - 1] - stX[m - 2]) * (stX[m - 1] - stX[m - 2]) +\n\t\t\t\t(stY[m - 1] - stY[m - 2]) * (stY[m - 1] - stY[m - 2]) <\n\t\t\t\tsize ** 2) ||\n\t\tpointsRemovedFromNearEnd > 0\n\n\t// Add extra points between the two, to help avoid \"dash\" lines for strokes with\n\t// tapered start and ends.\n\tif (m === 2 && options.simulatePressure) {\n\t\tconst x0 = stX[0]\n\t\tconst y0 = stY[0]\n\t\tconst z0 = stZ[0]\n\t\tconst x1 = stX[1]\n\t\tconst y1 = stY[1]\n\t\tconst z1 = stZ[1]\n\t\tfor (let i = 1; i < 5; i++) {\n\t\t\tconst u = i / 4\n\t\t\tstX[i] = x0 + (x1 - x0) * u\n\t\t\tstY[i] = y0 + (y1 - y0) * u\n\t\t\tstZ[i] = ((z0 + (z1 - z0)) * i) / 4\n\t\t}\n\t\tm = 5\n\t}\n\n\tconst ptX = pointX\n\tconst ptY = pointY\n\tconst inX = inputX\n\tconst inY = inputY\n\tconst inZ = inputZ\n\tconst press = pressures\n\tconst dists = distances\n\tconst runs = runningLengths\n\tconst rads = radii\n\n\t// The first point needs no adjustment.\n\tptX[0] = stX[0]\n\tptY[0] = stY[0]\n\tinX[0] = stX[0]\n\tinY[0] = stY[0]\n\tinZ[0] = stZ[0]\n\tpress[0] = simulatePressure ? 0.5 : stZ[0]\n\tdists[0] = 0\n\truns[0] = 0\n\trads[0] = 1\n\tlet count = 1\n\n\tif (isComplete && streamline > 0) {\n\t\tstX[m] = stX[m - 1]\n\t\tstY[m] = stY[m - 1]\n\t\tstZ[m] = stZ[m - 1]\n\t\tm++\n\t}\n\n\t// We use the totalLength to keep track of the total distance, and prevX/prevY as the\n\t// latest streamlined point, to calculate the next point's distance.\n\tlet totalLength = 0\n\tlet prevX = stX[0]\n\tlet prevY = stY[0]\n\tconst u = 1 - t\n\tconst isLast = options.last\n\n\tfor (let i = 1; i < m; i++) {\n\t\tlet x: number, y: number\n\t\tif (!t || (isLast && i === m - 1)) {\n\t\t\tx = stX[i]\n\t\t\ty = stY[i]\n\t\t} else {\n\t\t\tx = stX[i] + (prevX - stX[i]) * u\n\t\t\ty = stY[i] + (prevY - stY[i]) * u\n\t\t}\n\n\t\t// If the new point is the same as the previous point, skip ahead.\n\t\tif (Math.abs(prevX - x) < 0.0001 && Math.abs(prevY - y) < 0.0001) continue\n\n\t\t// How far is the new point from the previous point?\n\t\tconst distance = ((y - prevY) ** 2 + (x - prevX) ** 2) ** 0.5\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 certain distance\n\t\t// away from the original point, to avoid noise.\n\t\tif (i < 4 && totalLength < size) continue\n\n\t\tptX[count] = x\n\t\tptY[count] = y\n\t\tinX[count] = stX[i]\n\t\tinY[count] = stY[i]\n\t\tinZ[count] = stZ[i]\n\t\tpress[count] = simulatePressure ? 0.5 : stZ[i]\n\t\tdists[count] = distance\n\t\truns[count] = totalLength\n\t\trads[count] = 1\n\t\tcount++\n\t\tprevX = x\n\t\tprevY = y\n\t}\n\n\tif (totalLength < 1) {\n\t\tlet max = 0.5\n\t\tfor (let i = 0; i < count; i++) max = Math.max(max, press[i])\n\t\tfor (let i = 0; i < count; i++) press[i] = max\n\t}\n\n\tpointCount = count\n}\n\n/**\n * Resolve a taper option to a distance: `true` tapers over the whole stroke, `false` or\n * `undefined` not at all.\n *\n * @internal\n */\nexport function resolveTaper(\n\ttaper: number | boolean | undefined,\n\tsize: number,\n\ttotalLength: number\n): number {\n\tif (!taper) return 0\n\treturn taper === true ? Math.max(size, totalLength) : taper\n}\n\n/**\n * Phase 2: compute each point's radius from its pressure, distance and running length.\n * Same recurrences as the object pipeline, with the taper pass folded into the main\n * radius loop.\n *\n * @internal\n */\nexport function computeRadii(options: StrokeOptions): void {\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 = easeOutQuad } = start\n\tconst { easing: taperEndEase = easeOutCubic } = end\n\n\tconst n = pointCount\n\tconst press = pressures\n\tconst dists = distances\n\tconst runs = runningLengths\n\tconst rads = radii\n\n\tconst totalLength = runs[n - 1]\n\n\tif (!simulatePressure && totalLength < size) {\n\t\tlet max = 0.5\n\t\tfor (let i = 0; i < n; i++) max = Math.max(max, press[i])\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tpress[i] = max\n\t\t\trads[i] = size * easing(0.5 - thinning * (0.5 - max))\n\t\t}\n\t\treturn\n\t}\n\n\t// Calculate initial pressure based on the average of the first n number of points.\n\t// This prevents \"dots\" at the start of the line. Drawn lines almost always start slow!\n\tlet prevPressure = press[0]\n\tfor (let i = 0; i < n; i++) {\n\t\tif (runs[i] > size * 5) break\n\t\tconst sp = min(1, dists[i] / size)\n\t\tlet p: number\n\t\tif (simulatePressure) {\n\t\t\tconst rp = min(1, 1 - sp)\n\t\t\tp = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE))\n\t\t} else {\n\t\t\tp = min(1, prevPressure + (press[i] - prevPressure) * 0.5)\n\t\t}\n\t\tprevPressure = prevPressure + (p - prevPressure) * 0.5\n\t}\n\n\tconst taperStart = resolveTaper(start.taper, size, totalLength)\n\tconst taperEnd = resolveTaper(end.taper, size, totalLength)\n\n\tconst hasTaper = taperStart || taperEnd\n\n\t// Now calculate pressure and radius for each point. If the point falls within a taper\n\t// distance from either end, scale its radius by the smaller taper strength.\n\tfor (let i = 0; i < n; i++) {\n\t\tlet radius: number\n\t\tif (thinning) {\n\t\t\tlet pressure = press[i]\n\t\t\tconst sp = min(1, dists[i] / size)\n\t\t\tif (simulatePressure) {\n\t\t\t\t// If we're simulating pressure, then do so based on the distance between the\n\t\t\t\t// current point and the previous point, and the size of the stroke.\n\t\t\t\tconst rp = min(1, 1 - sp)\n\t\t\t\tpressure = min(1, prevPressure + (rp - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE))\n\t\t\t} else {\n\t\t\t\t// Otherwise, use the input pressure slightly smoothed based on the distance\n\t\t\t\t// between the current point and the previous point.\n\t\t\t\tpressure = min(1, prevPressure + (pressure - prevPressure) * (sp * RATE_OF_PRESSURE_CHANGE))\n\t\t\t}\n\t\t\tradius = size * easing(0.5 - thinning * (0.5 - pressure))\n\t\t\tprevPressure = pressure\n\t\t} else {\n\t\t\tradius = size / 2\n\t\t}\n\n\t\tif (hasTaper) {\n\t\t\tconst runningLength = runs[i]\n\t\t\tconst ts = runningLength < taperStart ? taperStartEase(runningLength / taperStart) : 1\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\t\t\tradius = Math.max(0.01, radius * Math.min(ts, te))\n\t\t}\n\n\t\trads[i] = radius\n\t}\n}\n\n// ---------------------------------------------------------------------------------\n// Track-source buffers: the (sub)sequence of stroke points the outline tracks are built\n// from \u2014 the whole stroke for getStroke/getStrokeOutlinePoints, one elbow partition at a\n// time for svgInk. `srcIsCap` marks points to treat as the first/last point when placing\n// the outline (the identity check `point === first || point === last` of the object\n// pipeline). Elbow points are loaded with their input coordinates as their point.\n// ---------------------------------------------------------------------------------\n\nlet srcCapacity = 256\nexport let srcX = new Float64Array(srcCapacity)\nexport let srcY = new Float64Array(srcCapacity)\nexport let srcZ = new Float64Array(srcCapacity)\nexport let srcInputX = new Float64Array(srcCapacity)\nexport let srcInputY = new Float64Array(srcCapacity)\nexport let srcRadius = new Float64Array(srcCapacity)\nexport let srcRunningLength = new Float64Array(srcCapacity)\nexport let srcIsCap = new Uint8Array(srcCapacity)\nexport let srcCount = 0\n\nfunction ensureSrcCapacity(n: number) {\n\tif (n <= srcCapacity) return\n\twhile (srcCapacity < n) srcCapacity *= 2\n\tsrcX = new Float64Array(srcCapacity)\n\tsrcY = new Float64Array(srcCapacity)\n\tsrcZ = new Float64Array(srcCapacity)\n\tsrcInputX = new Float64Array(srcCapacity)\n\tsrcInputY = new Float64Array(srcCapacity)\n\tsrcRadius = new Float64Array(srcCapacity)\n\tsrcRunningLength = new Float64Array(srcCapacity)\n\tsrcIsCap = new Uint8Array(srcCapacity)\n}\n\n/** Load the track source from materialized StrokePoints. @internal */\nexport function loadSrcFromStrokePoints(strokePoints: StrokePoint[]): void {\n\tconst n = strokePoints.length\n\tensureSrcCapacity(n)\n\tconst sx = srcX\n\tconst sy = srcY\n\tconst sz = srcZ\n\tconst six = srcInputX\n\tconst siy = srcInputY\n\tconst sr = srcRadius\n\tconst srl = srcRunningLength\n\tconst scap = srcIsCap\n\tconst first = strokePoints[0]\n\tconst last = strokePoints[n - 1]\n\tfor (let i = 0; i < n; i++) {\n\t\tconst sp = strokePoints[i]\n\t\tconst point = sp.point\n\t\tconst input = sp.input\n\t\tsx[i] = point.x\n\t\tsy[i] = point.y\n\t\tsz[i] = point.z\n\t\tsix[i] = input.x\n\t\tsiy[i] = input.y\n\t\tsr[i] = sp.radius\n\t\tsrl[i] = sp.runningLength\n\t\tscap[i] = sp === first || sp === last ? 1 : 0\n\t}\n\tsrcCount = n\n}\n\n/** Load the track source from the whole pipeline. @internal */\nexport function loadSrcFromPipeline(): void {\n\tconst n = pointCount\n\tensureSrcCapacity(n)\n\tconst sx = srcX\n\tconst sy = srcY\n\tconst sz = srcZ\n\tconst six = srcInputX\n\tconst siy = srcInputY\n\tconst sr = srcRadius\n\tconst srl = srcRunningLength\n\tconst scap = srcIsCap\n\tconst ptX = pointX\n\tconst ptY = pointY\n\tconst inX = inputX\n\tconst inY = inputY\n\tconst inZ = inputZ\n\tconst runs = runningLengths\n\tconst rads = radii\n\tfor (let i = 0; i < n; i++) {\n\t\tsx[i] = ptX[i]\n\t\tsy[i] = ptY[i]\n\t\tsz[i] = inZ[i]\n\t\tsix[i] = inX[i]\n\t\tsiy[i] = inY[i]\n\t\tsr[i] = rads[i]\n\t\tsrl[i] = runs[i]\n\t\tscap[i] = i === 0 || i === n - 1 ? 1 : 0\n\t}\n\tsrcCount = n\n}\n\n/**\n * Load one elbow partition from the pipeline as the track source: boundary point `a`,\n * the surviving inner points `innerStart..innerEnd`, and boundary point `b`. Elbow\n * boundaries read the input coordinates instead of the streamlined ones. When a hard\n * elbow's duplicated end point survived cleanup (`dupQuirk`), the inner copy of `b` is\n * also marked as a cap point, matching the object pipeline where both array slots held\n * the same point object.\n *\n * @internal\n */\nexport function loadSrcPartition(\n\ta: number,\n\taElbow: boolean,\n\tinnerStart: number,\n\tinnerEnd: number,\n\tb: number,\n\tbElbow: boolean,\n\tdupQuirk: boolean\n): void {\n\tensureSrcCapacity(innerEnd - innerStart + 3)\n\tconst sx = srcX\n\tconst sy = srcY\n\tconst sz = srcZ\n\tconst six = srcInputX\n\tconst siy = srcInputY\n\tconst sr = srcRadius\n\tconst srl = srcRunningLength\n\tconst scap = srcIsCap\n\tconst ptX = pointX\n\tconst ptY = pointY\n\tconst inX = inputX\n\tconst inY = inputY\n\tconst inZ = inputZ\n\tconst runs = runningLengths\n\tconst rads = radii\n\n\tsx[0] = aElbow ? inX[a] : ptX[a]\n\tsy[0] = aElbow ? inY[a] : ptY[a]\n\tsz[0] = inZ[a]\n\tsix[0] = inX[a]\n\tsiy[0] = inY[a]\n\tsr[0] = rads[a]\n\tsrl[0] = runs[a]\n\tscap[0] = 1\n\tlet w = 1\n\tfor (let i = innerStart; i <= innerEnd; i++) {\n\t\tsx[w] = ptX[i]\n\t\tsy[w] = ptY[i]\n\t\tsz[w] = inZ[i]\n\t\tsix[w] = inX[i]\n\t\tsiy[w] = inY[i]\n\t\tsr[w] = rads[i]\n\t\tsrl[w] = runs[i]\n\t\tscap[w] = 0\n\t\tw++\n\t}\n\tif (dupQuirk) scap[w - 1] = 1\n\tsx[w] = bElbow ? inX[b] : ptX[b]\n\tsy[w] = bElbow ? inY[b] : ptY[b]\n\tsz[w] = inZ[b]\n\tsix[w] = inX[b]\n\tsiy[w] = inY[b]\n\tsr[w] = rads[b]\n\tsrl[w] = runs[b]\n\tscap[w] = 1\n\tsrcCount = w + 1\n}\n"],
+  "mappings": "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",
+  "names": ["u"]
+}

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

@@ -0,0 +1,86 @@
+let buf = new Uint8Array(65536);
+let pos = 0;
+const decoder = new TextDecoder();
+function ensure(n) {
+  if (pos + n > buf.length) {
+    const next = new Uint8Array(buf.length * 2);
+    next.set(buf);
+    buf = next;
+  }
+}
+function resetPath() {
+  pos = 0;
+}
+function writeStr(s) {
+  ensure(s.length);
+  for (let i = 0; i < s.length; i++) {
+    buf[pos++] = s.charCodeAt(i);
+  }
+}
+function writeC(n) {
+  ensure(16);
+  if (n < 0) {
+    buf[pos++] = 45;
+    n = -n;
+  }
+  const i = n / 100 | 0;
+  const f = n - i * 100;
+  if (i === 0) {
+    if (f === 0) {
+      buf[pos++] = 48;
+      return;
+    }
+  } else if (i < 10) {
+    buf[pos++] = 48 + i;
+  } else if (i < 100) {
+    buf[pos++] = 48 + (i / 10 | 0);
+    buf[pos++] = 48 + i % 10;
+  } else {
+    const start = pos;
+    let m = i;
+    while (m > 0) {
+      buf[pos++] = 48 + m % 10;
+      m = m / 10 | 0;
+    }
+    let lo = start;
+    let hi = pos - 1;
+    while (lo < hi) {
+      const t = buf[lo];
+      buf[lo] = buf[hi];
+      buf[hi] = t;
+      lo++;
+      hi--;
+    }
+  }
+  if (f !== 0) {
+    buf[pos++] = 46;
+    const d2 = f % 10;
+    buf[pos++] = 48 + (f / 10 | 0);
+    if (d2 !== 0) {
+      buf[pos++] = 48 + d2;
+    }
+  }
+}
+function writeCPair(nx, ny) {
+  writeC(nx);
+  buf[pos++] = 44;
+  writeC(ny);
+  buf[pos++] = 32;
+}
+function finishPath() {
+  const s = decoder.decode(buf.subarray(0, pos));
+  pos = 0;
+  return s;
+}
+function toCenti(v) {
+  return Math.round(v * 100);
+}
+export {
+  finishPath,
+  resetPath,
+  toCenti,
+  writeC,
+  writeCPair,
+  writeStr
+};
+//# sourceMappingURL=fmt.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/lib/shapes/shared/freehand/fmt.ts"],
+  "sourcesContent": ["// Fast SVG path data building.\n//\n// Browsers don't render differences below a hundredth of a pixel, so we emit at most 2 decimal\n// places. Stringifying doubles rounded to 2 decimals is slow (they routinely miss V8's fast\n// float-to-string path), and concatenating many small strings costs more than the math itself.\n// Instead we round every coordinate to an integer number of hundredths (\"centi-pixels\") and\n// write decimal digits straight into a byte buffer, decoding to a string once per path.\n//\n// Paths use relative commands (t/q/a/l) wherever possible: deltas between consecutive points\n// are small numbers, which keeps the path data compact. Because deltas are differences of the\n// rounded integers, they sum back to the rounded absolute positions exactly: no drift.\n\nlet buf = new Uint8Array(65536)\nlet pos = 0\nconst decoder = new TextDecoder()\n\nfunction ensure(n: number) {\n\tif (pos + n > buf.length) {\n\t\tconst next = new Uint8Array(buf.length * 2)\n\t\tnext.set(buf)\n\t\tbuf = next\n\t}\n}\n\n/** Start a new path. Builders must call this before writing. */\nexport function resetPath() {\n\tpos = 0\n}\n\n/** Append a string of ASCII characters (command letters, arc flags) to the path. */\nexport function writeStr(s: string) {\n\tensure(s.length)\n\tfor (let i = 0; i < s.length; i++) {\n\t\tbuf[pos++] = s.charCodeAt(i)\n\t}\n}\n\n/**\n * Append a value given in integer hundredths, e.g. 255 as `2.55`, -30 as `-.3`, 0 as `0`.\n * Assumes |n| < 2^31, which holds for canvas coordinates (|v| < ~21 million px).\n */\nexport function writeC(n: number) {\n\tensure(16)\n\tif (n < 0) {\n\t\tbuf[pos++] = 45 // '-'\n\t\tn = -n\n\t}\n\tconst i = (n / 100) | 0\n\tconst f = n - i * 100\n\tif (i === 0) {\n\t\tif (f === 0) {\n\t\t\tbuf[pos++] = 48 // '0'\n\t\t\treturn\n\t\t}\n\t} else if (i < 10) {\n\t\tbuf[pos++] = 48 + i\n\t} else if (i < 100) {\n\t\tbuf[pos++] = 48 + ((i / 10) | 0)\n\t\tbuf[pos++] = 48 + (i % 10)\n\t} else {\n\t\tconst start = pos\n\t\tlet m = i\n\t\twhile (m > 0) {\n\t\t\tbuf[pos++] = 48 + (m % 10)\n\t\t\tm = (m / 10) | 0\n\t\t}\n\t\t// digits came out least-significant first; reverse them\n\t\tlet lo = start\n\t\tlet hi = pos - 1\n\t\twhile (lo < hi) {\n\t\t\tconst t = buf[lo]\n\t\t\tbuf[lo] = buf[hi]\n\t\t\tbuf[hi] = t\n\t\t\tlo++\n\t\t\thi--\n\t\t}\n\t}\n\tif (f !== 0) {\n\t\tbuf[pos++] = 46 // '.'\n\t\tconst d2 = f % 10\n\t\tbuf[pos++] = 48 + ((f / 10) | 0)\n\t\tif (d2 !== 0) {\n\t\t\tbuf[pos++] = 48 + d2\n\t\t}\n\t}\n}\n\n/** Append a coordinate pair given in integer hundredths as `x,y `. */\nexport function writeCPair(nx: number, ny: number) {\n\twriteC(nx)\n\tbuf[pos++] = 44 // ','\n\twriteC(ny)\n\tbuf[pos++] = 32 // ' '\n}\n\n/** Finish the path: decode everything written since `resetPath` and reset the writer. */\nexport function finishPath(): string {\n\tconst s = decoder.decode(buf.subarray(0, pos))\n\tpos = 0\n\treturn s\n}\n\n/** Round a coordinate to integer hundredths. */\nexport function toCenti(v: number): number {\n\treturn Math.round(v * 100)\n}\n"],
+  "mappings": "AAYA,IAAI,MAAM,IAAI,WAAW,KAAK;AAC9B,IAAI,MAAM;AACV,MAAM,UAAU,IAAI,YAAY;AAEhC,SAAS,OAAO,GAAW;AAC1B,MAAI,MAAM,IAAI,IAAI,QAAQ;AACzB,UAAM,OAAO,IAAI,WAAW,IAAI,SAAS,CAAC;AAC1C,SAAK,IAAI,GAAG;AACZ,UAAM;AAAA,EACP;AACD;AAGO,SAAS,YAAY;AAC3B,QAAM;AACP;AAGO,SAAS,SAAS,GAAW;AACnC,SAAO,EAAE,MAAM;AACf,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AAClC,QAAI,KAAK,IAAI,EAAE,WAAW,CAAC;AAAA,EAC5B;AACD;AAMO,SAAS,OAAO,GAAW;AACjC,SAAO,EAAE;AACT,MAAI,IAAI,GAAG;AACV,QAAI,KAAK,IAAI;AACb,QAAI,CAAC;AAAA,EACN;AACA,QAAM,IAAK,IAAI,MAAO;AACtB,QAAM,IAAI,IAAI,IAAI;AAClB,MAAI,MAAM,GAAG;AACZ,QAAI,MAAM,GAAG;AACZ,UAAI,KAAK,IAAI;AACb;AAAA,IACD;AAAA,EACD,WAAW,IAAI,IAAI;AAClB,QAAI,KAAK,IAAI,KAAK;AAAA,EACnB,WAAW,IAAI,KAAK;AACnB,QAAI,KAAK,IAAI,MAAO,IAAI,KAAM;AAC9B,QAAI,KAAK,IAAI,KAAM,IAAI;AAAA,EACxB,OAAO;AACN,UAAM,QAAQ;AACd,QAAI,IAAI;AACR,WAAO,IAAI,GAAG;AACb,UAAI,KAAK,IAAI,KAAM,IAAI;AACvB,UAAK,IAAI,KAAM;AAAA,IAChB;AAEA,QAAI,KAAK;AACT,QAAI,KAAK,MAAM;AACf,WAAO,KAAK,IAAI;AACf,YAAM,IAAI,IAAI,EAAE;AAChB,UAAI,EAAE,IAAI,IAAI,EAAE;AAChB,UAAI,EAAE,IAAI;AACV;AACA;AAAA,IACD;AAAA,EACD;AACA,MAAI,MAAM,GAAG;AACZ,QAAI,KAAK,IAAI;AACb,UAAM,KAAK,IAAI;AACf,QAAI,KAAK,IAAI,MAAO,IAAI,KAAM;AAC9B,QAAI,OAAO,GAAG;AACb,UAAI,KAAK,IAAI,KAAK;AAAA,IACnB;AAAA,EACD;AACD;AAGO,SAAS,WAAW,IAAY,IAAY;AAClD,SAAO,EAAE;AACT,MAAI,KAAK,IAAI;AACb,SAAO,EAAE;AACT,MAAI,KAAK,IAAI;AACd;AAGO,SAAS,aAAqB;AACpC,QAAM,IAAI,QAAQ,OAAO,IAAI,SAAS,GAAG,GAAG,CAAC;AAC7C,QAAM;AACN,SAAO;AACR;AAGO,SAAS,QAAQ,GAAmB;AAC1C,SAAO,KAAK,MAAM,IAAI,GAAG;AAC1B;",
+  "names": []
+}

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

@@ -1,11 +1,11 @@
-import { getStrokeOutlinePoints } from "./getStrokeOutlinePoints.mjs";
-import { getStrokePoints } from "./getStrokePoints.mjs";
-import { setStrokePointRadii } from "./setStrokePointRadii.mjs";
+import { computeRadii, ingest, loadSrcFromPipeline, pointCount } from "./core.mjs";
+import { outlineFromSrc } from "./getStrokeOutlinePoints.mjs";
 function getStroke(points, options = {}) {
-  return getStrokeOutlinePoints(
-    setStrokePointRadii(getStrokePoints(points, options), options),
-    options
-  );
+  ingest(points, options);
+  if (pointCount === 0) return [];
+  computeRadii(options);
+  loadSrcFromPipeline();
+  return outlineFromSrc(options);
 }
 export {
   getStroke

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

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../../src/lib/shapes/shared/freehand/getStroke.ts"],
-  "sourcesContent": ["import { Vec, VecLike } from '@tldraw/editor'\nimport { getStrokeOutlinePoints } from './getStrokeOutlinePoints'\nimport { getStrokePoints } from './getStrokePoints'\nimport { setStrokePointRadii } from './setStrokePointRadii'\nimport type { StrokeOptions } from './types'\n\n/**\n * ## getStroke\n *\n * Get an array of points describing a polygon that surrounds the input points.\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 */\n\nexport function getStroke(points: VecLike[], options: StrokeOptions = {}): Vec[] {\n\treturn getStrokeOutlinePoints(\n\t\tsetStrokePointRadii(getStrokePoints(points, options), options),\n\t\toptions\n\t)\n}\n"],
-  "mappings": "AACA,SAAS,8BAA8B;AACvC,SAAS,uBAAuB;AAChC,SAAS,2BAA2B;AAc7B,SAAS,UAAU,QAAmB,UAAyB,CAAC,GAAU;AAChF,SAAO;AAAA,IACN,oBAAoB,gBAAgB,QAAQ,OAAO,GAAG,OAAO;AAAA,IAC7D;AAAA,EACD;AACD;",
+  "sourcesContent": ["import { Vec, VecLike } from '@tldraw/editor'\nimport { computeRadii, ingest, loadSrcFromPipeline, pointCount } from './core'\nimport { outlineFromSrc } from './getStrokeOutlinePoints'\nimport type { StrokeOptions } from './types'\n\n/**\n * ## getStroke\n *\n * Get an array of points describing a polygon that surrounds the input points.\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 */\n\nexport function getStroke(points: VecLike[], options: StrokeOptions = {}): Vec[] {\n\tingest(points, options)\n\tif (pointCount === 0) return []\n\tcomputeRadii(options)\n\tloadSrcFromPipeline()\n\treturn outlineFromSrc(options)\n}\n"],
+  "mappings": "AACA,SAAS,cAAc,QAAQ,qBAAqB,kBAAkB;AACtE,SAAS,sBAAsB;AAcxB,SAAS,UAAU,QAAmB,UAAyB,CAAC,GAAU;AAChF,SAAO,QAAQ,OAAO;AACtB,MAAI,eAAe,EAAG,QAAO,CAAC;AAC9B,eAAa,OAAO;AACpB,sBAAoB;AACpB,SAAO,eAAe,OAAO;AAC9B;",
   "names": []
 }