web-annotation-renderer 0.6.0 → 0.6.2

package/dist/index15.js

@@ -1,78 +1,40 @@
-import { applyPressure as X } from "./index6.js";
-import { resolveGlyph as j } from "./index12.js";
-function q(n, t = 2) {
-  if (n.length < 2 || t < 1)
-    return n;
-  const e = [];
-  for (let r = 0; r < n.length - 1; r++) {
-    const [a, o] = n[r], [g, m] = n[r + 1];
-    e.push([a, o]);
-    for (let s = 1; s <= t; s++) {
-      const c = s / (t + 1);
-      e.push([a + (g - a) * c, o + (m - o) * c]);
-    }
-  }
-  return e.push(n[n.length - 1]), e;
-}
-function F(n, t, e) {
-  return n.map(([r, a]) => [(t + r) * e, a * e]);
-}
-function A(n, t) {
-  const { id: e, start: r, end: a, content: o, x: g, y: m, fontSize: s } = n;
-  if (!o || o.length === 0)
+import { roughLine as L, hashSeed as M } from "./index29.js";
+const o = 1e3;
+function R(h, n) {
+  const { id: e, start: r, end: g, quads: s } = h;
+  if (!s || s.length === 0)
     return [];
-  const c = [], I = a - r, T = s || t.fontSize || 16, P = t.subdivisions ?? 2, $ = T / 1e3;
-  let u = 0;
-  const k = o.length, S = I / k;
-  for (let h = 0; h < o.length; h++) {
-    const v = o[h], l = j(v);
-    if (!l) {
-      u += 0.5 + 0.18;
-      continue;
-    }
-    const b = l.width || 0.5, p = l.paths || [], E = l.pathTiming || "sequential";
-    if (p.length === 0) {
-      u += b + 0.18;
-      continue;
-    }
-    const x = r + h * S, G = x + S, O = p.length;
-    for (let i = 0; i < p.length; i++) {
-      let f = p[i].points || [];
-      if (f.length < 2) continue;
-      P > 0 && (f = q(f, P));
-      let w = F(f, u, $), z = null;
-      (t.pressure?.taperIn > 0 || t.pressure?.taperOut > 0) && (z = X(w, t.pressure));
-      let d, D;
-      if (E === "parallel")
-        d = x, D = G;
-      else {
-        const C = S / O;
-        d = x + i * C, D = d + C;
+  const u = [], f = g - r, l = s.length, i = f / l, p = n.roughness ?? 1, S = n.bowing ?? 1, m = n.curveFitting ?? 0.95, q = n.curveStepCount ?? 9, C = n.maxRandomnessOffset ?? 2, b = n.disableMultiStroke ?? !1;
+  for (let t = 0; t < s.length; t++) {
+    const w = s[t], { x: a, y: k, w: v, h: x } = w, c = k + x, $ = L(
+      a * o,
+      c * o,
+      (a + v) * o,
+      c * o,
+      {
+        roughness: p,
+        bowing: S,
+        seed: M(`${e}-${t}`),
+        curveFitting: m,
+        curveStepCount: q,
+        maxRandomnessOffset: C,
+        disableMultiStroke: b
       }
-      c.push({
-        id: `${e}-${h}-${i}`,
-        points: w,
-        // Offset coordinates from baseX/baseY (uniform space)
-        baseX: g,
-        // Base X position (width-normalized page coords)
-        baseY: m,
-        // Base Y position (height-normalized page coords)
-        start: d,
-        end: D,
-        color: t.color || "rgba(220, 20, 60, 1.0)",
-        width: t.width || 2,
-        lineCap: t.lineCap || "round",
-        pressures: z,
-        uniformScale: !0
-        // Preserve aspect ratio when rendering
-      });
-    }
-    u += b + 0.18;
+    ).map(([E, F]) => [E / o, F / o]), d = r + t * i, D = d + i;
+    u.push({
+      id: `${e}-${t}`,
+      points: $,
+      start: d,
+      end: D,
+      color: n.color || "rgba(0, 0, 255, 0.8)",
+      width: n.width || 2,
+      lineCap: n.lineCap || "round"
+    });
   }
-  return c;
+  return u;
 }
 export {
-  A as default,
-  A as textToStrokes
+  R as default,
+  R as underlineToStrokes
 };
 //# sourceMappingURL=index15.js.map

package/dist/index15.js.map

@@ -1 +1 @@
-{"version":3,"file":"index15.js","sources":["../src/converters/text.js"],"sourcesContent":["/**\n * Text Converter - Converts text annotations to stroke commands\n *\n * Transforms text content into stroke paths for each character,\n * using single-stroke font glyphs for smooth writing animation.\n *\n * @module converters/text\n */\n\nimport { applyPressure } from \"../pen/effects.js\";\nimport { resolveGlyph } from \"./glyphResolver.js\";\n\n/**\n * Subdivide a path by adding intermediate points between existing points.\n * This creates smoother interpolation during progressive rendering.\n *\n * @param {Array<[number, number]>} points - Original path points\n * @param {number} subdivisions - Number of points to add between each pair (default: 2)\n * @returns {Array<[number, number]>} Subdivided path with more points\n */\nfunction subdividePath(points, subdivisions = 2) {\n  if (points.length < 2 || subdivisions < 1) {\n    return points;\n  }\n\n  const result = [];\n\n  for (let i = 0; i < points.length - 1; i++) {\n    const [x1, y1] = points[i];\n    const [x2, y2] = points[i + 1];\n\n    // Add the start point\n    result.push([x1, y1]);\n\n    // Add intermediate points\n    for (let j = 1; j <= subdivisions; j++) {\n      const t = j / (subdivisions + 1);\n      result.push([x1 + (x2 - x1) * t, y1 + (y2 - y1) * t]);\n    }\n  }\n\n  // Add the final point\n  result.push(points[points.length - 1]);\n\n  return result;\n}\n\n\n/**\n * Scales glyph points by fontSize scale factor\n *\n * Glyph points are in normalized space where:\n * - X is 0 to charWidth (already scaled within the glyph)\n * - Y is 0 to ~1.0 (baseline at 0.8, cap height at 0)\n *\n * This scales them to the target size, but does NOT add the base position.\n * The base position is stored separately to allow correct rendering with\n * mixed coordinate systems (position in page coords, offsets in uniform space).\n *\n * @param {Array<[number, number]>} points - Glyph points in normalized space\n * @param {number} offsetX - X offset from base position (character offset within text)\n * @param {number} scale - Scale factor based on fontSize\n * @returns {Array<[number, number]>} Scaled offset points (not absolute positions)\n */\nfunction scaleGlyphPoints(points, offsetX, scale) {\n  // Scale points and add character offset (in uniform space)\n  return points.map(([px, py]) => [(offsetX + px) * scale, py * scale]);\n}\n\n/**\n * Converts a text annotation to stroke commands\n *\n * Each character in the content becomes one or more strokes.\n * Characters are staggered in timing to create a writing effect.\n * Multi-path characters (like 'i', 'j', '!') use pathTiming to\n * control whether paths are drawn sequentially or in parallel.\n *\n * @param {Object} annotation - Text annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {string} annotation.content - Text content to render\n * @param {number} annotation.x - X position (normalized 0-1)\n * @param {number} annotation.y - Y position (normalized 0-1)\n * @param {number} [annotation.fontSize=16] - Font size in pixels\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {number} [style.fontSize=16] - Default font size\n * @param {string} [style.lineCap='round'] - Line cap style\n * @param {Object} [style.jitter] - Jitter configuration\n * @param {Object} [style.pressure] - Pressure configuration\n * @param {number} [style.subdivisions=2] - Path subdivision level\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function textToStrokes(annotation, style) {\n  const { id, start, end, content, x, y, fontSize: annotFontSize } = annotation;\n\n  if (!content || content.length === 0) {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const fontSize = annotFontSize || style.fontSize || 16;\n  const subdivisions = style.subdivisions ?? 2;\n\n  // Scale factor: convert fontSize (pixels) to normalized coordinates\n  // Assuming a reference viewport of ~1000px\n  const scale = fontSize / 1000;\n\n  // Track character offset from base position (in glyph units, not page coords)\n  let charOffsetX = 0;\n\n  // Calculate timing per character\n  const charCount = content.length;\n  const charDuration = totalDuration / charCount;\n\n  for (let charIndex = 0; charIndex < content.length; charIndex++) {\n    const char = content[charIndex];\n    const glyph = resolveGlyph(char);\n\n    if (!glyph) {\n      // Skip unknown characters, but advance position with default width\n      charOffsetX += 0.5 + 0.18; // default width + spacing (in glyph units)\n      continue;\n    }\n\n    const charWidth = glyph.width || 0.5;\n    const charPaths = glyph.paths || [];\n    const pathTiming = glyph.pathTiming || \"sequential\";\n\n    // Skip if no paths (e.g., space character)\n    if (charPaths.length === 0) {\n      charOffsetX += charWidth + 0.18;\n      continue;\n    }\n\n    // Calculate timing for this character's paths\n    const charStart = start + charIndex * charDuration;\n    const charEnd = charStart + charDuration;\n\n    // Determine path timing based on pathTiming mode\n    const pathCount = charPaths.length;\n\n    for (let pathIndex = 0; pathIndex < charPaths.length; pathIndex++) {\n      const pathData = charPaths[pathIndex];\n      let rawPoints = pathData.points || [];\n\n      if (rawPoints.length < 2) continue;\n\n      // Apply path subdivision for smoother interpolation\n      if (subdivisions > 0) {\n        rawPoints = subdividePath(rawPoints, subdivisions);\n      }\n\n      // Scale glyph points (offset coordinates, not absolute)\n      let points = scaleGlyphPoints(rawPoints, charOffsetX, scale);\n\n      // Calculate pressure values if configured\n      let pressures = null;\n      if (style.pressure?.taperIn > 0 || style.pressure?.taperOut > 0) {\n        pressures = applyPressure(points, style.pressure);\n      }\n\n      // Calculate path timing based on pathTiming mode\n      let pathStart, pathEnd;\n\n      if (pathTiming === \"parallel\") {\n        // All paths drawn simultaneously during character duration\n        pathStart = charStart;\n        pathEnd = charEnd;\n      } else {\n        // Sequential: each path gets a portion of character duration\n        const pathDuration = charDuration / pathCount;\n        pathStart = charStart + pathIndex * pathDuration;\n        pathEnd = pathStart + pathDuration;\n      }\n\n      strokes.push({\n        id: `${id}-${charIndex}-${pathIndex}`,\n        points, // Offset coordinates from baseX/baseY (uniform space)\n        baseX: x, // Base X position (width-normalized page coords)\n        baseY: y, // Base Y position (height-normalized page coords)\n        start: pathStart,\n        end: pathEnd,\n        color: style.color || \"rgba(220, 20, 60, 1.0)\",\n        width: style.width || 2,\n        lineCap: style.lineCap || \"round\",\n        pressures,\n        uniformScale: true, // Preserve aspect ratio when rendering\n      });\n    }\n\n    // Advance offset for next character (in glyph units)\n    charOffsetX += charWidth + 0.18; // Add small spacing\n  }\n\n  return strokes;\n}\n\nexport default textToStrokes;\n"],"names":["subdividePath","points","subdivisions","result","i","x1","y1","x2","y2","j","t","scaleGlyphPoints","offsetX","scale","px","py","textToStrokes","annotation","style","id","start","end","content","x","y","annotFontSize","strokes","totalDuration","fontSize","charOffsetX","charCount","charDuration","charIndex","char","glyph","resolveGlyph","charWidth","charPaths","pathTiming","charStart","charEnd","pathCount","pathIndex","rawPoints","pressures","applyPressure","pathStart","pathEnd","pathDuration"],"mappings":"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"}
+{"version":3,"file":"index15.js","sources":["../src/converters/underline.js"],"sourcesContent":["/**\n * Underline Converter - Converts underline annotations to stroke commands\n *\n * Transforms quads into horizontal stroke paths at the bottom edge\n * that can be rendered progressively on canvas with hand-drawn style.\n *\n * @module converters/underline\n */\n\nimport { roughLine, hashSeed } from '../rough/roughPathExtractor.js';\n\nconst SCALE = 1000;\n\n/**\n * Converts an underline annotation to stroke commands\n *\n * Each quad in the annotation becomes a horizontal stroke at the\n * bottom edge of the quad. Multiple quads are staggered in timing.\n * Uses RoughJS for hand-drawn style.\n *\n * @param {Object} annotation - Underline annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {Array<{x: number, y: number, w: number, h: number}>} annotation.quads - Array of quads\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @param {number} [style.roughness=1.0] - Hand-drawn roughness\n * @param {number} [style.bowing=1.0] - Line curvature\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function underlineToStrokes(annotation, style) {\n  const { id, start, end, quads } = annotation;\n\n  if (!quads || quads.length === 0) {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const quadCount = quads.length;\n  const quadDuration = totalDuration / quadCount;\n\n  const roughness = style.roughness ?? 1.0;\n  const bowing = style.bowing ?? 1.0;\n  const curveFitting = style.curveFitting ?? 0.95;\n  const curveStepCount = style.curveStepCount ?? 9;\n  const maxRandomnessOffset = style.maxRandomnessOffset ?? 2;\n  const disableMultiStroke = style.disableMultiStroke ?? false;\n\n  for (let i = 0; i < quads.length; i++) {\n    const quad = quads[i];\n    const { x, y, w, h } = quad;\n\n    const lineY = y + h;\n\n    const roughPoints = roughLine(\n      x * SCALE,\n      lineY * SCALE,\n      (x + w) * SCALE,\n      lineY * SCALE,\n      {\n        roughness,\n        bowing,\n        seed: hashSeed(`${id}-${i}`),\n        curveFitting,\n        curveStepCount,\n        maxRandomnessOffset,\n        disableMultiStroke\n      }\n    );\n\n    const points = roughPoints.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n    const quadStart = start + i * quadDuration;\n    const quadEnd = quadStart + quadDuration;\n\n    strokes.push({\n      id: `${id}-${i}`,\n      points,\n      start: quadStart,\n      end: quadEnd,\n      color: style.color || 'rgba(0, 0, 255, 0.8)',\n      width: style.width || 2,\n      lineCap: style.lineCap || 'round'\n    });\n  }\n\n  return strokes;\n}\n\nexport default underlineToStrokes;\n"],"names":["SCALE","underlineToStrokes","annotation","style","id","start","end","quads","strokes","totalDuration","quadCount","quadDuration","roughness","bowing","curveFitting","curveStepCount","maxRandomnessOffset","disableMultiStroke","i","quad","x","y","w","h","lineY","points","roughLine","hashSeed","px","py","quadStart","quadEnd"],"mappings":";AAWA,MAAMA,IAAQ;AAuBP,SAASC,EAAmBC,GAAYC,GAAO;AACpD,QAAM,EAAE,IAAAC,GAAI,OAAAC,GAAO,KAAAC,GAAK,OAAAC,EAAK,IAAKL;AAElC,MAAI,CAACK,KAASA,EAAM,WAAW;AAC7B,WAAO,CAAA;AAGT,QAAMC,IAAU,CAAA,GACVC,IAAgBH,IAAMD,GACtBK,IAAYH,EAAM,QAClBI,IAAeF,IAAgBC,GAE/BE,IAAYT,EAAM,aAAa,GAC/BU,IAASV,EAAM,UAAU,GACzBW,IAAeX,EAAM,gBAAgB,MACrCY,IAAiBZ,EAAM,kBAAkB,GACzCa,IAAsBb,EAAM,uBAAuB,GACnDc,IAAqBd,EAAM,sBAAsB;AAEvD,WAASe,IAAI,GAAGA,IAAIX,EAAM,QAAQW,KAAK;AACrC,UAAMC,IAAOZ,EAAMW,CAAC,GACd,EAAE,GAAAE,GAAG,GAAAC,GAAG,GAAAC,GAAG,GAAAC,EAAC,IAAKJ,GAEjBK,IAAQH,IAAIE,GAkBZE,IAhBcC;AAAA,MAClBN,IAAIpB;AAAA,MACJwB,IAAQxB;AAAA,OACPoB,IAAIE,KAAKtB;AAAA,MACVwB,IAAQxB;AAAA,MACR;AAAA,QACE,WAAAY;AAAA,QACA,QAAAC;AAAA,QACA,MAAMc,EAAS,GAAGvB,CAAE,IAAIc,CAAC,EAAE;AAAA,QAC3B,cAAAJ;AAAA,QACA,gBAAAC;AAAA,QACA,qBAAAC;AAAA,QACA,oBAAAC;AAAA,MACR;AAAA,IACA,EAE+B,IAAI,CAAC,CAACW,GAAIC,CAAE,MAAM,CAACD,IAAK5B,GAAO6B,IAAK7B,CAAK,CAAC,GAE/D8B,IAAYzB,IAAQa,IAAIP,GACxBoB,IAAUD,IAAYnB;AAE5B,IAAAH,EAAQ,KAAK;AAAA,MACX,IAAI,GAAGJ,CAAE,IAAIc,CAAC;AAAA,MACd,QAAAO;AAAA,MACA,OAAOK;AAAA,MACP,KAAKC;AAAA,MACL,OAAO5B,EAAM,SAAS;AAAA,MACtB,OAAOA,EAAM,SAAS;AAAA,MACtB,SAASA,EAAM,WAAW;AAAA,IAChC,CAAK;AAAA,EACH;AAEA,SAAOK;AACT;"}

package/dist/index16.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});function i(c,o){const{id:l,start:e,end:h,quads:t}=c;if(!t||t.length===0)return[];const r=[],g=h-e,q=t.length,u=g/q;for(let n=0;n<t.length;n++){const f=t[n],{x:s,y:p,w:S,h:b}=f,d=p+b,k=[[s,d],[s+S,d]],a=e+n*u,w=a+u;r.push({id:`${l}-${n}`,points:k,start:a,end:w,color:o.color||"rgba(0, 0, 255, 0.8)",width:o.width||2,lineCap:o.lineCap||"round"})}return r}exports.default=i;exports.underlineToStrokes=i;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const r=require("./index29.cjs"),t=1e3;function E(W,n){const{id:i,start:h,end:_,from_x:c,from_y:u,to_x:o,to_y:e}=W;if(typeof c!="number"||typeof u!="number"||typeof o!="number"||typeof e!="number")return[];const d=[],L=_-h,P=L*.7,$=L*.3,m=n.roughness??.8,S=n.bowing??.8,b=n.curveFitting??.95,M=n.curveStepCount??9,w=n.maxRandomnessOffset??2,C=n.disableMultiStroke??!1,k=r.roughLine(c*t,u*t,o*t,e*t,{roughness:m,bowing:S,seed:r.hashSeed(`${i}-line`),curveFitting:b,curveStepCount:M,maxRandomnessOffset:w,disableMultiStroke:C}).map(([s,a])=>[s/t,a/t]);d.push({id:`${i}-0`,points:k,start:h,end:h+P,color:n.color||"rgba(255, 0, 0, 0.8)",width:n.width||2,lineCap:n.lineCap||"round"});const x=Math.sqrt((o-c)**2+(e-u)**2),g=Math.min(x*.2,.03),p=Math.atan2(e-u,o-c),f=Math.PI/6,D=o-g*Math.cos(p-f),R=e-g*Math.sin(p-f),O=o-g*Math.cos(p+f),T=e-g*Math.sin(p+f),q=r.roughLine(o*t,e*t,D*t,R*t,{roughness:m,bowing:S,seed:r.hashSeed(`${i}-left`),curveFitting:b,curveStepCount:M,maxRandomnessOffset:w,disableMultiStroke:C}).map(([s,a])=>[s/t,a/t]),A=r.roughLine(o*t,e*t,O*t,T*t,{roughness:m,bowing:S,seed:r.hashSeed(`${i}-right`),curveFitting:b,curveStepCount:M,maxRandomnessOffset:w,disableMultiStroke:C}).map(([s,a])=>[s/t,a/t]),l=h+P,v=$/2;return d.push({id:`${i}-1`,points:q,start:l,end:l+v,color:n.color||"rgba(255, 0, 0, 0.8)",width:n.width||2,lineCap:n.lineCap||"round"}),d.push({id:`${i}-2`,points:A,start:l,end:l+v,color:n.color||"rgba(255, 0, 0, 0.8)",width:n.width||2,lineCap:n.lineCap||"round"}),d}exports.arrowToStrokes=E;exports.default=E;
 //# sourceMappingURL=index16.cjs.map

package/dist/index16.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index16.cjs","sources":["../src/converters/underline.js"],"sourcesContent":["/**\n * Underline Converter - Converts underline annotations to stroke commands\n *\n * Transforms quads into horizontal stroke paths at the bottom edge\n * that can be rendered progressively on canvas.\n *\n * @module converters/underline\n */\n\n/**\n * Converts an underline annotation to stroke commands\n *\n * Each quad in the annotation becomes a horizontal stroke at the\n * bottom edge of the quad. Multiple quads are staggered in timing.\n *\n * @param {Object} annotation - Underline annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {Array<{x: number, y: number, w: number, h: number}>} annotation.quads - Array of quads\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function underlineToStrokes(annotation, style) {\n  const { id, start, end, quads } = annotation;\n\n  if (!quads || quads.length === 0) {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const quadCount = quads.length;\n  const quadDuration = totalDuration / quadCount;\n\n  for (let i = 0; i < quads.length; i++) {\n    const quad = quads[i];\n    const { x, y, w, h } = quad;\n\n    // Line at bottom edge of quad\n    const lineY = y + h;\n    const points = [\n      [x, lineY],\n      [x + w, lineY]\n    ];\n\n    // Calculate timing for this quad\n    const quadStart = start + i * quadDuration;\n    const quadEnd = quadStart + quadDuration;\n\n    strokes.push({\n      id: `${id}-${i}`,\n      points,\n      start: quadStart,\n      end: quadEnd,\n      color: style.color || 'rgba(0, 0, 255, 0.8)',\n      width: style.width || 2,\n      lineCap: style.lineCap || 'round'\n    });\n  }\n\n  return strokes;\n}\n\nexport default underlineToStrokes;\n"],"names":["underlineToStrokes","annotation","style","id","start","end","quads","strokes","totalDuration","quadCount","quadDuration","i","quad","x","y","w","h","lineY","points","quadStart","quadEnd"],"mappings":"4GA2BO,SAASA,EAAmBC,EAAYC,EAAO,CACpD,KAAM,CAAE,GAAAC,EAAI,MAAAC,EAAO,IAAAC,EAAK,MAAAC,CAAK,EAAKL,EAElC,GAAI,CAACK,GAASA,EAAM,SAAW,EAC7B,MAAO,CAAA,EAGT,MAAMC,EAAU,CAAA,EACVC,EAAgBH,EAAMD,EACtBK,EAAYH,EAAM,OAClBI,EAAeF,EAAgBC,EAErC,QAASE,EAAI,EAAGA,EAAIL,EAAM,OAAQK,IAAK,CACrC,MAAMC,EAAON,EAAMK,CAAC,EACd,CAAE,EAAAE,EAAG,EAAAC,EAAG,EAAAC,EAAG,EAAAC,CAAC,EAAKJ,EAGjBK,EAAQH,EAAIE,EACZE,EAAS,CACb,CAACL,EAAGI,CAAK,EACT,CAACJ,EAAIE,EAAGE,CAAK,CACnB,EAGUE,EAAYf,EAAQO,EAAID,EACxBU,EAAUD,EAAYT,EAE5BH,EAAQ,KAAK,CACX,GAAI,GAAGJ,CAAE,IAAIQ,CAAC,GACd,OAAAO,EACA,MAAOC,EACP,IAAKC,EACL,MAAOlB,EAAM,OAAS,uBACtB,MAAOA,EAAM,OAAS,EACtB,QAASA,EAAM,SAAW,OAChC,CAAK,CACH,CAEA,OAAOK,CACT"}
+{"version":3,"file":"index16.cjs","sources":["../src/converters/arrow.js"],"sourcesContent":["/**\n * Arrow Converter - Converts arrow annotations to stroke commands\n *\n * Transforms arrow data into a line stroke with arrowhead strokes\n * that can be rendered progressively on canvas with hand-drawn style.\n *\n * @module converters/arrow\n */\n\nimport { roughLine, hashSeed } from '../rough/roughPathExtractor.js';\n\nconst SCALE = 1000;\n\n/**\n * Converts an arrow annotation to stroke commands\n *\n * Creates a main line stroke from source to target, followed by\n * two wing strokes forming the arrowhead. Line draws first (70%),\n * then arrowhead (30%).\n *\n * @param {Object} annotation - Arrow annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {number} annotation.from_x - Source x position (0-1 normalized)\n * @param {number} annotation.from_y - Source y position (0-1 normalized)\n * @param {number} annotation.to_x - Target x position (0-1 normalized)\n * @param {number} annotation.to_y - Target y position (0-1 normalized)\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function arrowToStrokes(annotation, style) {\n  const { id, start, end, from_x, from_y, to_x, to_y } = annotation;\n\n  if (typeof from_x !== 'number' || typeof from_y !== 'number' ||\n      typeof to_x !== 'number' || typeof to_y !== 'number') {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const lineDuration = totalDuration * 0.7;\n  const headDuration = totalDuration * 0.3;\n\n  const roughness = style.roughness ?? 0.8;\n  const bowing = style.bowing ?? 0.8;\n  const curveFitting = style.curveFitting ?? 0.95;\n  const curveStepCount = style.curveStepCount ?? 9;\n  const maxRandomnessOffset = style.maxRandomnessOffset ?? 2;\n  const disableMultiStroke = style.disableMultiStroke ?? false;\n\n  // Main line stroke with RoughJS style\n  const roughLinePoints = roughLine(\n    from_x * SCALE,\n    from_y * SCALE,\n    to_x * SCALE,\n    to_y * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(`${id}-line`),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const linePoints = roughLinePoints.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  strokes.push({\n    id: `${id}-0`,\n    points: linePoints,\n    start: start,\n    end: start + lineDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  // Arrow head calculation\n  const lineLength = Math.sqrt((to_x - from_x) ** 2 + (to_y - from_y) ** 2);\n  const headSize = Math.min(lineLength * 0.2, 0.03);\n  const angle = Math.atan2(to_y - from_y, to_x - from_x);\n  const headAngle = Math.PI / 6; // 30 degrees\n\n  // Left wing end point\n  const leftEndX = to_x - headSize * Math.cos(angle - headAngle);\n  const leftEndY = to_y - headSize * Math.sin(angle - headAngle);\n\n  // Right wing end point\n  const rightEndX = to_x - headSize * Math.cos(angle + headAngle);\n  const rightEndY = to_y - headSize * Math.sin(angle + headAngle);\n\n  // Left wing with RoughJS style\n  const roughLeftWing = roughLine(\n    to_x * SCALE,\n    to_y * SCALE,\n    leftEndX * SCALE,\n    leftEndY * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(`${id}-left`),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const leftWingPoints = roughLeftWing.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  // Right wing with RoughJS style\n  const roughRightWing = roughLine(\n    to_x * SCALE,\n    to_y * SCALE,\n    rightEndX * SCALE,\n    rightEndY * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(`${id}-right`),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const rightWingPoints = roughRightWing.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  const headStart = start + lineDuration;\n  const wingDuration = headDuration / 2;\n\n  strokes.push({\n    id: `${id}-1`,\n    points: leftWingPoints,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  strokes.push({\n    id: `${id}-2`,\n    points: rightWingPoints,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  return strokes;\n}\n\nexport default arrowToStrokes;\n"],"names":["SCALE","arrowToStrokes","annotation","style","id","start","end","from_x","from_y","to_x","to_y","strokes","totalDuration","lineDuration","headDuration","roughness","bowing","curveFitting","curveStepCount","maxRandomnessOffset","disableMultiStroke","linePoints","roughLine","hashSeed","px","py","lineLength","headSize","angle","headAngle","leftEndX","leftEndY","rightEndX","rightEndY","leftWingPoints","rightWingPoints","headStart","wingDuration"],"mappings":"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"}

package/dist/index16.js

@@ -1,27 +1,82 @@
-function x(c, o) {
-  const { id: i, start: r, end: l, quads: t } = c;
-  if (!t || t.length === 0)
+import { roughLine as S, hashSeed as L } from "./index29.js";
+const n = 1e3;
+function T(x, t) {
+  const { id: r, start: a, end: E, from_x: c, from_y: h, to_x: o, to_y: i } = x;
+  if (typeof c != "number" || typeof h != "number" || typeof o != "number" || typeof i != "number")
     return [];
-  const s = [], h = l - r, q = t.length, a = h / q;
-  for (let n = 0; n < t.length; n++) {
-    const p = t[n], { x: d, y: f, w: g, h: w } = p, u = f + w, C = [
-      [d, u],
-      [d + g, u]
-    ], e = r + n * a, k = e + a;
-    s.push({
-      id: `${i}-${n}`,
-      points: C,
-      start: e,
-      end: k,
-      color: o.color || "rgba(0, 0, 255, 0.8)",
-      width: o.width || 2,
-      lineCap: o.lineCap || "round"
-    });
-  }
-  return s;
+  const u = [], P = E - a, W = P * 0.7, k = P * 0.3, m = t.roughness ?? 0.8, l = t.bowing ?? 0.8, b = t.curveFitting ?? 0.95, w = t.curveStepCount ?? 9, M = t.maxRandomnessOffset ?? 2, C = t.disableMultiStroke ?? !1, v = S(
+    c * n,
+    h * n,
+    o * n,
+    i * n,
+    {
+      roughness: m,
+      bowing: l,
+      seed: L(`${r}-line`),
+      curveFitting: b,
+      curveStepCount: w,
+      maxRandomnessOffset: M,
+      disableMultiStroke: C
+    }
+  ).map(([e, s]) => [e / n, s / n]);
+  u.push({
+    id: `${r}-0`,
+    points: v,
+    start: a,
+    end: a + W,
+    color: t.color || "rgba(255, 0, 0, 0.8)",
+    width: t.width || 2,
+    lineCap: t.lineCap || "round"
+  });
+  const D = Math.sqrt((o - c) ** 2 + (i - h) ** 2), d = Math.min(D * 0.2, 0.03), g = Math.atan2(i - h, o - c), p = Math.PI / 6, R = o - d * Math.cos(g - p), _ = i - d * Math.sin(g - p), A = o - d * Math.cos(g + p), F = i - d * Math.sin(g + p), O = S(
+    o * n,
+    i * n,
+    R * n,
+    _ * n,
+    {
+      roughness: m,
+      bowing: l,
+      seed: L(`${r}-left`),
+      curveFitting: b,
+      curveStepCount: w,
+      maxRandomnessOffset: M,
+      disableMultiStroke: C
+    }
+  ).map(([e, s]) => [e / n, s / n]), X = S(
+    o * n,
+    i * n,
+    A * n,
+    F * n,
+    {
+      roughness: m,
+      bowing: l,
+      seed: L(`${r}-right`),
+      curveFitting: b,
+      curveStepCount: w,
+      maxRandomnessOffset: M,
+      disableMultiStroke: C
+    }
+  ).map(([e, s]) => [e / n, s / n]), f = a + W, $ = k / 2;
+  return u.push({
+    id: `${r}-1`,
+    points: O,
+    start: f,
+    end: f + $,
+    color: t.color || "rgba(255, 0, 0, 0.8)",
+    width: t.width || 2,
+    lineCap: t.lineCap || "round"
+  }), u.push({
+    id: `${r}-2`,
+    points: X,
+    start: f,
+    end: f + $,
+    color: t.color || "rgba(255, 0, 0, 0.8)",
+    width: t.width || 2,
+    lineCap: t.lineCap || "round"
+  }), u;
 }
 export {
-  x as default,
-  x as underlineToStrokes
+  T as arrowToStrokes,
+  T as default
 };
 //# sourceMappingURL=index16.js.map

package/dist/index16.js.map

@@ -1 +1 @@
-{"version":3,"file":"index16.js","sources":["../src/converters/underline.js"],"sourcesContent":["/**\n * Underline Converter - Converts underline annotations to stroke commands\n *\n * Transforms quads into horizontal stroke paths at the bottom edge\n * that can be rendered progressively on canvas.\n *\n * @module converters/underline\n */\n\n/**\n * Converts an underline annotation to stroke commands\n *\n * Each quad in the annotation becomes a horizontal stroke at the\n * bottom edge of the quad. Multiple quads are staggered in timing.\n *\n * @param {Object} annotation - Underline annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {Array<{x: number, y: number, w: number, h: number}>} annotation.quads - Array of quads\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function underlineToStrokes(annotation, style) {\n  const { id, start, end, quads } = annotation;\n\n  if (!quads || quads.length === 0) {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const quadCount = quads.length;\n  const quadDuration = totalDuration / quadCount;\n\n  for (let i = 0; i < quads.length; i++) {\n    const quad = quads[i];\n    const { x, y, w, h } = quad;\n\n    // Line at bottom edge of quad\n    const lineY = y + h;\n    const points = [\n      [x, lineY],\n      [x + w, lineY]\n    ];\n\n    // Calculate timing for this quad\n    const quadStart = start + i * quadDuration;\n    const quadEnd = quadStart + quadDuration;\n\n    strokes.push({\n      id: `${id}-${i}`,\n      points,\n      start: quadStart,\n      end: quadEnd,\n      color: style.color || 'rgba(0, 0, 255, 0.8)',\n      width: style.width || 2,\n      lineCap: style.lineCap || 'round'\n    });\n  }\n\n  return strokes;\n}\n\nexport default underlineToStrokes;\n"],"names":["underlineToStrokes","annotation","style","id","start","end","quads","strokes","totalDuration","quadCount","quadDuration","i","quad","x","y","w","h","lineY","points","quadStart","quadEnd"],"mappings":"AA2BO,SAASA,EAAmBC,GAAYC,GAAO;AACpD,QAAM,EAAE,IAAAC,GAAI,OAAAC,GAAO,KAAAC,GAAK,OAAAC,EAAK,IAAKL;AAElC,MAAI,CAACK,KAASA,EAAM,WAAW;AAC7B,WAAO,CAAA;AAGT,QAAMC,IAAU,CAAA,GACVC,IAAgBH,IAAMD,GACtBK,IAAYH,EAAM,QAClBI,IAAeF,IAAgBC;AAErC,WAASE,IAAI,GAAGA,IAAIL,EAAM,QAAQK,KAAK;AACrC,UAAMC,IAAON,EAAMK,CAAC,GACd,EAAE,GAAAE,GAAG,GAAAC,GAAG,GAAAC,GAAG,GAAAC,EAAC,IAAKJ,GAGjBK,IAAQH,IAAIE,GACZE,IAAS;AAAA,MACb,CAACL,GAAGI,CAAK;AAAA,MACT,CAACJ,IAAIE,GAAGE,CAAK;AAAA,IACnB,GAGUE,IAAYf,IAAQO,IAAID,GACxBU,IAAUD,IAAYT;AAE5B,IAAAH,EAAQ,KAAK;AAAA,MACX,IAAI,GAAGJ,CAAE,IAAIQ,CAAC;AAAA,MACd,QAAAO;AAAA,MACA,OAAOC;AAAA,MACP,KAAKC;AAAA,MACL,OAAOlB,EAAM,SAAS;AAAA,MACtB,OAAOA,EAAM,SAAS;AAAA,MACtB,SAASA,EAAM,WAAW;AAAA,IAChC,CAAK;AAAA,EACH;AAEA,SAAOK;AACT;"}
+{"version":3,"file":"index16.js","sources":["../src/converters/arrow.js"],"sourcesContent":["/**\n * Arrow Converter - Converts arrow annotations to stroke commands\n *\n * Transforms arrow data into a line stroke with arrowhead strokes\n * that can be rendered progressively on canvas with hand-drawn style.\n *\n * @module converters/arrow\n */\n\nimport { roughLine, hashSeed } from '../rough/roughPathExtractor.js';\n\nconst SCALE = 1000;\n\n/**\n * Converts an arrow annotation to stroke commands\n *\n * Creates a main line stroke from source to target, followed by\n * two wing strokes forming the arrowhead. Line draws first (70%),\n * then arrowhead (30%).\n *\n * @param {Object} annotation - Arrow annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {number} annotation.from_x - Source x position (0-1 normalized)\n * @param {number} annotation.from_y - Source y position (0-1 normalized)\n * @param {number} annotation.to_x - Target x position (0-1 normalized)\n * @param {number} annotation.to_y - Target y position (0-1 normalized)\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function arrowToStrokes(annotation, style) {\n  const { id, start, end, from_x, from_y, to_x, to_y } = annotation;\n\n  if (typeof from_x !== 'number' || typeof from_y !== 'number' ||\n      typeof to_x !== 'number' || typeof to_y !== 'number') {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const lineDuration = totalDuration * 0.7;\n  const headDuration = totalDuration * 0.3;\n\n  const roughness = style.roughness ?? 0.8;\n  const bowing = style.bowing ?? 0.8;\n  const curveFitting = style.curveFitting ?? 0.95;\n  const curveStepCount = style.curveStepCount ?? 9;\n  const maxRandomnessOffset = style.maxRandomnessOffset ?? 2;\n  const disableMultiStroke = style.disableMultiStroke ?? false;\n\n  // Main line stroke with RoughJS style\n  const roughLinePoints = roughLine(\n    from_x * SCALE,\n    from_y * SCALE,\n    to_x * SCALE,\n    to_y * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(`${id}-line`),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const linePoints = roughLinePoints.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  strokes.push({\n    id: `${id}-0`,\n    points: linePoints,\n    start: start,\n    end: start + lineDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  // Arrow head calculation\n  const lineLength = Math.sqrt((to_x - from_x) ** 2 + (to_y - from_y) ** 2);\n  const headSize = Math.min(lineLength * 0.2, 0.03);\n  const angle = Math.atan2(to_y - from_y, to_x - from_x);\n  const headAngle = Math.PI / 6; // 30 degrees\n\n  // Left wing end point\n  const leftEndX = to_x - headSize * Math.cos(angle - headAngle);\n  const leftEndY = to_y - headSize * Math.sin(angle - headAngle);\n\n  // Right wing end point\n  const rightEndX = to_x - headSize * Math.cos(angle + headAngle);\n  const rightEndY = to_y - headSize * Math.sin(angle + headAngle);\n\n  // Left wing with RoughJS style\n  const roughLeftWing = roughLine(\n    to_x * SCALE,\n    to_y * SCALE,\n    leftEndX * SCALE,\n    leftEndY * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(`${id}-left`),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const leftWingPoints = roughLeftWing.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  // Right wing with RoughJS style\n  const roughRightWing = roughLine(\n    to_x * SCALE,\n    to_y * SCALE,\n    rightEndX * SCALE,\n    rightEndY * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(`${id}-right`),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const rightWingPoints = roughRightWing.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  const headStart = start + lineDuration;\n  const wingDuration = headDuration / 2;\n\n  strokes.push({\n    id: `${id}-1`,\n    points: leftWingPoints,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  strokes.push({\n    id: `${id}-2`,\n    points: rightWingPoints,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  return strokes;\n}\n\nexport default arrowToStrokes;\n"],"names":["SCALE","arrowToStrokes","annotation","style","id","start","end","from_x","from_y","to_x","to_y","strokes","totalDuration","lineDuration","headDuration","roughness","bowing","curveFitting","curveStepCount","maxRandomnessOffset","disableMultiStroke","linePoints","roughLine","hashSeed","px","py","lineLength","headSize","angle","headAngle","leftEndX","leftEndY","rightEndX","rightEndY","leftWingPoints","rightWingPoints","headStart","wingDuration"],"mappings":";AAWA,MAAMA,IAAQ;AAwBP,SAASC,EAAeC,GAAYC,GAAO;AAChD,QAAM,EAAE,IAAAC,GAAI,OAAAC,GAAO,KAAAC,GAAK,QAAAC,GAAQ,QAAAC,GAAQ,MAAAC,GAAM,MAAAC,EAAI,IAAKR;AAEvD,MAAI,OAAOK,KAAW,YAAY,OAAOC,KAAW,YAChD,OAAOC,KAAS,YAAY,OAAOC,KAAS;AAC9C,WAAO,CAAA;AAGT,QAAMC,IAAU,CAAA,GACVC,IAAgBN,IAAMD,GACtBQ,IAAeD,IAAgB,KAC/BE,IAAeF,IAAgB,KAE/BG,IAAYZ,EAAM,aAAa,KAC/Ba,IAASb,EAAM,UAAU,KACzBc,IAAed,EAAM,gBAAgB,MACrCe,IAAiBf,EAAM,kBAAkB,GACzCgB,IAAsBhB,EAAM,uBAAuB,GACnDiB,IAAqBjB,EAAM,sBAAsB,IAmBjDkB,IAhBkBC;AAAA,IACtBf,IAASP;AAAA,IACTQ,IAASR;AAAA,IACTS,IAAOT;AAAA,IACPU,IAAOV;AAAA,IACP;AAAA,MACE,WAAAe;AAAA,MACA,QAAAC;AAAA,MACA,MAAMO,EAAS,GAAGnB,CAAE,OAAO;AAAA,MAC3B,cAAAa;AAAA,MACA,gBAAAC;AAAA,MACA,qBAAAC;AAAA,MACA,oBAAAC;AAAA,IACN;AAAA,EACA,EAEqC,IAAI,CAAC,CAACI,GAAIC,CAAE,MAAM,CAACD,IAAKxB,GAAOyB,IAAKzB,CAAK,CAAC;AAE7E,EAAAW,EAAQ,KAAK;AAAA,IACX,IAAI,GAAGP,CAAE;AAAA,IACT,QAAQiB;AAAA,IACR,OAAOhB;AAAA,IACP,KAAKA,IAAQQ;AAAA,IACb,OAAOV,EAAM,SAAS;AAAA,IACtB,OAAOA,EAAM,SAAS;AAAA,IACtB,SAASA,EAAM,WAAW;AAAA,EAC9B,CAAG;AAGD,QAAMuB,IAAa,KAAK,MAAMjB,IAAOF,MAAW,KAAKG,IAAOF,MAAW,CAAC,GAClEmB,IAAW,KAAK,IAAID,IAAa,KAAK,IAAI,GAC1CE,IAAQ,KAAK,MAAMlB,IAAOF,GAAQC,IAAOF,CAAM,GAC/CsB,IAAY,KAAK,KAAK,GAGtBC,IAAWrB,IAAOkB,IAAW,KAAK,IAAIC,IAAQC,CAAS,GACvDE,IAAWrB,IAAOiB,IAAW,KAAK,IAAIC,IAAQC,CAAS,GAGvDG,IAAYvB,IAAOkB,IAAW,KAAK,IAAIC,IAAQC,CAAS,GACxDI,IAAYvB,IAAOiB,IAAW,KAAK,IAAIC,IAAQC,CAAS,GAmBxDK,IAhBgBZ;AAAA,IACpBb,IAAOT;AAAA,IACPU,IAAOV;AAAA,IACP8B,IAAW9B;AAAA,IACX+B,IAAW/B;AAAA,IACX;AAAA,MACE,WAAAe;AAAA,MACA,QAAAC;AAAA,MACA,MAAMO,EAAS,GAAGnB,CAAE,OAAO;AAAA,MAC3B,cAAAa;AAAA,MACA,gBAAAC;AAAA,MACA,qBAAAC;AAAA,MACA,oBAAAC;AAAA,IACN;AAAA,EACA,EAEuC,IAAI,CAAC,CAACI,GAAIC,CAAE,MAAM,CAACD,IAAKxB,GAAOyB,IAAKzB,CAAK,CAAC,GAmBzEmC,IAhBiBb;AAAA,IACrBb,IAAOT;AAAA,IACPU,IAAOV;AAAA,IACPgC,IAAYhC;AAAA,IACZiC,IAAYjC;AAAA,IACZ;AAAA,MACE,WAAAe;AAAA,MACA,QAAAC;AAAA,MACA,MAAMO,EAAS,GAAGnB,CAAE,QAAQ;AAAA,MAC5B,cAAAa;AAAA,MACA,gBAAAC;AAAA,MACA,qBAAAC;AAAA,MACA,oBAAAC;AAAA,IACN;AAAA,EACA,EAEyC,IAAI,CAAC,CAACI,GAAIC,CAAE,MAAM,CAACD,IAAKxB,GAAOyB,IAAKzB,CAAK,CAAC,GAE3EoC,IAAY/B,IAAQQ,GACpBwB,IAAevB,IAAe;AAEpC,SAAAH,EAAQ,KAAK;AAAA,IACX,IAAI,GAAGP,CAAE;AAAA,IACT,QAAQ8B;AAAA,IACR,OAAOE;AAAA,IACP,KAAKA,IAAYC;AAAA,IACjB,OAAOlC,EAAM,SAAS;AAAA,IACtB,OAAOA,EAAM,SAAS;AAAA,IACtB,SAASA,EAAM,WAAW;AAAA,EAC9B,CAAG,GAEDQ,EAAQ,KAAK;AAAA,IACX,IAAI,GAAGP,CAAE;AAAA,IACT,QAAQ+B;AAAA,IACR,OAAOC;AAAA,IACP,KAAKA,IAAYC;AAAA,IACjB,OAAOlC,EAAM,SAAS;AAAA,IACtB,OAAOA,EAAM,SAAS;AAAA,IACtB,SAASA,EAAM,WAAW;AAAA,EAC9B,CAAG,GAEMQ;AACT;"}

package/dist/index17.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});function w(C,t){const{id:h,start:e,end:S,from_x:r,from_y:i,to_x:o,to_y:n}=C;if(typeof r!="number"||typeof i!="number"||typeof o!="number"||typeof n!="number")return[];const a=[],p=S-e,f=p*.7,_=p*.3,g=20,M=[];for(let l=0;l<=g;l++){const m=l/g;M.push([r+(o-r)*m,i+(n-i)*m])}a.push({id:`${h}-0`,points:M,start:e,end:e+f,color:t.color||"rgba(255, 0, 0, 0.8)",width:t.width||2,lineCap:t.lineCap||"round"});const D=Math.sqrt((o-r)**2+(n-i)**2),s=Math.min(D*.2,.03),c=Math.atan2(n-i,o-r),u=Math.PI/6,P=[[o,n],[o-s*Math.cos(c-u),n-s*Math.sin(c-u)]],k=[[o,n],[o-s*Math.cos(c+u),n-s*Math.sin(c+u)]],d=e+f,b=_/2;return a.push({id:`${h}-1`,points:P,start:d,end:d+b,color:t.color||"rgba(255, 0, 0, 0.8)",width:t.width||2,lineCap:t.lineCap||"round"}),a.push({id:`${h}-2`,points:k,start:d,end:d+b,color:t.color||"rgba(255, 0, 0, 0.8)",width:t.width||2,lineCap:t.lineCap||"round"}),a}exports.arrowToStrokes=w;exports.default=w;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const i=require("./index29.cjs"),e=1e3;function c(a,o){const{id:t,start:d,end:f,cx:n,cy:r,rx:u,ry:s}=a;if(typeof n!="number"||typeof r!="number"||typeof u!="number"||typeof s!="number")return[];const g=o.roughness??1,p=o.bowing??1,b=o.curveFitting??.95,h=o.curveStepCount??9,l=o.maxRandomnessOffset??2,m=o.disableMultiStroke??!1,S=i.roughEllipse(n*e,r*e,u*2*e,s*2*e,{roughness:g,bowing:p,seed:i.hashSeed(t),curveFitting:b,curveStepCount:h,maxRandomnessOffset:l,disableMultiStroke:m}).map(([v,x])=>[v/e,x/e]);return[{id:t,points:S,start:d,end:f,color:o.color||"rgba(255, 165, 0, 0.8)",width:o.width||3,lineCap:o.lineCap||"round"}]}exports.circleToStrokes=c;exports.default=c;
 //# sourceMappingURL=index17.cjs.map

package/dist/index17.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index17.cjs","sources":["../src/converters/arrow.js"],"sourcesContent":["/**\n * Arrow Converter - Converts arrow annotations to stroke commands\n *\n * Transforms arrow data into a line stroke with arrowhead strokes\n * that can be rendered progressively on canvas.\n *\n * @module converters/arrow\n */\n\n/**\n * Converts an arrow annotation to stroke commands\n *\n * Creates a main line stroke from source to target, followed by\n * two wing strokes forming the arrowhead. Line draws first (70%),\n * then arrowhead (30%).\n *\n * @param {Object} annotation - Arrow annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {number} annotation.from_x - Source x position (0-1 normalized)\n * @param {number} annotation.from_y - Source y position (0-1 normalized)\n * @param {number} annotation.to_x - Target x position (0-1 normalized)\n * @param {number} annotation.to_y - Target y position (0-1 normalized)\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function arrowToStrokes(annotation, style) {\n  const { id, start, end, from_x, from_y, to_x, to_y } = annotation;\n\n  if (typeof from_x !== 'number' || typeof from_y !== 'number' ||\n      typeof to_x !== 'number' || typeof to_y !== 'number') {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const lineDuration = totalDuration * 0.7;\n  const headDuration = totalDuration * 0.3;\n\n  // Subdivide line for smooth progressive reveal\n  const numPoints = 20;\n  const linePoints = [];\n  for (let i = 0; i <= numPoints; i++) {\n    const t = i / numPoints;\n    linePoints.push([\n      from_x + (to_x - from_x) * t,\n      from_y + (to_y - from_y) * t\n    ]);\n  }\n\n  // Main line stroke\n  strokes.push({\n    id: `${id}-0`,\n    points: linePoints,\n    start: start,\n    end: start + lineDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  // Arrow head calculation\n  const lineLength = Math.sqrt((to_x - from_x) ** 2 + (to_y - from_y) ** 2);\n  const headSize = Math.min(lineLength * 0.2, 0.03);\n  const angle = Math.atan2(to_y - from_y, to_x - from_x);\n  const headAngle = Math.PI / 6; // 30 degrees\n\n  // Left wing\n  const leftWing = [\n    [to_x, to_y],\n    [\n      to_x - headSize * Math.cos(angle - headAngle),\n      to_y - headSize * Math.sin(angle - headAngle)\n    ]\n  ];\n\n  // Right wing\n  const rightWing = [\n    [to_x, to_y],\n    [\n      to_x - headSize * Math.cos(angle + headAngle),\n      to_y - headSize * Math.sin(angle + headAngle)\n    ]\n  ];\n\n  const headStart = start + lineDuration;\n  const wingDuration = headDuration / 2;\n\n  strokes.push({\n    id: `${id}-1`,\n    points: leftWing,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  strokes.push({\n    id: `${id}-2`,\n    points: rightWing,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  return strokes;\n}\n\nexport default arrowToStrokes;\n"],"names":["arrowToStrokes","annotation","style","id","start","end","from_x","from_y","to_x","to_y","strokes","totalDuration","lineDuration","headDuration","numPoints","linePoints","i","t","lineLength","headSize","angle","headAngle","leftWing","rightWing","headStart","wingDuration"],"mappings":"4GA+BO,SAASA,EAAeC,EAAYC,EAAO,CAChD,KAAM,CAAE,GAAAC,EAAI,MAAAC,EAAO,IAAAC,EAAK,OAAAC,EAAQ,OAAAC,EAAQ,KAAAC,EAAM,KAAAC,CAAI,EAAKR,EAEvD,GAAI,OAAOK,GAAW,UAAY,OAAOC,GAAW,UAChD,OAAOC,GAAS,UAAY,OAAOC,GAAS,SAC9C,MAAO,CAAA,EAGT,MAAMC,EAAU,CAAA,EACVC,EAAgBN,EAAMD,EACtBQ,EAAeD,EAAgB,GAC/BE,EAAeF,EAAgB,GAG/BG,EAAY,GACZC,EAAa,CAAA,EACnB,QAASC,EAAI,EAAGA,GAAKF,EAAWE,IAAK,CACnC,MAAMC,EAAID,EAAIF,EACdC,EAAW,KAAK,CACdT,GAAUE,EAAOF,GAAUW,EAC3BV,GAAUE,EAAOF,GAAUU,CACjC,CAAK,CACH,CAGAP,EAAQ,KAAK,CACX,GAAI,GAAGP,CAAE,KACT,OAAQY,EACR,MAAOX,EACP,IAAKA,EAAQQ,EACb,MAAOV,EAAM,OAAS,uBACtB,MAAOA,EAAM,OAAS,EACtB,QAASA,EAAM,SAAW,OAC9B,CAAG,EAGD,MAAMgB,EAAa,KAAK,MAAMV,EAAOF,IAAW,GAAKG,EAAOF,IAAW,CAAC,EAClEY,EAAW,KAAK,IAAID,EAAa,GAAK,GAAI,EAC1CE,EAAQ,KAAK,MAAMX,EAAOF,EAAQC,EAAOF,CAAM,EAC/Ce,EAAY,KAAK,GAAK,EAGtBC,EAAW,CACf,CAACd,EAAMC,CAAI,EACX,CACED,EAAOW,EAAW,KAAK,IAAIC,EAAQC,CAAS,EAC5CZ,EAAOU,EAAW,KAAK,IAAIC,EAAQC,CAAS,CAClD,CACA,EAGQE,EAAY,CAChB,CAACf,EAAMC,CAAI,EACX,CACED,EAAOW,EAAW,KAAK,IAAIC,EAAQC,CAAS,EAC5CZ,EAAOU,EAAW,KAAK,IAAIC,EAAQC,CAAS,CAClD,CACA,EAEQG,EAAYpB,EAAQQ,EACpBa,EAAeZ,EAAe,EAEpC,OAAAH,EAAQ,KAAK,CACX,GAAI,GAAGP,CAAE,KACT,OAAQmB,EACR,MAAOE,EACP,IAAKA,EAAYC,EACjB,MAAOvB,EAAM,OAAS,uBACtB,MAAOA,EAAM,OAAS,EACtB,QAASA,EAAM,SAAW,OAC9B,CAAG,EAEDQ,EAAQ,KAAK,CACX,GAAI,GAAGP,CAAE,KACT,OAAQoB,EACR,MAAOC,EACP,IAAKA,EAAYC,EACjB,MAAOvB,EAAM,OAAS,uBACtB,MAAOA,EAAM,OAAS,EACtB,QAASA,EAAM,SAAW,OAC9B,CAAG,EAEMQ,CACT"}
+{"version":3,"file":"index17.cjs","sources":["../src/converters/circle.js"],"sourcesContent":["/**\n * Circle Converter - Converts circle annotations to stroke commands\n *\n * Transforms circle/ellipse data into stroke paths that can be\n * rendered progressively on canvas with hand-drawn style.\n *\n * @module converters/circle\n */\n\nimport { roughEllipse, hashSeed } from '../rough/roughPathExtractor.js';\n\nconst SCALE = 1000;\n\n/**\n * Converts a circle annotation to stroke commands\n *\n * Generates an ellipse path that renders progressively around the perimeter.\n * Uses RoughJS for hand-drawn circle style.\n *\n * @param {Object} annotation - Circle annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {number} annotation.cx - Center x position (0-1 normalized)\n * @param {number} annotation.cy - Center y position (0-1 normalized)\n * @param {number} annotation.rx - Horizontal radius (0-1 normalized)\n * @param {number} annotation.ry - Vertical radius (0-1 normalized)\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @param {number} [style.roughness=1.0] - Hand-drawn roughness\n * @param {number} [style.bowing=1.0] - Line curvature\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function circleToStrokes(annotation, style) {\n  const { id, start, end, cx, cy, rx, ry } = annotation;\n\n  if (typeof cx !== 'number' || typeof cy !== 'number' ||\n      typeof rx !== 'number' || typeof ry !== 'number') {\n    return [];\n  }\n\n  const roughness = style.roughness ?? 1.0;\n  const bowing = style.bowing ?? 1.0;\n  const curveFitting = style.curveFitting ?? 0.95;\n  const curveStepCount = style.curveStepCount ?? 9;\n  const maxRandomnessOffset = style.maxRandomnessOffset ?? 2;\n  const disableMultiStroke = style.disableMultiStroke ?? false;\n\n  const roughPoints = roughEllipse(\n    cx * SCALE,\n    cy * SCALE,\n    rx * 2 * SCALE,\n    ry * 2 * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(id),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const points = roughPoints.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  return [{\n    id,\n    points,\n    start,\n    end,\n    color: style.color || 'rgba(255, 165, 0, 0.8)',\n    width: style.width || 3,\n    lineCap: style.lineCap || 'round'\n  }];\n}\n\nexport default circleToStrokes;\n"],"names":["SCALE","circleToStrokes","annotation","style","id","start","end","cx","cy","rx","ry","roughness","bowing","curveFitting","curveStepCount","maxRandomnessOffset","disableMultiStroke","points","roughEllipse","hashSeed","px","py"],"mappings":"6IAWMA,EAAQ,IAyBP,SAASC,EAAgBC,EAAYC,EAAO,CACjD,KAAM,CAAE,GAAAC,EAAI,MAAAC,EAAO,IAAAC,EAAK,GAAAC,EAAI,GAAAC,EAAI,GAAAC,EAAI,GAAAC,CAAE,EAAKR,EAE3C,GAAI,OAAOK,GAAO,UAAY,OAAOC,GAAO,UACxC,OAAOC,GAAO,UAAY,OAAOC,GAAO,SAC1C,MAAO,CAAA,EAGT,MAAMC,EAAYR,EAAM,WAAa,EAC/BS,EAAST,EAAM,QAAU,EACzBU,EAAeV,EAAM,cAAgB,IACrCW,EAAiBX,EAAM,gBAAkB,EACzCY,EAAsBZ,EAAM,qBAAuB,EACnDa,EAAqBb,EAAM,oBAAsB,GAkBjDc,EAhBcC,EAAAA,aAClBX,EAAKP,EACLQ,EAAKR,EACLS,EAAK,EAAIT,EACTU,EAAK,EAAIV,EACT,CACE,UAAAW,EACA,OAAAC,EACA,KAAMO,EAAAA,SAASf,CAAE,EACjB,aAAAS,EACA,eAAAC,EACA,oBAAAC,EACA,mBAAAC,CACN,CACA,EAE6B,IAAI,CAAC,CAACI,EAAIC,CAAE,IAAM,CAACD,EAAKpB,EAAOqB,EAAKrB,CAAK,CAAC,EAErE,MAAO,CAAC,CACN,GAAAI,EACA,OAAAa,EACA,MAAAZ,EACA,IAAAC,EACA,MAAOH,EAAM,OAAS,yBACtB,MAAOA,EAAM,OAAS,EACtB,QAASA,EAAM,SAAW,OAC9B,CAAG,CACH"}

package/dist/index17.js

@@ -1,57 +1,36 @@
-function S(b, t) {
-  const { id: u, start: a, end: C, from_x: i, from_y: r, to_x: n, to_y: o } = b;
-  if (typeof i != "number" || typeof r != "number" || typeof n != "number" || typeof o != "number")
+import { roughEllipse as x, hashSeed as C } from "./index29.js";
+const n = 1e3;
+function k(u, o) {
+  const { id: t, start: c, end: a, cx: e, cy: r, rx: s, ry: i } = u;
+  if (typeof e != "number" || typeof r != "number" || typeof s != "number" || typeof i != "number")
     return [];
-  const s = [], l = C - a, f = l * 0.7, D = l * 0.3, g = 20, m = [];
-  for (let p = 0; p <= g; p++) {
-    const M = p / g;
-    m.push([
-      i + (n - i) * M,
-      r + (o - r) * M
-    ]);
-  }
-  s.push({
-    id: `${u}-0`,
-    points: m,
-    start: a,
-    end: a + f,
-    color: t.color || "rgba(255, 0, 0, 0.8)",
-    width: t.width || 2,
-    lineCap: t.lineCap || "round"
-  });
-  const _ = Math.sqrt((n - i) ** 2 + (o - r) ** 2), e = Math.min(_ * 0.2, 0.03), c = Math.atan2(o - r, n - i), h = Math.PI / 6, x = [
-    [n, o],
-    [
-      n - e * Math.cos(c - h),
-      o - e * Math.sin(c - h)
-    ]
-  ], P = [
-    [n, o],
-    [
-      n - e * Math.cos(c + h),
-      o - e * Math.sin(c + h)
-    ]
-  ], d = a + f, w = D / 2;
-  return s.push({
-    id: `${u}-1`,
-    points: x,
-    start: d,
-    end: d + w,
-    color: t.color || "rgba(255, 0, 0, 0.8)",
-    width: t.width || 2,
-    lineCap: t.lineCap || "round"
-  }), s.push({
-    id: `${u}-2`,
-    points: P,
-    start: d,
-    end: d + w,
-    color: t.color || "rgba(255, 0, 0, 0.8)",
-    width: t.width || 2,
-    lineCap: t.lineCap || "round"
-  }), s;
+  const f = o.roughness ?? 1, p = o.bowing ?? 1, d = o.curveFitting ?? 0.95, m = o.curveStepCount ?? 9, g = o.maxRandomnessOffset ?? 2, b = o.disableMultiStroke ?? !1, h = x(
+    e * n,
+    r * n,
+    s * 2 * n,
+    i * 2 * n,
+    {
+      roughness: f,
+      bowing: p,
+      seed: C(t),
+      curveFitting: d,
+      curveStepCount: m,
+      maxRandomnessOffset: g,
+      disableMultiStroke: b
+    }
+  ).map(([S, l]) => [S / n, l / n]);
+  return [{
+    id: t,
+    points: h,
+    start: c,
+    end: a,
+    color: o.color || "rgba(255, 165, 0, 0.8)",
+    width: o.width || 3,
+    lineCap: o.lineCap || "round"
+  }];
 }
 export {
-  S as arrowToStrokes,
-  S as default
+  k as circleToStrokes,
+  k as default
 };
 //# sourceMappingURL=index17.js.map

package/dist/index17.js.map

@@ -1 +1 @@
-{"version":3,"file":"index17.js","sources":["../src/converters/arrow.js"],"sourcesContent":["/**\n * Arrow Converter - Converts arrow annotations to stroke commands\n *\n * Transforms arrow data into a line stroke with arrowhead strokes\n * that can be rendered progressively on canvas.\n *\n * @module converters/arrow\n */\n\n/**\n * Converts an arrow annotation to stroke commands\n *\n * Creates a main line stroke from source to target, followed by\n * two wing strokes forming the arrowhead. Line draws first (70%),\n * then arrowhead (30%).\n *\n * @param {Object} annotation - Arrow annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {number} annotation.from_x - Source x position (0-1 normalized)\n * @param {number} annotation.from_y - Source y position (0-1 normalized)\n * @param {number} annotation.to_x - Target x position (0-1 normalized)\n * @param {number} annotation.to_y - Target y position (0-1 normalized)\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function arrowToStrokes(annotation, style) {\n  const { id, start, end, from_x, from_y, to_x, to_y } = annotation;\n\n  if (typeof from_x !== 'number' || typeof from_y !== 'number' ||\n      typeof to_x !== 'number' || typeof to_y !== 'number') {\n    return [];\n  }\n\n  const strokes = [];\n  const totalDuration = end - start;\n  const lineDuration = totalDuration * 0.7;\n  const headDuration = totalDuration * 0.3;\n\n  // Subdivide line for smooth progressive reveal\n  const numPoints = 20;\n  const linePoints = [];\n  for (let i = 0; i <= numPoints; i++) {\n    const t = i / numPoints;\n    linePoints.push([\n      from_x + (to_x - from_x) * t,\n      from_y + (to_y - from_y) * t\n    ]);\n  }\n\n  // Main line stroke\n  strokes.push({\n    id: `${id}-0`,\n    points: linePoints,\n    start: start,\n    end: start + lineDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  // Arrow head calculation\n  const lineLength = Math.sqrt((to_x - from_x) ** 2 + (to_y - from_y) ** 2);\n  const headSize = Math.min(lineLength * 0.2, 0.03);\n  const angle = Math.atan2(to_y - from_y, to_x - from_x);\n  const headAngle = Math.PI / 6; // 30 degrees\n\n  // Left wing\n  const leftWing = [\n    [to_x, to_y],\n    [\n      to_x - headSize * Math.cos(angle - headAngle),\n      to_y - headSize * Math.sin(angle - headAngle)\n    ]\n  ];\n\n  // Right wing\n  const rightWing = [\n    [to_x, to_y],\n    [\n      to_x - headSize * Math.cos(angle + headAngle),\n      to_y - headSize * Math.sin(angle + headAngle)\n    ]\n  ];\n\n  const headStart = start + lineDuration;\n  const wingDuration = headDuration / 2;\n\n  strokes.push({\n    id: `${id}-1`,\n    points: leftWing,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  strokes.push({\n    id: `${id}-2`,\n    points: rightWing,\n    start: headStart,\n    end: headStart + wingDuration,\n    color: style.color || 'rgba(255, 0, 0, 0.8)',\n    width: style.width || 2,\n    lineCap: style.lineCap || 'round'\n  });\n\n  return strokes;\n}\n\nexport default arrowToStrokes;\n"],"names":["arrowToStrokes","annotation","style","id","start","end","from_x","from_y","to_x","to_y","strokes","totalDuration","lineDuration","headDuration","numPoints","linePoints","i","t","lineLength","headSize","angle","headAngle","leftWing","rightWing","headStart","wingDuration"],"mappings":"AA+BO,SAASA,EAAeC,GAAYC,GAAO;AAChD,QAAM,EAAE,IAAAC,GAAI,OAAAC,GAAO,KAAAC,GAAK,QAAAC,GAAQ,QAAAC,GAAQ,MAAAC,GAAM,MAAAC,EAAI,IAAKR;AAEvD,MAAI,OAAOK,KAAW,YAAY,OAAOC,KAAW,YAChD,OAAOC,KAAS,YAAY,OAAOC,KAAS;AAC9C,WAAO,CAAA;AAGT,QAAMC,IAAU,CAAA,GACVC,IAAgBN,IAAMD,GACtBQ,IAAeD,IAAgB,KAC/BE,IAAeF,IAAgB,KAG/BG,IAAY,IACZC,IAAa,CAAA;AACnB,WAASC,IAAI,GAAGA,KAAKF,GAAWE,KAAK;AACnC,UAAMC,IAAID,IAAIF;AACd,IAAAC,EAAW,KAAK;AAAA,MACdT,KAAUE,IAAOF,KAAUW;AAAA,MAC3BV,KAAUE,IAAOF,KAAUU;AAAA,IACjC,CAAK;AAAA,EACH;AAGA,EAAAP,EAAQ,KAAK;AAAA,IACX,IAAI,GAAGP,CAAE;AAAA,IACT,QAAQY;AAAA,IACR,OAAOX;AAAA,IACP,KAAKA,IAAQQ;AAAA,IACb,OAAOV,EAAM,SAAS;AAAA,IACtB,OAAOA,EAAM,SAAS;AAAA,IACtB,SAASA,EAAM,WAAW;AAAA,EAC9B,CAAG;AAGD,QAAMgB,IAAa,KAAK,MAAMV,IAAOF,MAAW,KAAKG,IAAOF,MAAW,CAAC,GAClEY,IAAW,KAAK,IAAID,IAAa,KAAK,IAAI,GAC1CE,IAAQ,KAAK,MAAMX,IAAOF,GAAQC,IAAOF,CAAM,GAC/Ce,IAAY,KAAK,KAAK,GAGtBC,IAAW;AAAA,IACf,CAACd,GAAMC,CAAI;AAAA,IACX;AAAA,MACED,IAAOW,IAAW,KAAK,IAAIC,IAAQC,CAAS;AAAA,MAC5CZ,IAAOU,IAAW,KAAK,IAAIC,IAAQC,CAAS;AAAA,IAClD;AAAA,EACA,GAGQE,IAAY;AAAA,IAChB,CAACf,GAAMC,CAAI;AAAA,IACX;AAAA,MACED,IAAOW,IAAW,KAAK,IAAIC,IAAQC,CAAS;AAAA,MAC5CZ,IAAOU,IAAW,KAAK,IAAIC,IAAQC,CAAS;AAAA,IAClD;AAAA,EACA,GAEQG,IAAYpB,IAAQQ,GACpBa,IAAeZ,IAAe;AAEpC,SAAAH,EAAQ,KAAK;AAAA,IACX,IAAI,GAAGP,CAAE;AAAA,IACT,QAAQmB;AAAA,IACR,OAAOE;AAAA,IACP,KAAKA,IAAYC;AAAA,IACjB,OAAOvB,EAAM,SAAS;AAAA,IACtB,OAAOA,EAAM,SAAS;AAAA,IACtB,SAASA,EAAM,WAAW;AAAA,EAC9B,CAAG,GAEDQ,EAAQ,KAAK;AAAA,IACX,IAAI,GAAGP,CAAE;AAAA,IACT,QAAQoB;AAAA,IACR,OAAOC;AAAA,IACP,KAAKA,IAAYC;AAAA,IACjB,OAAOvB,EAAM,SAAS;AAAA,IACtB,OAAOA,EAAM,SAAS;AAAA,IACtB,SAASA,EAAM,WAAW;AAAA,EAC9B,CAAG,GAEMQ;AACT;"}
+{"version":3,"file":"index17.js","sources":["../src/converters/circle.js"],"sourcesContent":["/**\n * Circle Converter - Converts circle annotations to stroke commands\n *\n * Transforms circle/ellipse data into stroke paths that can be\n * rendered progressively on canvas with hand-drawn style.\n *\n * @module converters/circle\n */\n\nimport { roughEllipse, hashSeed } from '../rough/roughPathExtractor.js';\n\nconst SCALE = 1000;\n\n/**\n * Converts a circle annotation to stroke commands\n *\n * Generates an ellipse path that renders progressively around the perimeter.\n * Uses RoughJS for hand-drawn circle style.\n *\n * @param {Object} annotation - Circle annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {number} annotation.cx - Center x position (0-1 normalized)\n * @param {number} annotation.cy - Center y position (0-1 normalized)\n * @param {number} annotation.rx - Horizontal radius (0-1 normalized)\n * @param {number} annotation.ry - Vertical radius (0-1 normalized)\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @param {number} [style.roughness=1.0] - Hand-drawn roughness\n * @param {number} [style.bowing=1.0] - Line curvature\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function circleToStrokes(annotation, style) {\n  const { id, start, end, cx, cy, rx, ry } = annotation;\n\n  if (typeof cx !== 'number' || typeof cy !== 'number' ||\n      typeof rx !== 'number' || typeof ry !== 'number') {\n    return [];\n  }\n\n  const roughness = style.roughness ?? 1.0;\n  const bowing = style.bowing ?? 1.0;\n  const curveFitting = style.curveFitting ?? 0.95;\n  const curveStepCount = style.curveStepCount ?? 9;\n  const maxRandomnessOffset = style.maxRandomnessOffset ?? 2;\n  const disableMultiStroke = style.disableMultiStroke ?? false;\n\n  const roughPoints = roughEllipse(\n    cx * SCALE,\n    cy * SCALE,\n    rx * 2 * SCALE,\n    ry * 2 * SCALE,\n    {\n      roughness,\n      bowing,\n      seed: hashSeed(id),\n      curveFitting,\n      curveStepCount,\n      maxRandomnessOffset,\n      disableMultiStroke\n    }\n  );\n\n  const points = roughPoints.map(([px, py]) => [px / SCALE, py / SCALE]);\n\n  return [{\n    id,\n    points,\n    start,\n    end,\n    color: style.color || 'rgba(255, 165, 0, 0.8)',\n    width: style.width || 3,\n    lineCap: style.lineCap || 'round'\n  }];\n}\n\nexport default circleToStrokes;\n"],"names":["SCALE","circleToStrokes","annotation","style","id","start","end","cx","cy","rx","ry","roughness","bowing","curveFitting","curveStepCount","maxRandomnessOffset","disableMultiStroke","points","roughEllipse","hashSeed","px","py"],"mappings":";AAWA,MAAMA,IAAQ;AAyBP,SAASC,EAAgBC,GAAYC,GAAO;AACjD,QAAM,EAAE,IAAAC,GAAI,OAAAC,GAAO,KAAAC,GAAK,IAAAC,GAAI,IAAAC,GAAI,IAAAC,GAAI,IAAAC,EAAE,IAAKR;AAE3C,MAAI,OAAOK,KAAO,YAAY,OAAOC,KAAO,YACxC,OAAOC,KAAO,YAAY,OAAOC,KAAO;AAC1C,WAAO,CAAA;AAGT,QAAMC,IAAYR,EAAM,aAAa,GAC/BS,IAAST,EAAM,UAAU,GACzBU,IAAeV,EAAM,gBAAgB,MACrCW,IAAiBX,EAAM,kBAAkB,GACzCY,IAAsBZ,EAAM,uBAAuB,GACnDa,IAAqBb,EAAM,sBAAsB,IAkBjDc,IAhBcC;AAAA,IAClBX,IAAKP;AAAA,IACLQ,IAAKR;AAAA,IACLS,IAAK,IAAIT;AAAA,IACTU,IAAK,IAAIV;AAAA,IACT;AAAA,MACE,WAAAW;AAAA,MACA,QAAAC;AAAA,MACA,MAAMO,EAASf,CAAE;AAAA,MACjB,cAAAS;AAAA,MACA,gBAAAC;AAAA,MACA,qBAAAC;AAAA,MACA,oBAAAC;AAAA,IACN;AAAA,EACA,EAE6B,IAAI,CAAC,CAACI,GAAIC,CAAE,MAAM,CAACD,IAAKpB,GAAOqB,IAAKrB,CAAK,CAAC;AAErE,SAAO,CAAC;AAAA,IACN,IAAAI;AAAA,IACA,QAAAa;AAAA,IACA,OAAAZ;AAAA,IACA,KAAAC;AAAA,IACA,OAAOH,EAAM,SAAS;AAAA,IACtB,OAAOA,EAAM,SAAS;AAAA,IACtB,SAASA,EAAM,WAAW;AAAA,EAC9B,CAAG;AACH;"}

package/dist/index18.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});function a(l,e){const{id:d,start:f,end:p,cx:o,cy:r,rx:n,ry:i}=l;if(typeof o!="number"||typeof r!="number"||typeof n!="number"||typeof i!="number")return[];const u=36,c=[];for(let t=0;t<=u;t++){const s=t/u*Math.PI*2;c.push([o+n*Math.cos(s),r+i*Math.sin(s)])}return[{id:d,points:c,start:f,end:p,color:e.color||"rgba(255, 165, 0, 0.8)",width:e.width||3,lineCap:e.lineCap||"round"}]}exports.circleToStrokes=a;exports.default=a;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function l(d,i){const{id:c,start:n,end:r,strokes:o}=d;if(!o||o.length===0)return[];const a=r-n;if(a<=0)return[];const f=o.reduce((t,e)=>Math.max(t,(e.timeOffset||0)+(e.duration||.5)),0)||1,s=a/f;return o.filter(t=>t.points&&t.points.length>=2).map((t,e)=>({id:`${c}-${e}`,points:t.points,start:n+(t.timeOffset||0)*s,end:Math.min(n+((t.timeOffset||0)+(t.duration||.5))*s,r),color:t.color||i.color||"#DC143C",width:t.width||i.width||2,lineCap:i.lineCap||"round"}))}exports.inkToStrokes=l;
 //# sourceMappingURL=index18.cjs.map

package/dist/index18.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index18.cjs","sources":["../src/converters/circle.js"],"sourcesContent":["/**\n * Circle Converter - Converts circle annotations to stroke commands\n *\n * Transforms circle/ellipse data into stroke paths that can be\n * rendered progressively on canvas.\n *\n * @module converters/circle\n */\n\n/**\n * Converts a circle annotation to stroke commands\n *\n * Generates an ellipse path from 0° to 360° that renders\n * progressively around the perimeter.\n *\n * @param {Object} annotation - Circle annotation object\n * @param {string} annotation.id - Unique identifier\n * @param {number} annotation.start - Start time in seconds\n * @param {number} annotation.end - End time in seconds\n * @param {number} annotation.cx - Center x position (0-1 normalized)\n * @param {number} annotation.cy - Center y position (0-1 normalized)\n * @param {number} annotation.rx - Horizontal radius (0-1 normalized)\n * @param {number} annotation.ry - Vertical radius (0-1 normalized)\n * @param {Object} [annotation.style] - Optional style overrides\n * @param {Object} style - Resolved style configuration\n * @param {string} style.color - Stroke color\n * @param {number} style.width - Stroke width in pixels\n * @param {string} [style.lineCap='round'] - Line cap style\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function circleToStrokes(annotation, style) {\n  const { id, start, end, cx, cy, rx, ry } = annotation;\n\n  if (typeof cx !== 'number' || typeof cy !== 'number' ||\n      typeof rx !== 'number' || typeof ry !== 'number') {\n    return [];\n  }\n\n  // Generate ellipse points (36 segments + closing point)\n  const numPoints = 36;\n  const points = [];\n\n  for (let i = 0; i <= numPoints; i++) {\n    const angle = (i / numPoints) * Math.PI * 2;\n    points.push([\n      cx + rx * Math.cos(angle),\n      cy + ry * Math.sin(angle)\n    ]);\n  }\n\n  return [{\n    id,\n    points,\n    start,\n    end,\n    color: style.color || 'rgba(255, 165, 0, 0.8)',\n    width: style.width || 3,\n    lineCap: style.lineCap || 'round'\n  }];\n}\n\nexport default circleToStrokes;\n"],"names":["circleToStrokes","annotation","style","id","start","end","cx","cy","rx","ry","numPoints","points","i","angle"],"mappings":"4GA8BO,SAASA,EAAgBC,EAAYC,EAAO,CACjD,KAAM,CAAE,GAAAC,EAAI,MAAAC,EAAO,IAAAC,EAAK,GAAAC,EAAI,GAAAC,EAAI,GAAAC,EAAI,GAAAC,CAAE,EAAKR,EAE3C,GAAI,OAAOK,GAAO,UAAY,OAAOC,GAAO,UACxC,OAAOC,GAAO,UAAY,OAAOC,GAAO,SAC1C,MAAO,CAAA,EAIT,MAAMC,EAAY,GACZC,EAAS,CAAA,EAEf,QAASC,EAAI,EAAGA,GAAKF,EAAWE,IAAK,CACnC,MAAMC,EAASD,EAAIF,EAAa,KAAK,GAAK,EAC1CC,EAAO,KAAK,CACVL,EAAKE,EAAK,KAAK,IAAIK,CAAK,EACxBN,EAAKE,EAAK,KAAK,IAAII,CAAK,CAC9B,CAAK,CACH,CAEA,MAAO,CAAC,CACN,GAAAV,EACA,OAAAQ,EACA,MAAAP,EACA,IAAAC,EACA,MAAOH,EAAM,OAAS,yBACtB,MAAOA,EAAM,OAAS,EACtB,QAASA,EAAM,SAAW,OAC9B,CAAG,CACH"}
+{"version":3,"file":"index18.cjs","sources":["../src/converters/ink.js"],"sourcesContent":["/**\n * Ink Annotation Converter\n *\n * Converts freehand ink annotations to renderer stroke commands.\n * Unlike other converters, ink does NOT use RoughJS — strokes are\n * already hand-drawn and only need timing mapped to the annotation window.\n *\n * @module converters/ink\n */\n\n/**\n * Convert ink annotation to renderer strokes\n *\n * Maps each sub-stroke's recorded timing (timeOffset + duration) to the\n * annotation's playback window [start, end] using a proportional timeScale.\n *\n * @param {Object} annotation - Ink annotation object\n * @param {string} annotation.id - Annotation ID\n * @param {number} annotation.start - Playback start time (seconds)\n * @param {number} annotation.end - Playback end time (seconds)\n * @param {Array} annotation.strokes - Sub-strokes with points and timing\n * @param {Object} style - Resolved style from StrokeRenderer config\n * @returns {Array} Renderer stroke commands\n */\nexport function inkToStrokes(annotation, style) {\n  const { id, start, end, strokes: subStrokes } = annotation;\n  if (!subStrokes || subStrokes.length === 0) return [];\n\n  const totalDuration = end - start;\n  if (totalDuration <= 0) return [];\n\n  // Calculate recorded session length from stroke timing\n  const sessionDuration = subStrokes.reduce(\n    (max, s) => Math.max(max, (s.timeOffset || 0) + (s.duration || 0.5)),\n    0\n  ) || 1;\n  const timeScale = totalDuration / sessionDuration;\n\n  return subStrokes\n    .filter((sub) => sub.points && sub.points.length >= 2)\n    .map((sub, i) => ({\n      id: `${id}-${i}`,\n      points: sub.points,\n      start: start + (sub.timeOffset || 0) * timeScale,\n      end: Math.min(\n        start + ((sub.timeOffset || 0) + (sub.duration || 0.5)) * timeScale,\n        end\n      ),\n      color: sub.color || style.color || '#DC143C',\n      width: sub.width || style.width || 2,\n      lineCap: style.lineCap || 'round',\n    }));\n}\n"],"names":["inkToStrokes","annotation","style","id","start","end","subStrokes","totalDuration","sessionDuration","max","s","timeScale","sub","i"],"mappings":"gFAwBO,SAASA,EAAaC,EAAYC,EAAO,CAC9C,KAAM,CAAE,GAAAC,EAAI,MAAAC,EAAO,IAAAC,EAAK,QAASC,CAAU,EAAKL,EAChD,GAAI,CAACK,GAAcA,EAAW,SAAW,EAAG,MAAO,CAAA,EAEnD,MAAMC,EAAgBF,EAAMD,EAC5B,GAAIG,GAAiB,EAAG,MAAO,CAAA,EAG/B,MAAMC,EAAkBF,EAAW,OACjC,CAACG,EAAKC,IAAM,KAAK,IAAID,GAAMC,EAAE,YAAc,IAAMA,EAAE,UAAY,GAAI,EACnE,CACJ,GAAO,EACCC,EAAYJ,EAAgBC,EAElC,OAAOF,EACJ,OAAQM,GAAQA,EAAI,QAAUA,EAAI,OAAO,QAAU,CAAC,EACpD,IAAI,CAACA,EAAKC,KAAO,CAChB,GAAI,GAAGV,CAAE,IAAIU,CAAC,GACd,OAAQD,EAAI,OACZ,MAAOR,GAASQ,EAAI,YAAc,GAAKD,EACvC,IAAK,KAAK,IACRP,IAAUQ,EAAI,YAAc,IAAMA,EAAI,UAAY,KAAQD,EAC1DN,CACR,EACM,MAAOO,EAAI,OAASV,EAAM,OAAS,UACnC,MAAOU,EAAI,OAASV,EAAM,OAAS,EACnC,QAASA,EAAM,SAAW,OAChC,EAAM,CACN"}