web-annotation-renderer 0.6.0 → 0.6.2

package/dist/index5.js

@@ -1,66 +1,137 @@
-import { deepMerge as v } from "./index6.js";
-import { circleToStrokes as b } from "./index18.js";
-import { arrowToStrokes as _ } from "./index17.js";
-import { underlineToStrokes as C } from "./index16.js";
-import { textToStrokes as P } from "./index15.js";
-import { highlightToStrokes as T } from "./index14.js";
-const R = {
-  pen: {
-    jitter: { amplitude: 1, frequency: 0.08 },
-    pressure: { taperIn: 0.15, taperOut: 0.2 },
-    wobble: { amplitude: 1.5, frequency: 0.05 }
-  },
+import { inkToStrokes as T } from "./index18.js";
+import { circleToStrokes as _ } from "./index17.js";
+import { arrowToStrokes as P } from "./index16.js";
+import { underlineToStrokes as R } from "./index15.js";
+import { textToStrokes as E } from "./index14.js";
+import { highlightToStrokes as O } from "./index13.js";
+const v = ["highlight", "text", "underline", "arrow", "circle", "ink"], S = 500, A = {
   highlight: {
     color: "rgba(255, 255, 0, 0.3)",
     width: 24,
-    lineCap: "butt",
-    jitter: { amplitude: 0 }
+    lineCap: "square",
+    roughness: 1.2,
+    bowing: 1.2,
+    curveFitting: 0.95,
+    curveStepCount: 9,
+    maxRandomnessOffset: 2,
+    disableMultiStroke: !1
   },
   text: {
     color: "rgba(220, 20, 60, 1.0)",
     width: 2,
     fontSize: 16,
     lineCap: "round",
-    jitter: { amplitude: 0 },
-    pressure: { taperIn: 0, taperOut: 0 }
+    roughness: 0.8
   },
   underline: {
     color: "rgba(0, 0, 255, 0.8)",
     width: 2,
-    lineCap: "round"
+    lineCap: "round",
+    roughness: 2,
+    bowing: 2.4,
+    curveFitting: 0.85,
+    curveStepCount: 9,
+    maxRandomnessOffset: 3,
+    disableMultiStroke: !1
   },
   arrow: {
     color: "rgba(255, 0, 0, 0.8)",
     width: 2,
-    lineCap: "round"
+    lineCap: "round",
+    roughness: 1.8,
+    bowing: 1.8,
+    curveFitting: 0.9,
+    curveStepCount: 9,
+    maxRandomnessOffset: 2,
+    disableMultiStroke: !1
   },
   circle: {
     color: "rgba(255, 165, 0, 0.8)",
     width: 3,
+    lineCap: "round",
+    roughness: 1.7,
+    bowing: 2,
+    curveFitting: 0.8,
+    curveStepCount: 12,
+    maxRandomnessOffset: 3,
+    disableMultiStroke: !1
+  },
+  ink: {
+    color: "#DC143C",
+    width: 2,
     lineCap: "round"
   }
 };
-class O {
+class $ {
   /**
    * Create StrokeRenderer instance
    *
    * @param {HTMLCanvasElement} canvas - Canvas element for rendering
-   * @param {Object} [config={}] - Configuration overrides
-   * @param {Object} [config.pen] - Global pen settings
+   * @param {Object} [config={}] - Configuration overrides per annotation type
    * @param {Object} [config.highlight] - Highlight type settings
    * @param {Object} [config.text] - Text type settings
+   * @param {Object} [config.underline] - Underline type settings
+   * @param {Object} [config.arrow] - Arrow type settings
+   * @param {Object} [config.circle] - Circle type settings
    */
   constructor(t, r = {}) {
     if (!t || !(t instanceof HTMLCanvasElement))
-      throw new Error("StrokeRenderer: canvas must be a valid HTMLCanvasElement");
-    this.canvas = t, this.ctx = t.getContext("2d"), this.config = v(R, r), this.strokes = [], this.viewport = { width: 0, height: 0 }, this.converters = {
-      highlight: T,
-      text: P,
-      underline: C,
-      arrow: _,
-      circle: b
+      throw new Error(
+        "StrokeRenderer: canvas must be a valid HTMLCanvasElement"
+      );
+    this.canvas = t, this.ctx = t.getContext("2d"), this.strokes = [], this.viewport = { width: 0, height: 0 }, this.config = {};
+    for (const i of v)
+      this.config[i] = { ...A[i] };
+    Object.keys(r).length > 0 && this.setConfig(r), this.converters = {
+      highlight: O,
+      text: E,
+      underline: R,
+      arrow: P,
+      circle: _,
+      ink: T
     };
   }
+  /**
+   * Set configuration options
+   *
+   * Supports global options (applied to all types) and type-specific options.
+   *
+   * @param {Object} config - Configuration object
+   * @param {number} [config.roughness] - Global roughness for all types
+   * @param {string} [config.color] - Global color for all types
+   * @param {number} [config.width] - Global width for all types
+   * @param {Object} [config.highlight] - Highlight-specific options
+   * @param {Object} [config.text] - Text-specific options
+   * @param {Object} [config.underline] - Underline-specific options
+   * @param {Object} [config.arrow] - Arrow-specific options
+   * @param {Object} [config.circle] - Circle-specific options
+   * @returns {StrokeRenderer} Returns this for chaining
+   *
+   * @example
+   * // Global options
+   * renderer.setConfig({ roughness: 2, color: "blue" });
+   *
+   * // Type-specific options
+   * renderer.setConfig({ highlight: { color: "yellow", width: 30 } });
+   *
+   * // Combined
+   * renderer.setConfig({
+   *   roughness: 2,
+   *   highlight: { color: "yellow" }
+   * });
+   */
+  setConfig(t) {
+    const r = {}, i = {};
+    for (const [e, s] of Object.entries(t))
+      v.includes(e) ? i[e] = s : r[e] = s;
+    for (const e of v)
+      this.config[e] = {
+        ...this.config[e],
+        ...r,
+        ...i[e] || {}
+      };
+    return this;
+  }
   /**
    * Register a custom converter for a new annotation type
    *
@@ -69,7 +140,9 @@ class O {
    */
   registerConverter(t, r) {
     if (typeof r != "function")
-      throw new Error("StrokeRenderer.registerConverter: converter must be a function");
+      throw new Error(
+        "StrokeRenderer.registerConverter: converter must be a function"
+      );
     this.converters[t] = r;
   }
   /**
@@ -95,16 +168,20 @@ class O {
    */
   setAnnotations(t, r = null) {
     if (!Array.isArray(t)) {
-      console.warn("StrokeRenderer.setAnnotations: annotations must be an array"), this.strokes = [];
+      console.warn(
+        "StrokeRenderer.setAnnotations: annotations must be an array"
+      ), this.strokes = [];
       return;
     }
     const i = r !== null ? t.filter((e) => e.page === r) : t;
     this.strokes = i.flatMap((e) => {
-      const n = this.converters[e.type];
-      if (!n)
-        return console.warn(`StrokeRenderer: Unknown annotation type "${e.type}"`), [];
-      const s = this._resolveStyle(e);
-      return n(e, s);
+      const s = this.converters[e.type];
+      if (!s)
+        return console.warn(
+          `StrokeRenderer: Unknown annotation type "${e.type}"`
+        ), [];
+      const n = this._resolveStyle(e);
+      return s(e, n);
     });
   }
   /**
@@ -131,11 +208,11 @@ class O {
   render(t) {
     const { ctx: r, viewport: i, strokes: e } = this;
     r.clearRect(0, 0, i.width, i.height);
-    for (const n of e) {
-      if (t < n.start)
+    for (const s of e) {
+      if (t < s.start)
         continue;
-      const s = n.end - n.start, h = t - n.start, o = s > 0 ? Math.min(1, h / s) : 1;
-      this._drawStroke(n, o);
+      const n = s.end - s.start, h = t - s.start, o = n > 0 ? Math.min(1, h / n) : 1;
+      this._drawStroke(s, o);
     }
   }
   /**
@@ -153,16 +230,16 @@ class O {
   /**
    * Resolve style for an annotation
    *
-   * Merges: pen config → type config → annotation.style
+   * Returns the config for the annotation type.
+   * Style is managed via setConfig(), not per-annotation.
    *
    * @private
    * @param {Object} annotation - Annotation object
    * @returns {Object} Resolved style object
    */
   _resolveStyle(t) {
-    const { type: r, style: i } = t;
-    let e = { ...this.config.pen };
-    return this.config[r] && (e = v(e, this.config[r])), i && (e = v(e, i)), e;
+    const { type: r } = t;
+    return this.config[r] || {};
   }
   /**
    * Linearly interpolate between two points
@@ -174,10 +251,7 @@ class O {
    * @returns {Array} Interpolated point [x, y]
    */
   _interpolatePoint(t, r, i) {
-    return [
-      t[0] + (r[0] - t[0]) * i,
-      t[1] + (r[1] - t[1]) * i
-    ];
+    return [t[0] + (r[0] - t[0]) * i, t[1] + (r[1] - t[1]) * i];
   }
   /**
    * Get pressure values for visible points including interpolated final
@@ -191,8 +265,8 @@ class O {
   _interpolatePressures(t, r, i) {
     const e = t.slice(0, r + 1);
     if (r < t.length - 1 && i > 0) {
-      const n = t[r], s = t[r + 1];
-      e.push(n + (s - n) * i);
+      const s = t[r], n = t[r + 1];
+      e.push(s + (n - s) * i);
     }
     return e;
   }
@@ -206,27 +280,62 @@ class O {
    * @param {number} progress - Progress from 0 to 1
    */
   _drawStroke(t, r) {
-    const { ctx: i } = this, { points: e, color: n, width: s, lineCap: h, pressures: o, uniformScale: g, baseX: l, baseY: a } = t;
+    const { ctx: i } = this, {
+      points: e,
+      color: s,
+      width: n,
+      lineCap: h,
+      pressures: o,
+      uniformScale: f,
+      baseX: l,
+      baseY: a
+    } = t;
     if (!e || e.length < 2) return;
-    if (i.strokeStyle = n || "rgba(0, 0, 0, 0.5)", i.lineCap = h || "round", i.lineJoin = "round", r >= 1) {
-      o && o.length >= e.length ? this._drawVariableWidthStroke(e, s, o, g, l, a) : this._drawConstantWidthStroke(e, s, g, l, a);
+    if (i.strokeStyle = s || "rgba(0, 0, 0, 0.5)", i.lineCap = h || "round", i.lineJoin = "round", r >= 1) {
+      o && o.length >= e.length ? this._drawVariableWidthStroke(
+        e,
+        n,
+        o,
+        f,
+        l,
+        a
+      ) : this._drawConstantWidthStroke(
+        e,
+        n,
+        f,
+        l,
+        a
+      );
       return;
     }
-    const c = e.length - 1, d = r * c, u = Math.floor(d), f = d - u, p = e.slice(0, u + 1);
-    if (u < c && f > 0) {
-      const w = e[u], k = e[u + 1];
-      p.push(this._interpolatePoint(w, k, f));
+    const u = e.length - 1, g = r * u, c = Math.floor(g), w = g - c, d = e.slice(0, c + 1);
+    if (c < u && w > 0) {
+      const p = e[c], k = e[c + 1];
+      d.push(this._interpolatePoint(p, k, w));
     }
-    if (!(p.length < 2))
+    if (!(d.length < 2))
       if (o && o.length >= e.length) {
-        const w = this._interpolatePressures(
+        const p = this._interpolatePressures(
           o,
-          u,
-          f
+          c,
+          w
+        );
+        this._drawVariableWidthStroke(
+          d,
+          n,
+          p,
+          f,
+          l,
+          a
         );
-        this._drawVariableWidthStroke(p, s, w, g, l, a);
       } else
-        this._drawConstantWidthStroke(p, s, g, l, a);
+        this._drawConstantWidthStroke(
+          d,
+          n,
+          f,
+          l,
+          a
+        );
   }
   /**
    * Draw stroke with constant width
@@ -238,16 +347,16 @@ class O {
    * @param {number} [baseX] - Base X position in width-normalized coords (for uniformScale with offset points)
    * @param {number} [baseY] - Base Y position in height-normalized coords (for uniformScale with offset points)
    */
-  _drawConstantWidthStroke(t, r, i = !1, e = null, n = null) {
-    const { ctx: s, viewport: h } = this;
-    s.lineWidth = r || 2, s.beginPath();
-    const o = i && e !== null && n !== null;
-    for (let g = 0; g < t.length; g++) {
-      const [l, a] = t[g];
-      let c, d;
-      o ? (c = e * h.width + l * h.height, d = n * h.height + a * h.height) : i ? (c = l * h.height, d = a * h.height) : (c = l * h.width, d = a * h.height), g === 0 ? s.moveTo(c, d) : s.lineTo(c, d);
+  _drawConstantWidthStroke(t, r, i = !1, e = null, s = null) {
+    const { ctx: n, viewport: h } = this, o = h.height / S;
+    n.lineWidth = (r || 2) * o, n.beginPath();
+    const f = i && e !== null && s !== null;
+    for (let l = 0; l < t.length; l++) {
+      const [a, u] = t[l];
+      let g, c;
+      f ? (g = e * h.width + a * h.height, c = s * h.height + u * h.height) : i ? (g = a * h.height, c = u * h.height) : (g = a * h.width, c = u * h.height), l === 0 ? n.moveTo(g, c) : n.lineTo(g, c);
     }
-    s.stroke();
+    n.stroke();
   }
   /**
    * Draw stroke with variable width based on pressure
@@ -260,19 +369,19 @@ class O {
    * @param {number} [baseX] - Base X position in width-normalized coords (for uniformScale with offset points)
    * @param {number} [baseY] - Base Y position in height-normalized coords (for uniformScale with offset points)
    */
-  _drawVariableWidthStroke(t, r, i, e = !1, n = null, s = null) {
-    const { ctx: h, viewport: o } = this, g = e && n !== null && s !== null;
+  _drawVariableWidthStroke(t, r, i, e = !1, s = null, n = null) {
+    const { ctx: h, viewport: o } = this, f = e && s !== null && n !== null;
     for (let l = 1; l < t.length; l++) {
-      const [a, c] = t[l - 1], [d, u] = t[l];
-      let f, p, w, k;
-      g ? (f = n * o.width + a * o.height, p = s * o.height + c * o.height, w = n * o.width + d * o.height, k = s * o.height + u * o.height) : e ? (f = a * o.height, p = c * o.height, w = d * o.height, k = u * o.height) : (f = a * o.width, p = c * o.height, w = d * o.width, k = u * o.height);
-      const y = i[l - 1] || 1, S = i[l] || 1, m = (y + S) / 2, x = Math.max(0.5, r * m);
-      h.lineWidth = x, h.beginPath(), h.moveTo(f, p), h.lineTo(w, k), h.stroke();
+      const [a, u] = t[l - 1], [g, c] = t[l];
+      let w, d, p, k;
+      f ? (w = s * o.width + a * o.height, d = n * o.height + u * o.height, p = s * o.width + g * o.height, k = n * o.height + c * o.height) : e ? (w = a * o.height, d = u * o.height, p = g * o.height, k = c * o.height) : (w = a * o.width, d = u * o.height, p = g * o.width, k = c * o.height);
+      const m = i[l - 1] || 1, y = i[l] || 1, b = (m + y) / 2, x = o.height / S, C = Math.max(0.5, r * b) * x;
+      h.lineWidth = C, h.beginPath(), h.moveTo(w, d), h.lineTo(p, k), h.stroke();
     }
   }
 }
 export {
-  O as StrokeRenderer,
-  O as default
+  $ as StrokeRenderer,
+  $ as default
 };
 //# sourceMappingURL=index5.js.map

package/dist/index5.js.map

@@ -1 +1 @@
-{"version":3,"file":"index5.js","sources":["../src/renderer/StrokeRenderer.js"],"sourcesContent":["/**\n * StrokeRenderer - Unified canvas-based annotation renderer\n *\n * Single entry point for rendering annotations as strokes on canvas.\n * Handles conversion from annotations to strokes and progressive rendering.\n *\n * @module renderer/StrokeRenderer\n */\n\nimport {\n  highlightToStrokes,\n  textToStrokes,\n  underlineToStrokes,\n  arrowToStrokes,\n  circleToStrokes\n} from '../converters/index.js';\nimport { deepMerge } from '../pen/effects.js';\n\n/**\n * Default configuration\n */\nconst DEFAULT_CONFIG = {\n  pen: {\n    jitter: { amplitude: 1.0, frequency: 0.08 },\n    pressure: { taperIn: 0.15, taperOut: 0.20 },\n    wobble: { amplitude: 1.5, frequency: 0.05 }\n  },\n  highlight: {\n    color: 'rgba(255, 255, 0, 0.3)',\n    width: 24,\n    lineCap: 'butt',\n    jitter: { amplitude: 0 }\n  },\n  text: {\n    color: 'rgba(220, 20, 60, 1.0)',\n    width: 2,\n    fontSize: 16,\n    lineCap: 'round',\n    jitter: { amplitude: 0 },\n    pressure: { taperIn: 0, taperOut: 0 }\n  },\n  underline: {\n    color: 'rgba(0, 0, 255, 0.8)',\n    width: 2,\n    lineCap: 'round'\n  },\n  arrow: {\n    color: 'rgba(255, 0, 0, 0.8)',\n    width: 2,\n    lineCap: 'round'\n  },\n  circle: {\n    color: 'rgba(255, 165, 0, 0.8)',\n    width: 3,\n    lineCap: 'round'\n  }\n};\n\n/**\n * StrokeRenderer class\n *\n * Converts annotations to strokes and renders them progressively on canvas.\n *\n * @class\n * @example\n * const renderer = new StrokeRenderer(canvas, {\n *   highlight: { color: 'rgba(0, 255, 200, 0.4)' }\n * });\n * renderer.setViewport(800, 600);\n * renderer.setAnnotations(annotations);\n * renderer.render(1.5); // Render at t=1.5 seconds\n */\nclass StrokeRenderer {\n  /**\n   * Create StrokeRenderer instance\n   *\n   * @param {HTMLCanvasElement} canvas - Canvas element for rendering\n   * @param {Object} [config={}] - Configuration overrides\n   * @param {Object} [config.pen] - Global pen settings\n   * @param {Object} [config.highlight] - Highlight type settings\n   * @param {Object} [config.text] - Text type settings\n   */\n  constructor(canvas, config = {}) {\n    if (!canvas || !(canvas instanceof HTMLCanvasElement)) {\n      throw new Error('StrokeRenderer: canvas must be a valid HTMLCanvasElement');\n    }\n\n    this.canvas = canvas;\n    this.ctx = canvas.getContext('2d');\n    this.config = deepMerge(DEFAULT_CONFIG, config);\n    this.strokes = [];\n    this.viewport = { width: 0, height: 0 };\n\n    // Register built-in converters\n    this.converters = {\n      highlight: highlightToStrokes,\n      text: textToStrokes,\n      underline: underlineToStrokes,\n      arrow: arrowToStrokes,\n      circle: circleToStrokes\n    };\n  }\n\n  /**\n   * Register a custom converter for a new annotation type\n   *\n   * @param {string} type - Annotation type name\n   * @param {Function} converter - Converter function (annotation, style) => strokes[]\n   */\n  registerConverter(type, converter) {\n    if (typeof converter !== 'function') {\n      throw new Error('StrokeRenderer.registerConverter: converter must be a function');\n    }\n    this.converters[type] = converter;\n  }\n\n  /**\n   * Set viewport dimensions and configure canvas\n   *\n   * Handles high-DPI displays by scaling the canvas buffer.\n   *\n   * @param {number} width - Viewport width in CSS pixels\n   * @param {number} height - Viewport height in CSS pixels\n   */\n  setViewport(width, height) {\n    this.viewport = { width, height };\n\n    const dpr = window.devicePixelRatio || 1;\n\n    // Set canvas buffer size (high-res)\n    this.canvas.width = width * dpr;\n    this.canvas.height = height * dpr;\n\n    // Set canvas display size (CSS)\n    this.canvas.style.width = `${width}px`;\n    this.canvas.style.height = `${height}px`;\n\n    // Scale context for high-DPI\n    this.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n  }\n\n  /**\n   * Set annotations and convert them to strokes\n   *\n   * Clears existing strokes and converts all annotations.\n   *\n   * @param {Array} annotations - Array of annotation objects\n   * @param {number} [page] - Optional page filter (only convert annotations for this page)\n   */\n  setAnnotations(annotations, page = null) {\n    if (!Array.isArray(annotations)) {\n      console.warn('StrokeRenderer.setAnnotations: annotations must be an array');\n      this.strokes = [];\n      return;\n    }\n\n    // Filter by page if specified\n    const filtered = page !== null\n      ? annotations.filter(a => a.page === page)\n      : annotations;\n\n    // Convert each annotation to strokes\n    this.strokes = filtered.flatMap(annotation => {\n      const converter = this.converters[annotation.type];\n\n      if (!converter) {\n        console.warn(`StrokeRenderer: Unknown annotation type \"${annotation.type}\"`);\n        return [];\n      }\n\n      // Resolve style: pen → type → annotation.style\n      const style = this._resolveStyle(annotation);\n\n      return converter(annotation, style);\n    });\n  }\n\n  /**\n   * Set pre-converted strokes directly\n   *\n   * Bypasses conversion, useful when strokes come from external source.\n   *\n   * @param {Array} strokes - Array of stroke command objects\n   */\n  setStrokes(strokes) {\n    if (!Array.isArray(strokes)) {\n      console.warn('StrokeRenderer.setStrokes: strokes must be an array');\n      this.strokes = [];\n      return;\n    }\n    this.strokes = strokes;\n  }\n\n  /**\n   * Render strokes at the given time\n   *\n   * Clears canvas and draws all visible strokes with appropriate progress.\n   *\n   * @param {number} time - Current time in seconds\n   */\n  render(time) {\n    const { ctx, viewport, strokes } = this;\n\n    // Clear canvas\n    ctx.clearRect(0, 0, viewport.width, viewport.height);\n\n    // Draw each stroke\n    for (const stroke of strokes) {\n      // Skip if not started yet\n      if (time < stroke.start) {\n        continue;\n      }\n\n      // Calculate progress\n      const duration = stroke.end - stroke.start;\n      const elapsed = time - stroke.start;\n      const progress = duration > 0 ? Math.min(1, elapsed / duration) : 1;\n\n      this._drawStroke(stroke, progress);\n    }\n  }\n\n  /**\n   * Clear the canvas\n   */\n  clear() {\n    this.ctx.clearRect(0, 0, this.viewport.width, this.viewport.height);\n  }\n\n  /**\n   * Destroy the renderer and release resources\n   */\n  destroy() {\n    this.strokes = [];\n    this.ctx = null;\n    this.canvas = null;\n    this.config = null;\n    this.converters = null;\n  }\n\n  /**\n   * Resolve style for an annotation\n   *\n   * Merges: pen config → type config → annotation.style\n   *\n   * @private\n   * @param {Object} annotation - Annotation object\n   * @returns {Object} Resolved style object\n   */\n  _resolveStyle(annotation) {\n    const { type, style: annotationStyle } = annotation;\n\n    // Start with pen config (global)\n    let resolved = { ...this.config.pen };\n\n    // Merge type config\n    if (this.config[type]) {\n      resolved = deepMerge(resolved, this.config[type]);\n    }\n\n    // Merge annotation-level style\n    if (annotationStyle) {\n      resolved = deepMerge(resolved, annotationStyle);\n    }\n\n    return resolved;\n  }\n\n  /**\n   * Linearly interpolate between two points\n   *\n   * @private\n   * @param {Array} p1 - Start point [x, y]\n   * @param {Array} p2 - End point [x, y]\n   * @param {number} t - Interpolation factor (0-1)\n   * @returns {Array} Interpolated point [x, y]\n   */\n  _interpolatePoint(p1, p2, t) {\n    return [\n      p1[0] + (p2[0] - p1[0]) * t,\n      p1[1] + (p2[1] - p1[1]) * t\n    ];\n  }\n\n  /**\n   * Get pressure values for visible points including interpolated final\n   *\n   * @private\n   * @param {Array} pressures - Full pressure array\n   * @param {number} lastCompleteIndex - Index of last complete point\n   * @param {number} segmentProgress - Progress within current segment (0-1)\n   * @returns {Array} Pressure values for visible points\n   */\n  _interpolatePressures(pressures, lastCompleteIndex, segmentProgress) {\n    const visiblePressures = pressures.slice(0, lastCompleteIndex + 1);\n\n    if (lastCompleteIndex < pressures.length - 1 && segmentProgress > 0) {\n      const p1 = pressures[lastCompleteIndex];\n      const p2 = pressures[lastCompleteIndex + 1];\n      visiblePressures.push(p1 + (p2 - p1) * segmentProgress);\n    }\n\n    return visiblePressures;\n  }\n\n  /**\n   * Draw a single stroke with progress\n   *\n   * Uses endpoint interpolation for smooth progressive rendering.\n   *\n   * @private\n   * @param {Object} stroke - Stroke command object\n   * @param {number} progress - Progress from 0 to 1\n   */\n  _drawStroke(stroke, progress) {\n    const { ctx } = this;\n    const { points, color, width, lineCap, pressures, uniformScale, baseX, baseY } = stroke;\n\n    if (!points || points.length < 2) return;\n\n    // Configure stroke style\n    ctx.strokeStyle = color || 'rgba(0, 0, 0, 0.5)';\n    ctx.lineCap = lineCap || 'round';\n    ctx.lineJoin = 'round';\n\n    // Fast path: full stroke, no interpolation needed\n    if (progress >= 1) {\n      if (pressures && pressures.length >= points.length) {\n        this._drawVariableWidthStroke(points, width, pressures, uniformScale, baseX, baseY);\n      } else {\n        this._drawConstantWidthStroke(points, width, uniformScale, baseX, baseY);\n      }\n      return;\n    }\n\n    // Calculate segment position for interpolation\n    const totalSegments = points.length - 1;\n    const progressAlongPath = progress * totalSegments;\n    const lastCompleteIndex = Math.floor(progressAlongPath);\n    const segmentProgress = progressAlongPath - lastCompleteIndex;\n\n    // Build visible points array with complete points\n    const visiblePoints = points.slice(0, lastCompleteIndex + 1);\n\n    // Interpolate final point if mid-segment\n    if (lastCompleteIndex < totalSegments && segmentProgress > 0) {\n      const p1 = points[lastCompleteIndex];\n      const p2 = points[lastCompleteIndex + 1];\n      visiblePoints.push(this._interpolatePoint(p1, p2, segmentProgress));\n    }\n\n    // Need at least 2 points to draw a line\n    if (visiblePoints.length < 2) return;\n\n    // Draw with variable width if pressures provided\n    if (pressures && pressures.length >= points.length) {\n      const visiblePressures = this._interpolatePressures(\n        pressures, lastCompleteIndex, segmentProgress\n      );\n      this._drawVariableWidthStroke(visiblePoints, width, visiblePressures, uniformScale, baseX, baseY);\n    } else {\n      this._drawConstantWidthStroke(visiblePoints, width, uniformScale, baseX, baseY);\n    }\n  }\n\n  /**\n   * Draw stroke with constant width\n   *\n   * @private\n   * @param {Array} points - Array of [x, y] coordinates (normalized or offset)\n   * @param {number} width - Stroke width in pixels\n   * @param {boolean} [uniformScale=false] - Use uniform scaling to preserve aspect ratio\n   * @param {number} [baseX] - Base X position in width-normalized coords (for uniformScale with offset points)\n   * @param {number} [baseY] - Base Y position in height-normalized coords (for uniformScale with offset points)\n   */\n  _drawConstantWidthStroke(points, width, uniformScale = false, baseX = null, baseY = null) {\n    const { ctx, viewport } = this;\n\n    ctx.lineWidth = width || 2;\n    ctx.beginPath();\n\n    // When uniformScale is true and baseX/baseY provided, points are offsets from base position\n    // Base position is in mixed coords (X: width-normalized, Y: height-normalized)\n    // Offsets are in uniform space (both scaled by viewport.height)\n    const hasBasePosition = uniformScale && baseX !== null && baseY !== null;\n\n    for (let i = 0; i < points.length; i++) {\n      const [coordX, coordY] = points[i];\n      let px, py;\n\n      if (hasBasePosition) {\n        // Base position in pixels + uniform-scaled offset\n        px = baseX * viewport.width + coordX * viewport.height;\n        py = baseY * viewport.height + coordY * viewport.height;\n      } else if (uniformScale) {\n        // Legacy: full coordinates in uniform space\n        px = coordX * viewport.height;\n        py = coordY * viewport.height;\n      } else {\n        // Standard: X scaled by width, Y by height\n        px = coordX * viewport.width;\n        py = coordY * viewport.height;\n      }\n\n      if (i === 0) {\n        ctx.moveTo(px, py);\n      } else {\n        ctx.lineTo(px, py);\n      }\n    }\n\n    ctx.stroke();\n  }\n\n  /**\n   * Draw stroke with variable width based on pressure\n   *\n   * @private\n   * @param {Array} points - Array of [x, y] coordinates (normalized or offset)\n   * @param {number} baseWidth - Base stroke width in pixels\n   * @param {Array} pressures - Pressure values (0-1) per point\n   * @param {boolean} [uniformScale=false] - Use uniform scaling to preserve aspect ratio\n   * @param {number} [baseX] - Base X position in width-normalized coords (for uniformScale with offset points)\n   * @param {number} [baseY] - Base Y position in height-normalized coords (for uniformScale with offset points)\n   */\n  _drawVariableWidthStroke(points, baseWidth, pressures, uniformScale = false, baseX = null, baseY = null) {\n    const { ctx, viewport } = this;\n\n    // When uniformScale is true and baseX/baseY provided, points are offsets from base position\n    const hasBasePosition = uniformScale && baseX !== null && baseY !== null;\n\n    for (let i = 1; i < points.length; i++) {\n      const [c1x, c1y] = points[i - 1];\n      const [c2x, c2y] = points[i];\n\n      let px1, py1, px2, py2;\n\n      if (hasBasePosition) {\n        // Base position in pixels + uniform-scaled offset\n        px1 = baseX * viewport.width + c1x * viewport.height;\n        py1 = baseY * viewport.height + c1y * viewport.height;\n        px2 = baseX * viewport.width + c2x * viewport.height;\n        py2 = baseY * viewport.height + c2y * viewport.height;\n      } else if (uniformScale) {\n        // Legacy: full coordinates in uniform space\n        px1 = c1x * viewport.height;\n        py1 = c1y * viewport.height;\n        px2 = c2x * viewport.height;\n        py2 = c2y * viewport.height;\n      } else {\n        // Standard: X scaled by width, Y by height\n        px1 = c1x * viewport.width;\n        py1 = c1y * viewport.height;\n        px2 = c2x * viewport.width;\n        py2 = c2y * viewport.height;\n      }\n\n      // Average pressure between two points\n      const p1 = pressures[i - 1] || 1;\n      const p2 = pressures[i] || 1;\n      const avgPressure = (p1 + p2) / 2;\n\n      // Apply pressure to width (min 0.5)\n      const width = Math.max(0.5, baseWidth * avgPressure);\n\n      ctx.lineWidth = width;\n      ctx.beginPath();\n      ctx.moveTo(px1, py1);\n      ctx.lineTo(px2, py2);\n      ctx.stroke();\n    }\n  }\n}\n\nexport { StrokeRenderer };\nexport default StrokeRenderer;\n"],"names":["DEFAULT_CONFIG","StrokeRenderer","canvas","config","deepMerge","highlightToStrokes","textToStrokes","underlineToStrokes","arrowToStrokes","circleToStrokes","type","converter","width","height","dpr","annotations","page","filtered","a","annotation","style","strokes","time","ctx","viewport","stroke","duration","elapsed","progress","annotationStyle","resolved","p1","p2","t","pressures","lastCompleteIndex","segmentProgress","visiblePressures","points","color","lineCap","uniformScale","baseX","baseY","totalSegments","progressAlongPath","visiblePoints","hasBasePosition","i","coordX","coordY","px","py","baseWidth","c1x","c1y","c2x","c2y","px1","py1","px2","py2","avgPressure"],"mappings":"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"}
+{"version":3,"file":"index5.js","sources":["../src/renderer/StrokeRenderer.js"],"sourcesContent":["/**\n * StrokeRenderer - Unified canvas-based annotation renderer\n *\n * Single entry point for rendering annotations as strokes on canvas.\n * Handles conversion from annotations to strokes and progressive rendering.\n *\n * @module renderer/StrokeRenderer\n */\n\nimport {\n  highlightToStrokes,\n  textToStrokes,\n  underlineToStrokes,\n  arrowToStrokes,\n  circleToStrokes,\n  inkToStrokes,\n} from \"../converters/index.js\";\n\n/**\n * Supported annotation types\n */\nconst ANNOTATION_TYPES = [\"highlight\", \"text\", \"underline\", \"arrow\", \"circle\", \"ink\"];\n\n/**\n * Reference viewport height for width scaling\n * Stroke widths are defined relative to this height (500px = roughjs-tester default)\n */\nconst REFERENCE_HEIGHT = 500;\n\n/**\n * Default configuration\n *\n * Each annotation type has:\n * - Rendering options: color, width, lineCap\n * - RoughJS options: roughness, bowing, curveFitting, curveStepCount, maxRandomnessOffset, disableMultiStroke\n */\nconst DEFAULT_CONFIG = {\n  highlight: {\n    color: \"rgba(255, 255, 0, 0.3)\",\n    width: 24,\n    lineCap: \"square\",\n    roughness: 1.2,\n    bowing: 1.2,\n    curveFitting: 0.95,\n    curveStepCount: 9,\n    maxRandomnessOffset: 2,\n    disableMultiStroke: false,\n  },\n  text: {\n    color: \"rgba(220, 20, 60, 1.0)\",\n    width: 2,\n    fontSize: 16,\n    lineCap: \"round\",\n    roughness: 0.8,\n  },\n  underline: {\n    color: \"rgba(0, 0, 255, 0.8)\",\n    width: 2,\n    lineCap: \"round\",\n    roughness: 2.0,\n    bowing: 2.4,\n    curveFitting: 0.85,\n    curveStepCount: 9,\n    maxRandomnessOffset: 3,\n    disableMultiStroke: false,\n  },\n  arrow: {\n    color: \"rgba(255, 0, 0, 0.8)\",\n    width: 2,\n    lineCap: \"round\",\n    roughness: 1.8,\n    bowing: 1.8,\n    curveFitting: 0.9,\n    curveStepCount: 9,\n    maxRandomnessOffset: 2,\n    disableMultiStroke: false,\n  },\n  circle: {\n    color: \"rgba(255, 165, 0, 0.8)\",\n    width: 3,\n    lineCap: \"round\",\n    roughness: 1.7,\n    bowing: 2.0,\n    curveFitting: 0.8,\n    curveStepCount: 12,\n    maxRandomnessOffset: 3,\n    disableMultiStroke: false,\n  },\n  ink: {\n    color: \"#DC143C\",\n    width: 2,\n    lineCap: \"round\",\n  },\n};\n\n/**\n * StrokeRenderer class\n *\n * Converts annotations to strokes and renders them progressively on canvas.\n *\n * @class\n * @example\n * const renderer = new StrokeRenderer(canvas, {\n *   highlight: { color: 'rgba(0, 255, 200, 0.4)' }\n * });\n * renderer.setViewport(800, 600);\n * renderer.setAnnotations(annotations);\n * renderer.render(1.5); // Render at t=1.5 seconds\n */\nclass StrokeRenderer {\n  /**\n   * Create StrokeRenderer instance\n   *\n   * @param {HTMLCanvasElement} canvas - Canvas element for rendering\n   * @param {Object} [config={}] - Configuration overrides per annotation type\n   * @param {Object} [config.highlight] - Highlight type settings\n   * @param {Object} [config.text] - Text type settings\n   * @param {Object} [config.underline] - Underline type settings\n   * @param {Object} [config.arrow] - Arrow type settings\n   * @param {Object} [config.circle] - Circle type settings\n   */\n  constructor(canvas, config = {}) {\n    if (!canvas || !(canvas instanceof HTMLCanvasElement)) {\n      throw new Error(\n        \"StrokeRenderer: canvas must be a valid HTMLCanvasElement\"\n      );\n    }\n\n    this.canvas = canvas;\n    this.ctx = canvas.getContext(\"2d\");\n    this.strokes = [];\n    this.viewport = { width: 0, height: 0 };\n\n    // Initialize config with defaults\n    this.config = {};\n    for (const type of ANNOTATION_TYPES) {\n      this.config[type] = { ...DEFAULT_CONFIG[type] };\n    }\n\n    // Apply user config if provided\n    if (Object.keys(config).length > 0) {\n      this.setConfig(config);\n    }\n\n    // Register built-in converters\n    this.converters = {\n      highlight: highlightToStrokes,\n      text: textToStrokes,\n      underline: underlineToStrokes,\n      arrow: arrowToStrokes,\n      circle: circleToStrokes,\n      ink: inkToStrokes,\n    };\n  }\n\n  /**\n   * Set configuration options\n   *\n   * Supports global options (applied to all types) and type-specific options.\n   *\n   * @param {Object} config - Configuration object\n   * @param {number} [config.roughness] - Global roughness for all types\n   * @param {string} [config.color] - Global color for all types\n   * @param {number} [config.width] - Global width for all types\n   * @param {Object} [config.highlight] - Highlight-specific options\n   * @param {Object} [config.text] - Text-specific options\n   * @param {Object} [config.underline] - Underline-specific options\n   * @param {Object} [config.arrow] - Arrow-specific options\n   * @param {Object} [config.circle] - Circle-specific options\n   * @returns {StrokeRenderer} Returns this for chaining\n   *\n   * @example\n   * // Global options\n   * renderer.setConfig({ roughness: 2, color: \"blue\" });\n   *\n   * // Type-specific options\n   * renderer.setConfig({ highlight: { color: \"yellow\", width: 30 } });\n   *\n   * // Combined\n   * renderer.setConfig({\n   *   roughness: 2,\n   *   highlight: { color: \"yellow\" }\n   * });\n   */\n  setConfig(config) {\n    const globalOptions = {};\n    const typeOptions = {};\n\n    // Separate global options from type-specific options\n    for (const [key, value] of Object.entries(config)) {\n      if (ANNOTATION_TYPES.includes(key)) {\n        typeOptions[key] = value;\n      } else {\n        globalOptions[key] = value;\n      }\n    }\n\n    // Apply to each type: current config + global + type-specific\n    for (const type of ANNOTATION_TYPES) {\n      this.config[type] = {\n        ...this.config[type],\n        ...globalOptions,\n        ...(typeOptions[type] || {}),\n      };\n    }\n\n    return this;\n  }\n\n  /**\n   * Register a custom converter for a new annotation type\n   *\n   * @param {string} type - Annotation type name\n   * @param {Function} converter - Converter function (annotation, style) => strokes[]\n   */\n  registerConverter(type, converter) {\n    if (typeof converter !== \"function\") {\n      throw new Error(\n        \"StrokeRenderer.registerConverter: converter must be a function\"\n      );\n    }\n    this.converters[type] = converter;\n  }\n\n  /**\n   * Set viewport dimensions and configure canvas\n   *\n   * Handles high-DPI displays by scaling the canvas buffer.\n   *\n   * @param {number} width - Viewport width in CSS pixels\n   * @param {number} height - Viewport height in CSS pixels\n   */\n  setViewport(width, height) {\n    this.viewport = { width, height };\n\n    const dpr = window.devicePixelRatio || 1;\n\n    // Set canvas buffer size (high-res)\n    this.canvas.width = width * dpr;\n    this.canvas.height = height * dpr;\n\n    // Set canvas display size (CSS)\n    this.canvas.style.width = `${width}px`;\n    this.canvas.style.height = `${height}px`;\n\n    // Scale context for high-DPI\n    this.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n  }\n\n  /**\n   * Set annotations and convert them to strokes\n   *\n   * Clears existing strokes and converts all annotations.\n   *\n   * @param {Array} annotations - Array of annotation objects\n   * @param {number} [page] - Optional page filter (only convert annotations for this page)\n   */\n  setAnnotations(annotations, page = null) {\n    if (!Array.isArray(annotations)) {\n      console.warn(\n        \"StrokeRenderer.setAnnotations: annotations must be an array\"\n      );\n      this.strokes = [];\n      return;\n    }\n\n    // Filter by page if specified\n    const filtered =\n      page !== null ? annotations.filter((a) => a.page === page) : annotations;\n\n    // Convert each annotation to strokes\n    this.strokes = filtered.flatMap((annotation) => {\n      const converter = this.converters[annotation.type];\n\n      if (!converter) {\n        console.warn(\n          `StrokeRenderer: Unknown annotation type \"${annotation.type}\"`\n        );\n        return [];\n      }\n\n      // Resolve style: pen → type → annotation.style\n      const style = this._resolveStyle(annotation);\n\n      return converter(annotation, style);\n    });\n  }\n\n  /**\n   * Set pre-converted strokes directly\n   *\n   * Bypasses conversion, useful when strokes come from external source.\n   *\n   * @param {Array} strokes - Array of stroke command objects\n   */\n  setStrokes(strokes) {\n    if (!Array.isArray(strokes)) {\n      console.warn(\"StrokeRenderer.setStrokes: strokes must be an array\");\n      this.strokes = [];\n      return;\n    }\n    this.strokes = strokes;\n  }\n\n  /**\n   * Render strokes at the given time\n   *\n   * Clears canvas and draws all visible strokes with appropriate progress.\n   *\n   * @param {number} time - Current time in seconds\n   */\n  render(time) {\n    const { ctx, viewport, strokes } = this;\n\n    // Clear canvas\n    ctx.clearRect(0, 0, viewport.width, viewport.height);\n\n    // Draw each stroke\n    for (const stroke of strokes) {\n      // Skip if not started yet\n      if (time < stroke.start) {\n        continue;\n      }\n\n      // Calculate progress\n      const duration = stroke.end - stroke.start;\n      const elapsed = time - stroke.start;\n      const progress = duration > 0 ? Math.min(1, elapsed / duration) : 1;\n\n      this._drawStroke(stroke, progress);\n    }\n  }\n\n  /**\n   * Clear the canvas\n   */\n  clear() {\n    this.ctx.clearRect(0, 0, this.viewport.width, this.viewport.height);\n  }\n\n  /**\n   * Destroy the renderer and release resources\n   */\n  destroy() {\n    this.strokes = [];\n    this.ctx = null;\n    this.canvas = null;\n    this.config = null;\n    this.converters = null;\n  }\n\n  /**\n   * Resolve style for an annotation\n   *\n   * Returns the config for the annotation type.\n   * Style is managed via setConfig(), not per-annotation.\n   *\n   * @private\n   * @param {Object} annotation - Annotation object\n   * @returns {Object} Resolved style object\n   */\n  _resolveStyle(annotation) {\n    const { type } = annotation;\n    return this.config[type] || {};\n  }\n\n  /**\n   * Linearly interpolate between two points\n   *\n   * @private\n   * @param {Array} p1 - Start point [x, y]\n   * @param {Array} p2 - End point [x, y]\n   * @param {number} t - Interpolation factor (0-1)\n   * @returns {Array} Interpolated point [x, y]\n   */\n  _interpolatePoint(p1, p2, t) {\n    return [p1[0] + (p2[0] - p1[0]) * t, p1[1] + (p2[1] - p1[1]) * t];\n  }\n\n  /**\n   * Get pressure values for visible points including interpolated final\n   *\n   * @private\n   * @param {Array} pressures - Full pressure array\n   * @param {number} lastCompleteIndex - Index of last complete point\n   * @param {number} segmentProgress - Progress within current segment (0-1)\n   * @returns {Array} Pressure values for visible points\n   */\n  _interpolatePressures(pressures, lastCompleteIndex, segmentProgress) {\n    const visiblePressures = pressures.slice(0, lastCompleteIndex + 1);\n\n    if (lastCompleteIndex < pressures.length - 1 && segmentProgress > 0) {\n      const p1 = pressures[lastCompleteIndex];\n      const p2 = pressures[lastCompleteIndex + 1];\n      visiblePressures.push(p1 + (p2 - p1) * segmentProgress);\n    }\n\n    return visiblePressures;\n  }\n\n  /**\n   * Draw a single stroke with progress\n   *\n   * Uses endpoint interpolation for smooth progressive rendering.\n   *\n   * @private\n   * @param {Object} stroke - Stroke command object\n   * @param {number} progress - Progress from 0 to 1\n   */\n  _drawStroke(stroke, progress) {\n    const { ctx } = this;\n    const {\n      points,\n      color,\n      width,\n      lineCap,\n      pressures,\n      uniformScale,\n      baseX,\n      baseY,\n    } = stroke;\n\n    if (!points || points.length < 2) return;\n\n    // Configure stroke style\n    ctx.strokeStyle = color || \"rgba(0, 0, 0, 0.5)\";\n    ctx.lineCap = lineCap || \"round\";\n    ctx.lineJoin = \"round\";\n\n    // Fast path: full stroke, no interpolation needed\n    if (progress >= 1) {\n      if (pressures && pressures.length >= points.length) {\n        this._drawVariableWidthStroke(\n          points,\n          width,\n          pressures,\n          uniformScale,\n          baseX,\n          baseY\n        );\n      } else {\n        this._drawConstantWidthStroke(\n          points,\n          width,\n          uniformScale,\n          baseX,\n          baseY\n        );\n      }\n      return;\n    }\n\n    // Calculate segment position for interpolation\n    const totalSegments = points.length - 1;\n    const progressAlongPath = progress * totalSegments;\n    const lastCompleteIndex = Math.floor(progressAlongPath);\n    const segmentProgress = progressAlongPath - lastCompleteIndex;\n\n    // Build visible points array with complete points\n    const visiblePoints = points.slice(0, lastCompleteIndex + 1);\n\n    // Interpolate final point if mid-segment\n    if (lastCompleteIndex < totalSegments && segmentProgress > 0) {\n      const p1 = points[lastCompleteIndex];\n      const p2 = points[lastCompleteIndex + 1];\n      visiblePoints.push(this._interpolatePoint(p1, p2, segmentProgress));\n    }\n\n    // Need at least 2 points to draw a line\n    if (visiblePoints.length < 2) return;\n\n    // Draw with variable width if pressures provided\n    if (pressures && pressures.length >= points.length) {\n      const visiblePressures = this._interpolatePressures(\n        pressures,\n        lastCompleteIndex,\n        segmentProgress\n      );\n      this._drawVariableWidthStroke(\n        visiblePoints,\n        width,\n        visiblePressures,\n        uniformScale,\n        baseX,\n        baseY\n      );\n    } else {\n      this._drawConstantWidthStroke(\n        visiblePoints,\n        width,\n        uniformScale,\n        baseX,\n        baseY\n      );\n    }\n  }\n\n  /**\n   * Draw stroke with constant width\n   *\n   * @private\n   * @param {Array} points - Array of [x, y] coordinates (normalized or offset)\n   * @param {number} width - Stroke width in pixels\n   * @param {boolean} [uniformScale=false] - Use uniform scaling to preserve aspect ratio\n   * @param {number} [baseX] - Base X position in width-normalized coords (for uniformScale with offset points)\n   * @param {number} [baseY] - Base Y position in height-normalized coords (for uniformScale with offset points)\n   */\n  _drawConstantWidthStroke(\n    points,\n    width,\n    uniformScale = false,\n    baseX = null,\n    baseY = null\n  ) {\n    const { ctx, viewport } = this;\n\n    // Scale width based on viewport height for consistent appearance\n    const scale = viewport.height / REFERENCE_HEIGHT;\n    ctx.lineWidth = (width || 2) * scale;\n    ctx.beginPath();\n\n    // When uniformScale is true and baseX/baseY provided, points are offsets from base position\n    // Base position is in mixed coords (X: width-normalized, Y: height-normalized)\n    // Offsets are in uniform space (both scaled by viewport.height)\n    const hasBasePosition = uniformScale && baseX !== null && baseY !== null;\n\n    for (let i = 0; i < points.length; i++) {\n      const [coordX, coordY] = points[i];\n      let px, py;\n\n      if (hasBasePosition) {\n        // Base position in pixels + uniform-scaled offset\n        px = baseX * viewport.width + coordX * viewport.height;\n        py = baseY * viewport.height + coordY * viewport.height;\n      } else if (uniformScale) {\n        // Legacy: full coordinates in uniform space\n        px = coordX * viewport.height;\n        py = coordY * viewport.height;\n      } else {\n        // Standard: X scaled by width, Y by height\n        px = coordX * viewport.width;\n        py = coordY * viewport.height;\n      }\n\n      if (i === 0) {\n        ctx.moveTo(px, py);\n      } else {\n        ctx.lineTo(px, py);\n      }\n    }\n\n    ctx.stroke();\n  }\n\n  /**\n   * Draw stroke with variable width based on pressure\n   *\n   * @private\n   * @param {Array} points - Array of [x, y] coordinates (normalized or offset)\n   * @param {number} baseWidth - Base stroke width in pixels\n   * @param {Array} pressures - Pressure values (0-1) per point\n   * @param {boolean} [uniformScale=false] - Use uniform scaling to preserve aspect ratio\n   * @param {number} [baseX] - Base X position in width-normalized coords (for uniformScale with offset points)\n   * @param {number} [baseY] - Base Y position in height-normalized coords (for uniformScale with offset points)\n   */\n  _drawVariableWidthStroke(\n    points,\n    baseWidth,\n    pressures,\n    uniformScale = false,\n    baseX = null,\n    baseY = null\n  ) {\n    const { ctx, viewport } = this;\n\n    // When uniformScale is true and baseX/baseY provided, points are offsets from base position\n    const hasBasePosition = uniformScale && baseX !== null && baseY !== null;\n\n    for (let i = 1; i < points.length; i++) {\n      const [c1x, c1y] = points[i - 1];\n      const [c2x, c2y] = points[i];\n\n      let px1, py1, px2, py2;\n\n      if (hasBasePosition) {\n        // Base position in pixels + uniform-scaled offset\n        px1 = baseX * viewport.width + c1x * viewport.height;\n        py1 = baseY * viewport.height + c1y * viewport.height;\n        px2 = baseX * viewport.width + c2x * viewport.height;\n        py2 = baseY * viewport.height + c2y * viewport.height;\n      } else if (uniformScale) {\n        // Legacy: full coordinates in uniform space\n        px1 = c1x * viewport.height;\n        py1 = c1y * viewport.height;\n        px2 = c2x * viewport.height;\n        py2 = c2y * viewport.height;\n      } else {\n        // Standard: X scaled by width, Y by height\n        px1 = c1x * viewport.width;\n        py1 = c1y * viewport.height;\n        px2 = c2x * viewport.width;\n        py2 = c2y * viewport.height;\n      }\n\n      // Average pressure between two points\n      const p1 = pressures[i - 1] || 1;\n      const p2 = pressures[i] || 1;\n      const avgPressure = (p1 + p2) / 2;\n\n      // Apply pressure to width (min 0.5) and scale for viewport\n      const scale = viewport.height / REFERENCE_HEIGHT;\n      const width = Math.max(0.5, baseWidth * avgPressure) * scale;\n\n      ctx.lineWidth = width;\n      ctx.beginPath();\n      ctx.moveTo(px1, py1);\n      ctx.lineTo(px2, py2);\n      ctx.stroke();\n    }\n  }\n}\n\nexport { StrokeRenderer };\nexport default StrokeRenderer;\n"],"names":["ANNOTATION_TYPES","REFERENCE_HEIGHT","DEFAULT_CONFIG","StrokeRenderer","canvas","config","type","highlightToStrokes","textToStrokes","underlineToStrokes","arrowToStrokes","circleToStrokes","inkToStrokes","globalOptions","typeOptions","key","value","converter","width","height","dpr","annotations","page","filtered","a","annotation","style","strokes","time","ctx","viewport","stroke","duration","elapsed","progress","p1","p2","t","pressures","lastCompleteIndex","segmentProgress","visiblePressures","points","color","lineCap","uniformScale","baseX","baseY","totalSegments","progressAlongPath","visiblePoints","scale","hasBasePosition","i","coordX","coordY","px","py","baseWidth","c1x","c1y","c2x","c2y","px1","py1","px2","py2","avgPressure"],"mappings":"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"}

package/dist/index6.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function h(e){if(e==null)return Math.random;let r=typeof e=="string"?e.split("").reduce((t,n)=>t+n.charCodeAt(0),0):e;return function(){r|=0,r=r+1831565813|0;let t=Math.imul(r^r>>>15,1|r);return t=t+Math.imul(t^t>>>7,61|t)^t,((t^t>>>14)>>>0)/4294967296}}function b(e,r,t=null){const{amplitude:n=0}=r||{};if(n===0||!e||e.length===0)return e;const l=h(t);return e.map(([u,a])=>[u+(l()-.5)*n,a+(l()-.5)*n])}function M(e,r){const{taperIn:t=0,taperOut:n=0}=r||{};if(!e||e.length===0)return[];if(t===0&&n===0)return e.map(()=>1);const l=e.length;return e.map((u,a)=>{const f=l>1?a/(l-1):0;return t>0&&f<t?f/t:n>0&&f>1-n?(1-f)/n:1})}function A(e,r){const{amplitude:t=0,frequency:n=.05}=r||{};return t===0||!e||e.length<2?e:e.map(([l,u],a)=>{const f=a/(e.length-1),y=Math.sin(f*Math.PI*2*n*e.length)*t;let d=0,p=1;if(a<e.length-1){const[m,g]=e[a+1],c=m-l,o=g-u,i=Math.sqrt(c*c+o*o);i>1e-4&&(d=-o/i,p=c/i)}return[l+d*y,u+p*y]})}function s(e,r){if(!r)return{...e};if(!e)return{...r};const t={...e};for(const n of Object.keys(r)){const l=r[n],u=e[n];l!==null&&typeof l=="object"&&!Array.isArray(l)&&u!==null&&typeof u=="object"&&!Array.isArray(u)?t[n]=s(u,l):l!==void 0&&(t[n]=l)}return t}exports.applyJitter=b;exports.applyPressure=M;exports.applyWobble=A;exports.deepMerge=s;exports.seededRandom=h;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=(t,h)=>({left:t.x*h.width,top:t.y*h.height,width:(t.w??0)*h.width,height:(t.h??0)*h.height}),i=(t,h)=>({left:t.x*h.width,top:t.y*h.height,width:(t.w??0)*h.width,height:(t.h??0)*h.height});function o(t,h){return{x:t.x*h.width,y:t.y*h.height}}exports.NormSizeToPixel=i;exports.pointNormToAbs=o;exports.rectNormToAbs=e;
 //# sourceMappingURL=index6.cjs.map

package/dist/index6.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index6.cjs","sources":["../src/pen/effects.js"],"sourcesContent":["/**\n * Pen Effects - Utility functions for hand-drawn feel\n *\n * Provides jitter, pressure, and wobble effects for stroke paths.\n * Pure functions that transform point arrays without side effects.\n *\n * @module pen/effects\n */\n\n/**\n * Creates a seeded random number generator\n *\n * Uses mulberry32 algorithm for deterministic randomness.\n * Same seed produces same sequence of random numbers.\n *\n * @param {string|number|null} seed - Seed value (null uses Math.random)\n * @returns {Function} Function that returns random numbers 0-1\n */\nexport function seededRandom(seed) {\n  if (seed === null || seed === undefined) {\n    return Math.random;\n  }\n\n  // Convert string seed to number\n  let numSeed = typeof seed === 'string'\n    ? seed.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0)\n    : seed;\n\n  // Mulberry32 algorithm\n  return function() {\n    numSeed |= 0;\n    numSeed = (numSeed + 0x6D2B79F5) | 0;\n    let t = Math.imul(numSeed ^ (numSeed >>> 15), 1 | numSeed);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n/**\n * Applies random jitter offset to points\n *\n * Adds small random displacement to each point for hand-drawn imperfection.\n * Returns new array, does not mutate input.\n *\n * @param {Array<[number, number]>} points - Array of [x, y] coordinates\n * @param {Object} config - Jitter configuration\n * @param {number} config.amplitude - Max offset in normalized units (0 = disabled)\n * @param {number} [config.frequency=1] - Not currently used, reserved for future\n * @param {string|number|null} [seed=null] - Seed for reproducible randomness\n * @returns {Array<[number, number]>} New array with jittered points\n */\nexport function applyJitter(points, config, seed = null) {\n  const { amplitude = 0 } = config || {};\n\n  if (amplitude === 0 || !points || points.length === 0) {\n    return points;\n  }\n\n  const rng = seededRandom(seed);\n\n  return points.map(([x, y]) => [\n    x + (rng() - 0.5) * amplitude,\n    y + (rng() - 0.5) * amplitude\n  ]);\n}\n\n/**\n * Calculates pressure values for variable stroke width\n *\n * Simulates pen pressure with taper at start and end of stroke.\n * Returns pressure multipliers (0-1) for each point.\n *\n * @param {Array<[number, number]>} points - Array of [x, y] coordinates\n * @param {Object} config - Pressure configuration\n * @param {number} [config.taperIn=0] - Start taper length (0-1, fraction of stroke)\n * @param {number} [config.taperOut=0] - End taper length (0-1, fraction of stroke)\n * @returns {Array<number>} Pressure values (0-1) per point\n */\nexport function applyPressure(points, config) {\n  const { taperIn = 0, taperOut = 0 } = config || {};\n\n  if (!points || points.length === 0) {\n    return [];\n  }\n\n  if (taperIn === 0 && taperOut === 0) {\n    return points.map(() => 1.0);\n  }\n\n  const len = points.length;\n\n  return points.map((_, i) => {\n    const t = len > 1 ? i / (len - 1) : 0;\n\n    // Taper in at start\n    if (taperIn > 0 && t < taperIn) {\n      return t / taperIn;\n    }\n\n    // Taper out at end\n    if (taperOut > 0 && t > 1 - taperOut) {\n      return (1 - t) / taperOut;\n    }\n\n    // Full pressure in middle\n    return 1.0;\n  });\n}\n\n/**\n * Applies low-frequency wobble perpendicular to stroke direction\n *\n * Adds gentle wave effect to simulate natural hand movement.\n * Returns new array, does not mutate input.\n *\n * @param {Array<[number, number]>} points - Array of [x, y] coordinates\n * @param {Object} config - Wobble configuration\n * @param {number} config.amplitude - Wave height in normalized units (0 = disabled)\n * @param {number} [config.frequency=0.05] - Wave frequency\n * @returns {Array<[number, number]>} New array with wobbled points\n */\nexport function applyWobble(points, config) {\n  const { amplitude = 0, frequency = 0.05 } = config || {};\n\n  if (amplitude === 0 || !points || points.length < 2) {\n    return points;\n  }\n\n  return points.map(([x, y], i) => {\n    // Calculate perpendicular direction based on position in stroke\n    // Use simple sine wave for now\n    const t = i / (points.length - 1);\n    const offset = Math.sin(t * Math.PI * 2 * frequency * points.length) * amplitude;\n\n    // Calculate perpendicular direction from neighbors\n    let perpX = 0;\n    let perpY = 1;\n\n    if (i < points.length - 1) {\n      const [nx, ny] = points[i + 1];\n      const dx = nx - x;\n      const dy = ny - y;\n      const len = Math.sqrt(dx * dx + dy * dy);\n\n      if (len > 0.0001) {\n        // Perpendicular is (-dy, dx) normalized\n        perpX = -dy / len;\n        perpY = dx / len;\n      }\n    }\n\n    return [\n      x + perpX * offset,\n      y + perpY * offset\n    ];\n  });\n}\n\n/**\n * Deep merges configuration objects\n *\n * Merges source into target, handling nested objects.\n * Returns new object, does not mutate inputs.\n *\n * @param {Object} target - Target object\n * @param {Object} source - Source object to merge\n * @returns {Object} Merged object\n */\nexport function deepMerge(target, source) {\n  if (!source) return { ...target };\n  if (!target) return { ...source };\n\n  const result = { ...target };\n\n  for (const key of Object.keys(source)) {\n    const sourceVal = source[key];\n    const targetVal = target[key];\n\n    if (\n      sourceVal !== null &&\n      typeof sourceVal === 'object' &&\n      !Array.isArray(sourceVal) &&\n      targetVal !== null &&\n      typeof targetVal === 'object' &&\n      !Array.isArray(targetVal)\n    ) {\n      result[key] = deepMerge(targetVal, sourceVal);\n    } else if (sourceVal !== undefined) {\n      result[key] = sourceVal;\n    }\n  }\n\n  return result;\n}\n"],"names":["seededRandom","seed","numSeed","acc","char","applyJitter","points","config","amplitude","rng","x","y","applyPressure","taperIn","taperOut","len","_","i","t","applyWobble","frequency","offset","perpX","perpY","nx","ny","dx","dy","deepMerge","target","source","result","key","sourceVal","targetVal"],"mappings":"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"}
+{"version":3,"file":"index6.cjs","sources":["../src/utils/coordinateUtils.js"],"sourcesContent":["/**\n * Coordinate Utility Functions\n *\n * This module provides utility functions for coordinate transformations\n * between normalized (0-1) coordinates and absolute pixel coordinates.\n * Used by annotation layers to position elements on the PDF canvas.\n */\n\n/**\n * Convert normalized rectangle to absolute pixel coordinates\n *\n * Transforms a rectangle with normalized coordinates (0-1 range) to\n * absolute pixel coordinates based on viewport dimensions.\n *\n * @param {{x: number, y: number, w: number, h: number}} rect - Normalized rectangle (0-1)\n * @param {{width: number, height: number}} viewport - Viewport dimensions in pixels\n * @returns {{left: number, top: number, width: number, height: number}} Absolute coordinates in pixels\n *\n * @example\n * const rect = { x: 0.1, y: 0.2, w: 0.5, h: 0.3 };\n * const viewport = { width: 1000, height: 1400 };\n * const absolute = rectNormToAbs(rect, viewport);\n * // Returns: { left: 100, top: 280, width: 500, height: 420 }\n */\nexport const rectNormToAbs = (r, vp) => ({\n  left: r.x * vp.width,\n  top: r.y * vp.height,\n  width: (r.w ?? 0) * vp.width,\n  height: (r.h ?? 0) * vp.height,\n});\n\n/**\n * Convert normalized size to pixel dimensions (Legacy)\n *\n * @deprecated Use rectNormToAbs instead. This function is kept for backward compatibility.\n *\n * Transforms normalized rectangle coordinates to absolute pixel coordinates.\n * This is an alias for rectNormToAbs maintained for backward compatibility.\n *\n * @param {{x: number, y: number, w: number, h: number}} r - Normalized rectangle (0-1)\n * @param {{width: number, height: number}} vp - Viewport dimensions in pixels\n * @returns {{left: number, top: number, width: number, height: number}} Absolute coordinates in pixels\n */\nexport const NormSizeToPixel = (r, vp) => ({\n  left: r.x * vp.width,\n  top: r.y * vp.height,\n  width: (r.w ?? 0) * vp.width,\n  height: (r.h ?? 0) * vp.height,\n});\n\n/**\n * Convert normalized point to absolute pixel coordinates\n *\n * Transforms a point with normalized coordinates (0-1 range) to\n * absolute pixel coordinates based on viewport dimensions.\n *\n * @param {{x: number, y: number}} point - Normalized point (0-1)\n * @param {{width: number, height: number}} viewport - Viewport dimensions in pixels\n * @returns {{x: number, y: number}} Absolute coordinates in pixels\n *\n * @example\n * const point = { x: 0.5, y: 0.5 };\n * const viewport = { width: 1000, height: 1400 };\n * const absolute = pointNormToAbs(point, viewport);\n * // Returns: { x: 500, y: 700 }\n */\nexport function pointNormToAbs(point, viewport) {\n  return {\n    x: point.x * viewport.width,\n    y: point.y * viewport.height\n  };\n}\n"],"names":["rectNormToAbs","r","vp","NormSizeToPixel","pointNormToAbs","point","viewport"],"mappings":"gFAwBY,MAACA,EAAgB,CAACC,EAAGC,KAAQ,CACvC,KAAMD,EAAE,EAAIC,EAAG,MACf,IAAKD,EAAE,EAAIC,EAAG,OACd,OAAQD,EAAE,GAAK,GAAKC,EAAG,MACvB,QAASD,EAAE,GAAK,GAAKC,EAAG,MAC1B,GAcaC,EAAkB,CAACF,EAAGC,KAAQ,CACzC,KAAMD,EAAE,EAAIC,EAAG,MACf,IAAKD,EAAE,EAAIC,EAAG,OACd,OAAQD,EAAE,GAAK,GAAKC,EAAG,MACvB,QAASD,EAAE,GAAK,GAAKC,EAAG,MAC1B,GAkBO,SAASE,EAAeC,EAAOC,EAAU,CAC9C,MAAO,CACL,EAAGD,EAAM,EAAIC,EAAS,MACtB,EAAGD,EAAM,EAAIC,EAAS,MAC1B,CACA"}