kviewer 0.1.2 → 0.2.0

package/dist/runtime/annotation/pdf-export/parse_strikeout.js

@@ -1,8 +1,9 @@
 import { PDFName, PDFString } from "pdf-lib";
 import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
+import { convertCanvasPointToPdf, pageTransformFromPdfLibPage } from "../pdf-import/transform.js";
 import { AnnotationParser } from "./parse.js";
 const UNKNOWN_USER = "Unknown user";
-function buildQuadPoints(konvaString, pageHeight) {
+function buildQuadPoints(konvaString, t) {
   const konvaGroup = JSON.parse(konvaString);
   const rects = (konvaGroup.children ?? []).filter((item) => item.className === "Rect");
   const quadPoints = [];
@@ -11,11 +12,11 @@ function buildQuadPoints(konvaString, pageHeight) {
     const y = rect.attrs?.y ?? 0;
     const width = rect.attrs?.width ?? 0;
     const height = rect.attrs?.height ?? 0;
-    const x1 = x;
-    const y1 = pageHeight - y;
-    const x2 = x + width;
-    const y2 = pageHeight - (y + height);
-    quadPoints.push(x1, y1, x2, y1, x1, y2, x2, y2);
+    const tl = convertCanvasPointToPdf(t, x, y);
+    const tr = convertCanvasPointToPdf(t, x + width, y);
+    const bl = convertCanvasPointToPdf(t, x, y + height);
+    const br = convertCanvasPointToPdf(t, x + width, y + height);
+    quadPoints.push(tl.x, tl.y, tr.x, tr.y, bl.x, bl.y, br.x, br.y);
   }
   return quadPoints;
 }
@@ -23,12 +24,12 @@ export class StrikeOutParser extends AnnotationParser {
   async parse() {
     const { annotation, page, pdfDoc } = this;
     const context = pdfDoc.context;
-    const pageHeight = page.getHeight();
-    const quadPoints = buildQuadPoints(annotation.konvaString, pageHeight);
+    const pageTransform = pageTransformFromPdfLibPage(page);
+    const quadPoints = buildQuadPoints(annotation.konvaString, pageTransform);
     const mainAnn = context.obj({
       Type: PDFName.of("Annot"),
       Subtype: PDFName.of("StrikeOut"),
-      Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+      Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageTransform),
       QuadPoints: quadPoints,
       C: rgbToPdfColor(annotation.color || void 0),
       T: stringToPDFHexString(annotation.title || UNKNOWN_USER),
@@ -42,7 +43,7 @@ export class StrikeOutParser extends AnnotationParser {
       const replyAnn = context.obj({
         Type: PDFName.of("Annot"),
         Subtype: PDFName.of("Text"),
-        Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+        Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageTransform),
         Contents: stringToPDFHexString(comment.content),
         T: stringToPDFHexString(comment.title || UNKNOWN_USER),
         M: PDFString.of(comment.date || ""),

package/dist/runtime/annotation/pdf-export/parse_text.js

@@ -1,13 +1,15 @@
 import { PDFName, PDFString } from "pdf-lib";
 import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
+import { pageTransformFromPdfLibPage } from "../pdf-import/transform.js";
 import { AnnotationParser } from "./parse.js";
 import { computeBoundsFromKonvaString } from "./parse_utils.js";
 const UNKNOWN_USER = "Unknown user";
 export class TextParser extends AnnotationParser {
   async parse() {
     const { annotation, page, pdfDoc } = this;
+    const pageTransform = pageTransformFromPdfLibPage(page);
     const bounds = computeBoundsFromKonvaString(annotation.konvaString);
-    const rect = convertKonvaRectToPdfRect(bounds ?? annotation.konvaClientRect, page.getHeight());
+    const rect = convertKonvaRectToPdfRect(bounds ?? annotation.konvaClientRect, pageTransform);
     const context = pdfDoc.context;
     const mainAnn = context.obj({
       Type: PDFName.of("Annot"),

package/dist/runtime/annotation/pdf-export/parse_underline.js

@@ -1,8 +1,9 @@
 import { PDFName, PDFString } from "pdf-lib";
 import { convertKonvaRectToPdfRect, rgbToPdfColor, stringToPDFHexString } from "../engine/utils.js";
+import { convertCanvasPointToPdf, pageTransformFromPdfLibPage } from "../pdf-import/transform.js";
 import { AnnotationParser } from "./parse.js";
 const UNKNOWN_USER = "Unknown user";
-function buildQuadPoints(konvaString, pageHeight) {
+function buildQuadPoints(konvaString, t) {
   const konvaGroup = JSON.parse(konvaString);
   const rects = (konvaGroup.children ?? []).filter((item) => item.className === "Rect");
   const quadPoints = [];
@@ -11,11 +12,11 @@ function buildQuadPoints(konvaString, pageHeight) {
     const y = rect.attrs?.y ?? 0;
     const width = rect.attrs?.width ?? 0;
     const height = rect.attrs?.height ?? 0;
-    const x1 = x;
-    const y1 = pageHeight - y;
-    const x2 = x + width;
-    const y2 = pageHeight - (y + height);
-    quadPoints.push(x1, y1, x2, y1, x1, y2, x2, y2);
+    const tl = convertCanvasPointToPdf(t, x, y);
+    const tr = convertCanvasPointToPdf(t, x + width, y);
+    const bl = convertCanvasPointToPdf(t, x, y + height);
+    const br = convertCanvasPointToPdf(t, x + width, y + height);
+    quadPoints.push(tl.x, tl.y, tr.x, tr.y, bl.x, bl.y, br.x, br.y);
   }
   return quadPoints;
 }
@@ -23,12 +24,12 @@ export class UnderlineParser extends AnnotationParser {
   async parse() {
     const { annotation, page, pdfDoc } = this;
     const context = pdfDoc.context;
-    const pageHeight = page.getHeight();
-    const quadPoints = buildQuadPoints(annotation.konvaString, pageHeight);
+    const pageTransform = pageTransformFromPdfLibPage(page);
+    const quadPoints = buildQuadPoints(annotation.konvaString, pageTransform);
     const mainAnn = context.obj({
       Type: PDFName.of("Annot"),
       Subtype: PDFName.of("Underline"),
-      Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+      Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageTransform),
       QuadPoints: quadPoints,
       C: rgbToPdfColor(annotation.color || void 0),
       T: stringToPDFHexString(annotation.title || UNKNOWN_USER),
@@ -42,7 +43,7 @@ export class UnderlineParser extends AnnotationParser {
       const replyAnn = context.obj({
         Type: PDFName.of("Annot"),
         Subtype: PDFName.of("Text"),
-        Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageHeight),
+        Rect: convertKonvaRectToPdfRect(annotation.konvaClientRect, pageTransform),
         Contents: stringToPDFHexString(comment.content),
         T: stringToPDFHexString(comment.title || UNKNOWN_USER),
         M: PDFString.of(comment.date || ""),

package/dist/runtime/annotation/pdf-export/parse_utils.d.ts

@@ -24,3 +24,14 @@ export declare function computeBoundsFromKonvaString(konvaString: string): {
     width: number;
     height: number;
 } | null;
+/**
+ * `/Matrix` for an annotation appearance form XObject that should read
+ * upright on a `/Rotate` page. Form-local content is drawn in display-
+ * upright orientation inside `/BBox = [0, 0, W, H]`; the returned matrix
+ * rotates that by `rotation` degrees CCW so the page's intrinsic clockwise
+ * `/Rotate` cancels out at view time. Translation values place the rotated
+ * bounding box at the origin so the PDF viewer can scale it 1:1 into
+ * `/Rect` (whose user-space dims will be `(W, H)` for 0°/180° and
+ * `(H, W)` for 90°/270° — matching the rotated form box).
+ */
+export declare function formAppearanceMatrix(rotation: number, W: number, H: number): [number, number, number, number, number, number];

package/dist/runtime/annotation/pdf-export/parse_utils.js

@@ -52,3 +52,15 @@ export function computeBoundsFromKonvaString(konvaString) {
     height: maxY - minY
   };
 }
+export function formAppearanceMatrix(rotation, W, H) {
+  switch (rotation) {
+    case 90:
+      return [0, 1, -1, 0, H, 0];
+    case 180:
+      return [-1, 0, 0, -1, W, H];
+    case 270:
+      return [0, -1, 1, 0, 0, W];
+    default:
+      return [1, 0, 0, 1, 0, 0];
+  }
+}

package/dist/runtime/annotation/pdf-import/decode.d.ts

@@ -1,5 +1,6 @@
 import type { PDFDocumentProxy } from 'pdfjs-dist';
 import { type IAnnotationStore } from '../engine/types.js';
+import { type PageTransform } from './transform.js';
 import { type StampAppearance } from './types.js';
 export interface DecodePdfAnnotationsResult {
     annotations: IAnnotationStore[];
@@ -16,6 +17,6 @@ export declare function filterCollidingAnnotations(annotations: IAnnotationStore
     annotations: IAnnotationStore[];
     skipped: number;
 };
-export declare function decodePdfPageAnnotations(pageAnnotations: unknown[], pageNumber: number, pageHeight: number, options?: DecodePageOptions): DecodePdfAnnotationsResult;
+export declare function decodePdfPageAnnotations(pageAnnotations: unknown[], pageNumber: number, pageTransform: PageTransform, options?: DecodePageOptions): DecodePdfAnnotationsResult;
 export declare function decodePdfAnnotationsFromDocument(pdfDoc: PDFDocumentProxy): Promise<DecodePdfAnnotationsResult>;
 export {};

package/dist/runtime/annotation/pdf-import/decode.js

@@ -8,6 +8,7 @@ import { decodeStampAnnotation } from "./decode_stamp.js";
 import { decodeSquareAnnotation } from "./decode_square.js";
 import { decodeTextAnnotation } from "./decode_text.js";
 import { extractStampAppearancesForPage } from "./extract_stamp_appearance.js";
+import { pageTransformFromProxy } from "./transform.js";
 import { isRawPdfAnnotation } from "./types.js";
 const decoderMap = {
   [PdfjsAnnotationType.TEXT]: decodeTextAnnotation,
@@ -34,7 +35,7 @@ export function filterCollidingAnnotations(annotations, existingIds) {
   }
   return { annotations: result, skipped };
 }
-export function decodePdfPageAnnotations(pageAnnotations, pageNumber, pageHeight, options = {}) {
+export function decodePdfPageAnnotations(pageAnnotations, pageNumber, pageTransform, options = {}) {
   const annotations = [];
   let skipped = 0;
   let errors = 0;
@@ -42,7 +43,7 @@ export function decodePdfPageAnnotations(pageAnnotations, pageNumber, pageHeight
   skipped += pageAnnotations.length - rawAnnotations.length;
   const context = {
     pageNumber,
-    pageHeight,
+    pageTransform,
     allAnnotations: rawAnnotations,
     stampAppearances: options.stampAppearances
   };
@@ -89,7 +90,7 @@ export async function decodePdfAnnotationsFromDocument(pdfDoc) {
   for (let pageNumber = 1; pageNumber <= pdfDoc.numPages; pageNumber++) {
     try {
       const page = await pdfDoc.getPage(pageNumber);
-      const viewport = page.getViewport({ scale: 1 });
+      const pageTransform = pageTransformFromProxy(page);
       const pageAnnotations = await page.getAnnotations();
       const rawAnnotations = pageAnnotations.filter(isRawPdfAnnotation);
       const hasStampAnnotations = rawAnnotations.some(
@@ -100,7 +101,7 @@ export async function decodePdfAnnotationsFromDocument(pdfDoc) {
         try {
           stampAppearances = await extractStampAppearancesForPage(
             page,
-            viewport.height,
+            pageTransform,
             rawAnnotations
           );
         } catch (error) {
@@ -110,7 +111,7 @@ export async function decodePdfAnnotationsFromDocument(pdfDoc) {
       const decoded = decodePdfPageAnnotations(
         pageAnnotations,
         pageNumber,
-        viewport.height,
+        pageTransform,
         { stampAppearances }
       );
       annotations.push(...decoded.annotations);

package/dist/runtime/annotation/pdf-import/decode_circle.js

@@ -8,7 +8,7 @@ import {
   rectFromPdfRect
 } from "./utils.js";
 export function decodeCircleAnnotation(annotation, context) {
-  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  const rect = rectFromPdfRect(annotation.rect, context.pageTransform);
   if (!rect || typeof annotation.id !== "string") return null;
   const color = getAnnotationColor(annotation, AnnotationType.CIRCLE);
   const strokeWidth = normalizedStrokeWidth(annotation, 1);

package/dist/runtime/annotation/pdf-import/decode_freetext.js

@@ -44,7 +44,7 @@ function inferTextAlign(rectWidth, textPositionX, measuredWidth) {
   return "left";
 }
 export function decodeFreeTextAnnotation(annotation, context) {
-  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  const rect = rectFromPdfRect(annotation.rect, context.pageTransform);
   if (!rect || typeof annotation.id !== "string") return null;
   const appearance = asAppearanceData(annotation.defaultAppearanceData);
   const color = colorArrayToRgb(appearance?.fontColor) ?? getAnnotationColor(annotation, AnnotationType.FREETEXT);

package/dist/runtime/annotation/pdf-import/decode_highlight.js

@@ -75,7 +75,7 @@ export function decodeHighlightAnnotation(annotation, context) {
   const color = getAnnotationColor(annotation, type);
   const group = createGhostGroup(annotation.id);
   for (const quadSet of quadSets) {
-    const rect = rectFromQuadPoints(quadSet, context.pageHeight);
+    const rect = rectFromQuadPoints(quadSet, context.pageTransform);
     if (!rect) continue;
     group.add(createSegment(type, color, rect));
   }

package/dist/runtime/annotation/pdf-import/decode_ink.js

@@ -16,7 +16,7 @@ export function decodeInkAnnotation(annotation, context) {
   const opacity = isNumber(annotation.opacity) ? annotation.opacity : 1;
   const group = createGhostGroup(annotation.id);
   for (const list of annotation.inkLists) {
-    const points = pointsFromInkList(list, context.pageHeight);
+    const points = pointsFromInkList(list, context.pageTransform);
     if (points.length < 4) continue;
     group.add(new Konva.Line({
       points,

package/dist/runtime/annotation/pdf-import/decode_line.js

@@ -11,7 +11,7 @@ import {
 } from "./utils.js";
 export function decodeLineAnnotation(annotation, context) {
   if (typeof annotation.id !== "string") return null;
-  const points = linePointsFromCoordinates(annotation.lineCoordinates, context.pageHeight);
+  const points = linePointsFromCoordinates(annotation.lineCoordinates, context.pageTransform);
   if (!points) return null;
   const color = getAnnotationColor(annotation, AnnotationType.ARROW);
   const strokeWidth = normalizedStrokeWidth(annotation, 1);

package/dist/runtime/annotation/pdf-import/decode_square.js

@@ -8,7 +8,7 @@ import {
   rectFromPdfRect
 } from "./utils.js";
 export function decodeSquareAnnotation(annotation, context) {
-  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  const rect = rectFromPdfRect(annotation.rect, context.pageTransform);
   if (!rect || typeof annotation.id !== "string") return null;
   const color = getAnnotationColor(annotation, AnnotationType.RECTANGLE);
   const strokeWidth = normalizedStrokeWidth(annotation, 1);

package/dist/runtime/annotation/pdf-import/decode_stamp.js

@@ -8,7 +8,7 @@ import {
 } from "./utils.js";
 export function decodeStampAnnotation(annotation, context) {
   if (typeof annotation.id !== "string") return null;
-  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  const rect = rectFromPdfRect(annotation.rect, context.pageTransform);
   if (!rect) return null;
   const appearance = context.stampAppearances?.get(annotation.id);
   if (!appearance) {

package/dist/runtime/annotation/pdf-import/decode_text.js

@@ -9,7 +9,7 @@ import {
 } from "./utils.js";
 export function decodeTextAnnotation(annotation, context) {
   if (annotation.inReplyTo) return null;
-  const rect = rectFromPdfRect(annotation.rect, context.pageHeight);
+  const rect = rectFromPdfRect(annotation.rect, context.pageTransform);
   if (!rect || typeof annotation.id !== "string") return null;
   const color = getAnnotationColor(annotation, AnnotationType.NOTE);
   const group = createGhostGroup(annotation.id);

package/dist/runtime/annotation/pdf-import/extract_stamp_appearance.d.ts

@@ -1,4 +1,5 @@
 import type { PDFPageProxy } from 'pdfjs-dist';
+import { type PageTransform } from './transform.js';
 import { type RawPdfAnnotation, type StampAppearance } from './types.js';
 export interface StampExtractionOptions {
     scale?: number;
@@ -10,7 +11,7 @@ export interface PixelBounds {
     width: number;
     height: number;
 }
-export declare function stampRectToPixelBounds(rect: unknown, pageHeight: number, scale: number, canvasWidth: number, canvasHeight: number): PixelBounds | null;
+export declare function stampRectToPixelBounds(rect: unknown, transform: PageTransform, scale: number, canvasWidth: number, canvasHeight: number): PixelBounds | null;
 export declare function findMaskBounds(mask: Uint8Array, width: number, height: number): PixelBounds | null;
 export declare function computeDiffMask(base: Uint8ClampedArray, annotated: Uint8ClampedArray, width: number, height: number, threshold?: number): {
     mask: Uint8Array;
@@ -20,4 +21,4 @@ export declare function applyMaskOrFallback(annotated: Uint8ClampedArray, mask:
     data: Uint8ClampedArray;
     usedMask: boolean;
 };
-export declare function extractStampAppearancesForPage(page: PDFPageProxy, pageHeight: number, annotations: RawPdfAnnotation[], options?: StampExtractionOptions): Promise<Map<string, StampAppearance>>;
+export declare function extractStampAppearancesForPage(page: PDFPageProxy, pageTransform: PageTransform, annotations: RawPdfAnnotation[], options?: StampExtractionOptions): Promise<Map<string, StampAppearance>>;

package/dist/runtime/annotation/pdf-import/extract_stamp_appearance.js

@@ -1,26 +1,18 @@
 import { PdfjsAnnotationType } from "../engine/types.js";
+import { convertPdfRectToCanvas } from "./transform.js";
 import { isNumber } from "./types.js";
 const PDFJS_ANNOTATION_MODE_DISABLE = 0;
 const PDFJS_ANNOTATION_MODE_ENABLE = 1;
 const DEFAULT_RENDER_SCALE = 2;
 const DEFAULT_DIFF_THRESHOLD = 24;
-function normalizedPageRect(rect, pageHeight) {
+function normalizedPageRect(rect, transform) {
   if (!Array.isArray(rect) || rect.length < 4) return null;
   const [rx1, ry1, rx2, ry2] = rect;
   if (!isNumber(rx1) || !isNumber(ry1) || !isNumber(rx2) || !isNumber(ry2)) return null;
-  const x1 = Math.min(rx1, rx2);
-  const x2 = Math.max(rx1, rx2);
-  const y1 = Math.min(ry1, ry2);
-  const y2 = Math.max(ry1, ry2);
-  return {
-    x: x1,
-    y: pageHeight - y2,
-    width: x2 - x1,
-    height: y2 - y1
-  };
+  return convertPdfRectToCanvas(transform, [rx1, ry1, rx2, ry2]);
 }
-export function stampRectToPixelBounds(rect, pageHeight, scale, canvasWidth, canvasHeight) {
-  const normalized = normalizedPageRect(rect, pageHeight);
+export function stampRectToPixelBounds(rect, transform, scale, canvasWidth, canvasHeight) {
+  const normalized = normalizedPageRect(rect, transform);
   if (!normalized) return null;
   const left = Math.max(0, Math.floor(normalized.x * scale));
   const top = Math.max(0, Math.floor(normalized.y * scale));
@@ -102,7 +94,7 @@ async function renderPageToCanvas(page, canvas, annotationMode, scale) {
   });
   await task.promise;
 }
-export async function extractStampAppearancesForPage(page, pageHeight, annotations, options = {}) {
+export async function extractStampAppearancesForPage(page, pageTransform, annotations, options = {}) {
   const appearances = /* @__PURE__ */ new Map();
   const stampAnnotations = annotations.filter(
     (annotation) => annotation.annotationType === PdfjsAnnotationType.STAMP && typeof annotation.id === "string"
@@ -131,7 +123,7 @@ export async function extractStampAppearancesForPage(page, pageHeight, annotatio
       const id = annotation.id;
       const bounds = stampRectToPixelBounds(
         annotation.rect,
-        pageHeight,
+        pageTransform,
         scale,
         renderWidth,
         renderHeight

package/dist/runtime/annotation/pdf-import/transform.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Coordinate transform from a PDF page's unrotated user space to top-left
+ * origin canvas space, accounting for the page's intrinsic `/Rotate`.
+ *
+ * PDF annotation coordinates (`/Rect`, `QuadPoints`, ink lists, line
+ * endpoints) are stored in unrotated user space regardless of the page's
+ * `/Rotate`. To draw them at the right spot, we apply the same
+ * rotation pdf.js does when it produces a viewport at scale = 1 — this is a
+ * minimal mirror of `PageViewport.convertToViewportPoint` for that scale.
+ */
+export interface PageTransform {
+    /** Displayed page width in PDF points (rotation already applied). */
+    width: number;
+    /** Displayed page height in PDF points (rotation already applied). */
+    height: number;
+    /** Page intrinsic `/Rotate`, normalized to 0 | 90 | 180 | 270. */
+    rotation: number;
+    /** Unrotated MediaBox origin (`view[0]`, `view[1]`). Almost always 0. */
+    viewOffsetX: number;
+    viewOffsetY: number;
+}
+export interface CanvasPoint {
+    x: number;
+    y: number;
+}
+export interface CanvasRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Build a `PageTransform` from a pdf.js page proxy. */
+export declare function pageTransformFromProxy(page: {
+    view: number[];
+    rotate: number;
+}): PageTransform;
+/**
+ * Map a point from unrotated PDF user space to canvas (top-left origin)
+ * space at scale = 1. Equivalent to `viewport.convertToViewportPoint(x, y)`
+ * when the viewport is built with `getViewport({ scale: 1 })`.
+ */
+export declare function convertPdfPointToCanvas(t: PageTransform, x: number, y: number): CanvasPoint;
+/**
+ * Map a PDF rect `[x1, y1, x2, y2]` (unrotated user space) to a normalized
+ * canvas-space rect. Rotation may swap which corner is which, so the result
+ * is built from `min`/`abs` of the transformed corners.
+ */
+export declare function convertPdfRectToCanvas(t: PageTransform, rect: readonly [number, number, number, number]): CanvasRect;
+/**
+ * Inverse of `convertPdfPointToCanvas`: map a top-left-origin canvas point
+ * back to unrotated PDF user space. Used by the export path to write
+ * annotation `/Rect` and point lists in the coordinates a PDF viewer
+ * expects (display content is rotated by the page's `/Rotate` at view time,
+ * so we must store the inverse).
+ */
+export declare function convertCanvasPointToPdf(t: PageTransform, cx: number, cy: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Inverse of `convertPdfRectToCanvas`: map a top-left-origin canvas rect
+ * back to an unrotated PDF user-space rect `[x1, y1, x2, y2]`. Rotation may
+ * swap which corner is which, so the result is normalized.
+ */
+export declare function convertCanvasRectToPdf(t: PageTransform, rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): [number, number, number, number];
+/**
+ * Build a `PageTransform` from a pdf-lib `PDFPage`. Note pdf-lib's
+ * `getWidth()` / `getHeight()` return the *unrotated* MediaBox extent, so
+ * we swap for the displayed dimensions on 90°/270° pages, mirroring what
+ * pdfjs does in its default `getViewport({ scale: 1 })` call. MediaBox
+ * origin is assumed (0, 0) — almost universal in real PDFs; if a future
+ * input needs non-zero origins, read `/MediaBox` directly.
+ */
+export declare function pageTransformFromPdfLibPage(page: {
+    getWidth: () => number;
+    getHeight: () => number;
+    getRotation: () => {
+        angle: number;
+    };
+}): PageTransform;

package/dist/runtime/annotation/pdf-import/transform.js

@@ -0,0 +1,81 @@
+export function pageTransformFromProxy(page) {
+  const view = page.view;
+  const vx = view[0] ?? 0;
+  const vy = view[1] ?? 0;
+  const unrotatedW = (view[2] ?? 0) - vx;
+  const unrotatedH = (view[3] ?? 0) - vy;
+  const rotation = (page.rotate % 360 + 360) % 360;
+  const swap = rotation % 180 !== 0;
+  return {
+    width: swap ? unrotatedH : unrotatedW,
+    height: swap ? unrotatedW : unrotatedH,
+    rotation,
+    viewOffsetX: vx,
+    viewOffsetY: vy
+  };
+}
+export function convertPdfPointToCanvas(t, x, y) {
+  const { rotation, viewOffsetX: vx, viewOffsetY: vy } = t;
+  const swap = rotation % 180 !== 0;
+  const W = swap ? t.height : t.width;
+  const H = swap ? t.width : t.height;
+  switch (rotation) {
+    case 90:
+      return { x: y - vy, y: x - vx };
+    case 180:
+      return { x: W + vx - x, y: y - vy };
+    case 270:
+      return { x: H + vy - y, y: W + vx - x };
+    default:
+      return { x: x - vx, y: H + vy - y };
+  }
+}
+export function convertPdfRectToCanvas(t, rect) {
+  const a = convertPdfPointToCanvas(t, rect[0], rect[1]);
+  const b = convertPdfPointToCanvas(t, rect[2], rect[3]);
+  return {
+    x: Math.min(a.x, b.x),
+    y: Math.min(a.y, b.y),
+    width: Math.abs(b.x - a.x),
+    height: Math.abs(b.y - a.y)
+  };
+}
+export function convertCanvasPointToPdf(t, cx, cy) {
+  const { rotation, viewOffsetX: vx, viewOffsetY: vy } = t;
+  const swap = rotation % 180 !== 0;
+  const W = swap ? t.height : t.width;
+  const H = swap ? t.width : t.height;
+  switch (rotation) {
+    case 90:
+      return { x: cy + vx, y: cx + vy };
+    case 180:
+      return { x: W + vx - cx, y: cy + vy };
+    case 270:
+      return { x: W + vx - cy, y: H + vy - cx };
+    default:
+      return { x: cx + vx, y: H + vy - cy };
+  }
+}
+export function convertCanvasRectToPdf(t, rect) {
+  const a = convertCanvasPointToPdf(t, rect.x, rect.y);
+  const b = convertCanvasPointToPdf(t, rect.x + rect.width, rect.y + rect.height);
+  return [
+    Math.min(a.x, b.x),
+    Math.min(a.y, b.y),
+    Math.max(a.x, b.x),
+    Math.max(a.y, b.y)
+  ];
+}
+export function pageTransformFromPdfLibPage(page) {
+  const W_u = page.getWidth();
+  const H_u = page.getHeight();
+  const rotation = (page.getRotation().angle % 360 + 360) % 360;
+  const swap = rotation % 180 !== 0;
+  return {
+    width: swap ? H_u : W_u,
+    height: swap ? W_u : H_u,
+    rotation,
+    viewOffsetX: 0,
+    viewOffsetY: 0
+  };
+}

package/dist/runtime/annotation/pdf-import/types.d.ts

@@ -1,3 +1,4 @@
+import type { PageTransform } from './transform.js';
 export interface RawPdfTextObject {
     str?: unknown;
 }
@@ -43,7 +44,10 @@ export interface StampAppearance {
 }
 export interface DecodeContext {
     pageNumber: number;
-    pageHeight: number;
+    /** Page coord transform — applies the page's intrinsic `/Rotate` so
+     *  annotation `/Rect` values in unrotated user space land at the right
+     *  canvas pixels regardless of page rotation. */
+    pageTransform: PageTransform;
     allAnnotations: RawPdfAnnotation[];
     stampAppearances?: Map<string, StampAppearance>;
 }

package/dist/runtime/annotation/pdf-import/utils.d.ts

@@ -1,6 +1,7 @@
 import Konva from 'konva';
 import { type AnnotationType, type IAnnotationComment, type IAnnotationStore, type PdfjsAnnotationSubtype } from '../engine/types.js';
 import { type RawPdfAnnotation } from './types.js';
+import { type PageTransform } from './transform.js';
 type Rect = {
     x: number;
     y: number;
@@ -17,8 +18,8 @@ export declare function getAnnotationText(annotation: RawPdfAnnotation): string;
 export declare function getFreeTextContent(annotation: RawPdfAnnotation): string;
 export declare function getAnnotationDate(annotation: RawPdfAnnotation): string;
 export declare function getComments(annotation: RawPdfAnnotation, allAnnotations: RawPdfAnnotation[]): IAnnotationComment[];
-export declare function rectFromPdfRect(input: unknown, pageHeight: number): Rect | null;
-export declare function pointFromPdfPoint(input: unknown, pageHeight: number): {
+export declare function rectFromPdfRect(input: unknown, transform: PageTransform): Rect | null;
+export declare function pointFromPdfPoint(input: unknown, transform: PageTransform): {
     x: number;
     y: number;
 } | null;
@@ -26,9 +27,9 @@ export declare function localPointFromPdfPoint(input: unknown): {
     x: number;
     y: number;
 } | null;
-export declare function rectFromQuadPoints(input: unknown, pageHeight: number): Rect | null;
-export declare function pointsFromInkList(input: unknown, pageHeight: number): number[];
-export declare function linePointsFromCoordinates(input: unknown, pageHeight: number): number[] | null;
+export declare function rectFromQuadPoints(input: unknown, transform: PageTransform): Rect | null;
+export declare function pointsFromInkList(input: unknown, transform: PageTransform): number[];
+export declare function linePointsFromCoordinates(input: unknown, transform: PageTransform): number[] | null;
 export declare function normalizedStrokeWidth(annotation: RawPdfAnnotation, fallback?: number, options?: StrokeWidthOptions): number;
 export declare function dashedBorder(annotation: RawPdfAnnotation): number[];
 export declare function hasArrowEnding(value: unknown): boolean;