hazo_pdf 1.0.0

package/dist/index.js

@@ -0,0 +1,2815 @@
+"use client";
+import {
+  __require,
+  default_config,
+  download_pdf,
+  save_and_download_pdf,
+  save_annotations_to_pdf
+} from "./chunk-2POHPGR3.js";
+
+// src/components/pdf_viewer/pdf_viewer.tsx
+import { useState as useState5, useEffect as useEffect5, useRef as useRef6, useCallback as useCallback2 } from "react";
+import { Save, Undo2 as Undo22, Redo2 } from "lucide-react";
+
+// src/components/pdf_viewer/pdf_worker_setup.ts
+var worker_configured = false;
+async function configure_worker() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return;
+  }
+  if (worker_configured) {
+    return;
+  }
+  try {
+    const pdfjs_module = await (async () => {
+      if (typeof window === "undefined") {
+        throw new Error("Cannot configure PDF.js worker in non-browser environment");
+      }
+      return await import("pdfjs-dist");
+    })();
+    const { GlobalWorkerOptions, version } = pdfjs_module;
+    const pdfjsVersion = version;
+    GlobalWorkerOptions.workerSrc = `https://cdn.jsdelivr.net/npm/pdfjs-dist@${pdfjsVersion}/build/pdf.worker.min.mjs`;
+    console.log(`[PDF Worker] Worker configured: ${GlobalWorkerOptions.workerSrc}`);
+    worker_configured = true;
+  } catch (error) {
+    if (typeof window !== "undefined") {
+      console.error("[PDF Worker] Error configuring worker:", error);
+      throw error;
+    }
+  }
+}
+async function load_pdf_document(source) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    throw new Error("load_pdf_document can only be called in the browser");
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    throw new Error("load_pdf_document cannot be called in Node.js environment");
+  }
+  await configure_worker();
+  const pdfjs_module = await import("pdfjs-dist");
+  const { getDocument } = pdfjs_module;
+  console.log("[PDF Loader] Loading PDF from:", typeof source === "string" ? source : "ArrayBuffer/Uint8Array");
+  try {
+    let pdfData = source;
+    if (typeof source === "string") {
+      if (source.startsWith("/") || source.startsWith("./") || !source.includes("://")) {
+        console.log("[PDF Loader] Fetching local PDF file as ArrayBuffer:", source);
+        try {
+          const response = await fetch(source);
+          if (!response.ok) {
+            throw new Error(`Failed to fetch PDF: ${response.status} ${response.statusText}`);
+          }
+          pdfData = await response.arrayBuffer();
+          console.log("[PDF Loader] PDF fetched successfully, size:", pdfData.byteLength, "bytes");
+        } catch (fetchError) {
+          console.error("[PDF Loader] Error fetching PDF as ArrayBuffer, trying URL directly:", fetchError);
+          pdfData = source;
+        }
+      }
+    }
+    const loading_task = getDocument({
+      url: typeof pdfData === "string" ? pdfData : void 0,
+      data: typeof pdfData !== "string" ? pdfData : void 0,
+      verbosity: 0,
+      // Suppress console warnings
+      // Add CORS support
+      httpHeaders: {},
+      withCredentials: false,
+      // Enable range requests for better performance
+      rangeChunkSize: 65536
+    });
+    const document2 = await loading_task.promise;
+    console.log("[PDF Loader] PDF loaded successfully:", document2.numPages, "pages");
+    return document2;
+  } catch (error) {
+    console.error("[PDF Loader] Error loading PDF:", error);
+    throw error;
+  }
+}
+
+// src/components/pdf_viewer/pdf_viewer_layout.tsx
+import { useState as useState2, useRef as useRef3, useEffect as useEffect2, useCallback } from "react";
+
+// src/components/pdf_viewer/pdf_page_renderer.tsx
+import { useRef, useEffect, useMemo } from "react";
+
+// src/utils/coordinate_mapper.ts
+function create_coordinate_mapper(page, scale) {
+  const viewport = page.getViewport({ scale });
+  return {
+    /**
+     * Convert screen (CSS pixel) coordinates to PDF (abstract) coordinates
+     * @param x_screen - X coordinate in screen space
+     * @param y_screen - Y coordinate in screen space
+     * @returns [x_pdf, y_pdf] coordinates in PDF space
+     */
+    to_pdf: (x_screen, y_screen) => {
+      const result = viewport.convertToPdfPoint(x_screen, y_screen);
+      return [result[0], result[1]];
+    },
+    /**
+     * Convert PDF (abstract) coordinates to Screen (CSS pixel) coordinates
+     * @param x_pdf - X coordinate in PDF space
+     * @param y_pdf - Y coordinate in PDF space
+     * @returns [x_screen, y_screen] coordinates in screen space
+     */
+    to_screen: (x_pdf, y_pdf) => {
+      const result = viewport.convertToViewportPoint(x_pdf, y_pdf);
+      return [result[0], result[1]];
+    }
+  };
+}
+function get_viewport_dimensions(page, scale) {
+  const viewport = page.getViewport({ scale });
+  return {
+    width: viewport.width,
+    height: viewport.height
+  };
+}
+
+// src/utils/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/components/pdf_viewer/pdf_page_renderer.tsx
+import { jsx } from "react/jsx-runtime";
+var PdfPageRenderer = ({
+  page,
+  page_index,
+  scale,
+  className = "",
+  on_coordinate_mapper_ready,
+  config = null
+}) => {
+  const canvas_ref = useRef(null);
+  const render_task_ref = useRef(null);
+  const notified_dimensions_ref = useRef(null);
+  const callback_ref = useRef(on_coordinate_mapper_ready);
+  useEffect(() => {
+    callback_ref.current = on_coordinate_mapper_ready;
+  }, [on_coordinate_mapper_ready]);
+  const viewport_dimensions = useMemo(() => {
+    if (!page) return { width: 0, height: 0 };
+    const viewport = page.getViewport({ scale });
+    return {
+      width: viewport.width,
+      height: viewport.height
+    };
+  }, [page, scale]);
+  const coordinate_mapper = useMemo(() => {
+    if (!page) return null;
+    return create_coordinate_mapper(page, scale);
+  }, [page, scale]);
+  useEffect(() => {
+    if (!page || !coordinate_mapper) return;
+    const current_dimensions = viewport_dimensions;
+    const last_notified = notified_dimensions_ref.current;
+    if (!last_notified || last_notified.width !== current_dimensions.width || last_notified.height !== current_dimensions.height || last_notified.scale !== scale) {
+      if (callback_ref.current) {
+        callback_ref.current(coordinate_mapper, current_dimensions);
+        notified_dimensions_ref.current = { ...current_dimensions, scale };
+      }
+    }
+  }, [page, coordinate_mapper, viewport_dimensions.width, viewport_dimensions.height, scale]);
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (!page) {
+      return;
+    }
+    if (!canvas_ref.current) {
+      return;
+    }
+    let cancelled = false;
+    const cancel_previous = async () => {
+      if (render_task_ref.current) {
+        try {
+          render_task_ref.current.cancel();
+          await render_task_ref.current.promise.catch(() => {
+          });
+        } catch (error) {
+        }
+        render_task_ref.current = null;
+      }
+    };
+    cancel_previous().then(() => {
+      if (cancelled || !canvas_ref.current) {
+        return;
+      }
+      const viewport = page.getViewport({ scale });
+      const canvas = canvas_ref.current;
+      const context = canvas.getContext("2d", { alpha: false });
+      if (!context) {
+        console.error(`[PdfPageRenderer] Page ${page_index}: Cannot get 2D context`);
+        return;
+      }
+      const output_scale = window.devicePixelRatio || 1;
+      canvas.width = viewport.width * output_scale;
+      canvas.height = viewport.height * output_scale;
+      canvas.style.width = `${viewport.width}px`;
+      canvas.style.height = `${viewport.height}px`;
+      context.scale(output_scale, output_scale);
+      const render_context = {
+        canvasContext: context,
+        viewport
+      };
+      const render_task = page.render(render_context);
+      render_task_ref.current = render_task;
+      render_task.promise.then(() => {
+        if (render_task_ref.current === render_task) {
+          render_task_ref.current = null;
+        }
+      }).catch((error) => {
+        if (error.name !== "RenderingCancelledException") {
+          console.error(`[PdfPageRenderer] Page ${page_index}: Error rendering:`, error);
+        }
+        if (render_task_ref.current === render_task) {
+          render_task_ref.current = null;
+        }
+      });
+    });
+    return () => {
+      cancelled = true;
+      if (render_task_ref.current) {
+        try {
+          render_task_ref.current.cancel();
+        } catch (error) {
+        }
+        render_task_ref.current = null;
+      }
+    };
+  }, [page, scale, page_index]);
+  if (!page) {
+    return /* @__PURE__ */ jsx("div", { className: cn("cls_pdf_page_loading", className), children: /* @__PURE__ */ jsx("div", { className: "cls_pdf_page_spinner", children: "Loading page..." }) });
+  }
+  const page_config = config?.page_styling || default_config.page_styling;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn("cls_pdf_page_container", className),
+      style: {
+        position: "relative",
+        width: viewport_dimensions.width,
+        height: viewport_dimensions.height,
+        margin: "0 auto",
+        border: `1px solid ${page_config.page_border_color}`,
+        boxShadow: page_config.page_box_shadow,
+        backgroundColor: page_config.page_background_color,
+        // Inherit cursor from parent (grab/grabbing in pan mode)
+        cursor: "inherit"
+      },
+      children: /* @__PURE__ */ jsx(
+        "canvas",
+        {
+          ref: canvas_ref,
+          className: "cls_pdf_page_canvas",
+          style: {
+            display: "block",
+            width: "100%",
+            height: "100%",
+            pointerEvents: "none"
+            // Allow events to pass through to SVG overlay
+          },
+          "aria-label": `PDF page ${page_index + 1}`
+        }
+      )
+    }
+  );
+};
+
+// src/components/pdf_viewer/annotation_overlay.tsx
+import { useState, useRef as useRef2 } from "react";
+
+// src/utils/annotation_utils.ts
+function calculate_rectangle_coords(p1, p2) {
+  const x = Math.min(p1.x, p2.x);
+  const y = Math.min(p1.y, p2.y);
+  const width = Math.abs(p1.x - p2.x);
+  const height = Math.abs(p1.y - p2.y);
+  return { x, y, width, height };
+}
+function rectangle_to_pdf_rect(rect) {
+  return [
+    rect.x,
+    rect.y,
+    rect.x + rect.width,
+    rect.y + rect.height
+  ];
+}
+function pdf_rect_to_rectangle(pdf_rect) {
+  const [x1, y1, x2, y2] = pdf_rect;
+  return {
+    x: Math.min(x1, x2),
+    y: Math.min(y1, y2),
+    width: Math.abs(x2 - x1),
+    height: Math.abs(y2 - y1)
+  };
+}
+function is_rectangle_too_small(rect, min_size = 5) {
+  return rect.width < min_size || rect.height < min_size;
+}
+
+// src/components/pdf_viewer/annotation_overlay.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var TempDrawBox = ({ start, current, tool_type = "Square", config = null }) => {
+  if (!start || !current) return null;
+  const { x, y, width, height } = calculate_rectangle_coords(start, current);
+  const highlight_config = config?.highlight_annotation || default_config.highlight_annotation;
+  const square_config = config?.square_annotation || default_config.square_annotation;
+  const hex_to_rgba = (hex, opacity) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+  };
+  const get_fill_props = () => {
+    switch (tool_type) {
+      case "Highlight":
+        return {
+          fill: hex_to_rgba(highlight_config.highlight_fill_color, highlight_config.highlight_fill_opacity),
+          stroke: highlight_config.highlight_border_color
+        };
+      case "Square":
+        return {
+          fill: hex_to_rgba(square_config.square_fill_color, square_config.square_fill_opacity),
+          stroke: square_config.square_border_color
+        };
+      default:
+        return {
+          fill: "rgba(0, 0, 255, 0.2)",
+          stroke: "#0000FF"
+        };
+    }
+  };
+  const { fill, stroke } = get_fill_props();
+  return /* @__PURE__ */ jsx2(
+    "rect",
+    {
+      x,
+      y,
+      width,
+      height,
+      stroke,
+      strokeWidth: "2",
+      fill,
+      pointerEvents: "none"
+    }
+  );
+};
+var AnnotationOverlay = ({
+  width,
+  height,
+  page_index,
+  map_coords,
+  annotations = [],
+  current_tool = "Square",
+  on_annotation_create,
+  on_context_menu,
+  on_annotation_click,
+  config = null,
+  className = ""
+}) => {
+  const [is_drawing, setIsDrawing] = useState(false);
+  const [start_point, setStartPoint] = useState(null);
+  const [current_point, setCurrentPoint] = useState(null);
+  const [hovered_annotation_id, setHoveredAnnotationId] = useState(null);
+  const svg_ref = useRef2(null);
+  const log_annotation_click = (annotation, origin, point) => {
+    console.log(
+      `\u{1F7E2} [AnnotationClick] origin=${origin}, id=${annotation.id}, page=${annotation.page_index}, screen=(${point.x.toFixed(
+        1
+      )}, ${point.y.toFixed(1)})`
+    );
+  };
+  const page_annotations = annotations.filter(
+    (ann) => ann.page_index === page_index
+  );
+  const is_point_in_annotation = (point, annotation) => {
+    const [screen_x1, screen_y1] = map_coords.to_screen(
+      annotation.rect[0],
+      annotation.rect[1]
+    );
+    const [screen_x2, screen_y2] = map_coords.to_screen(
+      annotation.rect[2],
+      annotation.rect[3]
+    );
+    if (annotation.type === "FreeText") {
+      const fonts_config = config?.fonts || default_config.fonts;
+      const freetext_config = config?.freetext_annotation || default_config.freetext_annotation;
+      const text = annotation.contents || "";
+      if (!text) return false;
+      const font_size = fonts_config.freetext_font_size_default;
+      const padding_h = freetext_config.freetext_padding_horizontal;
+      const padding_v = freetext_config.freetext_padding_vertical;
+      const text_width_estimate = font_size * 0.6 * text.length;
+      const box_width = text_width_estimate + padding_h * 2;
+      const box_height = font_size + padding_v * 2;
+      const box_x = screen_x1;
+      const box_y = screen_y1;
+      return point.x >= box_x && point.x <= box_x + box_width && point.y >= box_y && point.y <= box_y + box_height;
+    }
+    const screen_x = Math.min(screen_x1, screen_x2);
+    const screen_y = Math.min(screen_y1, screen_y2);
+    const screen_width = Math.abs(screen_x2 - screen_x1);
+    const screen_height = Math.abs(screen_y2 - screen_y1);
+    return point.x >= screen_x && point.x <= screen_x + screen_width && point.y >= screen_y && point.y <= screen_y + screen_height;
+  };
+  const handle_mouse_down = (e) => {
+    if (e.button !== 0) return;
+    const rect = svg_ref.current?.getBoundingClientRect();
+    if (!rect) return;
+    const point = {
+      x: e.clientX - rect.left,
+      y: e.clientY - rect.top
+    };
+    if (e.button === 0 && on_annotation_click) {
+      for (const annotation of page_annotations) {
+        if (is_point_in_annotation(point, annotation)) {
+          e.nativeEvent.__annotation_clicked = annotation.id;
+          e.nativeEvent.__annotation_click_source = "svg_hit_test";
+          e.preventDefault();
+          e.stopPropagation();
+          e.nativeEvent.stopImmediatePropagation();
+          log_annotation_click(annotation, "svg_hit_test", point);
+          on_annotation_click(annotation, point.x, point.y);
+          return;
+        }
+      }
+    } else if (e.button !== 0) {
+      return;
+    } else if (!on_annotation_click) {
+      console.warn(`\u26A0\uFE0F [AnnotationOverlay] on_annotation_click not provided`);
+    }
+    if (!current_tool) {
+      return;
+    }
+    setIsDrawing(true);
+    setStartPoint(point);
+    setCurrentPoint(point);
+  };
+  const handle_mouse_move = (e) => {
+    if (!is_drawing || !start_point) return;
+    const rect = svg_ref.current?.getBoundingClientRect();
+    if (!rect) return;
+    const point = {
+      x: e.clientX - rect.left,
+      y: e.clientY - rect.top
+    };
+    setCurrentPoint(point);
+  };
+  const handle_mouse_up = (_e) => {
+    if (!is_drawing || !start_point || !current_point) return;
+    setIsDrawing(false);
+    const screen_rect = calculate_rectangle_coords(start_point, current_point);
+    if (is_rectangle_too_small(screen_rect, 5)) {
+      setStartPoint(null);
+      setCurrentPoint(null);
+      return;
+    }
+    const [pdf_x1, pdf_y1] = map_coords.to_pdf(screen_rect.x, screen_rect.y);
+    const [pdf_x2, pdf_y2] = map_coords.to_pdf(
+      screen_rect.x + screen_rect.width,
+      screen_rect.y + screen_rect.height
+    );
+    const pdf_rect = [
+      Math.min(pdf_x1, pdf_x2),
+      Math.min(pdf_y1, pdf_y2),
+      Math.max(pdf_x1, pdf_x2),
+      Math.max(pdf_y1, pdf_y2)
+    ];
+    const highlight_config = config?.highlight_annotation || default_config.highlight_annotation;
+    const square_config = config?.square_annotation || default_config.square_annotation;
+    const new_annotation = {
+      id: crypto.randomUUID(),
+      type: current_tool || "Square",
+      page_index,
+      rect: pdf_rect,
+      author: "User",
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      contents: "",
+      color: current_tool === "Highlight" ? highlight_config.highlight_fill_color : square_config.square_fill_color
+    };
+    if (on_annotation_create) {
+      on_annotation_create(new_annotation);
+    }
+    setStartPoint(null);
+    setCurrentPoint(null);
+  };
+  const handle_mouse_leave = () => {
+    if (is_drawing) {
+      setIsDrawing(false);
+      setStartPoint(null);
+      setCurrentPoint(null);
+    }
+  };
+  const handle_context_menu = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    const rect = svg_ref.current?.getBoundingClientRect();
+    if (!rect) {
+      console.warn("[AnnotationOverlay] Could not get SVG bounding rect");
+      return;
+    }
+    if (!on_context_menu) {
+      console.warn("[AnnotationOverlay] on_context_menu callback not provided");
+      return;
+    }
+    const screen_x = e.clientX - rect.left;
+    const screen_y = e.clientY - rect.top;
+    on_context_menu(e, screen_x, screen_y);
+  };
+  const render_annotation = (annotation) => {
+    const [screen_x1, screen_y1] = map_coords.to_screen(
+      annotation.rect[0],
+      // Top-left X in PDF space
+      annotation.rect[1]
+      // Top-left Y in PDF space
+    );
+    const [screen_x2, screen_y2] = map_coords.to_screen(
+      annotation.rect[2],
+      // Bottom-right X in PDF space
+      annotation.rect[3]
+      // Bottom-right Y in PDF space
+    );
+    const screen_x = Math.min(screen_x1, screen_x2);
+    const screen_y = Math.min(screen_y1, screen_y2);
+    const screen_width = Math.abs(screen_x2 - screen_x1);
+    const screen_height = Math.abs(screen_y2 - screen_y1);
+    const fonts_config = config?.fonts || default_config.fonts;
+    const highlight_config = config?.highlight_annotation || default_config.highlight_annotation;
+    const square_config = config?.square_annotation || default_config.square_annotation;
+    const freetext_config = config?.freetext_annotation || default_config.freetext_annotation;
+    const hex_to_rgba = (hex, opacity) => {
+      const r = parseInt(hex.slice(1, 3), 16);
+      const g = parseInt(hex.slice(3, 5), 16);
+      const b = parseInt(hex.slice(5, 7), 16);
+      return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+    };
+    if (annotation.type === "FreeText") {
+      const text = annotation.contents || "";
+      if (!text) return null;
+      let stamp_styling = null;
+      if (annotation.subject) {
+        try {
+          const parsed = JSON.parse(annotation.subject);
+          if (parsed && parsed.stamp_name) {
+            stamp_styling = parsed;
+          }
+        } catch (e) {
+        }
+      }
+      const font_size = stamp_styling?.font_size !== void 0 ? stamp_styling.font_size : fonts_config.freetext_font_size_default;
+      const text_color = stamp_styling?.font_color || annotation.color || (freetext_config.freetext_text_color && freetext_config.freetext_text_color !== "#000000" ? freetext_config.freetext_text_color : fonts_config.font_foreground_color) || "#000000";
+      const font_family = stamp_styling?.font_name || fonts_config.freetext_font_family;
+      const font_weight = stamp_styling?.font_weight !== void 0 ? stamp_styling.font_weight : freetext_config.freetext_font_weight;
+      const font_style = stamp_styling?.font_style !== void 0 ? stamp_styling.font_style : freetext_config.freetext_font_style;
+      const padding_h = freetext_config.freetext_padding_horizontal;
+      const padding_v = freetext_config.freetext_padding_vertical;
+      const text_lines = text.split("\n");
+      const max_line_length = Math.max(...text_lines.map((line) => line.length), 1);
+      const text_width_estimate = font_size * 0.6 * max_line_length;
+      const box_width = text_width_estimate + padding_h * 2;
+      const box_height = font_size * text_lines.length + padding_v * 2;
+      const box_x = screen_x1;
+      const box_y = screen_y1;
+      const text_x = box_x + padding_h;
+      const text_y = box_y + padding_v + font_size;
+      const border_size = stamp_styling?.border_size !== void 0 ? stamp_styling.border_size : freetext_config.freetext_border_width;
+      const border_color_trimmed = freetext_config.freetext_border_color?.trim() || "";
+      const has_border = border_size > 0 && border_color_trimmed !== "";
+      const background_color_trimmed = (stamp_styling?.background_color !== void 0 ? String(stamp_styling.background_color) : freetext_config.freetext_background_color)?.trim() || "";
+      const has_background = background_color_trimmed !== "";
+      const hex_to_rgba_bg = (color_str, opacity) => {
+        if (!color_str || color_str === "") return "transparent";
+        const trimmed = color_str.trim();
+        const rgb_pattern = /^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i;
+        const rgb_match = trimmed.match(rgb_pattern);
+        if (rgb_match) {
+          const r = parseInt(rgb_match[1], 10);
+          const g = parseInt(rgb_match[2], 10);
+          const b = parseInt(rgb_match[3], 10);
+          if (r >= 0 && r <= 255 && g >= 0 && g <= 255 && b >= 0 && b <= 255) {
+            return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+          }
+          console.warn(`[FreeText] Invalid RGB values: r=${r}, g=${g}, b=${b} (must be 0-255)`);
+          return "transparent";
+        }
+        if (trimmed.startsWith("#")) {
+          const hex = trimmed.slice(1).trim();
+          if (hex.length === 6 && /^[0-9A-Fa-f]{6}$/.test(hex)) {
+            const r = parseInt(hex.slice(0, 2), 16);
+            const g = parseInt(hex.slice(2, 4), 16);
+            const b = parseInt(hex.slice(4, 6), 16);
+            return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+          }
+          console.warn(`[FreeText] Invalid hex color format: ${trimmed}`);
+          return "transparent";
+        }
+        console.warn(`[FreeText] Unrecognized color format: ${trimmed}`);
+        return "transparent";
+      };
+      return /* @__PURE__ */ jsxs("g", { children: [
+        has_background && /* @__PURE__ */ jsx2(
+          "rect",
+          {
+            x: box_x,
+            y: box_y,
+            width: box_width,
+            height: box_height,
+            fill: hex_to_rgba_bg(background_color_trimmed, freetext_config.freetext_background_opacity),
+            pointerEvents: "none"
+          }
+        ),
+        has_border && /* @__PURE__ */ jsx2(
+          "rect",
+          {
+            x: box_x,
+            y: box_y,
+            width: box_width,
+            height: box_height,
+            fill: "none",
+            stroke: border_color_trimmed,
+            strokeWidth: border_size,
+            pointerEvents: "none"
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "rect",
+          {
+            x: box_x,
+            y: box_y,
+            width: box_width,
+            height: box_height,
+            fill: "transparent",
+            stroke: "none",
+            pointerEvents: "auto",
+            style: { cursor: "pointer" },
+            onMouseEnter: () => {
+              setHoveredAnnotationId(annotation.id);
+              if (svg_ref.current) {
+                svg_ref.current.style.cursor = "pointer";
+              }
+            },
+            onMouseLeave: () => {
+              setHoveredAnnotationId(null);
+              if (svg_ref.current) {
+                if (current_tool === null) {
+                  svg_ref.current.style.cursor = "inherit";
+                } else {
+                  svg_ref.current.style.cursor = current_tool ? "crosshair" : "default";
+                }
+              }
+            },
+            onMouseDown: (e) => {
+              if (e.button !== 0) return;
+              e.nativeEvent.__annotation_clicked = annotation.id;
+              e.nativeEvent.__annotation_click_source = "freetext_rect";
+              e.stopPropagation();
+              e.nativeEvent.stopImmediatePropagation();
+              if (on_annotation_click) {
+                const rect = svg_ref.current?.getBoundingClientRect();
+                if (!rect) return;
+                const click_x = e.clientX - rect.left;
+                const click_y = e.clientY - rect.top;
+                log_annotation_click(annotation, "freetext_rect", { x: click_x, y: click_y });
+                on_annotation_click(annotation, click_x, click_y);
+              }
+            },
+            onClick: (e) => {
+              e.preventDefault();
+              e.stopPropagation();
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "text",
+          {
+            x: text_x,
+            y: text_y,
+            fontSize: font_size,
+            fill: text_color,
+            pointerEvents: "none",
+            style: {
+              fontFamily: font_family,
+              fontWeight: font_weight,
+              fontStyle: font_style,
+              textDecoration: freetext_config.freetext_text_decoration,
+              userSelect: "none"
+            },
+            children: text.split("\n").map((line, line_index) => /* @__PURE__ */ jsx2(
+              "tspan",
+              {
+                x: text_x,
+                dy: line_index === 0 ? 0 : font_size,
+                children: line
+              },
+              line_index
+            ))
+          }
+        )
+      ] }, annotation.id);
+    }
+    const get_annotation_props = () => {
+      switch (annotation.type) {
+        case "Highlight":
+          const highlight_color = annotation.color || highlight_config.highlight_fill_color;
+          return {
+            fill: hex_to_rgba(highlight_color, highlight_config.highlight_fill_opacity),
+            stroke: highlight_config.highlight_border_color
+          };
+        case "Square":
+          const square_color = annotation.color || square_config.square_fill_color;
+          return {
+            fill: hex_to_rgba(square_color, square_config.square_fill_opacity),
+            stroke: square_config.square_border_color
+          };
+        default:
+          return {
+            fill: "rgba(0, 0, 255, 0.2)",
+            stroke: "#0000FF"
+          };
+      }
+    };
+    const { fill, stroke } = get_annotation_props();
+    return /* @__PURE__ */ jsxs("g", { children: [
+      /* @__PURE__ */ jsx2(
+        "rect",
+        {
+          x: screen_x,
+          y: screen_y,
+          width: screen_width,
+          height: screen_height,
+          fill: "transparent",
+          stroke: "none",
+          pointerEvents: "auto",
+          style: { cursor: "pointer" },
+          onMouseEnter: () => {
+            setHoveredAnnotationId(annotation.id);
+            if (svg_ref.current) {
+              svg_ref.current.style.cursor = "pointer";
+            }
+          },
+          onMouseLeave: () => {
+            setHoveredAnnotationId(null);
+            if (svg_ref.current) {
+              if (current_tool === null) {
+                svg_ref.current.style.cursor = "inherit";
+              } else {
+                svg_ref.current.style.cursor = current_tool ? "crosshair" : "default";
+              }
+            }
+          },
+          onMouseDown: (e) => {
+            if (e.button !== 0) return;
+            e.nativeEvent.__annotation_clicked = annotation.id;
+            e.nativeEvent.__annotation_click_source = "rect_overlay";
+            e.stopPropagation();
+            e.nativeEvent.stopImmediatePropagation();
+            if (on_annotation_click) {
+              const rect = svg_ref.current?.getBoundingClientRect();
+              if (!rect) return;
+              const click_x = e.clientX - rect.left;
+              const click_y = e.clientY - rect.top;
+              log_annotation_click(annotation, "rect_overlay", { x: click_x, y: click_y });
+              on_annotation_click(annotation, click_x, click_y);
+            }
+          },
+          onClick: (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx2(
+        "rect",
+        {
+          x: screen_x,
+          y: screen_y,
+          width: screen_width,
+          height: screen_height,
+          stroke,
+          strokeWidth: "2",
+          fill,
+          pointerEvents: "none"
+        }
+      )
+    ] }, annotation.id);
+  };
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      ref: svg_ref,
+      className: cn("cls_annotation_overlay", className),
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width,
+        height,
+        // Cursor will be dynamically updated by onMouseEnter/Leave on annotations
+        // Default: In pan mode, inherit cursor from parent (grab/grabbing)
+        // In annotation mode, show crosshair
+        cursor: hovered_annotation_id ? "pointer" : current_tool === null ? "inherit" : current_tool ? "crosshair" : "default",
+        // Always allow pointer events so context menu (right-click) and annotation clicks work
+        // Left-click panning is handled by returning early in handle_mouse_down
+        pointerEvents: "auto",
+        zIndex: 10
+        // Ensure annotations are above the canvas but below dialogs
+      },
+      width,
+      height,
+      onMouseDown: handle_mouse_down,
+      onMouseMove: handle_mouse_move,
+      onMouseUp: handle_mouse_up,
+      onMouseLeave: () => {
+        setHoveredAnnotationId(null);
+        handle_mouse_leave();
+      },
+      onContextMenu: handle_context_menu,
+      children: [
+        page_annotations.map(render_annotation),
+        is_drawing && /* @__PURE__ */ jsx2(
+          TempDrawBox,
+          {
+            start: start_point,
+            current: current_point,
+            tool_type: current_tool || "Square",
+            config
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/pdf_viewer/pdf_viewer_layout.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var PdfViewerLayout = ({
+  pdf_document,
+  scale,
+  annotations = [],
+  current_tool = "Square",
+  on_annotation_create,
+  on_context_menu,
+  on_annotation_click,
+  background_color = "#2d2d2d",
+  config = null,
+  className = ""
+}) => {
+  const [pages, setPages] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [coordinate_mappers, setCoordinateMappers] = useState2(/* @__PURE__ */ new Map());
+  const container_ref = useRef3(null);
+  const has_centered_ref = useRef3(false);
+  const [is_panning, setIsPanning] = useState2(false);
+  const pan_start_ref = useRef3(null);
+  useEffect2(() => {
+    if (!pdf_document) {
+      return;
+    }
+    setLoading(true);
+    const num_pages = pdf_document.numPages;
+    const page_promises = [];
+    for (let i = 1; i <= num_pages; i++) {
+      page_promises.push(pdf_document.getPage(i));
+    }
+    Promise.all(page_promises).then((loaded_pages) => {
+      setPages(loaded_pages);
+      setLoading(false);
+      has_centered_ref.current = false;
+    }).catch((error) => {
+      console.error("[PdfViewerLayout] Error loading PDF pages:", error);
+      setLoading(false);
+    });
+  }, [pdf_document]);
+  const handle_coordinate_mapper_ready = useCallback((page_index, mapper, dimensions) => {
+    setCoordinateMappers((prev) => {
+      const existing = prev.get(page_index);
+      if (existing && existing.dimensions.width === dimensions.width && existing.dimensions.height === dimensions.height) {
+        return prev;
+      }
+      const new_map = new Map(prev);
+      new_map.set(page_index, { mapper, dimensions });
+      return new_map;
+    });
+  }, []);
+  useEffect2(() => {
+    if (loading || pages.length === 0 || coordinate_mappers.size === 0 || has_centered_ref.current) {
+      return;
+    }
+    const timeout_id = setTimeout(() => {
+      if (container_ref.current) {
+        const container = container_ref.current;
+        const scroll_width = container.scrollWidth;
+        const client_width = container.clientWidth;
+        if (scroll_width > client_width) {
+          const center_scroll = (scroll_width - client_width) / 2;
+          container.scrollLeft = center_scroll;
+          has_centered_ref.current = true;
+        } else {
+          has_centered_ref.current = true;
+        }
+      }
+    }, 100);
+    return () => {
+      clearTimeout(timeout_id);
+    };
+  }, [loading, pages.length, coordinate_mappers.size]);
+  const handle_mouse_down = useCallback((e) => {
+    if (e.button !== 0) return;
+    const native_event = e.nativeEvent;
+    if (native_event?.__annotation_clicked) {
+      console.log(
+        `\u{1F7E2} [AnnotationClick] layout received marker id=${native_event.__annotation_clicked}, source=${native_event.__annotation_click_source || "unknown"}`
+      );
+      return;
+    }
+    if (current_tool !== null) return;
+    if (container_ref.current) {
+      setIsPanning(true);
+      pan_start_ref.current = {
+        x: e.clientX,
+        y: e.clientY,
+        scrollLeft: container_ref.current.scrollLeft,
+        scrollTop: container_ref.current.scrollTop
+      };
+      e.preventDefault();
+      e.stopPropagation();
+      container_ref.current.style.cursor = "grabbing";
+    }
+  }, [current_tool]);
+  const handle_mouse_move = useCallback((e) => {
+    if (!is_panning || !pan_start_ref.current || !container_ref.current) return;
+    e.preventDefault();
+    const delta_x = pan_start_ref.current.x - e.clientX;
+    const delta_y = pan_start_ref.current.y - e.clientY;
+    const max_scroll_left = Math.max(0, container_ref.current.scrollWidth - container_ref.current.clientWidth);
+    const max_scroll_top = Math.max(0, container_ref.current.scrollHeight - container_ref.current.clientHeight);
+    const new_scroll_left = Math.max(0, Math.min(max_scroll_left, pan_start_ref.current.scrollLeft + delta_x));
+    const new_scroll_top = Math.max(0, Math.min(max_scroll_top, pan_start_ref.current.scrollTop + delta_y));
+    container_ref.current.scrollLeft = new_scroll_left;
+    container_ref.current.scrollTop = new_scroll_top;
+  }, [is_panning]);
+  const handle_mouse_up = useCallback(() => {
+    if (container_ref.current) {
+      container_ref.current.style.cursor = current_tool === null ? "grab" : "default";
+    }
+    setIsPanning(false);
+    pan_start_ref.current = null;
+  }, [current_tool]);
+  useEffect2(() => {
+    if (container_ref.current) {
+      if (current_tool === null) {
+        container_ref.current.style.cursor = is_panning ? "grabbing" : "grab";
+      } else {
+        container_ref.current.style.cursor = "default";
+      }
+    }
+  }, [current_tool, is_panning]);
+  useEffect2(() => {
+    if (is_panning) {
+      window.addEventListener("mousemove", handle_mouse_move);
+      window.addEventListener("mouseup", handle_mouse_up);
+      return () => {
+        window.removeEventListener("mousemove", handle_mouse_move);
+        window.removeEventListener("mouseup", handle_mouse_up);
+      };
+    }
+    return void 0;
+  }, [is_panning, handle_mouse_move, handle_mouse_up]);
+  if (loading) {
+    return /* @__PURE__ */ jsx3("div", { className: cn("cls_pdf_viewer_loading", className), children: /* @__PURE__ */ jsx3("div", { className: "cls_pdf_viewer_spinner", children: "Loading PDF..." }) });
+  }
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref: container_ref,
+      className: cn("cls_pdf_viewer_layout", className),
+      style: {
+        // Don't constrain width/height - let content determine size
+        // This allows container to expand beyond viewport when zoomed
+        position: "relative",
+        backgroundColor: background_color,
+        // Cursor is managed dynamically - default to grab in pan mode, but annotations will override
+        cursor: current_tool === null ? is_panning ? "grabbing" : "grab" : "default",
+        userSelect: is_panning ? "none" : "auto",
+        // Allow both horizontal and vertical scrolling
+        overflow: "auto",
+        overflowX: "auto",
+        overflowY: "auto",
+        // Container must be viewport size (100%) to create scrollable area
+        // Content inside (pages_container) expands beyond this to enable scrolling
+        width: "100%",
+        height: "100%",
+        // Don't constrain content expansion
+        minWidth: 0,
+        minHeight: 0
+      },
+      onMouseDown: handle_mouse_down,
+      onMouseMove: (e) => {
+        const target = e.target;
+        if (target.closest("svg.cls_annotation_overlay") || target.closest('rect[style*="cursor: pointer"]')) {
+          return;
+        }
+        if (container_ref.current && current_tool === null && !is_panning) {
+          container_ref.current.style.cursor = "grab";
+        }
+      },
+      children: /* @__PURE__ */ jsx3("div", { className: "cls_pdf_viewer_pages_container", children: pages.map((page, index) => {
+        const mapper_data = coordinate_mappers.get(index);
+        const page_annotations = annotations?.filter(
+          (ann) => ann.page_index === index
+        ) || [];
+        return /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            className: "cls_pdf_viewer_page_wrapper",
+            style: {
+              position: "relative",
+              marginBottom: "20px",
+              display: "flex",
+              justifyContent: "center",
+              // Inherit cursor from parent (grab/grabbing in pan mode)
+              cursor: "inherit",
+              // Ensure page wrapper doesn't constrain width
+              width: "auto",
+              minWidth: "fit-content"
+            },
+            children: [
+              /* @__PURE__ */ jsx3(
+                PdfPageRenderer,
+                {
+                  page,
+                  page_index: index,
+                  scale,
+                  config,
+                  on_coordinate_mapper_ready: (mapper, dimensions) => handle_coordinate_mapper_ready(index, mapper, dimensions)
+                }
+              ),
+              mapper_data && /* @__PURE__ */ jsx3(
+                AnnotationOverlay,
+                {
+                  width: mapper_data.dimensions.width,
+                  height: mapper_data.dimensions.height,
+                  page_index: index,
+                  map_coords: mapper_data.mapper,
+                  annotations: page_annotations,
+                  current_tool,
+                  config,
+                  on_annotation_create,
+                  on_context_menu: (e, screen_x, screen_y) => {
+                    if (on_context_menu && mapper_data.mapper) {
+                      on_context_menu(e, index, screen_x, screen_y, mapper_data.mapper);
+                    }
+                  },
+                  on_annotation_click: (annotation, screen_x, screen_y) => {
+                    if (on_annotation_click && mapper_data.mapper) {
+                      on_annotation_click(annotation, screen_x, screen_y, mapper_data.mapper);
+                    }
+                  }
+                }
+              )
+            ]
+          },
+          index
+        );
+      }) })
+    }
+  );
+};
+
+// src/components/pdf_viewer/context_menu.tsx
+import { useEffect as useEffect3, useRef as useRef4, useState as useState3 } from "react";
+import { createPortal } from "react-dom";
+import { Undo2, FileText } from "lucide-react";
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var ContextMenu = ({
+  x,
+  y,
+  can_undo = false,
+  on_undo,
+  on_annotate,
+  on_close,
+  config = null,
+  custom_stamps = [],
+  on_stamp_click
+}) => {
+  const menu_ref = useRef4(null);
+  const render_count_ref = useRef4(0);
+  const [adjusted_position, setAdjustedPosition] = useState3({ x, y });
+  const props_received_time_ref = useRef4(performance.now());
+  const [mounted, setMounted] = useState3(false);
+  useEffect3(() => {
+    setMounted(true);
+    return () => setMounted(false);
+  }, []);
+  useEffect3(() => {
+    props_received_time_ref.current = performance.now();
+  }, [x, y]);
+  useEffect3(() => {
+    render_count_ref.current += 1;
+    if (menu_ref.current && mounted) {
+      const rect = menu_ref.current.getBoundingClientRect();
+      const actual_x = x;
+      const actual_y = y;
+      const menu_element = menu_ref.current;
+      const positioned_ancestors = [];
+      let current = menu_element.parentElement;
+      while (current && current !== document.body && current !== document.documentElement) {
+        const style = window.getComputedStyle(current);
+        const position = style.position;
+        if (position === "fixed" || position === "absolute" || position === "relative" || position === "sticky") {
+          positioned_ancestors.push({
+            element: current,
+            boundingRect: current.getBoundingClientRect(),
+            computedStyle: style
+          });
+        }
+        current = current.parentElement;
+      }
+      const parent_transforms = [];
+      let check = menu_element.parentElement;
+      while (check && check !== document.body) {
+        const style = window.getComputedStyle(check);
+        const transform = style.transform;
+        if (transform && transform !== "none") {
+          parent_transforms.push({
+            element: check,
+            transform
+          });
+        }
+        check = check.parentElement;
+      }
+      const x_offset = rect.left - x;
+      const y_offset = rect.top - y;
+      const position_correct = Math.abs(x_offset) < 1 && Math.abs(y_offset) < 1;
+      const parent_transform_count = parent_transforms.length;
+      const positioned_ancestor_count = positioned_ancestors.length;
+      console.log(`\u{1F7E1} [ContextMenu] Position debug: render=${render_count_ref.current}, expected=(${x}, ${y}), actual=(${rect.left.toFixed(1)}, ${rect.top.toFixed(1)}), offset=(${x_offset.toFixed(1)}, ${y_offset.toFixed(1)}), correct=${position_correct}, ancestors=${positioned_ancestor_count}, transforms=${parent_transform_count}`);
+      const bottom_left_x = rect.left;
+      const bottom_left_y = rect.bottom;
+      const tolerance = 5;
+      const offset_x = 0;
+      const offset_y = 0;
+      if (Math.abs(bottom_left_x - x) < tolerance && Math.abs(bottom_left_y - y) < tolerance) {
+        console.log("[ContextMenu] Detected bottom-left positioning, adjusting to top-left");
+        setAdjustedPosition({
+          x: actual_x + offset_x,
+          y: actual_y + offset_y - rect.height
+        });
+      } else {
+        setAdjustedPosition({
+          x: actual_x + offset_x,
+          y: actual_y + offset_y
+        });
+      }
+    }
+  }, [x, y, mounted]);
+  const handle_item_click = (callback) => {
+    if (callback) {
+      callback();
+    }
+    if (on_close) {
+      on_close();
+    }
+  };
+  console.log(`\u26AA [ContextMenu] Render call: render=${render_count_ref.current}, props=(${x}, ${y}), adjusted=(${adjusted_position.x}, ${adjusted_position.y}), mounted=${mounted}`);
+  if (!mounted) {
+    return null;
+  }
+  const handle_mouse_leave = () => {
+    if (on_close) {
+      on_close();
+    }
+  };
+  const menu_config = config?.context_menu || default_config.context_menu;
+  const menu_content = /* @__PURE__ */ jsx4(
+    "div",
+    {
+      ref: menu_ref,
+      className: "cls_pdf_viewer_context_menu",
+      style: {
+        position: "fixed",
+        left: `${adjusted_position.x}px`,
+        top: `${adjusted_position.y}px`,
+        zIndex: 1e4,
+        backgroundColor: menu_config.context_menu_background_color,
+        borderColor: menu_config.context_menu_border_color
+      },
+      onClick: (e) => e.stopPropagation(),
+      onContextMenu: (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+      },
+      onMouseLeave: handle_mouse_leave,
+      children: /* @__PURE__ */ jsxs3("div", { className: "cls_pdf_viewer_context_menu_items", children: [
+        /* @__PURE__ */ jsxs3(
+          "button",
+          {
+            type: "button",
+            onClick: () => handle_item_click(on_undo),
+            disabled: !can_undo,
+            className: cn(
+              "cls_pdf_viewer_context_menu_item",
+              !can_undo && "cls_pdf_viewer_context_menu_item_disabled"
+            ),
+            style: {
+              opacity: !can_undo ? menu_config.context_menu_item_disabled_opacity : 1
+            },
+            onMouseEnter: (e) => {
+              if (can_undo) {
+                e.currentTarget.style.backgroundColor = menu_config.context_menu_item_hover_background;
+              }
+            },
+            onMouseLeave: (e) => {
+              e.currentTarget.style.backgroundColor = "transparent";
+            },
+            "aria-label": "Undo",
+            children: [
+              /* @__PURE__ */ jsx4(Undo2, { className: "cls_pdf_viewer_context_menu_icon", size: 16 }),
+              /* @__PURE__ */ jsx4("span", { className: "cls_pdf_viewer_context_menu_text", children: "Undo" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs3(
+          "button",
+          {
+            type: "button",
+            onClick: () => handle_item_click(on_annotate),
+            className: "cls_pdf_viewer_context_menu_item",
+            onMouseEnter: (e) => {
+              e.currentTarget.style.backgroundColor = menu_config.context_menu_item_hover_background;
+            },
+            onMouseLeave: (e) => {
+              e.currentTarget.style.backgroundColor = "transparent";
+            },
+            "aria-label": "Annotate",
+            children: [
+              /* @__PURE__ */ jsx4(FileText, { className: "cls_pdf_viewer_context_menu_icon", size: 16 }),
+              /* @__PURE__ */ jsx4("span", { className: "cls_pdf_viewer_context_menu_text", children: "Annotate" })
+            ]
+          }
+        ),
+        custom_stamps.length > 0 && /* @__PURE__ */ jsxs3(Fragment, { children: [
+          /* @__PURE__ */ jsx4(
+            "div",
+            {
+              style: {
+                height: "1px",
+                backgroundColor: menu_config.context_menu_border_color,
+                margin: "4px 0"
+              }
+            }
+          ),
+          [...custom_stamps].sort((a, b) => a.order - b.order).map((stamp, index) => /* @__PURE__ */ jsxs3(
+            "button",
+            {
+              type: "button",
+              onClick: () => {
+                if (on_stamp_click) {
+                  on_stamp_click(stamp);
+                }
+                if (on_close) {
+                  on_close();
+                }
+              },
+              className: "cls_pdf_viewer_context_menu_item",
+              onMouseEnter: (e) => {
+                e.currentTarget.style.backgroundColor = menu_config.context_menu_item_hover_background;
+              },
+              onMouseLeave: (e) => {
+                e.currentTarget.style.backgroundColor = "transparent";
+              },
+              "aria-label": stamp.name,
+              children: [
+                /* @__PURE__ */ jsx4(FileText, { className: "cls_pdf_viewer_context_menu_icon", size: 16 }),
+                /* @__PURE__ */ jsx4("span", { className: "cls_pdf_viewer_context_menu_text", children: stamp.name })
+              ]
+            },
+            `${stamp.name}-${index}`
+          ))
+        ] })
+      ] })
+    }
+  );
+  return createPortal(menu_content, document.body);
+};
+
+// src/components/pdf_viewer/text_annotation_dialog.tsx
+import { useState as useState4, useEffect as useEffect4, useRef as useRef5 } from "react";
+import { createPortal as createPortal2 } from "react-dom";
+import { Check, X, Trash2 } from "lucide-react";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var TextAnnotationDialog = ({
+  open,
+  x,
+  y,
+  on_close,
+  on_submit,
+  on_delete,
+  initial_text = "",
+  is_editing = false,
+  config = null
+}) => {
+  const [text, setText] = useState4(initial_text);
+  const input_ref = useRef5(null);
+  const [mounted, setMounted] = useState4(false);
+  useEffect4(() => {
+    setMounted(true);
+    return () => setMounted(false);
+  }, []);
+  useEffect4(() => {
+    if (open) {
+      setText(initial_text);
+      setTimeout(() => {
+        input_ref.current?.focus();
+        input_ref.current?.select();
+      }, 0);
+    }
+  }, [open, initial_text]);
+  const handle_submit = (e) => {
+    if (e) {
+      e.preventDefault();
+    }
+    if (text.trim()) {
+      on_submit(text.trim());
+      setText("");
+      on_close();
+    }
+  };
+  const handle_cancel = () => {
+    setText("");
+    on_close();
+  };
+  const handle_delete = () => {
+    if (on_delete) {
+      on_delete();
+      setText("");
+      on_close();
+    }
+  };
+  useEffect4(() => {
+    const handle_keydown = (e) => {
+      if (!open) return;
+      if (e.key === "Escape") {
+        e.preventDefault();
+        handle_cancel();
+      } else if (e.key === "Enter" && !e.shiftKey) {
+        e.preventDefault();
+        handle_submit();
+      }
+    };
+    if (open) {
+      window.addEventListener("keydown", handle_keydown);
+      return () => {
+        window.removeEventListener("keydown", handle_keydown);
+      };
+    }
+    return void 0;
+  }, [open, text]);
+  if (!open || !mounted) {
+    return null;
+  }
+  const dialog_config = config?.dialog || default_config.dialog;
+  const dialog_content = /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    /* @__PURE__ */ jsx5(
+      "div",
+      {
+        className: "cls_pdf_viewer_dialog_backdrop",
+        onClick: handle_cancel,
+        "aria-hidden": "true",
+        style: {
+          backgroundColor: `rgba(0, 0, 0, ${dialog_config.dialog_backdrop_opacity})`
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      "div",
+      {
+        className: "cls_pdf_viewer_text_dialog",
+        role: "dialog",
+        "aria-modal": "true",
+        style: {
+          position: "fixed",
+          left: `${x}px`,
+          top: `${y}px`,
+          zIndex: 10001,
+          // Higher than context menu
+          backgroundColor: dialog_config.dialog_background_color,
+          borderColor: dialog_config.dialog_border_color
+        },
+        onClick: (e) => e.stopPropagation(),
+        children: /* @__PURE__ */ jsxs4("form", { onSubmit: handle_submit, className: "cls_pdf_viewer_dialog_form", children: [
+          /* @__PURE__ */ jsx5(
+            "input",
+            {
+              ref: input_ref,
+              type: "text",
+              value: text,
+              onChange: (e) => setText(e.target.value),
+              className: "cls_pdf_viewer_dialog_input",
+              placeholder: "Enter annotation text...",
+              autoFocus: true
+            }
+          ),
+          /* @__PURE__ */ jsxs4("div", { className: "cls_pdf_viewer_dialog_buttons", children: [
+            is_editing && on_delete && /* @__PURE__ */ jsx5(
+              "button",
+              {
+                type: "button",
+                onClick: handle_delete,
+                className: cn(
+                  "cls_pdf_viewer_dialog_button",
+                  "cls_pdf_viewer_dialog_button_delete"
+                ),
+                style: {
+                  color: dialog_config.dialog_button_cancel_color
+                },
+                onMouseEnter: (e) => {
+                  e.currentTarget.style.color = dialog_config.dialog_button_cancel_color_hover;
+                },
+                onMouseLeave: (e) => {
+                  e.currentTarget.style.color = dialog_config.dialog_button_cancel_color;
+                },
+                "aria-label": "Delete annotation",
+                title: "Delete annotation",
+                children: /* @__PURE__ */ jsx5(Trash2, { size: 14 })
+              }
+            ),
+            /* @__PURE__ */ jsx5(
+              "button",
+              {
+                type: "button",
+                onClick: handle_cancel,
+                className: cn(
+                  "cls_pdf_viewer_dialog_button",
+                  "cls_pdf_viewer_dialog_button_cancel"
+                ),
+                style: {
+                  color: dialog_config.dialog_button_cancel_color
+                },
+                onMouseEnter: (e) => {
+                  e.currentTarget.style.color = dialog_config.dialog_button_cancel_color_hover;
+                },
+                onMouseLeave: (e) => {
+                  e.currentTarget.style.color = dialog_config.dialog_button_cancel_color;
+                },
+                "aria-label": "Cancel",
+                title: "Cancel (Esc)",
+                children: /* @__PURE__ */ jsx5(X, { size: 14 })
+              }
+            ),
+            /* @__PURE__ */ jsx5(
+              "button",
+              {
+                type: "submit",
+                disabled: !text.trim(),
+                className: cn(
+                  "cls_pdf_viewer_dialog_button",
+                  "cls_pdf_viewer_dialog_button_submit",
+                  !text.trim() && "cls_pdf_viewer_dialog_button_disabled"
+                ),
+                style: {
+                  color: !text.trim() ? void 0 : dialog_config.dialog_button_submit_color,
+                  opacity: !text.trim() ? dialog_config.dialog_button_disabled_opacity : 1
+                },
+                onMouseEnter: (e) => {
+                  if (text.trim()) {
+                    e.currentTarget.style.color = dialog_config.dialog_button_submit_color_hover;
+                  }
+                },
+                onMouseLeave: (e) => {
+                  if (text.trim()) {
+                    e.currentTarget.style.color = dialog_config.dialog_button_submit_color;
+                  }
+                },
+                "aria-label": "Submit",
+                title: "Submit (Enter)",
+                children: /* @__PURE__ */ jsx5(Check, { size: 14 })
+              }
+            )
+          ] })
+        ] })
+      }
+    )
+  ] });
+  return createPortal2(dialog_content, document.body);
+};
+
+// src/utils/config_loader.ts
+function parse_ini_browser(ini_text) {
+  const result = {};
+  let current_section = "";
+  const lines = ini_text.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const section_match = trimmed.match(/^\[([^\]]+)\]$/);
+    if (section_match) {
+      current_section = section_match[1].trim();
+      if (!result[current_section]) {
+        result[current_section] = {};
+      }
+      continue;
+    }
+    const key_value_match = trimmed.match(/^([^=]+)=(.*)$/);
+    if (key_value_match && current_section) {
+      const key = key_value_match[1].trim();
+      const value = key_value_match[2].trim();
+      result[current_section][key] = value;
+    }
+  }
+  return result;
+}
+async function load_config_browser(config_file) {
+  try {
+    const config_url = config_file === "hazo_pdf_config.ini" || config_file.includes("hazo_pdf_config.ini") ? "/api/config" : config_file;
+    const response = await fetch(config_url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch config file: ${response.status} ${response.statusText}`);
+    }
+    const ini_text = await response.text();
+    const parsed = parse_ini_browser(ini_text);
+    console.log("[ConfigLoader] Parsed config sections:", Object.keys(parsed));
+    if (parsed["fonts"]) {
+      console.log("[ConfigLoader] fonts section:", parsed["fonts"]);
+    }
+    if (parsed["freetext_annotation"]) {
+      console.log("[ConfigLoader] freetext_annotation section:", parsed["freetext_annotation"]);
+    }
+    if (parsed["viewer"]) {
+      console.log("[ConfigLoader] viewer section:", parsed["viewer"]);
+    } else {
+      console.warn("[ConfigLoader] viewer section NOT found in parsed config!");
+    }
+    const get_value = (section, key) => {
+      return parsed[section]?.[key];
+    };
+    const config = build_config_from_ini(get_value);
+    console.log("[ConfigLoader] Final config values:");
+    console.log("  font_foreground_color:", config.fonts.font_foreground_color);
+    console.log("  freetext_text_color:", config.freetext_annotation.freetext_text_color);
+    console.log("  freetext_background_color:", config.freetext_annotation.freetext_background_color);
+    console.log("  freetext_background_opacity:", config.freetext_annotation.freetext_background_opacity);
+    console.log("  append_timestamp_to_text_edits:", config.viewer.append_timestamp_to_text_edits);
+    console.log("  annotation_text_suffix_fixed_text:", config.viewer.annotation_text_suffix_fixed_text);
+    const raw_value = get_value("viewer", "append_timestamp_to_text_edits");
+    console.log("[ConfigLoader] append_timestamp_to_text_edits:");
+    console.log("  raw_value from INI:", raw_value, "(type:", typeof raw_value, ")");
+    console.log("  parsed boolean:", config.viewer.append_timestamp_to_text_edits);
+    console.log("  parse_boolean test:", parse_boolean(raw_value, false));
+    if (parsed["viewer"]) {
+      console.log("[ConfigLoader] All viewer section keys:", Object.keys(parsed["viewer"]));
+      console.log("[ConfigLoader] All viewer section values:", parsed["viewer"]);
+    }
+    return config;
+  } catch (error) {
+    console.warn(`[ConfigLoader] Could not load config file "${config_file}" in browser, using defaults:`, error);
+    return default_config;
+  }
+}
+async function load_pdf_config_async(config_file) {
+  const is_browser = typeof window !== "undefined" && typeof fetch !== "undefined";
+  if (is_browser) {
+    return load_config_browser(config_file);
+  }
+  try {
+    const { HazoConfig } = __require("hazo_config");
+    const hazo_config = new HazoConfig({ filePath: config_file });
+    console.log(`[ConfigLoader] Using hazo_config to load: ${config_file}`);
+    const get_value = (section, key) => {
+      return hazo_config.get(section, key);
+    };
+    const config = build_config_from_ini(get_value);
+    console.log(`[ConfigLoader] Successfully loaded config using hazo_config from: ${config_file}`);
+    return config;
+  } catch (error) {
+    console.warn(
+      `[ConfigLoader] Could not load config file "${config_file}" using hazo_config, using defaults:`,
+      error instanceof Error ? error.message : String(error)
+    );
+    return default_config;
+  }
+}
+function build_config_from_ini(get_value) {
+  return {
+    fonts: {
+      freetext_font_family: parse_string(
+        get_value("fonts", "freetext_font_family"),
+        default_config.fonts.freetext_font_family
+      ),
+      freetext_font_size_min: parse_number(
+        get_value("fonts", "freetext_font_size_min"),
+        default_config.fonts.freetext_font_size_min
+      ),
+      freetext_font_size_max: parse_number(
+        get_value("fonts", "freetext_font_size_max"),
+        default_config.fonts.freetext_font_size_max
+      ),
+      freetext_font_size_default: parse_number(
+        get_value("fonts", "freetext_font_size_default"),
+        default_config.fonts.freetext_font_size_default
+      ),
+      font_foreground_color: parse_color(
+        get_value("fonts", "font_foreground_color"),
+        default_config.fonts.font_foreground_color
+      )
+    },
+    highlight_annotation: {
+      highlight_fill_color: parse_color(
+        get_value("highlight_annotation", "highlight_fill_color"),
+        default_config.highlight_annotation.highlight_fill_color
+      ),
+      highlight_fill_opacity: parse_opacity(
+        get_value("highlight_annotation", "highlight_fill_opacity"),
+        default_config.highlight_annotation.highlight_fill_opacity
+      ),
+      highlight_border_color: parse_color(
+        get_value("highlight_annotation", "highlight_border_color"),
+        default_config.highlight_annotation.highlight_border_color
+      ),
+      highlight_border_color_hover: parse_color(
+        get_value("highlight_annotation", "highlight_border_color_hover"),
+        default_config.highlight_annotation.highlight_border_color_hover
+      ),
+      highlight_fill_opacity_hover: parse_opacity(
+        get_value("highlight_annotation", "highlight_fill_opacity_hover"),
+        default_config.highlight_annotation.highlight_fill_opacity_hover
+      )
+    },
+    square_annotation: {
+      square_fill_color: parse_color(
+        get_value("square_annotation", "square_fill_color"),
+        default_config.square_annotation.square_fill_color
+      ),
+      square_fill_opacity: parse_opacity(
+        get_value("square_annotation", "square_fill_opacity"),
+        default_config.square_annotation.square_fill_opacity
+      ),
+      square_border_color: parse_color(
+        get_value("square_annotation", "square_border_color"),
+        default_config.square_annotation.square_border_color
+      ),
+      square_border_color_hover: parse_color(
+        get_value("square_annotation", "square_border_color_hover"),
+        default_config.square_annotation.square_border_color_hover
+      ),
+      square_fill_opacity_hover: parse_opacity(
+        get_value("square_annotation", "square_fill_opacity_hover"),
+        default_config.square_annotation.square_fill_opacity_hover
+      )
+    },
+    freetext_annotation: {
+      freetext_text_color: parse_color(
+        get_value("freetext_annotation", "freetext_text_color"),
+        default_config.freetext_annotation.freetext_text_color
+      ),
+      freetext_text_color_hover: parse_color(
+        get_value("freetext_annotation", "freetext_text_color_hover"),
+        default_config.freetext_annotation.freetext_text_color_hover
+      ),
+      freetext_border_color: parse_string(
+        get_value("freetext_annotation", "freetext_border_color"),
+        default_config.freetext_annotation.freetext_border_color
+      ),
+      freetext_border_width: parse_number(
+        get_value("freetext_annotation", "freetext_border_width"),
+        default_config.freetext_annotation.freetext_border_width
+      ),
+      freetext_background_color: (() => {
+        const raw_value = get_value("freetext_annotation", "freetext_background_color");
+        const parsed = parse_string(raw_value, default_config.freetext_annotation.freetext_background_color);
+        console.log(`[ConfigLoader] freetext_background_color: raw="${raw_value}", parsed="${parsed}"`);
+        return parsed;
+      })(),
+      freetext_background_opacity: parse_opacity(
+        get_value("freetext_annotation", "freetext_background_opacity"),
+        default_config.freetext_annotation.freetext_background_opacity
+      ),
+      freetext_font_weight: parse_string(
+        get_value("freetext_annotation", "freetext_font_weight"),
+        default_config.freetext_annotation.freetext_font_weight
+      ),
+      freetext_font_style: parse_string(
+        get_value("freetext_annotation", "freetext_font_style"),
+        default_config.freetext_annotation.freetext_font_style
+      ),
+      freetext_text_decoration: parse_string(
+        get_value("freetext_annotation", "freetext_text_decoration"),
+        default_config.freetext_annotation.freetext_text_decoration
+      ),
+      freetext_padding_horizontal: parse_number(
+        get_value("freetext_annotation", "freetext_padding_horizontal"),
+        default_config.freetext_annotation.freetext_padding_horizontal
+      ),
+      freetext_padding_vertical: parse_number(
+        get_value("freetext_annotation", "freetext_padding_vertical"),
+        default_config.freetext_annotation.freetext_padding_vertical
+      )
+    },
+    page_styling: {
+      page_border_color: parse_color(
+        get_value("page_styling", "page_border_color"),
+        default_config.page_styling.page_border_color
+      ),
+      page_box_shadow: parse_string(
+        get_value("page_styling", "page_box_shadow"),
+        default_config.page_styling.page_box_shadow
+      ),
+      page_background_color: parse_color(
+        get_value("page_styling", "page_background_color"),
+        default_config.page_styling.page_background_color
+      )
+    },
+    viewer: {
+      viewer_background_color: parse_color(
+        get_value("viewer", "viewer_background_color"),
+        default_config.viewer.viewer_background_color
+      ),
+      append_timestamp_to_text_edits: parse_boolean(
+        get_value("viewer", "append_timestamp_to_text_edits"),
+        default_config.viewer.append_timestamp_to_text_edits
+      ),
+      annotation_text_suffix_fixed_text: parse_string(
+        get_value("viewer", "annotation_text_suffix_fixed_text"),
+        default_config.viewer.annotation_text_suffix_fixed_text
+      ),
+      add_enclosing_brackets_to_suffixes: parse_boolean(
+        get_value("viewer", "add_enclosing_brackets_to_suffixes"),
+        default_config.viewer.add_enclosing_brackets_to_suffixes
+      ),
+      suffix_enclosing_brackets: (() => {
+        const raw_value = parse_string(
+          get_value("viewer", "suffix_enclosing_brackets"),
+          default_config.viewer.suffix_enclosing_brackets
+        );
+        if (raw_value.length === 2) {
+          return raw_value;
+        }
+        console.warn(
+          `[ConfigLoader] suffix_enclosing_brackets must be 2 characters, received "${raw_value}". Using default.`
+        );
+        return default_config.viewer.suffix_enclosing_brackets;
+      })(),
+      suffix_text_position: (() => {
+        const raw_value = parse_string(
+          get_value("viewer", "suffix_text_position"),
+          default_config.viewer.suffix_text_position
+        );
+        const valid_values = [
+          "adjacent",
+          "below_single_line",
+          "below_multi_line"
+        ];
+        if (valid_values.includes(raw_value)) {
+          return raw_value;
+        }
+        console.warn(
+          `[ConfigLoader] Invalid suffix_text_position "${raw_value}". Using default "${default_config.viewer.suffix_text_position}".`
+        );
+        return default_config.viewer.suffix_text_position;
+      })()
+    },
+    context_menu: {
+      context_menu_background_color: parse_color(
+        get_value("context_menu", "context_menu_background_color"),
+        default_config.context_menu.context_menu_background_color
+      ),
+      context_menu_border_color: parse_color(
+        get_value("context_menu", "context_menu_border_color"),
+        default_config.context_menu.context_menu_border_color
+      ),
+      context_menu_item_hover_background: parse_color(
+        get_value("context_menu", "context_menu_item_hover_background"),
+        default_config.context_menu.context_menu_item_hover_background
+      ),
+      context_menu_item_disabled_opacity: parse_opacity(
+        get_value("context_menu", "context_menu_item_disabled_opacity"),
+        default_config.context_menu.context_menu_item_disabled_opacity
+      ),
+      right_click_custom_stamps: parse_string(
+        get_value("context_menu", "right_click_custom_stamps"),
+        default_config.context_menu.right_click_custom_stamps
+      )
+    },
+    dialog: {
+      dialog_backdrop_opacity: parse_opacity(
+        get_value("dialog", "dialog_backdrop_opacity"),
+        default_config.dialog.dialog_backdrop_opacity
+      ),
+      dialog_background_color: parse_color(
+        get_value("dialog", "dialog_background_color"),
+        default_config.dialog.dialog_background_color
+      ),
+      dialog_border_color: parse_color(
+        get_value("dialog", "dialog_border_color"),
+        default_config.dialog.dialog_border_color
+      ),
+      dialog_button_submit_color: parse_color(
+        get_value("dialog", "dialog_button_submit_color"),
+        default_config.dialog.dialog_button_submit_color
+      ),
+      dialog_button_submit_color_hover: parse_color(
+        get_value("dialog", "dialog_button_submit_color_hover"),
+        default_config.dialog.dialog_button_submit_color_hover
+      ),
+      dialog_button_cancel_color: parse_color(
+        get_value("dialog", "dialog_button_cancel_color"),
+        default_config.dialog.dialog_button_cancel_color
+      ),
+      dialog_button_cancel_color_hover: parse_color(
+        get_value("dialog", "dialog_button_cancel_color_hover"),
+        default_config.dialog.dialog_button_cancel_color_hover
+      ),
+      dialog_button_disabled_opacity: parse_opacity(
+        get_value("dialog", "dialog_button_disabled_opacity"),
+        default_config.dialog.dialog_button_disabled_opacity
+      )
+    }
+  };
+}
+function parse_color(value, default_value) {
+  if (!value) return default_value;
+  if (/^#[0-9A-Fa-f]{6}$/.test(value)) {
+    return value;
+  }
+  if (value.startsWith("rgba") || value.startsWith("rgb")) {
+    return value;
+  }
+  console.warn(`[ConfigLoader] Invalid color format: ${value}, using default: ${default_value}`);
+  return default_value;
+}
+function parse_opacity(value, default_value) {
+  if (!value) return default_value;
+  const parsed = parseFloat(value);
+  if (!isNaN(parsed) && parsed >= 0 && parsed <= 1) {
+    return parsed;
+  }
+  console.warn(`[ConfigLoader] Invalid opacity value: ${value}, using default: ${default_value}`);
+  return default_value;
+}
+function parse_number(value, default_value) {
+  if (!value) return default_value;
+  const parsed = parseFloat(value);
+  if (!isNaN(parsed)) {
+    return parsed;
+  }
+  console.warn(`[ConfigLoader] Invalid number value: ${value}, using default: ${default_value}`);
+  return default_value;
+}
+function parse_string(value, default_value) {
+  return value || default_value;
+}
+function parse_boolean(value, default_value) {
+  if (!value) return default_value;
+  const lower = value.toLowerCase().trim();
+  if (lower === "true" || lower === "yes" || lower === "1") {
+    return true;
+  }
+  if (lower === "false" || lower === "no" || lower === "0") {
+    return false;
+  }
+  console.warn(`[ConfigLoader] Invalid boolean value: ${value}, using default: ${default_value}`);
+  return default_value;
+}
+function load_pdf_config(config_file) {
+  if (!config_file) {
+    console.log("[ConfigLoader] No config file specified, using defaults");
+    return default_config;
+  }
+  const is_browser = typeof window !== "undefined" && typeof fetch !== "undefined";
+  if (is_browser) {
+    console.warn("[ConfigLoader] Browser environment detected. Config loading should be async, but load_pdf_config is sync. Using defaults. Consider making this async or using a different approach.");
+    return default_config;
+  }
+  try {
+    const { HazoConfig } = __require("hazo_config");
+    const hazo_config = new HazoConfig({ filePath: config_file });
+    const get_value = (section, key) => {
+      return hazo_config.get(section, key);
+    };
+    const config = build_config_from_ini(get_value);
+    console.log(`[ConfigLoader] Successfully loaded config from: ${config_file}`);
+    return config;
+  } catch (error) {
+    console.warn(
+      `[ConfigLoader] Could not load config file "${config_file}", using defaults:`,
+      error instanceof Error ? error.message : String(error)
+    );
+    return default_config;
+  }
+}
+
+// src/components/pdf_viewer/pdf_viewer.tsx
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+var PdfViewer = ({
+  url,
+  className = "",
+  scale: initial_scale = 1,
+  on_load,
+  on_error,
+  annotations: initial_annotations = [],
+  on_annotation_create,
+  on_annotation_update,
+  on_annotation_delete,
+  on_save,
+  background_color,
+  config_file,
+  append_timestamp_to_text_edits,
+  annotation_text_suffix_fixed_text,
+  right_click_custom_stamps
+}) => {
+  const [pdf_document, setPdfDocument] = useState5(null);
+  const [loading, setLoading] = useState5(true);
+  const [error, setError] = useState5(null);
+  const [scale, setScale] = useState5(initial_scale);
+  const [annotations, setAnnotations] = useState5(initial_annotations);
+  const [current_tool, setCurrentTool] = useState5(null);
+  const [saving, setSaving] = useState5(false);
+  const config_ref = useRef6(null);
+  useEffect5(() => {
+    if (!config_file) {
+      config_ref.current = load_pdf_config();
+      return;
+    }
+    const is_browser = typeof window !== "undefined" && typeof fetch !== "undefined";
+    if (is_browser) {
+      load_pdf_config_async(config_file).then((config) => {
+        config_ref.current = config;
+        console.log("[PdfViewer] Config loaded:", {
+          append_timestamp_to_text_edits: config.viewer.append_timestamp_to_text_edits,
+          config_object: config
+        });
+      }).catch((error2) => {
+        console.warn(`[PdfViewer] Could not load config file "${config_file}", using defaults:`, error2);
+        config_ref.current = load_pdf_config();
+      });
+    } else {
+      config_ref.current = load_pdf_config(config_file);
+      console.log("[PdfViewer] Config loaded (Node.js):", {
+        append_timestamp_to_text_edits: config_ref.current?.viewer.append_timestamp_to_text_edits
+      });
+    }
+  }, [config_file]);
+  const effective_background_color = background_color || config_ref.current?.viewer.viewer_background_color || "#2d2d2d";
+  const format_annotation_timestamp = () => {
+    const now = /* @__PURE__ */ new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    let hours = now.getHours();
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    const am_pm = hours >= 12 ? "pm" : "am";
+    hours = hours % 12;
+    if (hours === 0) hours = 12;
+    return `${year}-${month}-${day} ${hours}:${minutes}${am_pm}`;
+  };
+  const parse_custom_stamps = (stamps_json) => {
+    if (!stamps_json || stamps_json.trim() === "") {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(stamps_json);
+      if (!Array.isArray(parsed)) {
+        console.warn("[PdfViewer] Custom stamps must be a JSON array");
+        return [];
+      }
+      return parsed.filter((stamp) => stamp && typeof stamp === "object").map((stamp) => ({
+        name: String(stamp.name || ""),
+        text: String(stamp.text || ""),
+        order: typeof stamp.order === "number" ? stamp.order : 999,
+        time_stamp_suffix_enabled: Boolean(stamp.time_stamp_suffix_enabled),
+        fixed_text_suffix_enabled: Boolean(stamp.fixed_text_suffix_enabled),
+        // Optional styling fields
+        background_color: stamp.background_color !== void 0 ? String(stamp.background_color) : void 0,
+        border_size: stamp.border_size !== void 0 ? typeof stamp.border_size === "number" ? stamp.border_size : void 0 : void 0,
+        font_color: stamp.font_color !== void 0 ? String(stamp.font_color) : void 0,
+        font_weight: stamp.font_weight !== void 0 ? String(stamp.font_weight) : void 0,
+        font_style: stamp.font_style !== void 0 ? String(stamp.font_style) : void 0,
+        font_size: stamp.font_size !== void 0 ? typeof stamp.font_size === "number" ? stamp.font_size : void 0 : void 0,
+        font_name: stamp.font_name !== void 0 ? String(stamp.font_name) : void 0
+      })).filter((stamp) => stamp.name && stamp.text);
+    } catch (error2) {
+      console.warn("[PdfViewer] Failed to parse custom stamps JSON:", error2);
+      return [];
+    }
+  };
+  const add_suffix_text = (text, fixed_text_suffix_enabled, time_stamp_suffix_enabled, fixed_text, add_enclosing_brackets_override) => {
+    const viewer_config = config_ref.current?.viewer;
+    const add_enclosing_brackets = add_enclosing_brackets_override ?? viewer_config?.add_enclosing_brackets_to_suffixes ?? true;
+    const suffix_enclosing_brackets = viewer_config?.suffix_enclosing_brackets || "[]";
+    const suffix_text_position = viewer_config?.suffix_text_position || "below_multi_line";
+    const opening_bracket = suffix_enclosing_brackets[0] || "[";
+    const closing_bracket = suffix_enclosing_brackets[1] || "]";
+    const suffix_parts = [];
+    if (fixed_text_suffix_enabled) {
+      const trimmed_fixed_text = fixed_text?.trim();
+      if (trimmed_fixed_text && trimmed_fixed_text.length > 0) {
+        suffix_parts.push(
+          add_enclosing_brackets ? `${opening_bracket}${trimmed_fixed_text}${closing_bracket}` : trimmed_fixed_text
+        );
+      }
+    }
+    if (time_stamp_suffix_enabled) {
+      const timestamp = format_annotation_timestamp();
+      suffix_parts.push(
+        add_enclosing_brackets ? `${opening_bracket}${timestamp}${closing_bracket}` : timestamp
+      );
+    }
+    if (suffix_parts.length === 0) {
+      return text;
+    }
+    switch (suffix_text_position) {
+      case "adjacent": {
+        if (!text) {
+          return suffix_parts.join(" ");
+        }
+        const separator = text.endsWith(" ") ? "" : " ";
+        return `${text}${separator}${suffix_parts.join(" ")}`;
+      }
+      case "below_single_line":
+        return text ? `${text}
+${suffix_parts.join(" ")}` : suffix_parts.join(" ");
+      case "below_multi_line":
+      default:
+        return text ? `${text}
+${suffix_parts.join("\n")}` : suffix_parts.join("\n");
+    }
+  };
+  const format_stamp_text = (stamp, base_text) => {
+    const fixed_text_prop = annotation_text_suffix_fixed_text;
+    const fixed_text_config = config_ref.current?.viewer.annotation_text_suffix_fixed_text || "";
+    const fixed_text = fixed_text_prop !== void 0 ? fixed_text_prop : fixed_text_config;
+    return add_suffix_text(
+      base_text,
+      stamp.fixed_text_suffix_enabled ?? false,
+      stamp.time_stamp_suffix_enabled ?? false,
+      fixed_text
+    );
+  };
+  const strip_auto_inserted_suffix = (text) => {
+    const viewer_config = config_ref.current?.viewer;
+    const bracket_pair = viewer_config?.suffix_enclosing_brackets || "[]";
+    const add_enclosing_brackets = viewer_config?.add_enclosing_brackets_to_suffixes ?? true;
+    const suffix_text_position = viewer_config?.suffix_text_position || "below_multi_line";
+    const opening_bracket = bracket_pair[0] || "[";
+    const closing_bracket = bracket_pair[1] || "]";
+    const escape_regexp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const timestamp_core_pattern = "\\d{4}-\\d{2}-\\d{2} \\d{1,2}:\\d{2}(?:am|pm)";
+    const timestamp_pattern = add_enclosing_brackets ? `${escape_regexp(opening_bracket)}${timestamp_core_pattern}${escape_regexp(
+      closing_bracket
+    )}` : timestamp_core_pattern;
+    const timestamp_line_regex = new RegExp(`^${timestamp_pattern}$`);
+    const timestamp_trailing_regex = new RegExp(
+      `(?:[ \\t]+)?${timestamp_pattern}$`
+    );
+    const fixed_text_prop = annotation_text_suffix_fixed_text;
+    const fixed_text_config = viewer_config?.annotation_text_suffix_fixed_text || "";
+    const fixed_text = fixed_text_prop !== void 0 ? fixed_text_prop : fixed_text_config;
+    const trimmed_fixed_text = fixed_text?.trim() || "";
+    const fixed_segment = trimmed_fixed_text ? add_enclosing_brackets ? `${opening_bracket}${trimmed_fixed_text}${closing_bracket}` : trimmed_fixed_text : null;
+    const fixed_line_regex = fixed_segment ? new RegExp(`^${escape_regexp(fixed_segment)}$`) : null;
+    const fixed_trailing_regex = fixed_segment ? new RegExp(`(?:[ \\t]+)?${escape_regexp(fixed_segment)}$`) : null;
+    const remove_trailing_pattern = (value, pattern) => {
+      if (!pattern) {
+        return { updated: value, removed: false };
+      }
+      const new_value = value.replace(pattern, "");
+      return { updated: new_value, removed: new_value !== value };
+    };
+    const strip_adjacent_suffix = (value) => {
+      let updated = value;
+      let removed_any = false;
+      const timestamp_removal = remove_trailing_pattern(
+        updated,
+        timestamp_trailing_regex
+      );
+      updated = timestamp_removal.updated;
+      removed_any || (removed_any = timestamp_removal.removed);
+      const fixed_removal = remove_trailing_pattern(
+        updated,
+        fixed_trailing_regex
+      );
+      updated = fixed_removal.updated;
+      removed_any || (removed_any = fixed_removal.removed);
+      return removed_any ? updated.replace(/[ \\t]+$/, "") : value;
+    };
+    const strip_below_single_line_suffix = (value) => {
+      const last_newline_index = value.lastIndexOf("\n");
+      if (last_newline_index === -1) {
+        return strip_adjacent_suffix(value);
+      }
+      const prefix = value.slice(0, last_newline_index);
+      let suffix_line = value.slice(last_newline_index + 1);
+      let suffix_changed = false;
+      const timestamp_removal = remove_trailing_pattern(
+        suffix_line,
+        timestamp_trailing_regex
+      );
+      suffix_line = timestamp_removal.updated;
+      suffix_changed || (suffix_changed = timestamp_removal.removed);
+      const fixed_removal = remove_trailing_pattern(
+        suffix_line,
+        fixed_trailing_regex
+      );
+      suffix_line = fixed_removal.updated;
+      suffix_changed || (suffix_changed = fixed_removal.removed);
+      if (!suffix_changed) {
+        return value;
+      }
+      if (suffix_line.trim().length === 0) {
+        return prefix;
+      }
+      return `${prefix}
+${suffix_line}`;
+    };
+    const strip_below_multi_line_suffix = (value) => {
+      const lines = value.split("\n");
+      if (lines.length === 0) {
+        return value;
+      }
+      let changed = false;
+      const remove_last_line_if_matches = (pattern) => {
+        if (!pattern || lines.length === 0) {
+          return;
+        }
+        const last_line = lines[lines.length - 1].trim();
+        if (pattern.test(last_line)) {
+          lines.pop();
+          changed = true;
+        }
+      };
+      remove_last_line_if_matches(timestamp_line_regex);
+      remove_last_line_if_matches(fixed_line_regex);
+      return changed ? lines.join("\n") : value;
+    };
+    switch (suffix_text_position) {
+      case "adjacent":
+        return strip_adjacent_suffix(text);
+      case "below_single_line":
+        return strip_below_single_line_suffix(text);
+      case "below_multi_line":
+      default:
+        return strip_below_multi_line_suffix(text);
+    }
+  };
+  const append_timestamp_if_enabled = (text) => {
+    const prop_value = append_timestamp_to_text_edits;
+    const config_value = config_ref.current?.viewer.append_timestamp_to_text_edits;
+    const should_append = prop_value !== void 0 ? prop_value : config_value ?? false;
+    const fixed_text_prop = annotation_text_suffix_fixed_text;
+    const fixed_text_config = config_ref.current?.viewer.annotation_text_suffix_fixed_text || "";
+    const fixed_text = fixed_text_prop !== void 0 ? fixed_text_prop : fixed_text_config;
+    console.log("[PdfViewer] append_timestamp_if_enabled:", {
+      prop_value,
+      config_value,
+      should_append,
+      fixed_text_prop,
+      fixed_text_config,
+      fixed_text,
+      config_loaded: !!config_ref.current,
+      original_text: text
+    });
+    if (!should_append) {
+      console.log("[PdfViewer] Timestamp NOT appended (disabled)");
+      return text;
+    }
+    const include_fixed_text_suffix = Boolean(fixed_text && fixed_text.trim().length > 0);
+    const result = add_suffix_text(
+      text,
+      include_fixed_text_suffix,
+      true,
+      fixed_text
+    );
+    console.log("[PdfViewer] Timestamp appended via add_suffix_text:", {
+      original: text,
+      fixed_text,
+      include_fixed_text_suffix,
+      result
+    });
+    return result;
+  };
+  const [history, setHistory] = useState5([initial_annotations]);
+  const [history_index, setHistoryIndex] = useState5(0);
+  const history_ref = useRef6({ saving: false });
+  const [context_menu, setContextMenu] = useState5(null);
+  const [text_dialog, setTextDialog] = useState5(null);
+  useEffect5(() => {
+    if (history.length === 1 && history[0].length === 0 && initial_annotations.length === 0) {
+      return;
+    }
+    setHistory([initial_annotations]);
+    setHistoryIndex(0);
+    history_ref.current.saving = false;
+  }, [url]);
+  useEffect5(() => {
+    if (typeof window === "undefined") {
+      return;
+    }
+    if (!url) {
+      console.warn("PdfViewer: No URL provided");
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    const load_timeout = setTimeout(() => {
+      load_pdf_document(url).then((document2) => {
+        setPdfDocument(document2);
+        setLoading(false);
+        if (on_load) {
+          on_load(document2);
+        }
+      }).catch((err) => {
+        console.error("PdfViewer: Error loading PDF:", err);
+        const error_obj = err instanceof Error ? err : new Error(String(err));
+        setError(error_obj);
+        setLoading(false);
+        if (on_error) {
+          on_error(error_obj);
+        }
+      });
+    }, 0);
+    return () => {
+      clearTimeout(load_timeout);
+    };
+  }, [url, on_load, on_error]);
+  const save_to_history = (new_annotations) => {
+    if (history_ref.current.saving) {
+      return;
+    }
+    const new_history = history.slice(0, history_index + 1);
+    new_history.push(new_annotations);
+    if (new_history.length > 50) {
+      new_history.shift();
+      setHistory(new_history);
+      setHistoryIndex(new_history.length - 1);
+    } else {
+      setHistory(new_history);
+      setHistoryIndex(new_history.length - 1);
+    }
+  };
+  const handle_annotation_create = (annotation) => {
+    const new_annotations = [...annotations, annotation];
+    setAnnotations(new_annotations);
+    save_to_history(new_annotations);
+    if (on_annotation_create) {
+      on_annotation_create(annotation);
+    }
+  };
+  const handle_annotation_update = (annotation) => {
+    const updated_annotations = annotations.map(
+      (ann) => ann.id === annotation.id ? annotation : ann
+    );
+    setAnnotations(updated_annotations);
+    save_to_history(updated_annotations);
+    if (on_annotation_update) {
+      on_annotation_update(annotation);
+    }
+  };
+  const handle_annotation_delete = (annotation_id) => {
+    const filtered_annotations = annotations.filter(
+      (ann) => ann.id !== annotation_id
+    );
+    setAnnotations(filtered_annotations);
+    save_to_history(filtered_annotations);
+    if (on_annotation_delete) {
+      on_annotation_delete(annotation_id);
+    }
+  };
+  const handle_undo = useCallback2(() => {
+    if (history_index > 0) {
+      history_ref.current.saving = true;
+      const previous_index = history_index - 1;
+      const previous_annotations = history[previous_index];
+      setAnnotations([...previous_annotations]);
+      setHistoryIndex(previous_index);
+      setTimeout(() => {
+        history_ref.current.saving = false;
+      }, 0);
+    }
+  }, [history_index, history]);
+  const handle_redo = useCallback2(() => {
+    if (history_index < history.length - 1) {
+      history_ref.current.saving = true;
+      const next_index = history_index + 1;
+      const next_annotations = history[next_index];
+      setAnnotations([...next_annotations]);
+      setHistoryIndex(next_index);
+      setTimeout(() => {
+        history_ref.current.saving = false;
+      }, 0);
+    }
+  }, [history_index, history]);
+  useEffect5(() => {
+    const handle_keydown = (e) => {
+      const target = e.target;
+      if (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable) {
+        return;
+      }
+      if ((e.ctrlKey || e.metaKey) && e.key === "z" && !e.shiftKey) {
+        e.preventDefault();
+        handle_undo();
+      }
+      if ((e.ctrlKey || e.metaKey) && (e.key === "y" || e.key === "z" && e.shiftKey)) {
+        e.preventDefault();
+        handle_redo();
+      }
+    };
+    window.addEventListener("keydown", handle_keydown);
+    return () => {
+      window.removeEventListener("keydown", handle_keydown);
+    };
+  }, [handle_undo, handle_redo]);
+  const handle_zoom_in = () => {
+    setScale((prev) => Math.min(prev + 0.25, 3));
+  };
+  const handle_zoom_out = () => {
+    setScale((prev) => Math.max(prev - 0.25, 0.5));
+  };
+  const handle_zoom_reset = () => {
+    setScale(1);
+  };
+  const handle_save = async () => {
+    if (annotations.length === 0) {
+      console.warn("PdfViewer: No annotations to save");
+      return;
+    }
+    if (!url) {
+      console.error("PdfViewer: No PDF URL available for saving");
+      return;
+    }
+    setSaving(true);
+    try {
+      const original_filename = url.split("/").pop() || "document.pdf";
+      const filename_without_ext = original_filename.replace(/\.pdf$/i, "");
+      const output_filename = `${filename_without_ext}_annotated.pdf`;
+      const { save_annotations_to_pdf: save_annotations_to_pdf2, download_pdf: download_pdf2 } = await import("./pdf_saver-D2H5SLPN.js");
+      const pdf_bytes = await save_annotations_to_pdf2(url, annotations, output_filename, config_ref.current);
+      download_pdf2(pdf_bytes, output_filename);
+      if (on_save) {
+        on_save(pdf_bytes, output_filename);
+      }
+    } catch (error2) {
+      console.error("PdfViewer: Error saving PDF:", error2);
+      const error_obj = error2 instanceof Error ? error2 : new Error(String(error2));
+      if (on_error) {
+        on_error(error_obj);
+      }
+    } finally {
+      setSaving(false);
+    }
+  };
+  if (loading) {
+    return /* @__PURE__ */ jsx6("div", { className: cn("cls_pdf_viewer", "cls_pdf_viewer_loading", className), children: /* @__PURE__ */ jsx6("div", { className: "cls_pdf_viewer_spinner", children: "Loading PDF document..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx6("div", { className: cn("cls_pdf_viewer", "cls_pdf_viewer_error", className), children: /* @__PURE__ */ jsxs5("div", { className: "cls_pdf_viewer_error_message", children: [
+      "Error loading PDF: ",
+      error.message
+    ] }) });
+  }
+  if (!pdf_document) {
+    return /* @__PURE__ */ jsx6("div", { className: cn("cls_pdf_viewer", className), children: /* @__PURE__ */ jsx6("div", { className: "cls_pdf_viewer_no_document", children: "No PDF document loaded" }) });
+  }
+  return /* @__PURE__ */ jsxs5("div", { className: cn("cls_pdf_viewer", className), children: [
+    /* @__PURE__ */ jsxs5("div", { className: "cls_pdf_viewer_toolbar", children: [
+      /* @__PURE__ */ jsxs5("div", { className: "cls_pdf_viewer_toolbar_group", children: [
+        /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            onClick: handle_zoom_out,
+            className: "cls_pdf_viewer_toolbar_button",
+            "aria-label": "Zoom out",
+            children: "\u2212"
+          }
+        ),
+        /* @__PURE__ */ jsxs5("span", { className: "cls_pdf_viewer_zoom_level", children: [
+          Math.round(scale * 100),
+          "%"
+        ] }),
+        /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            onClick: handle_zoom_in,
+            className: "cls_pdf_viewer_toolbar_button",
+            "aria-label": "Zoom in",
+            children: "+"
+          }
+        ),
+        /* @__PURE__ */ jsx6(
+          "button",
+          {
+            type: "button",
+            onClick: handle_zoom_reset,
+            className: "cls_pdf_viewer_toolbar_button",
+            "aria-label": "Reset zoom",
+            children: "Reset"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx6("div", { className: "cls_pdf_viewer_toolbar_group", children: /* @__PURE__ */ jsx6(
+        "button",
+        {
+          type: "button",
+          onClick: () => setCurrentTool("Square"),
+          className: cn(
+            "cls_pdf_viewer_toolbar_button",
+            current_tool === "Square" && "cls_pdf_viewer_toolbar_button_active"
+          ),
+          "aria-label": "Square annotation tool",
+          children: "Square"
+        }
+      ) }),
+      /* @__PURE__ */ jsxs5("div", { className: "cls_pdf_viewer_toolbar_group", children: [
+        /* @__PURE__ */ jsxs5(
+          "button",
+          {
+            type: "button",
+            onClick: handle_undo,
+            disabled: history_index === 0,
+            className: cn(
+              "cls_pdf_viewer_toolbar_button",
+              history_index === 0 && "cls_pdf_viewer_toolbar_button_disabled"
+            ),
+            "aria-label": "Undo last annotation",
+            title: "Undo (Ctrl+Z)",
+            children: [
+              /* @__PURE__ */ jsx6(Undo22, { className: "cls_pdf_viewer_toolbar_icon", size: 16 }),
+              /* @__PURE__ */ jsx6("span", { className: "cls_pdf_viewer_toolbar_button_text", children: "Undo" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs5(
+          "button",
+          {
+            type: "button",
+            onClick: handle_redo,
+            disabled: history_index >= history.length - 1,
+            className: cn(
+              "cls_pdf_viewer_toolbar_button",
+              history_index >= history.length - 1 && "cls_pdf_viewer_toolbar_button_disabled"
+            ),
+            "aria-label": "Redo last undone annotation",
+            title: "Redo (Ctrl+Y)",
+            children: [
+              /* @__PURE__ */ jsx6(Redo2, { className: "cls_pdf_viewer_toolbar_icon", size: 16 }),
+              /* @__PURE__ */ jsx6("span", { className: "cls_pdf_viewer_toolbar_button_text", children: "Redo" })
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx6("div", { className: "cls_pdf_viewer_toolbar_group", children: /* @__PURE__ */ jsxs5(
+        "button",
+        {
+          type: "button",
+          onClick: handle_save,
+          disabled: saving || annotations.length === 0,
+          className: cn(
+            "cls_pdf_viewer_toolbar_button",
+            "cls_pdf_viewer_toolbar_button_save",
+            (saving || annotations.length === 0) && "cls_pdf_viewer_toolbar_button_disabled"
+          ),
+          "aria-label": "Save annotations to PDF",
+          title: annotations.length === 0 ? "No annotations to save" : "Save annotations to PDF",
+          children: [
+            /* @__PURE__ */ jsx6(Save, { className: "cls_pdf_viewer_toolbar_icon", size: 16 }),
+            /* @__PURE__ */ jsx6("span", { className: "cls_pdf_viewer_toolbar_button_text", children: saving ? "Saving..." : "Save" })
+          ]
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsx6("div", { className: "cls_pdf_viewer_content", children: /* @__PURE__ */ jsx6(
+      PdfViewerLayout,
+      {
+        pdf_document,
+        scale,
+        annotations,
+        current_tool,
+        background_color: effective_background_color,
+        config: config_ref.current,
+        on_annotation_create: handle_annotation_create,
+        on_annotation_click: (annotation, screen_x, screen_y, mapper) => {
+          console.log(
+            `\u{1F7E0} [AnnotationClick] opening editor id=${annotation.id}, page=${annotation.page_index}, screen=(${screen_x.toFixed(
+              1
+            )}, ${screen_y.toFixed(1)})`
+          );
+          const dialog_x = window.innerWidth / 2;
+          const dialog_y = Math.max(50, screen_y);
+          setTextDialog({
+            open: true,
+            page_index: annotation.page_index,
+            x: dialog_x,
+            y: dialog_y,
+            screen_x,
+            screen_y,
+            mapper,
+            editing_annotation: annotation
+          });
+        },
+        on_context_menu: (e, page_index, screen_x, screen_y, mapper) => {
+          const menu_x = e.clientX;
+          const menu_y = e.clientY;
+          setContextMenu({
+            visible: true,
+            x: menu_x,
+            y: menu_y,
+            page_index,
+            screen_x,
+            screen_y,
+            mapper
+          });
+        }
+      }
+    ) }),
+    context_menu?.visible && /* @__PURE__ */ jsxs5(Fragment3, { children: [
+      /* @__PURE__ */ jsx6(
+        "div",
+        {
+          className: "cls_pdf_viewer_context_menu_backdrop",
+          onClick: () => setContextMenu(null),
+          onContextMenu: (e) => {
+            e.preventDefault();
+            setContextMenu(null);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx6(
+        ContextMenu,
+        {
+          x: context_menu.x,
+          y: context_menu.y,
+          can_undo: history_index > 0,
+          config: config_ref.current,
+          custom_stamps: (() => {
+            const stamps_json = right_click_custom_stamps || config_ref.current?.context_menu.right_click_custom_stamps || "";
+            return parse_custom_stamps(stamps_json);
+          })(),
+          on_undo: () => {
+            handle_undo();
+            setContextMenu(null);
+          },
+          on_annotate: () => {
+            setTextDialog({
+              open: true,
+              page_index: context_menu.page_index,
+              x: context_menu.x,
+              // Use same viewport coordinates as context menu
+              y: context_menu.y,
+              screen_x: context_menu.screen_x,
+              screen_y: context_menu.screen_y,
+              mapper: context_menu.mapper
+            });
+            setContextMenu(null);
+          },
+          on_stamp_click: (stamp) => {
+            if (!context_menu || !context_menu.mapper) return;
+            const formatted_text = format_stamp_text(stamp, stamp.text);
+            const [pdf_x, pdf_y] = context_menu.mapper.to_pdf(context_menu.screen_x, context_menu.screen_y);
+            const fonts_config = config_ref.current?.fonts || default_config.fonts;
+            const freetext_config = config_ref.current?.freetext_annotation || default_config.freetext_annotation;
+            const text_color = stamp.font_color || (freetext_config.freetext_text_color && freetext_config.freetext_text_color !== "#000000" ? freetext_config.freetext_text_color : fonts_config.font_foreground_color);
+            const stamp_styling = {
+              stamp_name: stamp.name,
+              background_color: stamp.background_color,
+              border_size: stamp.border_size,
+              font_color: stamp.font_color,
+              font_weight: stamp.font_weight,
+              font_style: stamp.font_style,
+              font_size: stamp.font_size,
+              font_name: stamp.font_name
+            };
+            const annotation = {
+              id: crypto.randomUUID(),
+              type: "FreeText",
+              page_index: context_menu.page_index,
+              rect: [pdf_x, pdf_y, pdf_x + 10, pdf_y + 10],
+              // Placeholder rect
+              author: "User",
+              date: (/* @__PURE__ */ new Date()).toISOString(),
+              contents: formatted_text,
+              color: text_color,
+              subject: JSON.stringify(stamp_styling)
+              // Store stamp styling metadata
+            };
+            handle_annotation_create(annotation);
+            setContextMenu(null);
+          },
+          on_close: () => setContextMenu(null)
+        }
+      )
+    ] }),
+    text_dialog && /* @__PURE__ */ jsx6(
+      TextAnnotationDialog,
+      {
+        open: text_dialog.open,
+        x: text_dialog.x,
+        y: text_dialog.y,
+        config: config_ref.current,
+        initial_text: text_dialog.editing_annotation ? strip_auto_inserted_suffix(text_dialog.editing_annotation.contents) : "",
+        is_editing: !!text_dialog.editing_annotation,
+        on_close: () => setTextDialog(null),
+        on_delete: () => {
+          if (text_dialog.editing_annotation) {
+            handle_annotation_delete(text_dialog.editing_annotation.id);
+          }
+          setTextDialog(null);
+        },
+        on_submit: (text) => {
+          if (!text_dialog || !text_dialog.mapper) return;
+          if (text_dialog.editing_annotation) {
+            const stripped_text = strip_auto_inserted_suffix(text);
+            const final_text2 = append_timestamp_if_enabled(stripped_text);
+            const updated_annotation = {
+              ...text_dialog.editing_annotation,
+              contents: final_text2,
+              date: (/* @__PURE__ */ new Date()).toISOString()
+              // Update modification date
+            };
+            handle_annotation_update(updated_annotation);
+            setTextDialog(null);
+            return;
+          }
+          const final_text = append_timestamp_if_enabled(text);
+          const [pdf_x, pdf_y] = text_dialog.mapper.to_pdf(text_dialog.screen_x, text_dialog.screen_y);
+          const placeholder_width = 100;
+          const placeholder_height = 30;
+          const freetext_text_color = config_ref.current?.freetext_annotation.freetext_text_color;
+          const font_foreground_color = config_ref.current?.fonts.font_foreground_color;
+          const text_color = freetext_text_color && freetext_text_color !== "#000000" ? freetext_text_color : font_foreground_color || "#000000";
+          const annotation = {
+            id: crypto.randomUUID(),
+            type: "FreeText",
+            page_index: text_dialog.page_index,
+            rect: [
+              pdf_x,
+              // Top-left X (click position)
+              pdf_y,
+              // Top-left Y (click position)
+              pdf_x + placeholder_width,
+              // Bottom-right X (placeholder)
+              pdf_y + placeholder_height
+              // Bottom-right Y (placeholder)
+            ],
+            author: "User",
+            date: (/* @__PURE__ */ new Date()).toISOString(),
+            contents: final_text,
+            color: text_color
+          };
+          handle_annotation_create(annotation);
+          setTextDialog(null);
+        }
+      }
+    )
+  ] });
+};
+
+// src/utils/xfdf_generator.ts
+function format_pdf_date(date) {
+  let date_obj;
+  if (typeof date === "string") {
+    date_obj = new Date(date);
+    if (isNaN(date_obj.getTime())) {
+      console.warn(`Invalid date string: ${date}. Using current date.`);
+      date_obj = /* @__PURE__ */ new Date();
+    }
+  } else {
+    date_obj = date;
+    if (isNaN(date_obj.getTime())) {
+      console.warn(`Invalid date object. Using current date.`);
+      date_obj = /* @__PURE__ */ new Date();
+    }
+  }
+  const year = date_obj.getFullYear();
+  const month = String(date_obj.getMonth() + 1).padStart(2, "0");
+  const day = String(date_obj.getDate()).padStart(2, "0");
+  const hours = String(date_obj.getHours()).padStart(2, "0");
+  const minutes = String(date_obj.getMinutes()).padStart(2, "0");
+  const seconds = String(date_obj.getSeconds()).padStart(2, "0");
+  const offset_minutes = date_obj.getTimezoneOffset();
+  const offset_hours = Math.abs(Math.floor(offset_minutes / 60));
+  const offset_mins = Math.abs(offset_minutes % 60);
+  const offset_sign = offset_minutes <= 0 ? "+" : "-";
+  return `D:${year}${month}${day}${hours}${minutes}${seconds}${offset_sign}${String(offset_hours).padStart(2, "0")}'${String(offset_mins).padStart(2, "0")}'`;
+}
+function escape_xml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function annotation_type_to_tag(type) {
+  return type.toLowerCase();
+}
+function generate_xfdf(annotations, bookmarks = [], pdf_file_name = "document.pdf") {
+  let xfdf = `<?xml version="1.0" encoding="UTF-8"?>
+`;
+  xfdf += `<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve">
+`;
+  xfdf += `  <f href="${escape_xml(pdf_file_name)}"/>
+`;
+  if (annotations.length > 0) {
+    xfdf += `  <annots>
+`;
+    annotations.forEach((ann) => {
+      const rect_string = ann.rect.map((c) => c.toFixed(2)).join(", ");
+      let date_string;
+      try {
+        date_string = format_pdf_date(ann.date);
+      } catch (error) {
+        console.warn(`Error formatting date for annotation ${ann.id}:`, error);
+        date_string = format_pdf_date(/* @__PURE__ */ new Date());
+      }
+      const tag_name = annotation_type_to_tag(ann.type);
+      const attributes = [];
+      attributes.push(`subject="${escape_xml(ann.subject || ann.type)}"`);
+      attributes.push(`page="${ann.page_index}"`);
+      attributes.push(`rect="${rect_string}"`);
+      attributes.push(`flags="print"`);
+      attributes.push(`name="${escape_xml(ann.id)}"`);
+      attributes.push(`title="${escape_xml(ann.author)}"`);
+      attributes.push(`date="${date_string}"`);
+      if (ann.color) {
+        attributes.push(`color="${escape_xml(ann.color)}"`);
+      }
+      xfdf += `    <${tag_name} ${attributes.join(" ")}>
+`;
+      if (ann.contents) {
+        xfdf += `      <contents><![CDATA[${ann.contents}]]></contents>
+`;
+      }
+      xfdf += `    </${tag_name}>
+`;
+    });
+    xfdf += `  </annots>
+`;
+  }
+  if (bookmarks.length > 0) {
+    xfdf += `  <bookmarks>
+`;
+    bookmarks.forEach((bookmark) => {
+      const attributes = [];
+      attributes.push(`title="${escape_xml(bookmark.title)}"`);
+      attributes.push(`action="${bookmark.action || "GoTo"}"`);
+      attributes.push(`page="${bookmark.page_index}"`);
+      if (bookmark.y !== void 0) {
+        attributes.push(`y="${bookmark.y}"`);
+      }
+      xfdf += `    <bookmark ${attributes.join(" ")} />
+`;
+    });
+    xfdf += `  </bookmarks>
+`;
+  }
+  xfdf += `</xfdf>`;
+  return xfdf;
+}
+function download_xfdf(xfdf_content, file_name = "annotations.xfdf") {
+  const blob = new Blob([xfdf_content], { type: "application/vnd.adobe.xfdf" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = file_name;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+function export_annotations_to_xfdf(annotations, bookmarks = [], pdf_file_name = "document.pdf", file_name = "annotations.xfdf") {
+  const xfdf_content = generate_xfdf(annotations, bookmarks, pdf_file_name);
+  download_xfdf(xfdf_content, file_name);
+}
+export {
+  AnnotationOverlay,
+  PdfPageRenderer,
+  PdfViewer,
+  PdfViewerLayout,
+  build_config_from_ini,
+  calculate_rectangle_coords,
+  create_coordinate_mapper,
+  default_config,
+  download_pdf,
+  download_xfdf,
+  export_annotations_to_xfdf,
+  generate_xfdf,
+  get_viewport_dimensions,
+  is_rectangle_too_small,
+  load_pdf_config,
+  load_pdf_config_async,
+  load_pdf_document,
+  parse_color,
+  parse_number,
+  parse_opacity,
+  parse_string,
+  pdf_rect_to_rectangle,
+  rectangle_to_pdf_rect,
+  save_and_download_pdf,
+  save_annotations_to_pdf
+};
+//# sourceMappingURL=index.js.map