web-annotation-renderer 0.3.0 → 0.4.0

package/dist/index13.js

@@ -1,203 +1,34 @@
-import { HIGHLIGHT_DEFAULTS as f, TEXT_DEFAULTS as a, INK_DEFAULTS as d, BASE_DEFAULTS as p } from "./index21.js";
-function r(t, n, o, s, e) {
-  let i = t;
-  return typeof t == "string" && (i = parseFloat(t)), typeof i != "number" || isNaN(i) ? (e.push(
-    `[${o}]: Field "${s}" invalid value "${t}", using default ${n}`
-  ), n) : i < 0 ? (e.push(
-    `[${o}]: Field "${s}" value ${i} below range [0,1], clamping to 0`
-  ), 0) : i > 1 ? (e.push(
-    `[${o}]: Field "${s}" value ${i} exceeds range [0,1], clamping to 1`
-  ), 1) : i;
-}
-function c(t, n, o, s) {
-  if (typeof t != "string" || t.trim().length === 0)
-    return s.push(
-      `[${o}]: Invalid color format "${t}", using default ${n}`
-    ), n;
-  const e = t.trim(), i = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/, l = /^rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(,\s*[\d.]+\s*)?\)$/, u = [
-    "red",
-    "blue",
-    "green",
-    "yellow",
-    "black",
-    "white",
-    "gray",
-    "grey",
-    "orange",
-    "purple",
-    "pink",
-    "brown",
-    "transparent"
-  ], m = i.test(e), y = l.test(e), g = u.includes(e.toLowerCase());
-  return m || y || g ? e : (s.push(
-    `[${o}]: Invalid color format "${t}", using default ${n}`
-  ), n);
-}
-function h(t, n, o, s, e) {
-  let i = t;
-  return typeof t == "string" && (i = parseFloat(t)), typeof i != "number" || isNaN(i) || i <= 0 ? (e.push(
-    `[${o}]: Field "${s}" invalid value "${t}", using default ${n}`
-  ), n) : i;
-}
-function $(t, n, o) {
-  const s = {};
-  if (typeof t.id != "string" || t.id.trim().length === 0) {
-    const e = Date.now(), i = Math.random().toString(36).substr(2, 9);
-    s.id = `anno-${e}-${i}`, o.push(`[${s.id}]: Auto-generated ID (original was missing or invalid)`);
-  } else
-    s.id = t.id.trim();
-  return s.type = t.type, typeof t.page != "number" || t.page < 1 ? (n.push(
-    `[${s.id}]: Field "page" invalid value "${t.page}", using default ${p.page}`
-  ), s.page = p.page) : s.page = Math.floor(t.page), typeof t.start != "number" || t.start < 0 ? (n.push(
-    `[${s.id}]: Field "start" invalid value "${t.start}", using default ${p.start}`
-  ), s.start = p.start) : s.start = t.start, typeof t.end != "number" || t.end < 0 ? (n.push(
-    `[${s.id}]: Field "end" invalid value "${t.end}", using start value ${s.start}`
-  ), s.end = s.start) : t.end < s.start ? (n.push(
-    `[${s.id}]: Field "end" (${t.end}) less than start (${s.start}), clamping to start`
-  ), s.end = s.start) : s.end = t.end, s;
-}
-function z(t, n, o) {
-  return !t || typeof t != "object" ? (o.push(`[${n}]: Invalid quad object, using default`), { x: 0.1, y: 0.1, w: 0.8, h: 0.05 }) : {
-    x: r(t.x, 0.1, n, "quad.x", o),
-    y: r(t.y, 0.1, n, "quad.y", o),
-    w: r(t.w, 0.8, n, "quad.w", o),
-    h: r(t.h, 0.05, n, "quad.h", o)
-  };
-}
-function A(t, n, o, s) {
-  const e = { ...t };
-  n.mode !== "quads" ? (o.push(
-    `[${t.id}]: Field "mode" invalid value "${n.mode}", using default "${f.mode}"`
-  ), e.mode = f.mode) : e.mode = n.mode, !Array.isArray(n.quads) || n.quads.length === 0 ? (o.push(
-    `[${t.id}]: Field "quads" missing or empty, using default`
-  ), e.quads = f.quads) : e.quads = n.quads.map((l, u) => z(l, t.id, o));
-  const i = f.style.color;
-  return !n.style || typeof n.style != "object" ? (o.push(
-    `[${t.id}]: Field "style" missing or invalid, using default`
-  ), e.style = { color: i }) : e.style = {
-    color: c(n.style.color, i, t.id, o)
-  }, e;
-}
-function F(t, n, o, s) {
-  const e = { ...t };
-  typeof n.content != "string" || n.content.trim().length === 0 ? (o.push(
-    `[${t.id}]: Field "content" missing or empty, using default "${a.content}"`
-  ), e.content = a.content) : e.content = n.content, e.x = r(n.x, a.x, t.id, "x", o), e.y = r(n.y, a.y, t.id, "y", o), e.w = r(n.w, a.w, t.id, "w", o), e.h = r(n.h, a.h, t.id, "h", o);
-  const i = a.style.bg, l = a.style.color;
-  return !n.style || typeof n.style != "object" ? (o.push(
-    `[${t.id}]: Field "style" missing or invalid, using defaults`
-  ), e.style = {
-    bg: i,
-    color: l
-  }) : e.style = {
-    bg: c(n.style.bg, i, t.id, o),
-    color: c(n.style.color, l, t.id, o)
-  }, e;
-}
-function k(t, n, o) {
-  return !t || typeof t != "object" ? (o.push(`[${n}]: Invalid point object, using default`), { t: 0, x: 0.1, y: 0.1 }) : {
-    t: r(t.t, 0, n, "point.t", o),
-    x: r(t.x, 0.1, n, "point.x", o),
-    y: r(t.y, 0.1, n, "point.y", o)
-  };
-}
-function x(t, n, o) {
-  if (!t || typeof t != "object")
-    return o.push(`[${n}]: Invalid stroke object, using default`), d.strokes[0];
-  const s = {
-    color: c(t.color, d.strokes[0].color, n, o),
-    size: h(t.size, d.strokes[0].size, n, "stroke.size", o)
-  };
-  return !Array.isArray(t.points) || t.points.length === 0 ? (o.push(`[${n}]: Stroke missing points array, using default`), s.points = d.strokes[0].points) : s.points = t.points.map((e) => k(e, n, o)), s;
-}
-function v(t, n, o, s) {
-  const e = { ...t };
-  return !Array.isArray(n.strokes) || n.strokes.length === 0 ? (o.push(
-    `[${t.id}]: Field "strokes" missing or empty, using default`
-  ), e.strokes = d.strokes) : e.strokes = n.strokes.map((i) => x(i, t.id, o)), e;
-}
-function b(t, n) {
-  const o = [], s = [];
-  if (!t || typeof t != "object")
-    return {
-      annotation: null,
-      warnings: [],
-      info: [],
-      critical: `Annotation at index ${n}: Not a valid object`
-    };
-  if (typeof t.type != "string" || t.type.trim().length === 0)
-    return {
-      annotation: null,
-      warnings: [],
-      info: [],
-      critical: `Annotation at index ${n}: Missing or invalid type field`
-    };
-  const e = t.type.trim(), i = $(t, o, s);
-  let l;
-  if (e === "highlight")
-    l = A(i, t, o);
-  else if (e === "text")
-    l = F(i, t, o);
-  else if (e === "ink")
-    l = v(i, t, o);
-  else
-    return {
-      annotation: null,
-      warnings: [],
-      info: [],
-      critical: `Annotation at index ${n}: Unsupported type "${e}"`
-    };
-  return {
-    annotation: l,
-    warnings: o,
-    info: s,
-    critical: null
-  };
-}
-function E(t, n = {}) {
-  n.skipInvalid;
-  const o = n.warnInConsole !== !1, s = n.onWarning || null, e = {
-    normalized: [],
-    warnings: [],
-    info: [],
-    skipped: []
-  };
-  if (!Array.isArray(t)) {
-    const i = "normalizeAnnotationArray: Input is not an array, returning empty result";
-    return e.warnings.push(i), o && console.warn(`[Annotation Normalizer] ${i}`), e;
+import { applyJitter as b, applyPressure as j } from "./index6.js";
+function x(l, t) {
+  const { id: o, start: s, end: h, quads: n } = l;
+  if (!n || n.length === 0)
+    return [];
+  const u = [], f = h - s, g = n.length, a = f / g;
+  for (let r = 0; r < n.length; r++) {
+    const q = n[r], { x: i, y: C, w: $, h: m } = q, p = C + m / 2;
+    let e = [
+      [i, p],
+      [i + $, p]
+    ];
+    t.jitter?.amplitude > 0 && (e = b(e, t.jitter, `${o}-${r}`));
+    let d = null;
+    (t.pressure?.taperIn > 0 || t.pressure?.taperOut > 0) && (d = j(e, t.pressure));
+    const c = s + r * a, w = c + a;
+    u.push({
+      id: `${o}-${r}`,
+      points: e,
+      start: c,
+      end: w,
+      color: t.color || "rgba(255, 255, 0, 0.3)",
+      width: t.width || 24,
+      lineCap: t.lineCap || "butt",
+      pressures: d
+    });
   }
-  return t.forEach((i, l) => {
-    if (i == null) {
-      e.skipped.push({
-        index: l,
-        annotation: i,
-        reason: "Annotation is null or undefined"
-      });
-      return;
-    }
-    const u = b(i, l);
-    if (u.critical) {
-      e.skipped.push({
-        index: l,
-        annotation: i,
-        reason: u.critical
-      }), o && console.error(`[Annotation Normalizer] ${u.critical}`);
-      return;
-    }
-    e.normalized.push(u.annotation), e.warnings.push(...u.warnings), e.info.push(...u.info);
-  }), o && (e.warnings.length > 0 || e.info.length > 0 || e.skipped.length > 0) && (console.group("[Annotation Normalizer] Validation Summary"), e.normalized.length > 0 && console.info(`✓ Normalized ${e.normalized.length} annotation(s)`), e.skipped.length > 0 && (console.error(`✗ Skipped ${e.skipped.length} annotation(s)`), e.skipped.forEach((i) => {
-    console.error(`  Index ${i.index}: ${i.reason}`);
-  })), e.warnings.length > 0 && (console.warn(`⚠ ${e.warnings.length} warning(s):`), e.warnings.forEach((i) => console.warn(`  ${i}`))), e.info.length > 0 && (console.info(`ℹ ${e.info.length} info message(s):`), e.info.forEach((i) => console.info(`  ${i}`))), console.groupEnd()), s && typeof s == "function" && s(e), e;
+  return u;
 }
 export {
-  b as normalizeAnnotation,
-  E as normalizeAnnotationArray,
-  $ as normalizeBaseFields,
-  c as normalizeColor,
-  r as normalizeCoordinate,
-  A as normalizeHighlight,
-  v as normalizeInk,
-  h as normalizePositiveNumber,
-  F as normalizeText
+  x as default,
+  x as highlightToStrokes
 };
 //# sourceMappingURL=index13.js.map

package/dist/index13.js.map

@@ -1 +1 @@
-{"version":3,"file":"index13.js","sources":["../src/types/validators.js"],"sourcesContent":["/**\n * Annotation Data Normalization Utilities\n *\n * This module provides defensive normalization functions that validate and fix\n * annotation data. Invalid values are replaced with safe defaults and warnings\n * are collected for user feedback.\n *\n * @module types/validators\n */\n\nimport {\n  BASE_DEFAULTS,\n  HIGHLIGHT_DEFAULTS,\n  TEXT_DEFAULTS,\n  INK_DEFAULTS\n} from './defaults.js';\n\n// ============================================================================\n// FIELD-LEVEL NORMALIZERS\n// ============================================================================\n\n/**\n * Normalize coordinate value to 0-1 range\n *\n * Validates that a value is a number in the 0-1 range. Out-of-range values\n * are clamped. Invalid values use the provided default.\n *\n * @param {*} value - Value to normalize\n * @param {number} defaultValue - Fallback value if invalid\n * @param {string} id - Annotation ID for warning messages\n * @param {string} fieldName - Field name for warning messages\n * @param {Array<string>} warnings - Array to collect warning messages\n * @returns {number} Normalized coordinate value in range [0, 1]\n *\n * @example\n * normalizeCoordinate(0.5, 0.1, 'txt-1', 'x', warnings)  // Returns: 0.5\n * normalizeCoordinate(5, 0.1, 'txt-1', 'x', warnings)    // Returns: 1, adds warning\n * normalizeCoordinate('abc', 0.1, 'txt-1', 'x', warnings) // Returns: 0.1, adds warning\n */\nexport function normalizeCoordinate(value, defaultValue, id, fieldName, warnings) {\n  // Type coercion: parse string to number if needed\n  let numValue = value;\n  if (typeof value === 'string') {\n    numValue = parseFloat(value);\n    if (!isNaN(numValue) && numValue === value) {\n      // Successfully parsed - no warning needed\n    }\n  }\n\n  // Validate is valid number\n  if (typeof numValue !== 'number' || isNaN(numValue)) {\n    warnings.push(\n      `[${id}]: Field \"${fieldName}\" invalid value \"${value}\", using default ${defaultValue}`\n    );\n    return defaultValue;\n  }\n\n  // Range check: clamp to [0, 1]\n  if (numValue < 0) {\n    warnings.push(\n      `[${id}]: Field \"${fieldName}\" value ${numValue} below range [0,1], clamping to 0`\n    );\n    return 0;\n  }\n\n  if (numValue > 1) {\n    warnings.push(\n      `[${id}]: Field \"${fieldName}\" value ${numValue} exceeds range [0,1], clamping to 1`\n    );\n    return 1;\n  }\n\n  // Valid value\n  return numValue;\n}\n\n/**\n * Normalize color string\n *\n * Validates that a value is a valid color string. Supports hex, rgb/rgba,\n * and named colors. Invalid colors use the provided default.\n *\n * @param {*} value - Color value to normalize\n * @param {string} defaultValue - Fallback color if invalid\n * @param {string} id - Annotation ID for warning messages\n * @param {Array<string>} warnings - Array to collect warning messages\n * @returns {string} Valid color string\n *\n * @example\n * normalizeColor('#fff', '#000', 'txt-1', warnings)           // Returns: '#fff'\n * normalizeColor('rgba(255,0,0,0.5)', '#000', 'txt-1', warnings) // Returns: 'rgba(255,0,0,0.5)'\n * normalizeColor('notacolor', '#000', 'txt-1', warnings)      // Returns: '#000', adds warning\n */\nexport function normalizeColor(value, defaultValue, id, warnings) {\n  // Type check: must be non-empty string\n  if (typeof value !== 'string' || value.trim().length === 0) {\n    warnings.push(\n      `[${id}]: Invalid color format \"${value}\", using default ${defaultValue}`\n    );\n    return defaultValue;\n  }\n\n  const trimmed = value.trim();\n\n  // Regex patterns for color validation (cached at module level)\n  const hexPattern = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/;\n  const rgbPattern = /^rgba?\\(\\s*\\d+\\s*,\\s*\\d+\\s*,\\s*\\d+\\s*(,\\s*[\\d.]+\\s*)?\\)$/;\n\n  // Named colors (basic set)\n  const namedColors = [\n    'red', 'blue', 'green', 'yellow', 'black', 'white', 'gray',\n    'grey', 'orange', 'purple', 'pink', 'brown', 'transparent'\n  ];\n\n  // Validate format\n  const isHex = hexPattern.test(trimmed);\n  const isRgb = rgbPattern.test(trimmed);\n  const isNamed = namedColors.includes(trimmed.toLowerCase());\n\n  if (isHex || isRgb || isNamed) {\n    return trimmed;\n  }\n\n  // Invalid format\n  warnings.push(\n    `[${id}]: Invalid color format \"${value}\", using default ${defaultValue}`\n  );\n  return defaultValue;\n}\n\n/**\n * Normalize positive number\n *\n * Validates that a value is a positive number. Invalid values use the\n * provided default.\n *\n * @param {*} value - Value to normalize\n * @param {number} defaultValue - Fallback value if invalid\n * @param {string} id - Annotation ID for warning messages\n * @param {string} fieldName - Field name for warning messages\n * @param {Array<string>} warnings - Array to collect warning messages\n * @returns {number} Positive number\n *\n * @example\n * normalizePositiveNumber(5, 3, 'ink-1', 'size', warnings)      // Returns: 5\n * normalizePositiveNumber(-1, 3, 'ink-1', 'size', warnings)     // Returns: 3, adds warning\n * normalizePositiveNumber('abc', 3, 'ink-1', 'size', warnings)  // Returns: 3, adds warning\n */\nexport function normalizePositiveNumber(value, defaultValue, id, fieldName, warnings) {\n  // Type coercion: parse string to number if needed\n  let numValue = value;\n  if (typeof value === 'string') {\n    numValue = parseFloat(value);\n  }\n\n  // Validate is valid number and positive\n  if (typeof numValue !== 'number' || isNaN(numValue) || numValue <= 0) {\n    warnings.push(\n      `[${id}]: Field \"${fieldName}\" invalid value \"${value}\", using default ${defaultValue}`\n    );\n    return defaultValue;\n  }\n\n  return numValue;\n}\n\n// ============================================================================\n// BASE FIELDS NORMALIZER\n// ============================================================================\n\n/**\n * Normalize common base annotation fields\n *\n * Validates and normalizes fields common to all annotation types: id, type,\n * page, start, and end. Auto-generates ID if missing. Applies safe defaults\n * for invalid values.\n *\n * @param {Object} raw - Raw annotation object\n * @param {Array<string>} warnings - Array to collect warning messages\n * @param {Array<string>} info - Array to collect info messages\n * @returns {Object} Object with normalized base fields\n *\n * @example\n * normalizeBaseFields({ type: 'text', page: 2 }, warnings, info)\n * // Returns: { id: 'anno-1234...', type: 'text', page: 2, start: 0, end: 0 }\n */\nexport function normalizeBaseFields(raw, warnings, info) {\n  const base = {};\n\n  // ===== ID Field =====\n  // Check: non-empty string\n  // Invalid: auto-generate unique ID\n  if (typeof raw.id !== 'string' || raw.id.trim().length === 0) {\n    const timestamp = Date.now();\n    const random = Math.random().toString(36).substr(2, 9);\n    base.id = `anno-${timestamp}-${random}`;\n    info.push(`[${base.id}]: Auto-generated ID (original was missing or invalid)`);\n  } else {\n    base.id = raw.id.trim();\n  }\n\n  // ===== Type Field =====\n  // Pass through as-is (validated in parent function)\n  base.type = raw.type;\n\n  // ===== Page Field =====\n  // Check: positive integer\n  // Invalid: default to 1\n  if (typeof raw.page !== 'number' || raw.page < 1) {\n    warnings.push(\n      `[${base.id}]: Field \"page\" invalid value \"${raw.page}\", using default ${BASE_DEFAULTS.page}`\n    );\n    base.page = BASE_DEFAULTS.page;\n  } else {\n    // Floor to ensure integer\n    base.page = Math.floor(raw.page);\n  }\n\n  // ===== Start Field =====\n  // Check: non-negative number\n  // Invalid: default to 0\n  if (typeof raw.start !== 'number' || raw.start < 0) {\n    warnings.push(\n      `[${base.id}]: Field \"start\" invalid value \"${raw.start}\", using default ${BASE_DEFAULTS.start}`\n    );\n    base.start = BASE_DEFAULTS.start;\n  } else {\n    base.start = raw.start;\n  }\n\n  // ===== End Field =====\n  // Check: non-negative number >= start\n  // Invalid: clamp to start value\n  if (typeof raw.end !== 'number' || raw.end < 0) {\n    warnings.push(\n      `[${base.id}]: Field \"end\" invalid value \"${raw.end}\", using start value ${base.start}`\n    );\n    base.end = base.start;\n  } else if (raw.end < base.start) {\n    warnings.push(\n      `[${base.id}]: Field \"end\" (${raw.end}) less than start (${base.start}), clamping to start`\n    );\n    base.end = base.start;\n  } else {\n    base.end = raw.end;\n  }\n\n  return base;\n}\n\n// ============================================================================\n// TYPE-SPECIFIC NORMALIZERS\n// ============================================================================\n\n/**\n * Normalize a single quad (rectangular region)\n *\n * @private\n * @param {Object} quad - Quad object with x, y, w, h\n * @param {string} id - Annotation ID\n * @param {Array<string>} warnings - Warnings array\n * @returns {Object} Normalized quad\n */\nfunction normalizeQuad(quad, id, warnings) {\n  if (!quad || typeof quad !== 'object') {\n    warnings.push(`[${id}]: Invalid quad object, using default`);\n    return { x: 0.1, y: 0.1, w: 0.8, h: 0.05 };\n  }\n\n  return {\n    x: normalizeCoordinate(quad.x, 0.1, id, 'quad.x', warnings),\n    y: normalizeCoordinate(quad.y, 0.1, id, 'quad.y', warnings),\n    w: normalizeCoordinate(quad.w, 0.8, id, 'quad.w', warnings),\n    h: normalizeCoordinate(quad.h, 0.05, id, 'quad.h', warnings)\n  };\n}\n\n/**\n * Normalize highlight annotation\n *\n * Validates and normalizes highlight-specific fields: mode, quads array,\n * and style.color. Applies defaults for invalid fields.\n *\n * @param {Object} base - Object with normalized base fields\n * @param {Object} raw - Raw annotation object\n * @param {Array<string>} warnings - Warnings array\n * @param {Array<string>} info - Info array\n * @returns {Object} Fully normalized highlight annotation\n *\n * @example\n * normalizeHighlight(base, raw, warnings, info)\n * // Returns: { ...base, mode: 'quads', quads: [...], style: {...} }\n */\nexport function normalizeHighlight(base, raw, warnings, info) {\n  const annotation = { ...base };\n\n  // ===== Mode Field =====\n  // Check: value equals \"quads\"\n  // Invalid: default to \"quads\"\n  if (raw.mode !== 'quads') {\n    warnings.push(\n      `[${base.id}]: Field \"mode\" invalid value \"${raw.mode}\", using default \"${HIGHLIGHT_DEFAULTS.mode}\"`\n    );\n    annotation.mode = HIGHLIGHT_DEFAULTS.mode;\n  } else {\n    annotation.mode = raw.mode;\n  }\n\n  // ===== Quads Array =====\n  // Check: non-empty array\n  // Invalid: use default quads\n  if (!Array.isArray(raw.quads) || raw.quads.length === 0) {\n    warnings.push(\n      `[${base.id}]: Field \"quads\" missing or empty, using default`\n    );\n    annotation.quads = HIGHLIGHT_DEFAULTS.quads;\n  } else {\n    // Normalize each quad\n    annotation.quads = raw.quads.map((quad, idx) => normalizeQuad(quad, base.id, warnings));\n  }\n\n  // ===== Style Object =====\n  // Check: object with color property\n  const defaultColor = HIGHLIGHT_DEFAULTS.style.color;\n  if (!raw.style || typeof raw.style !== 'object') {\n    warnings.push(\n      `[${base.id}]: Field \"style\" missing or invalid, using default`\n    );\n    annotation.style = { color: defaultColor };\n  } else {\n    annotation.style = {\n      color: normalizeColor(raw.style.color, defaultColor, base.id, warnings)\n    };\n  }\n\n  return annotation;\n}\n\n/**\n * Normalize text annotation\n *\n * Validates and normalizes text-specific fields: content, position (x, y),\n * dimensions (w, h), and style (bg, color). Applies defaults for invalid fields.\n *\n * @param {Object} base - Object with normalized base fields\n * @param {Object} raw - Raw annotation object\n * @param {Array<string>} warnings - Warnings array\n * @param {Array<string>} info - Info array\n * @returns {Object} Fully normalized text annotation\n *\n * @example\n * normalizeText(base, raw, warnings, info)\n * // Returns: { ...base, content: '...', x: 0.1, y: 0.1, w: 0.3, h: 0.1, style: {...} }\n */\nexport function normalizeText(base, raw, warnings, info) {\n  const annotation = { ...base };\n\n  // ===== Content Field =====\n  // Check: non-empty string\n  // Invalid: default to placeholder\n  if (typeof raw.content !== 'string' || raw.content.trim().length === 0) {\n    warnings.push(\n      `[${base.id}]: Field \"content\" missing or empty, using default \"${TEXT_DEFAULTS.content}\"`\n    );\n    annotation.content = TEXT_DEFAULTS.content;\n  } else {\n    annotation.content = raw.content;\n  }\n\n  // ===== Position Fields (x, y) =====\n  annotation.x = normalizeCoordinate(raw.x, TEXT_DEFAULTS.x, base.id, 'x', warnings);\n  annotation.y = normalizeCoordinate(raw.y, TEXT_DEFAULTS.y, base.id, 'y', warnings);\n\n  // ===== Dimension Fields (w, h) =====\n  annotation.w = normalizeCoordinate(raw.w, TEXT_DEFAULTS.w, base.id, 'w', warnings);\n  annotation.h = normalizeCoordinate(raw.h, TEXT_DEFAULTS.h, base.id, 'h', warnings);\n\n  // ===== Style Object =====\n  const defaultBg = TEXT_DEFAULTS.style.bg;\n  const defaultColor = TEXT_DEFAULTS.style.color;\n\n  if (!raw.style || typeof raw.style !== 'object') {\n    warnings.push(\n      `[${base.id}]: Field \"style\" missing or invalid, using defaults`\n    );\n    annotation.style = {\n      bg: defaultBg,\n      color: defaultColor\n    };\n  } else {\n    annotation.style = {\n      bg: normalizeColor(raw.style.bg, defaultBg, base.id, warnings),\n      color: normalizeColor(raw.style.color, defaultColor, base.id, warnings)\n    };\n  }\n\n  return annotation;\n}\n\n/**\n * Normalize a single ink point\n *\n * @private\n * @param {Object} point - Point object with t, x, y\n * @param {string} id - Annotation ID\n * @param {Array<string>} warnings - Warnings array\n * @returns {Object} Normalized point\n */\nfunction normalizePoint(point, id, warnings) {\n  if (!point || typeof point !== 'object') {\n    warnings.push(`[${id}]: Invalid point object, using default`);\n    return { t: 0, x: 0.1, y: 0.1 };\n  }\n\n  return {\n    t: normalizeCoordinate(point.t, 0, id, 'point.t', warnings),\n    x: normalizeCoordinate(point.x, 0.1, id, 'point.x', warnings),\n    y: normalizeCoordinate(point.y, 0.1, id, 'point.y', warnings)\n  };\n}\n\n/**\n * Normalize a single ink stroke\n *\n * @private\n * @param {Object} stroke - Stroke object with color, size, points\n * @param {string} id - Annotation ID\n * @param {Array<string>} warnings - Warnings array\n * @returns {Object} Normalized stroke\n */\nfunction normalizeStroke(stroke, id, warnings) {\n  if (!stroke || typeof stroke !== 'object') {\n    warnings.push(`[${id}]: Invalid stroke object, using default`);\n    return INK_DEFAULTS.strokes[0];\n  }\n\n  const normalized = {\n    color: normalizeColor(stroke.color, INK_DEFAULTS.strokes[0].color, id, warnings),\n    size: normalizePositiveNumber(stroke.size, INK_DEFAULTS.strokes[0].size, id, 'stroke.size', warnings)\n  };\n\n  // ===== Points Array =====\n  if (!Array.isArray(stroke.points) || stroke.points.length === 0) {\n    warnings.push(`[${id}]: Stroke missing points array, using default`);\n    normalized.points = INK_DEFAULTS.strokes[0].points;\n  } else {\n    normalized.points = stroke.points.map(point => normalizePoint(point, id, warnings));\n  }\n\n  return normalized;\n}\n\n/**\n * Normalize ink annotation\n *\n * Validates and normalizes ink-specific fields: strokes array with color,\n * size, and points. Applies defaults for invalid fields.\n *\n * @param {Object} base - Object with normalized base fields\n * @param {Object} raw - Raw annotation object\n * @param {Array<string>} warnings - Warnings array\n * @param {Array<string>} info - Info array\n * @returns {Object} Fully normalized ink annotation\n *\n * @example\n * normalizeInk(base, raw, warnings, info)\n * // Returns: { ...base, strokes: [{ color: '...', size: 3, points: [...] }] }\n */\nexport function normalizeInk(base, raw, warnings, info) {\n  const annotation = { ...base };\n\n  // ===== Strokes Array =====\n  // Check: non-empty array\n  // Invalid: use default single stroke\n  if (!Array.isArray(raw.strokes) || raw.strokes.length === 0) {\n    warnings.push(\n      `[${base.id}]: Field \"strokes\" missing or empty, using default`\n    );\n    annotation.strokes = INK_DEFAULTS.strokes;\n  } else {\n    // Normalize each stroke\n    annotation.strokes = raw.strokes.map(stroke => normalizeStroke(stroke, base.id, warnings));\n  }\n\n  return annotation;\n}\n\n// ============================================================================\n// ORCHESTRATION - SINGLE ANNOTATION & ARRAY\n// ============================================================================\n\n/**\n * Normalize a single annotation\n *\n * Routes annotation to appropriate type-specific normalizer based on type field.\n * Handles critical validation errors (missing/invalid type).\n *\n * @param {Object} raw - Raw annotation object\n * @param {number} index - Position in original array (for error context)\n * @returns {Object} Result object with annotation, warnings, info, and critical error\n * @returns {Object|null} return.annotation - Normalized annotation or null if critical error\n * @returns {Array<string>} return.warnings - Warning messages\n * @returns {Array<string>} return.info - Info messages\n * @returns {string|null} return.critical - Critical error message or null\n *\n * @example\n * normalizeAnnotation({ type: 'text', content: 'Hello' }, 0)\n * // Returns: { annotation: {...}, warnings: [], info: [], critical: null }\n */\nexport function normalizeAnnotation(raw, index) {\n  const warnings = [];\n  const info = [];\n\n  // Validate input is object\n  if (!raw || typeof raw !== 'object') {\n    return {\n      annotation: null,\n      warnings: [],\n      info: [],\n      critical: `Annotation at index ${index}: Not a valid object`\n    };\n  }\n\n  // Check type field (critical - cannot route without type)\n  if (typeof raw.type !== 'string' || raw.type.trim().length === 0) {\n    return {\n      annotation: null,\n      warnings: [],\n      info: [],\n      critical: `Annotation at index ${index}: Missing or invalid type field`\n    };\n  }\n\n  const type = raw.type.trim();\n\n  // Normalize base fields first\n  const base = normalizeBaseFields(raw, warnings, info);\n\n  // Route to type-specific normalizer\n  let annotation;\n\n  if (type === 'highlight') {\n    annotation = normalizeHighlight(base, raw, warnings, info);\n  } else if (type === 'text') {\n    annotation = normalizeText(base, raw, warnings, info);\n  } else if (type === 'ink') {\n    annotation = normalizeInk(base, raw, warnings, info);\n  } else {\n    return {\n      annotation: null,\n      warnings: [],\n      info: [],\n      critical: `Annotation at index ${index}: Unsupported type \"${type}\"`\n    };\n  }\n\n  return {\n    annotation,\n    warnings,\n    info,\n    critical: null\n  };\n}\n\n/**\n * Normalize array of annotations\n *\n * MAIN ENTRY POINT for annotation normalization. Processes each annotation,\n * collects warnings, and returns normalized data ready for rendering.\n *\n * @param {Array} rawAnnotations - Array of raw annotation objects\n * @param {Object} [options] - Configuration options\n * @param {boolean} [options.skipInvalid=true] - Skip critically invalid annotations\n * @param {boolean} [options.warnInConsole=true] - Log warnings to console\n * @param {Function} [options.onWarning] - Custom warning callback\n * @returns {Object} ValidationResult with normalized annotations and messages\n * @returns {Array} return.normalized - Successfully normalized annotations\n * @returns {Array<string>} return.warnings - Warning messages\n * @returns {Array<string>} return.info - Informational messages\n * @returns {Array<Object>} return.skipped - Skipped annotations with reasons\n *\n * @example\n * const result = normalizeAnnotationArray(rawAnnotations, {\n *   skipInvalid: true,\n *   warnInConsole: true\n * });\n *\n * renderer.setAnnotations(result.normalized);\n */\nexport function normalizeAnnotationArray(rawAnnotations, options = {}) {\n  // Default options\n  const skipInvalid = options.skipInvalid !== false;  // Default: true\n  const warnInConsole = options.warnInConsole !== false;  // Default: true\n  const onWarning = options.onWarning || null;\n\n  // Initialize result structure\n  const result = {\n    normalized: [],\n    warnings: [],\n    info: [],\n    skipped: []\n  };\n\n  // Validate input is array\n  if (!Array.isArray(rawAnnotations)) {\n    const warning = 'normalizeAnnotationArray: Input is not an array, returning empty result';\n    result.warnings.push(warning);\n\n    if (warnInConsole) {\n      console.warn(`[Annotation Normalizer] ${warning}`);\n    }\n\n    return result;\n  }\n\n  // Process each annotation\n  rawAnnotations.forEach((raw, index) => {\n    // Skip null/undefined\n    if (raw == null) {\n      result.skipped.push({\n        index,\n        annotation: raw,\n        reason: 'Annotation is null or undefined'\n      });\n      return;\n    }\n\n    // Normalize annotation\n    const normalized = normalizeAnnotation(raw, index);\n\n    // Check for critical error\n    if (normalized.critical) {\n      result.skipped.push({\n        index,\n        annotation: raw,\n        reason: normalized.critical\n      });\n\n      if (warnInConsole) {\n        console.error(`[Annotation Normalizer] ${normalized.critical}`);\n      }\n\n      return;\n    }\n\n    // Add to normalized array\n    result.normalized.push(normalized.annotation);\n\n    // Collect warnings and info\n    result.warnings.push(...normalized.warnings);\n    result.info.push(...normalized.info);\n  });\n\n  // Console output\n  if (warnInConsole) {\n    if (result.warnings.length > 0 || result.info.length > 0 || result.skipped.length > 0) {\n      console.group('[Annotation Normalizer] Validation Summary');\n\n      if (result.normalized.length > 0) {\n        console.info(`✓ Normalized ${result.normalized.length} annotation(s)`);\n      }\n\n      if (result.skipped.length > 0) {\n        console.error(`✗ Skipped ${result.skipped.length} annotation(s)`);\n        result.skipped.forEach(s => {\n          console.error(`  Index ${s.index}: ${s.reason}`);\n        });\n      }\n\n      if (result.warnings.length > 0) {\n        console.warn(`⚠ ${result.warnings.length} warning(s):`);\n        result.warnings.forEach(w => console.warn(`  ${w}`));\n      }\n\n      if (result.info.length > 0) {\n        console.info(`ℹ ${result.info.length} info message(s):`);\n        result.info.forEach(i => console.info(`  ${i}`));\n      }\n\n      console.groupEnd();\n    }\n  }\n\n  // Call custom warning handler\n  if (onWarning && typeof onWarning === 'function') {\n    onWarning(result);\n  }\n\n  return result;\n}\n"],"names":["normalizeCoordinate","value","defaultValue","id","fieldName","warnings","numValue","normalizeColor","trimmed","hexPattern","rgbPattern","namedColors","isHex","isRgb","isNamed","normalizePositiveNumber","normalizeBaseFields","raw","info","base","timestamp","random","BASE_DEFAULTS","normalizeQuad","quad","normalizeHighlight","annotation","HIGHLIGHT_DEFAULTS","idx","defaultColor","normalizeText","TEXT_DEFAULTS","defaultBg","normalizePoint","point","normalizeStroke","stroke","INK_DEFAULTS","normalized","normalizeInk","normalizeAnnotation","index","type","normalizeAnnotationArray","rawAnnotations","options","warnInConsole","onWarning","result","warning","s","w"],"mappings":"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"}
+{"version":3,"file":"index13.js","sources":["../src/converters/highlight.js"],"sourcesContent":["/**\n * Highlight Converter - Converts highlight annotations to stroke commands\n *\n * Transforms rectangular quads into horizontal stroke paths that can be\n * rendered progressively on canvas.\n *\n * @module converters/highlight\n */\n\nimport { applyJitter, applyPressure } from '../pen/effects.js';\n\n/**\n * Converts a highlight annotation to stroke commands\n *\n * Each quad in the annotation becomes a horizontal stroke at the\n * vertical center of the quad. Multiple quads are staggered in timing.\n *\n * @param {Object} annotation - Highlight 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='butt'] - Line cap style\n * @param {Object} [style.jitter] - Jitter configuration\n * @param {Object} [style.pressure] - Pressure configuration\n * @returns {Array<Object>} Array of stroke commands\n */\nexport function highlightToStrokes(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\n  // Calculate timing for each quad (staggered)\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    // Calculate center-line Y position\n    const yCenter = y + h / 2;\n\n    // Create stroke points (left to right horizontal line)\n    let points = [\n      [x, yCenter],\n      [x + w, yCenter]\n    ];\n\n    // Apply jitter if configured\n    if (style.jitter?.amplitude > 0) {\n      points = applyJitter(points, style.jitter, `${id}-${i}`);\n    }\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 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(255, 255, 0, 0.3)',\n      width: style.width || 24,\n      lineCap: style.lineCap || 'butt',\n      pressures\n    });\n  }\n\n  return strokes;\n}\n\nexport default highlightToStrokes;\n"],"names":["highlightToStrokes","annotation","style","id","start","end","quads","strokes","totalDuration","quadCount","quadDuration","i","quad","x","y","w","h","yCenter","points","applyJitter","pressures","applyPressure","quadStart","quadEnd"],"mappings":";AA+BO,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,QAGlBI,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,IAAUH,IAAIE,IAAI;AAGxB,QAAIE,IAAS;AAAA,MACX,CAACL,GAAGI,CAAO;AAAA,MACX,CAACJ,IAAIE,GAAGE,CAAO;AAAA,IACrB;AAGI,IAAIf,EAAM,QAAQ,YAAY,MAC5BgB,IAASC,EAAYD,GAAQhB,EAAM,QAAQ,GAAGC,CAAE,IAAIQ,CAAC,EAAE;AAIzD,QAAIS,IAAY;AAChB,KAAIlB,EAAM,UAAU,UAAU,KAAKA,EAAM,UAAU,WAAW,OAC5DkB,IAAYC,EAAcH,GAAQhB,EAAM,QAAQ;AAIlD,UAAMoB,IAAYlB,IAAQO,IAAID,GACxBa,IAAUD,IAAYZ;AAE5B,IAAAH,EAAQ,KAAK;AAAA,MACX,IAAI,GAAGJ,CAAE,IAAIQ,CAAC;AAAA,MACd,QAAAO;AAAA,MACA,OAAOI;AAAA,MACP,KAAKC;AAAA,MACL,OAAOrB,EAAM,SAAS;AAAA,MACtB,OAAOA,EAAM,SAAS;AAAA,MACtB,SAASA,EAAM,WAAW;AAAA,MAC1B,WAAAkB;AAAA,IACN,CAAK;AAAA,EACH;AAEA,SAAOb;AACT;"}

package/dist/index14.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("./index13.cjs"),e=require("./index21.cjs");exports.normalizeAnnotation=o.normalizeAnnotation;exports.normalizeAnnotationArray=o.normalizeAnnotationArray;exports.normalizeBaseFields=o.normalizeBaseFields;exports.normalizeColor=o.normalizeColor;exports.normalizeCoordinate=o.normalizeCoordinate;exports.normalizeHighlight=o.normalizeHighlight;exports.normalizeInk=o.normalizeInk;exports.normalizePositiveNumber=o.normalizePositiveNumber;exports.normalizeText=o.normalizeText;exports.BASE_DEFAULTS=e.BASE_DEFAULTS;exports.HIGHLIGHT_DEFAULTS=e.HIGHLIGHT_DEFAULTS;exports.INK_DEFAULTS=e.INK_DEFAULTS;exports.TEXT_DEFAULTS=e.TEXT_DEFAULTS;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const z=require("./index6.cjs"),p=require("./index23.cjs");function T(e){return p.default.glyphs&&p.default.glyphs[e]?p.default.glyphs[e]:e===" "?{strokes:[],width:.3}:null}function q(e,t,i,o,c){return e.map(([n,l])=>[t+n*o*c,i+l*o])}function D(e,t){const{id:i,start:o,end:c,content:n,x:l,y:m,fontSize:C}=e;if(!n||n.length===0)return[];const d=[],P=c-o,a=(C||t.fontSize||16)/1e3;let f=l;const b=n.length,g=P/b;for(let r=0;r<n.length;r++){const j=n[r],h=T(j);if(!h){f+=a*.5;continue}const S=h.width||.8,k=h.strokes||[],$=o+r*g,I=$+g;for(let s=0;s<k.length;s++){const w=k[s].points||[];if(w.length<2)continue;let u=q(w,f,m,a,S);t.jitter?.amplitude>0&&(u=z.applyJitter(u,t.jitter,`${i}-${r}-${s}`));let x=null;(t.pressure?.taperIn>0||t.pressure?.taperOut>0)&&(x=z.applyPressure(u,t.pressure)),d.push({id:`${i}-${r}-${s}`,points:u,start:$,end:I,color:t.color||"rgba(220, 20, 60, 1.0)",width:t.width||2,lineCap:t.lineCap||"round",pressures:x})}f+=a*S+a*.1}return d}exports.default=D;exports.textToStrokes=D;
 //# sourceMappingURL=index14.cjs.map

package/dist/index14.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index14.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index14.cjs","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 * looking up glyphs from the stroke library.\n *\n * @module converters/text\n */\n\nimport { applyJitter, applyPressure } from '../pen/effects.js';\nimport latinStrokes from '../strokes/latin.json';\n\n/**\n * Looks up character strokes from the stroke library\n *\n * @param {string} char - Single character to look up\n * @returns {Object|null} Character data with strokes and width, or null if not found\n */\nfunction lookupCharacter(char) {\n  // Check Latin library\n  if (latinStrokes.glyphs && latinStrokes.glyphs[char]) {\n    return latinStrokes.glyphs[char];\n  }\n\n  // Space character - return empty with width\n  if (char === ' ') {\n    return { strokes: [], width: 0.3 };\n  }\n\n  // Fallback: return null (character will be skipped)\n  return null;\n}\n\n/**\n * Transforms stroke points from glyph space to target position\n *\n * Glyph points are in 0-1 normalized space within the glyph's bounding box.\n * This transforms them to the target position on the page.\n *\n * @param {Array<[number, number]>} points - Glyph points in 0-1 space\n * @param {number} x - Target X position (normalized page coordinates)\n * @param {number} y - Target Y position (normalized page coordinates)\n * @param {number} scale - Scale factor based on fontSize\n * @param {number} charWidth - Character width for positioning\n * @returns {Array<[number, number]>} Transformed points\n */\nfunction transformPoints(points, x, y, scale, charWidth) {\n  return points.map(([px, py]) => [\n    x + px * scale * charWidth,\n    y + py * scale\n  ]);\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 *\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 * @returns {Array<Object>} Array of stroke commands\n */\nexport function textToStrokes(annotation, style) {\n  const {\n    id,\n    start,\n    end,\n    content,\n    x,\n    y,\n    fontSize: annotFontSize\n  } = 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\n  // Scale factor: convert fontSize (pixels) to normalized coordinates\n  // Assuming a reference viewport of ~1000px, adjust as needed\n  const scale = fontSize / 1000;\n\n  // Track current X position for character placement\n  let currentX = x;\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 charData = lookupCharacter(char);\n\n    if (!charData) {\n      // Skip unknown characters, but advance position\n      currentX += scale * 0.5;\n      continue;\n    }\n\n    const charWidth = charData.width || 0.8;\n    const charStrokes = charData.strokes || [];\n\n    // Calculate timing for this character\n    const charStart = start + charIndex * charDuration;\n    const charEnd = charStart + charDuration;\n\n    // Process each stroke in the character\n    for (let strokeIndex = 0; strokeIndex < charStrokes.length; strokeIndex++) {\n      const strokeData = charStrokes[strokeIndex];\n      const rawPoints = strokeData.points || [];\n\n      if (rawPoints.length < 2) continue;\n\n      // Transform points to target position\n      let points = transformPoints(rawPoints, currentX, y, scale, charWidth);\n\n      // Apply jitter if configured\n      if (style.jitter?.amplitude > 0) {\n        points = applyJitter(points, style.jitter, `${id}-${charIndex}-${strokeIndex}`);\n      }\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      strokes.push({\n        id: `${id}-${charIndex}-${strokeIndex}`,\n        points,\n        start: charStart,\n        end: charEnd,\n        color: style.color || 'rgba(220, 20, 60, 1.0)',\n        width: style.width || 2,\n        lineCap: style.lineCap || 'round',\n        pressures\n      });\n    }\n\n    // Advance X position for next character\n    currentX += scale * charWidth + scale * 0.1; // Add small spacing\n  }\n\n  return strokes;\n}\n\nexport default textToStrokes;\n"],"names":["lookupCharacter","char","latinStrokes","transformPoints","points","x","y","scale","charWidth","px","py","textToStrokes","annotation","style","id","start","end","content","annotFontSize","strokes","totalDuration","currentX","charCount","charDuration","charIndex","charData","charStrokes","charStart","charEnd","strokeIndex","rawPoints","applyJitter","pressures","applyPressure"],"mappings":"uKAkBA,SAASA,EAAgBC,EAAM,CAE7B,OAAIC,EAAAA,QAAa,QAAUA,EAAAA,QAAa,OAAOD,CAAI,EAC1CC,EAAAA,QAAa,OAAOD,CAAI,EAI7BA,IAAS,IACJ,CAAE,QAAS,GAAI,MAAO,EAAG,EAI3B,IACT,CAeA,SAASE,EAAgBC,EAAQC,EAAGC,EAAGC,EAAOC,EAAW,CACvD,OAAOJ,EAAO,IAAI,CAAC,CAACK,EAAIC,CAAE,IAAM,CAC9BL,EAAII,EAAKF,EAAQC,EACjBF,EAAII,EAAKH,CACb,CAAG,CACH,CA0BO,SAASI,EAAcC,EAAYC,EAAO,CAC/C,KAAM,CACJ,GAAAC,EACA,MAAAC,EACA,IAAAC,EACA,QAAAC,EACA,EAAAZ,EACA,EAAAC,EACA,SAAUY,CACd,EAAMN,EAEJ,GAAI,CAACK,GAAWA,EAAQ,SAAW,EACjC,MAAO,CAAA,EAGT,MAAME,EAAU,CAAA,EACVC,EAAgBJ,EAAMD,EAKtBR,GAJWW,GAAiBL,EAAM,UAAY,IAI3B,IAGzB,IAAIQ,EAAWhB,EAGf,MAAMiB,EAAYL,EAAQ,OACpBM,EAAeH,EAAgBE,EAErC,QAASE,EAAY,EAAGA,EAAYP,EAAQ,OAAQO,IAAa,CAC/D,MAAMvB,EAAOgB,EAAQO,CAAS,EACxBC,EAAWzB,EAAgBC,CAAI,EAErC,GAAI,CAACwB,EAAU,CAEbJ,GAAYd,EAAQ,GACpB,QACF,CAEA,MAAMC,EAAYiB,EAAS,OAAS,GAC9BC,EAAcD,EAAS,SAAW,CAAA,EAGlCE,EAAYZ,EAAQS,EAAYD,EAChCK,EAAUD,EAAYJ,EAG5B,QAASM,EAAc,EAAGA,EAAcH,EAAY,OAAQG,IAAe,CAEzE,MAAMC,EADaJ,EAAYG,CAAW,EACb,QAAU,CAAA,EAEvC,GAAIC,EAAU,OAAS,EAAG,SAG1B,IAAI1B,EAASD,EAAgB2B,EAAWT,EAAUf,EAAGC,EAAOC,CAAS,EAGjEK,EAAM,QAAQ,UAAY,IAC5BT,EAAS2B,EAAAA,YAAY3B,EAAQS,EAAM,OAAQ,GAAGC,CAAE,IAAIU,CAAS,IAAIK,CAAW,EAAE,GAIhF,IAAIG,EAAY,MACZnB,EAAM,UAAU,QAAU,GAAKA,EAAM,UAAU,SAAW,KAC5DmB,EAAYC,EAAAA,cAAc7B,EAAQS,EAAM,QAAQ,GAGlDM,EAAQ,KAAK,CACX,GAAI,GAAGL,CAAE,IAAIU,CAAS,IAAIK,CAAW,GACrC,OAAAzB,EACA,MAAOuB,EACP,IAAKC,EACL,MAAOf,EAAM,OAAS,yBACtB,MAAOA,EAAM,OAAS,EACtB,QAASA,EAAM,SAAW,QAC1B,UAAAmB,CACR,CAAO,CACH,CAGAX,GAAYd,EAAQC,EAAYD,EAAQ,EAC1C,CAEA,OAAOY,CACT"}

package/dist/index14.js

@@ -1,18 +1,59 @@
-import { normalizeAnnotation as e, normalizeAnnotationArray as i, normalizeBaseFields as n, normalizeColor as a, normalizeCoordinate as l, normalizeHighlight as m, normalizeInk as t, normalizePositiveNumber as z, normalizeText as A } from "./index13.js";
-import { BASE_DEFAULTS as E, HIGHLIGHT_DEFAULTS as F, INK_DEFAULTS as L, TEXT_DEFAULTS as S } from "./index21.js";
+import { applyJitter as j, applyPressure as b } from "./index6.js";
+import l from "./index23.js";
+function E(n) {
+  return l.glyphs && l.glyphs[n] ? l.glyphs[n] : n === " " ? { strokes: [], width: 0.3 } : null;
+}
+function F(n, t, i, e, u) {
+  return n.map(([r, p]) => [
+    t + r * e * u,
+    i + p * e
+  ]);
+}
+function X(n, t) {
+  const {
+    id: i,
+    start: e,
+    end: u,
+    content: r,
+    x: p,
+    y: x,
+    fontSize: z
+  } = n;
+  if (!r || r.length === 0)
+    return [];
+  const d = [], D = u - e, a = (z || t.fontSize || 16) / 1e3;
+  let h = p;
+  const C = r.length, k = D / C;
+  for (let o = 0; o < r.length; o++) {
+    const I = r[o], f = E(I);
+    if (!f) {
+      h += a * 0.5;
+      continue;
+    }
+    const g = f.width || 0.8, S = f.strokes || [], m = e + o * k, P = m + k;
+    for (let s = 0; s < S.length; s++) {
+      const $ = S[s].points || [];
+      if ($.length < 2) continue;
+      let c = F($, h, x, a, g);
+      t.jitter?.amplitude > 0 && (c = j(c, t.jitter, `${i}-${o}-${s}`));
+      let w = null;
+      (t.pressure?.taperIn > 0 || t.pressure?.taperOut > 0) && (w = b(c, t.pressure)), d.push({
+        id: `${i}-${o}-${s}`,
+        points: c,
+        start: m,
+        end: P,
+        color: t.color || "rgba(220, 20, 60, 1.0)",
+        width: t.width || 2,
+        lineCap: t.lineCap || "round",
+        pressures: w
+      });
+    }
+    h += a * g + a * 0.1;
+  }
+  return d;
+}
 export {
-  E as BASE_DEFAULTS,
-  F as HIGHLIGHT_DEFAULTS,
-  L as INK_DEFAULTS,
-  S as TEXT_DEFAULTS,
-  e as normalizeAnnotation,
-  i as normalizeAnnotationArray,
-  n as normalizeBaseFields,
-  a as normalizeColor,
-  l as normalizeCoordinate,
-  m as normalizeHighlight,
-  t as normalizeInk,
-  z as normalizePositiveNumber,
-  A as normalizeText
+  X as default,
+  X as textToStrokes
 };
 //# sourceMappingURL=index14.js.map

package/dist/index14.js.map

@@ -1 +1 @@
-{"version":3,"file":"index14.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}
+{"version":3,"file":"index14.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 * looking up glyphs from the stroke library.\n *\n * @module converters/text\n */\n\nimport { applyJitter, applyPressure } from '../pen/effects.js';\nimport latinStrokes from '../strokes/latin.json';\n\n/**\n * Looks up character strokes from the stroke library\n *\n * @param {string} char - Single character to look up\n * @returns {Object|null} Character data with strokes and width, or null if not found\n */\nfunction lookupCharacter(char) {\n  // Check Latin library\n  if (latinStrokes.glyphs && latinStrokes.glyphs[char]) {\n    return latinStrokes.glyphs[char];\n  }\n\n  // Space character - return empty with width\n  if (char === ' ') {\n    return { strokes: [], width: 0.3 };\n  }\n\n  // Fallback: return null (character will be skipped)\n  return null;\n}\n\n/**\n * Transforms stroke points from glyph space to target position\n *\n * Glyph points are in 0-1 normalized space within the glyph's bounding box.\n * This transforms them to the target position on the page.\n *\n * @param {Array<[number, number]>} points - Glyph points in 0-1 space\n * @param {number} x - Target X position (normalized page coordinates)\n * @param {number} y - Target Y position (normalized page coordinates)\n * @param {number} scale - Scale factor based on fontSize\n * @param {number} charWidth - Character width for positioning\n * @returns {Array<[number, number]>} Transformed points\n */\nfunction transformPoints(points, x, y, scale, charWidth) {\n  return points.map(([px, py]) => [\n    x + px * scale * charWidth,\n    y + py * scale\n  ]);\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 *\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 * @returns {Array<Object>} Array of stroke commands\n */\nexport function textToStrokes(annotation, style) {\n  const {\n    id,\n    start,\n    end,\n    content,\n    x,\n    y,\n    fontSize: annotFontSize\n  } = 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\n  // Scale factor: convert fontSize (pixels) to normalized coordinates\n  // Assuming a reference viewport of ~1000px, adjust as needed\n  const scale = fontSize / 1000;\n\n  // Track current X position for character placement\n  let currentX = x;\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 charData = lookupCharacter(char);\n\n    if (!charData) {\n      // Skip unknown characters, but advance position\n      currentX += scale * 0.5;\n      continue;\n    }\n\n    const charWidth = charData.width || 0.8;\n    const charStrokes = charData.strokes || [];\n\n    // Calculate timing for this character\n    const charStart = start + charIndex * charDuration;\n    const charEnd = charStart + charDuration;\n\n    // Process each stroke in the character\n    for (let strokeIndex = 0; strokeIndex < charStrokes.length; strokeIndex++) {\n      const strokeData = charStrokes[strokeIndex];\n      const rawPoints = strokeData.points || [];\n\n      if (rawPoints.length < 2) continue;\n\n      // Transform points to target position\n      let points = transformPoints(rawPoints, currentX, y, scale, charWidth);\n\n      // Apply jitter if configured\n      if (style.jitter?.amplitude > 0) {\n        points = applyJitter(points, style.jitter, `${id}-${charIndex}-${strokeIndex}`);\n      }\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      strokes.push({\n        id: `${id}-${charIndex}-${strokeIndex}`,\n        points,\n        start: charStart,\n        end: charEnd,\n        color: style.color || 'rgba(220, 20, 60, 1.0)',\n        width: style.width || 2,\n        lineCap: style.lineCap || 'round',\n        pressures\n      });\n    }\n\n    // Advance X position for next character\n    currentX += scale * charWidth + scale * 0.1; // Add small spacing\n  }\n\n  return strokes;\n}\n\nexport default textToStrokes;\n"],"names":["lookupCharacter","char","latinStrokes","transformPoints","points","x","y","scale","charWidth","px","py","textToStrokes","annotation","style","id","start","end","content","annotFontSize","strokes","totalDuration","currentX","charCount","charDuration","charIndex","charData","charStrokes","charStart","charEnd","strokeIndex","rawPoints","applyJitter","pressures","applyPressure"],"mappings":";;AAkBA,SAASA,EAAgBC,GAAM;AAE7B,SAAIC,EAAa,UAAUA,EAAa,OAAOD,CAAI,IAC1CC,EAAa,OAAOD,CAAI,IAI7BA,MAAS,MACJ,EAAE,SAAS,IAAI,OAAO,IAAG,IAI3B;AACT;AAeA,SAASE,EAAgBC,GAAQC,GAAGC,GAAGC,GAAOC,GAAW;AACvD,SAAOJ,EAAO,IAAI,CAAC,CAACK,GAAIC,CAAE,MAAM;AAAA,IAC9BL,IAAII,IAAKF,IAAQC;AAAA,IACjBF,IAAII,IAAKH;AAAA,EACb,CAAG;AACH;AA0BO,SAASI,EAAcC,GAAYC,GAAO;AAC/C,QAAM;AAAA,IACJ,IAAAC;AAAA,IACA,OAAAC;AAAA,IACA,KAAAC;AAAA,IACA,SAAAC;AAAA,IACA,GAAAZ;AAAA,IACA,GAAAC;AAAA,IACA,UAAUY;AAAA,EACd,IAAMN;AAEJ,MAAI,CAACK,KAAWA,EAAQ,WAAW;AACjC,WAAO,CAAA;AAGT,QAAME,IAAU,CAAA,GACVC,IAAgBJ,IAAMD,GAKtBR,KAJWW,KAAiBL,EAAM,YAAY,MAI3B;AAGzB,MAAIQ,IAAWhB;AAGf,QAAMiB,IAAYL,EAAQ,QACpBM,IAAeH,IAAgBE;AAErC,WAASE,IAAY,GAAGA,IAAYP,EAAQ,QAAQO,KAAa;AAC/D,UAAMvB,IAAOgB,EAAQO,CAAS,GACxBC,IAAWzB,EAAgBC,CAAI;AAErC,QAAI,CAACwB,GAAU;AAEb,MAAAJ,KAAYd,IAAQ;AACpB;AAAA,IACF;AAEA,UAAMC,IAAYiB,EAAS,SAAS,KAC9BC,IAAcD,EAAS,WAAW,CAAA,GAGlCE,IAAYZ,IAAQS,IAAYD,GAChCK,IAAUD,IAAYJ;AAG5B,aAASM,IAAc,GAAGA,IAAcH,EAAY,QAAQG,KAAe;AAEzE,YAAMC,IADaJ,EAAYG,CAAW,EACb,UAAU,CAAA;AAEvC,UAAIC,EAAU,SAAS,EAAG;AAG1B,UAAI1B,IAASD,EAAgB2B,GAAWT,GAAUf,GAAGC,GAAOC,CAAS;AAGrE,MAAIK,EAAM,QAAQ,YAAY,MAC5BT,IAAS2B,EAAY3B,GAAQS,EAAM,QAAQ,GAAGC,CAAE,IAAIU,CAAS,IAAIK,CAAW,EAAE;AAIhF,UAAIG,IAAY;AAChB,OAAInB,EAAM,UAAU,UAAU,KAAKA,EAAM,UAAU,WAAW,OAC5DmB,IAAYC,EAAc7B,GAAQS,EAAM,QAAQ,IAGlDM,EAAQ,KAAK;AAAA,QACX,IAAI,GAAGL,CAAE,IAAIU,CAAS,IAAIK,CAAW;AAAA,QACrC,QAAAzB;AAAA,QACA,OAAOuB;AAAA,QACP,KAAKC;AAAA,QACL,OAAOf,EAAM,SAAS;AAAA,QACtB,OAAOA,EAAM,SAAS;AAAA,QACtB,SAASA,EAAM,WAAW;AAAA,QAC1B,WAAAmB;AAAA,MACR,CAAO;AAAA,IACH;AAGA,IAAAX,KAAYd,IAAQC,IAAYD,IAAQ;AAAA,EAC1C;AAEA,SAAOY;AACT;"}

package/dist/index15.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const d=require("react/jsx-runtime"),n=require("react"),j=require("./index2.cjs");function m({pdfUrl:l,page:c=1,scale:u=1.5,annotations:y=[],currentTime:i=0,onLoad:P,onError:t,onPageChange:A,className:F,style:R,canvasStyle:p}){const f=n.useRef(null),a=n.useRef(null),r=n.useRef(null),h=n.useRef(Promise.resolve()),o=n.useCallback(e=>{h.current=h.current.then(e).catch(v=>{console.error("AnnotPdf: Queued operation failed:",v)})},[]);n.useEffect(()=>{if(!(!f.current||!a.current)){try{r.current=new j.AnnotationRenderer({canvasElement:f.current,container:a.current})}catch(e){console.error("AnnotPdf: Failed to initialize renderer:",e),t&&t(e)}return()=>{r.current&&(r.current.destroy(),r.current=null)}}},[]),n.useEffect(()=>{if(!r.current||!l)return;let e=!1;return o(async()=>{try{const s=await r.current.loadPDF(l);if(e)return;if(!s.success){console.error("AnnotPdf: Failed to load PDF:",s.error),t&&t(new Error(s.error));return}P&&P({pageCount:s.pageCount})}catch(s){if(e)return;console.error("AnnotPdf: Failed to load PDF:",s),t&&t(s)}}),()=>{e=!0}},[l,o]),n.useEffect(()=>{!r.current||!c||typeof c!="number"||o(async()=>{try{const e=await r.current.setPage(c);if(!e.success){console.error("AnnotPdf: Failed to set page:",e.error),t&&t(new Error(e.error));return}A&&A(c)}catch(e){console.error("AnnotPdf: Failed to set page:",e),t&&t(e)}})},[c,o]),n.useEffect(()=>{!r.current||!u||typeof u!="number"||o(async()=>{try{const e=await r.current.setScale(u);e.success||(console.error("AnnotPdf: Failed to set scale:",e.error),t&&t(new Error(e.error)))}catch(e){console.error("AnnotPdf: Failed to set scale:",e),t&&t(e)}})},[u,o]),n.useEffect(()=>{if(r.current)try{r.current.setAnnotations(y||[])}catch(e){console.error("AnnotPdf: Failed to set annotations:",e),t&&t(e)}},[y]),n.useEffect(()=>{if(!(!r.current||i===void 0||i===null))try{r.current.setTime(i)}catch(e){console.error("AnnotPdf: Failed to set time:",e),t&&t(e)}},[i]);const w={position:"relative",display:"inline-block",lineHeight:0,...R},b={position:"absolute",top:0,left:0,width:"100%",height:"100%",pointerEvents:"none",overflow:"hidden"},S={display:"block",...p};return d.jsxs("div",{className:F,style:w,children:[d.jsx("canvas",{ref:f,style:S}),d.jsx("div",{ref:a,style:b})]})}exports.default=m;
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const n=require("./index16.cjs");class o{constructor(t,s){this.canvas=t,this.dimensions={...s},this.ctx=null,this.strokeDrawer=null,this.strokeCommands=[],this.currentTime=0,this.isDestroyed=!1,this._setupCanvas()}_setupCanvas(){const t=window.devicePixelRatio||1,{width:s,height:e}=this.dimensions;this.canvas.width=Math.round(s*t),this.canvas.height=Math.round(e*t),this.canvas.style.width=`${s}px`,this.canvas.style.height=`${e}px`,this.ctx=this.canvas.getContext("2d"),this.ctx.setTransform(t,0,0,t,0,0),this.strokeDrawer=new n.default(this.ctx,this.dimensions)}setStrokeCommands(t){this.isDestroyed||(this.strokeCommands=t||[],this.strokeCommands.sort((s,e)=>{const r=s.start??0,i=e.start??0;return r-i}))}setTime(t){this.isDestroyed||(this.currentTime=t)}setDimensions(t){this.isDestroyed||(this.dimensions={...t},this._setupCanvas())}render(){if(!(this.isDestroyed||!this.ctx)){this.strokeDrawer.clear();for(const t of this.strokeCommands){const s=t.start??0,e=t.end??s+1;if(this.currentTime<s)continue;const r=this._calculateProgress(s,e);this.strokeDrawer.drawStroke(t,r)}}}_calculateProgress(t,s){if(this.currentTime>=s)return 1;const e=s-t;if(e<=0)return 1;const r=this.currentTime-t;return Math.max(0,Math.min(1,r/e))}clear(){this.isDestroyed||!this.strokeDrawer||this.strokeDrawer.clear()}getVisibleStrokeCount(){let t=0;for(const s of this.strokeCommands){const e=s.start??0;this.currentTime>=e&&t++}return t}destroy(){this.isDestroyed||(this.strokeCommands=[],this.strokeDrawer=null,this.ctx=null,this.canvas=null,this.isDestroyed=!0)}}exports.default=o;
 //# sourceMappingURL=index15.cjs.map

package/dist/index15.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index15.cjs","sources":["../src/adapters/AnnotPdf.jsx"],"sourcesContent":["// ============================================================================\n// SECTION 1: IMPORTS\n// ============================================================================\n\nimport { useRef, useEffect, useCallback } from 'react';\nimport { AnnotationRenderer } from '../core/AnnotationRenderer.js';\n\n// ============================================================================\n// SECTION 2: JSDOC DOCUMENTATION\n// ============================================================================\n\n/**\n * AnnotPdf - Declarative React component for PDF annotation rendering\n *\n * A React wrapper around the AnnotationRenderer core engine that provides\n * a declarative, props-based API for rendering PDF documents with\n * timeline-synchronized annotations.\n *\n * Features:\n * - Automatic lifecycle management (initialization and cleanup)\n * - Declarative prop-to-method synchronization\n * - PDF rendering with pdf.js\n * - Timeline-synchronized annotation display\n * - Support for highlight, text, and ink annotations\n * - Page navigation and zoom control\n *\n * @component\n * @example\n * // Basic usage\n * <AnnotPdf\n *   pdfUrl=\"/document.pdf\"\n *   page={1}\n *   scale={1.5}\n *   annotations={[]}\n *   currentTime={0}\n * />\n *\n * @example\n * // With audio synchronization\n * const [currentTime, setCurrentTime] = useState(0);\n *\n * <div>\n *   <AnnotPdf\n *     pdfUrl=\"/lecture.pdf\"\n *     page={1}\n *     scale={1.5}\n *     annotations={annotations}\n *     currentTime={currentTime}\n *     onLoad={({ pageCount }) => console.log('Loaded:', pageCount)}\n *   />\n *   <audio\n *     src=\"/lecture.mp3\"\n *     onTimeUpdate={(e) => setCurrentTime(e.target.currentTime)}\n *     controls\n *   />\n * </div>\n *\n * @param {Object} props - Component props\n * @param {string} props.pdfUrl - PDF document URL (required)\n * @param {number} [props.page=1] - Current page number (1-indexed)\n * @param {number} [props.scale=1.5] - Zoom scale factor\n * @param {Array} [props.annotations=[]] - Array of annotation objects\n * @param {number} [props.currentTime=0] - Timeline position in seconds\n * @param {Function} [props.onLoad] - Callback when PDF loads: ({pageCount}) => void\n * @param {Function} [props.onError] - Callback on error: (error) => void\n * @param {Function} [props.onPageChange] - Callback when page changes: (page) => void\n * @param {string} [props.className] - CSS class for container div\n * @param {Object} [props.style] - Inline styles for container div\n * @param {Object} [props.canvasStyle] - Inline styles for canvas element\n * @returns {JSX.Element} PDF viewer component with annotation layers\n */\n\n// ============================================================================\n// SECTION 3: COMPONENT DEFINITION\n// ============================================================================\n\nfunction AnnotPdf({\n  // Required props\n  pdfUrl,\n\n  // Optional props with defaults\n  page = 1,\n  scale = 1.5,\n  annotations = [],\n  currentTime = 0,\n\n  // Callbacks\n  onLoad,\n  onError,\n  onPageChange,\n\n  // Styling\n  className,\n  style,\n  canvasStyle\n}) {\n\n  // ==========================================================================\n  // SECTION 4: REFS INITIALIZATION\n  // ==========================================================================\n\n  /**\n   * Reference to the canvas element for PDF rendering\n   * @type {React.RefObject<HTMLCanvasElement>}\n   */\n  const canvasRef = useRef(null);\n\n  /**\n   * Reference to the layer container div for annotation layers\n   * @type {React.RefObject<HTMLDivElement>}\n   */\n  const layerContainerRef = useRef(null);\n\n  /**\n   * Reference to the AnnotationRenderer engine instance\n   * Stored in ref to avoid triggering re-renders\n   * @type {React.RefObject<AnnotationRenderer|null>}\n   */\n  const engineRef = useRef(null);\n\n  /**\n   * Reference to the render operation queue\n   * Ensures sequential execution of async canvas operations\n   * Prevents PDF.js race condition: \"Cannot use the same canvas during multiple render() operations\"\n   * @type {React.RefObject<Promise<void>>}\n   */\n  const renderQueue = useRef(Promise.resolve());\n\n  // ==========================================================================\n  // SECTION 4.5: RENDER QUEUE HELPER\n  // ==========================================================================\n\n  /**\n   * Queue a render operation to execute sequentially\n   *\n   * This helper ensures that async canvas operations (loadPDF, setPage, setScale)\n   * execute one at a time, preventing concurrent access to the PDF.js canvas.\n   * Uses Promise chaining to maintain operation order.\n   *\n   * @param {Function} operation - Async function returning a Promise\n   * @returns {void}\n   */\n  const queueOperation = useCallback((operation) => {\n    renderQueue.current = renderQueue.current\n      .then(operation)\n      .catch(error => {\n        // Log errors but don't break the queue\n        console.error('AnnotPdf: Queued operation failed:', error);\n      });\n  }, []);\n\n  // ==========================================================================\n  // SECTION 5: ENGINE INITIALIZATION AND CLEANUP\n  // ==========================================================================\n\n  /**\n   * Initialize AnnotationRenderer on component mount\n   * Cleanup on component unmount\n   */\n  useEffect(() => {\n    // Guard: Wait for DOM elements to be ready\n    if (!canvasRef.current || !layerContainerRef.current) {\n      return;\n    }\n\n    // Initialize engine\n    try {\n      engineRef.current = new AnnotationRenderer({\n        canvasElement: canvasRef.current,\n        container: layerContainerRef.current\n      });\n    } catch (error) {\n      console.error('AnnotPdf: Failed to initialize renderer:', error);\n      if (onError) {\n        onError(error);\n      }\n    }\n\n    // Cleanup on unmount\n    return () => {\n      if (engineRef.current) {\n        engineRef.current.destroy();\n        engineRef.current = null;\n      }\n    };\n  }, []); // Empty deps - run once on mount\n\n  // ==========================================================================\n  // SECTION 6: PDF LOADING SYNCHRONIZATION\n  // ==========================================================================\n\n  /**\n   * Load PDF document when pdfUrl prop changes\n   * Handles async operation with cancellation support\n   * Uses render queue to prevent concurrent canvas operations\n   */\n  useEffect(() => {\n    // Guard: Engine must exist and pdfUrl must be valid\n    if (!engineRef.current || !pdfUrl) {\n      return;\n    }\n\n    let cancelled = false;\n\n    const loadPdf = async () => {\n      try {\n        const result = await engineRef.current.loadPDF(pdfUrl);\n\n        // Check if component unmounted during async operation\n        if (cancelled) return;\n\n        // Check if load was successful\n        if (!result.success) {\n          console.error('AnnotPdf: Failed to load PDF:', result.error);\n          if (onError) {\n            onError(new Error(result.error));\n          }\n          return;\n        }\n\n        // Call onLoad callback with pageCount from result\n        if (onLoad) {\n          onLoad({ pageCount: result.pageCount });\n        }\n      } catch (error) {\n        if (cancelled) return;\n\n        console.error('AnnotPdf: Failed to load PDF:', error);\n        if (onError) {\n          onError(error);\n        }\n      }\n    };\n\n    // Queue the PDF loading operation to prevent race conditions\n    queueOperation(loadPdf);\n\n    // Cleanup: Prevent state updates if component unmounts during load\n    return () => {\n      cancelled = true;\n    };\n  }, [pdfUrl, queueOperation]);\n\n  // ==========================================================================\n  // SECTION 7: PAGE SYNCHRONIZATION\n  // ==========================================================================\n\n  /**\n   * Sync page prop to engine.setPage() method\n   * Uses render queue to prevent concurrent canvas operations\n   */\n  useEffect(() => {\n    // Guard: Engine must exist and page must be valid\n    if (!engineRef.current || !page || typeof page !== 'number') {\n      return;\n    }\n\n    // Queue the page change operation to prevent race conditions\n    queueOperation(async () => {\n      try {\n        const result = await engineRef.current.setPage(page);\n\n        // Check if page change was successful\n        if (!result.success) {\n          console.error('AnnotPdf: Failed to set page:', result.error);\n          if (onError) {\n            onError(new Error(result.error));\n          }\n          return;\n        }\n\n        // Optional: Notify parent of successful page change\n        if (onPageChange) {\n          onPageChange(page);\n        }\n      } catch (error) {\n        console.error('AnnotPdf: Failed to set page:', error);\n        if (onError) {\n          onError(error);\n        }\n      }\n    });\n  }, [page, queueOperation]);\n\n  // ==========================================================================\n  // SECTION 8: SCALE SYNCHRONIZATION\n  // ==========================================================================\n\n  /**\n   * Sync scale prop to engine.setScale() method\n   * Uses render queue to prevent concurrent canvas operations\n   */\n  useEffect(() => {\n    // Guard: Engine must exist and scale must be valid\n    if (!engineRef.current || !scale || typeof scale !== 'number') {\n      return;\n    }\n\n    // Queue the scale change operation to prevent race conditions\n    queueOperation(async () => {\n      try {\n        const result = await engineRef.current.setScale(scale);\n\n        // Check if scale change was successful\n        if (!result.success) {\n          console.error('AnnotPdf: Failed to set scale:', result.error);\n          if (onError) {\n            onError(new Error(result.error));\n          }\n        }\n      } catch (error) {\n        console.error('AnnotPdf: Failed to set scale:', error);\n        if (onError) {\n          onError(error);\n        }\n      }\n    });\n  }, [scale, queueOperation]);\n\n  // ==========================================================================\n  // SECTION 9: ANNOTATIONS SYNCHRONIZATION\n  // ==========================================================================\n\n  /**\n   * Sync annotations prop to engine.setAnnotations() method\n   */\n  useEffect(() => {\n    // Guard: Engine must exist\n    if (!engineRef.current) {\n      return;\n    }\n\n    // Sync annotations to engine (default to empty array)\n    try {\n      engineRef.current.setAnnotations(annotations || []);\n    } catch (error) {\n      console.error('AnnotPdf: Failed to set annotations:', error);\n      if (onError) {\n        onError(error);\n      }\n    }\n  }, [annotations]);\n\n  // ==========================================================================\n  // SECTION 10: TIMELINE SYNCHRONIZATION\n  // ==========================================================================\n\n  /**\n   * Sync currentTime prop to engine.setTime() method\n   */\n  useEffect(() => {\n    // Guard: Engine must exist and currentTime must be defined\n    if (!engineRef.current || currentTime === undefined || currentTime === null) {\n      return;\n    }\n\n    // Sync timeline to engine\n    try {\n      engineRef.current.setTime(currentTime);\n    } catch (error) {\n      console.error('AnnotPdf: Failed to set time:', error);\n      if (onError) {\n        onError(error);\n      }\n    }\n  }, [currentTime]);\n\n  // ==========================================================================\n  // SECTION 11: STYLING DEFINITIONS\n  // ==========================================================================\n\n  /**\n   * Default container styles\n   * Merged with user-provided styles (user styles override defaults)\n   */\n  const defaultContainerStyle = {\n    position: 'relative',\n    display: 'inline-block',\n    lineHeight: 0, // Remove extra space below canvas\n    ...style // User styles override defaults\n  };\n\n  /**\n   * Default layer container styles\n   * Positions layer div absolutely over canvas\n   */\n  const defaultLayerStyle = {\n    position: 'absolute',\n    top: 0,\n    left: 0,\n    width: '100%',\n    height: '100%',\n    pointerEvents: 'none', // Allow clicks to pass through to canvas\n    overflow: 'hidden'\n  };\n\n  /**\n   * Default canvas styles\n   * Merged with user-provided canvasStyle\n   */\n  const defaultCanvasStyle = {\n    display: 'block',\n    ...canvasStyle // User styles override defaults\n  };\n\n  // ==========================================================================\n  // SECTION 12: JSX RETURN\n  // ==========================================================================\n\n  return (\n    <div className={className} style={defaultContainerStyle}>\n      <canvas ref={canvasRef} style={defaultCanvasStyle} />\n      <div ref={layerContainerRef} style={defaultLayerStyle} />\n    </div>\n  );\n}\n\n// ============================================================================\n// SECTION 13: EXPORT\n// ============================================================================\n\nexport default AnnotPdf;\n"],"names":["AnnotPdf","pdfUrl","page","scale","annotations","currentTime","onLoad","onError","onPageChange","className","style","canvasStyle","canvasRef","useRef","layerContainerRef","engineRef","renderQueue","queueOperation","useCallback","operation","error","useEffect","AnnotationRenderer","cancelled","result","defaultContainerStyle","defaultLayerStyle","defaultCanvasStyle","jsxs","jsx"],"mappings":"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"}
+{"version":3,"file":"index15.cjs","sources":["../src/pen/GradualRenderer.js"],"sourcesContent":["import StrokeDrawer from './StrokeDrawer.js';\n\n/**\n * GradualRenderer - Progressive stroke rendering synced to timeline\n *\n * Renders stroke commands with progressive reveal based on current\n * audio/video timeline position.\n *\n * Features:\n * - Progressive stroke reveal synced to audio timeline\n * - High-DPI canvas support for crisp rendering\n * - Efficient single-pass render per timeline update\n * - Accepts timing in seconds (start/end fields)\n *\n * @example\n * const renderer = new GradualRenderer(canvas, { width: 800, height: 600 });\n * renderer.setStrokeCommands(commands);\n * renderer.setTime(1.5);  // seconds\n * renderer.render();\n */\nclass GradualRenderer {\n  /**\n   * Creates a new GradualRenderer instance\n   *\n   * @param {HTMLCanvasElement} canvas - Canvas element for rendering\n   * @param {Object} pdfDimensions - PDF page dimensions\n   * @param {number} pdfDimensions.width - Page width in pixels\n   * @param {number} pdfDimensions.height - Page height in pixels\n   */\n  constructor(canvas, pdfDimensions) {\n    this.canvas = canvas;\n    this.dimensions = { ...pdfDimensions };\n    this.ctx = null;\n    this.strokeDrawer = null;\n    this.strokeCommands = [];\n    this.currentTime = 0; // seconds\n    this.isDestroyed = false;\n\n    this._setupCanvas();\n  }\n\n  /**\n   * Configures canvas for high-DPI rendering\n   *\n   * @private\n   */\n  _setupCanvas() {\n    const dpr = window.devicePixelRatio || 1;\n    const { width, height } = this.dimensions;\n\n    // Set canvas buffer resolution (high-res)\n    this.canvas.width = Math.round(width * dpr);\n    this.canvas.height = Math.round(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    // Get context and scale for DPR\n    this.ctx = this.canvas.getContext('2d');\n    this.ctx.setTransform(dpr, 0, 0, dpr, 0, 0);\n\n    // Create stroke drawer\n    this.strokeDrawer = new StrokeDrawer(this.ctx, this.dimensions);\n  }\n\n  /**\n   * Sets the stroke commands to render\n   *\n   * @param {Array} commands - Array of stroke command objects\n   * @param {string} commands[].id - Unique stroke identifier\n   * @param {Array} commands[].points - [[x, y], ...] normalized coordinates\n   * @param {string} commands[].color - Stroke color\n   * @param {number} commands[].width - Stroke width in pixels\n   * @param {number} commands[].start - Start time in seconds\n   * @param {number} commands[].end - End time in seconds\n   */\n  setStrokeCommands(commands) {\n    if (this.isDestroyed) return;\n\n    this.strokeCommands = commands || [];\n\n    // Sort by start time for efficient rendering\n    this.strokeCommands.sort((a, b) => {\n      const startA = a.start ?? 0;\n      const startB = b.start ?? 0;\n      return startA - startB;\n    });\n  }\n\n  /**\n   * Sets the current timeline position\n   *\n   * @param {number} time - Current time in seconds\n   */\n  setTime(time) {\n    if (this.isDestroyed) return;\n    this.currentTime = time;\n  }\n\n  /**\n   * Updates dimensions when viewport changes\n   *\n   * @param {Object} dimensions - New dimensions\n   * @param {number} dimensions.width - Width in pixels\n   * @param {number} dimensions.height - Height in pixels\n   */\n  setDimensions(dimensions) {\n    if (this.isDestroyed) return;\n\n    this.dimensions = { ...dimensions };\n    this._setupCanvas();\n  }\n\n  /**\n   * Renders all visible strokes at current timeline position\n   *\n   * Called once per timeline update. Clears canvas and redraws\n   * all strokes with appropriate progress.\n   */\n  render() {\n    if (this.isDestroyed || !this.ctx) return;\n\n    // Clear canvas\n    this.strokeDrawer.clear();\n\n    // Draw each stroke based on timing\n    for (const stroke of this.strokeCommands) {\n      const start = stroke.start ?? 0;\n      const end = stroke.end ?? start + 1;\n\n      // Skip strokes that haven't started\n      if (this.currentTime < start) {\n        continue;\n      }\n\n      // Calculate progress\n      const progress = this._calculateProgress(start, end);\n\n      // Draw stroke with progress\n      this.strokeDrawer.drawStroke(stroke, progress);\n    }\n  }\n\n  /**\n   * Calculates stroke progress based on timing\n   *\n   * @private\n   * @param {number} start - Stroke start time in seconds\n   * @param {number} end - Stroke end time in seconds\n   * @returns {number} Progress from 0 to 1\n   */\n  _calculateProgress(start, end) {\n    if (this.currentTime >= end) {\n      return 1.0;  // Fully visible\n    }\n\n    const duration = end - start;\n    if (duration <= 0) return 1.0;\n\n    const elapsed = this.currentTime - start;\n    return Math.max(0, Math.min(1, elapsed / duration));\n  }\n\n  /**\n   * Clears the canvas\n   */\n  clear() {\n    if (this.isDestroyed || !this.strokeDrawer) return;\n    this.strokeDrawer.clear();\n  }\n\n  /**\n   * Gets visible stroke count at current time\n   *\n   * @returns {number} Number of visible strokes\n   */\n  getVisibleStrokeCount() {\n    let count = 0;\n    for (const stroke of this.strokeCommands) {\n      const start = stroke.start ?? 0;\n      if (this.currentTime >= start) {\n        count++;\n      }\n    }\n    return count;\n  }\n\n  /**\n   * Destroys the renderer and releases resources\n   */\n  destroy() {\n    if (this.isDestroyed) return;\n\n    this.strokeCommands = [];\n    this.strokeDrawer = null;\n    this.ctx = null;\n    this.canvas = null;\n    this.isDestroyed = true;\n  }\n}\n\nexport default GradualRenderer;\n"],"names":["GradualRenderer","canvas","pdfDimensions","dpr","width","height","StrokeDrawer","commands","a","b","startA","startB","time","dimensions","stroke","start","end","progress","duration","elapsed","count"],"mappings":"6IAoBA,MAAMA,CAAgB,CASpB,YAAYC,EAAQC,EAAe,CACjC,KAAK,OAASD,EACd,KAAK,WAAa,CAAE,GAAGC,CAAa,EACpC,KAAK,IAAM,KACX,KAAK,aAAe,KACpB,KAAK,eAAiB,CAAA,EACtB,KAAK,YAAc,EACnB,KAAK,YAAc,GAEnB,KAAK,aAAY,CACnB,CAOA,cAAe,CACb,MAAMC,EAAM,OAAO,kBAAoB,EACjC,CAAE,MAAAC,EAAO,OAAAC,CAAM,EAAK,KAAK,WAG/B,KAAK,OAAO,MAAQ,KAAK,MAAMD,EAAQD,CAAG,EAC1C,KAAK,OAAO,OAAS,KAAK,MAAME,EAASF,CAAG,EAG5C,KAAK,OAAO,MAAM,MAAQ,GAAGC,CAAK,KAClC,KAAK,OAAO,MAAM,OAAS,GAAGC,CAAM,KAGpC,KAAK,IAAM,KAAK,OAAO,WAAW,IAAI,EACtC,KAAK,IAAI,aAAaF,EAAK,EAAG,EAAGA,EAAK,EAAG,CAAC,EAG1C,KAAK,aAAe,IAAIG,EAAAA,QAAa,KAAK,IAAK,KAAK,UAAU,CAChE,CAaA,kBAAkBC,EAAU,CACtB,KAAK,cAET,KAAK,eAAiBA,GAAY,CAAA,EAGlC,KAAK,eAAe,KAAK,CAACC,EAAGC,IAAM,CACjC,MAAMC,EAASF,EAAE,OAAS,EACpBG,EAASF,EAAE,OAAS,EAC1B,OAAOC,EAASC,CAClB,CAAC,EACH,CAOA,QAAQC,EAAM,CACR,KAAK,cACT,KAAK,YAAcA,EACrB,CASA,cAAcC,EAAY,CACpB,KAAK,cAET,KAAK,WAAa,CAAE,GAAGA,CAAU,EACjC,KAAK,aAAY,EACnB,CAQA,QAAS,CACP,GAAI,OAAK,aAAe,CAAC,KAAK,KAG9B,MAAK,aAAa,MAAK,EAGvB,UAAWC,KAAU,KAAK,eAAgB,CACxC,MAAMC,EAAQD,EAAO,OAAS,EACxBE,EAAMF,EAAO,KAAOC,EAAQ,EAGlC,GAAI,KAAK,YAAcA,EACrB,SAIF,MAAME,EAAW,KAAK,mBAAmBF,EAAOC,CAAG,EAGnD,KAAK,aAAa,WAAWF,EAAQG,CAAQ,CAC/C,EACF,CAUA,mBAAmBF,EAAOC,EAAK,CAC7B,GAAI,KAAK,aAAeA,EACtB,MAAO,GAGT,MAAME,EAAWF,EAAMD,EACvB,GAAIG,GAAY,EAAG,MAAO,GAE1B,MAAMC,EAAU,KAAK,YAAcJ,EACnC,OAAO,KAAK,IAAI,EAAG,KAAK,IAAI,EAAGI,EAAUD,CAAQ,CAAC,CACpD,CAKA,OAAQ,CACF,KAAK,aAAe,CAAC,KAAK,cAC9B,KAAK,aAAa,MAAK,CACzB,CAOA,uBAAwB,CACtB,IAAIE,EAAQ,EACZ,UAAWN,KAAU,KAAK,eAAgB,CACxC,MAAMC,EAAQD,EAAO,OAAS,EAC1B,KAAK,aAAeC,GACtBK,GAEJ,CACA,OAAOA,CACT,CAKA,SAAU,CACJ,KAAK,cAET,KAAK,eAAiB,CAAA,EACtB,KAAK,aAAe,KACpB,KAAK,IAAM,KACX,KAAK,OAAS,KACd,KAAK,YAAc,GACrB,CACF"}