kviewer 0.0.10 → 0.0.11

package/README.md

@@ -81,6 +81,11 @@ await viewerRef.value?.importAnnotations(draft, { mode: 'replace' })
 // Read / write form field values
 const fields = viewerRef.value?.getFormFieldValues()
 viewerRef.value?.setFormFieldValue('email', 'user@example.com')
+
+// Toggle form-edit mode programmatically
+viewerRef.value?.setFormEditMode(true)
+viewerRef.value?.toggleFormEditMode()
+const isEditing = viewerRef.value?.formEditMode.value
 </script>
 ```
 
@@ -92,9 +97,33 @@ viewerRef.value?.setFormFieldValue('email', 'user@example.com')
 | `getFormFieldValues()` | `FormFieldValue[]` |
 | `setFormFieldValue(fieldName, value)` | `void` |
 | `getKonvaCanvasState()` | `Record<number, string>` |
+| `formEditMode` | `Ref<boolean>` |
+| `setFormEditMode(enabled)` | `void` |
+| `toggleFormEditMode()` | `boolean` (the new state) |
 
 `exportPdf` options default to `{ flatten: false, download: false, preserveOriginalAnnotations: false }`.
 
+### Form-edit mode
+
+`KViewer` exposes a **form-edit mode** that turns every form field into a movable/resizable widget with a property sidebar. It's also reachable from the burger menu in the toolbar, but consumers can drive it externally via prop binding or the imperative API.
+
+Two-way binding via `v-model:form-edit-mode`:
+
+```vue
+<template>
+  <button @click="formEditMode = !formEditMode">
+    {{ formEditMode ? 'Exit edit mode' : 'Edit form' }}
+  </button>
+  <KViewer v-model:form-edit-mode="formEditMode" :source="pdfUrl" />
+</template>
+
+<script setup lang="ts">
+const formEditMode = ref(false)
+</script>
+```
+
+Or imperatively from the ref API (`setFormEditMode`, `toggleFormEditMode`, reactive `formEditMode` ref).
+
 When native PDF annotations are auto-imported into Konva, exporting with `preserveOriginalAnnotations: true` may duplicate annotations. Prefer `preserveOriginalAnnotations: false` in that workflow.
 
 ## Development

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "kviewer",
   "configKey": "kviewer",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,3 +1,5 @@
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
 import { defineNuxtModule, createResolver, addPlugin, addComponentsDir } from '@nuxt/kit';
 
 const module$1 = defineNuxtModule({
@@ -20,6 +22,23 @@ const module$1 = defineNuxtModule({
       prefix: options.prefix,
       ignore: ["color-mode/**", "content/**", "prose/**"]
     });
+    const require_ = createRequire(import.meta.url);
+    const pdfjsDir = dirname(require_.resolve("pdfjs-dist/package.json"));
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.publicAssets ||= [];
+      nitroConfig.publicAssets.push(
+        {
+          dir: join(pdfjsDir, "standard_fonts"),
+          baseURL: "/_kviewer/standard_fonts",
+          maxAge: 60 * 60 * 24 * 365
+        },
+        {
+          dir: join(pdfjsDir, "cmaps"),
+          baseURL: "/_kviewer/cmaps",
+          maxAge: 60 * 60 * 24 * 365
+        }
+      );
+    });
   }
 });
 

package/dist/runtime/annotation/checkbox-styles.d.ts

@@ -0,0 +1,19 @@
+import type { CheckboxStyle } from './engine/types.js';
+/**
+ * Maps each standard checkbox style to:
+ * - `caption`: the single ZapfDingbats character written to `/MK /CA` on
+ *   the widget when the PDF is exported (per ISO 32000-1 §12.5.6.19).
+ * - `glyph`: a Unicode character with the same visual meaning, used by
+ *   the HTML viewer to render the checkbox in the user's browser without
+ *   needing to embed the ZapfDingbats font.
+ */
+export declare const CHECKBOX_STYLE_TABLE: Record<CheckboxStyle, {
+    caption: string;
+    glyph: string;
+}>;
+/** Reverse lookup: ZapfDingbats `/MK /CA` character → CheckboxStyle. */
+export declare function captionToStyle(caption: string): CheckboxStyle | undefined;
+export declare const CHECKBOX_STYLE_OPTIONS: {
+    label: string;
+    value: CheckboxStyle;
+}[];

package/dist/runtime/annotation/checkbox-styles.js

@@ -0,0 +1,27 @@
+export const CHECKBOX_STYLE_TABLE = {
+  // Heavy check / cross (U+2714 / U+2718) match Apple Preview's chunkier
+  // ZapfDingbats-style rendering — the thin U+2713/U+2717 glyphs feel
+  // anemic next to the field border. The trailing U+FE0E (variation
+  // selector-15) forces the text presentation, otherwise macOS swaps
+  // them for colored emoji.
+  check: { caption: "4", glyph: "\u2714\uFE0E" },
+  cross: { caption: "8", glyph: "\u2718\uFE0E" },
+  diamond: { caption: "u", glyph: "\u25C6" },
+  circle: { caption: "l", glyph: "\u25CF" },
+  star: { caption: "H", glyph: "\u2605" },
+  square: { caption: "n", glyph: "\u25A0" }
+};
+export function captionToStyle(caption) {
+  for (const [style, info] of Object.entries(CHECKBOX_STYLE_TABLE)) {
+    if (info.caption === caption) return style;
+  }
+  return void 0;
+}
+export const CHECKBOX_STYLE_OPTIONS = [
+  { label: "Check", value: "check" },
+  { label: "Cross", value: "cross" },
+  { label: "Diamond", value: "diamond" },
+  { label: "Circle", value: "circle" },
+  { label: "Star", value: "star" },
+  { label: "Square", value: "square" }
+];

package/dist/runtime/annotation/engine/config.js

@@ -279,5 +279,49 @@ export const annotationDefinitions = [
     resizable: true,
     draggable: true,
     icon: "i-lucide-stamp"
+  },
+  {
+    name: "formText",
+    type: AnnotationType.FORM_TEXT,
+    pdfjsEditorType: PdfjsAnnotationEditorType.NONE,
+    pdfjsAnnotationType: PdfjsAnnotationType.WIDGET,
+    subtype: "Widget",
+    isOnce: true,
+    resizable: false,
+    draggable: false,
+    icon: "i-lucide-text-cursor-input"
+  },
+  {
+    name: "formCheckbox",
+    type: AnnotationType.FORM_CHECKBOX,
+    pdfjsEditorType: PdfjsAnnotationEditorType.NONE,
+    pdfjsAnnotationType: PdfjsAnnotationType.WIDGET,
+    subtype: "Widget",
+    isOnce: true,
+    resizable: false,
+    draggable: false,
+    icon: "i-lucide-square-check"
+  },
+  {
+    name: "formSignature",
+    type: AnnotationType.FORM_SIGNATURE,
+    pdfjsEditorType: PdfjsAnnotationEditorType.NONE,
+    pdfjsAnnotationType: PdfjsAnnotationType.WIDGET,
+    subtype: "Widget",
+    isOnce: true,
+    resizable: false,
+    draggable: false,
+    icon: "i-lucide-signature"
+  },
+  {
+    name: "formRadio",
+    type: AnnotationType.FORM_RADIO,
+    pdfjsEditorType: PdfjsAnnotationEditorType.NONE,
+    pdfjsAnnotationType: PdfjsAnnotationType.WIDGET,
+    subtype: "Widget",
+    isOnce: true,
+    resizable: false,
+    draggable: false,
+    icon: "i-lucide-circle-dot"
   }
 ];

package/dist/runtime/annotation/engine/painter.d.ts

@@ -1,12 +1,14 @@
 import Konva from 'konva';
 import type { IRect } from 'konva/lib/types';
-import { type IAnnotationStore, type IAnnotationStyle, type IAnnotationType } from './types.js';
+import { type IAnnotationStore, type IAnnotationStyle, type IAnnotationType, type PlaceFieldPayload } from './types.js';
 import { type IEditorFreeTextOptions } from './tools/free-text.js';
 export interface KonvaCanvas {
     pageNumber: number;
     konvaStage: Konva.Stage;
     wrapper: HTMLDivElement;
     isActive: boolean;
+    /** Base PDF-space page height — needed for coord flipping in placement tools. */
+    pageHeight: number;
 }
 export interface PainterCallbacks {
     setDefaultMode: () => void;
@@ -20,6 +22,7 @@ export interface PainterCallbacks {
     onAnnotationChanged: (annotationStore: IAnnotationStore, selectorRect: IRect) => void;
     onRequestTextInput: IEditorFreeTextOptions['onRequestTextInput'];
     onRequestDeleteConfirm?: (id: string) => Promise<boolean>;
+    onPlaceField?: (payload: PlaceFieldPayload) => void;
 }
 export declare class Painter {
     private userName;

package/dist/runtime/annotation/engine/painter.js

@@ -22,6 +22,7 @@ import { EditorStamp } from "./tools/stamp.js";
 import { EditorNote } from "./tools/note.js";
 import { EditorArrow } from "./tools/arrow.js";
 import { EditorCloud } from "./tools/cloud.js";
+import { EditorFormField } from "./tools/form-field.js";
 import { Selector } from "./editor/selector.js";
 import { Store } from "./store.js";
 import { isIPad } from "./input-device.js";
@@ -244,6 +245,11 @@ export class Painter {
         );
         return;
       }
+      if (storeEditor instanceof EditorFormField) {
+        storeEditor.setPageHeight(
+          this.konvaCanvasStore.get(pageNumber)?.pageHeight ?? 0
+        );
+      }
       storeEditor.activate(konvaStage, annotation);
       return;
     }
@@ -312,6 +318,24 @@ export class Painter {
       case AnnotationType.STRIKEOUT:
         editor = new EditorHighLight(editorOpts, annotation.type);
         break;
+      case AnnotationType.FORM_TEXT:
+      case AnnotationType.FORM_CHECKBOX:
+      case AnnotationType.FORM_RADIO:
+      case AnnotationType.FORM_SIGNATURE: {
+        const onPlaceField = this.callbacks.onPlaceField;
+        if (!onPlaceField) {
+          console.warn("Form-field placement requires an onPlaceField callback.");
+          return;
+        }
+        const pageHeight = this.konvaCanvasStore.get(pageNumber)?.pageHeight ?? 0;
+        const fieldType = annotation.type === AnnotationType.FORM_TEXT ? "text" : annotation.type === AnnotationType.FORM_CHECKBOX ? "checkbox" : annotation.type === AnnotationType.FORM_RADIO ? "radio" : "signature";
+        editor = new EditorFormField(editorOpts, {
+          fieldType,
+          pageHeight,
+          onPlaceField
+        });
+        break;
+      }
       case AnnotationType.SELECT:
         this.selector.activate(pageNumber);
         break;
@@ -451,7 +475,8 @@ export class Painter {
       pageNumber,
       konvaStage,
       wrapper: container,
-      isActive: false
+      isActive: false,
+      pageHeight: height
     });
     this.reDrawAnnotation(pageNumber);
     this.enablePainting();

package/dist/runtime/annotation/engine/tools/form-field.d.ts

@@ -0,0 +1,24 @@
+import type { KonvaEventObject } from 'konva/lib/Node';
+import { type FormFieldType, type IAnnotationStore, type IAnnotationStyle, type PlaceFieldPayload } from '../types.js';
+import { Editor, type IEditorOptions } from '../editor/editor.js';
+export interface IEditorFormFieldOptions {
+    fieldType: FormFieldType;
+    /** PDF-space page height, needed to flip Konva page-local Y → PDF Y. */
+    pageHeight: number;
+    onPlaceField: (payload: PlaceFieldPayload) => void;
+}
+export declare class EditorFormField extends Editor {
+    private fieldType;
+    private pageHeight;
+    private onPlaceField;
+    private preview;
+    private vertex;
+    constructor(editorOptions: IEditorOptions, opts: IEditorFormFieldOptions);
+    setPageHeight(pageHeight: number): void;
+    protected mouseDownHandler(e: KonvaEventObject<MouseEvent | TouchEvent>): void;
+    protected mouseMoveHandler(e: KonvaEventObject<MouseEvent | TouchEvent>): void;
+    protected mouseUpHandler(): void;
+    private globalPointerUpHandler;
+    protected changeStyle(_a: IAnnotationStore, _s: IAnnotationStyle): void;
+    addSerializedGroupToLayer(): void;
+}

package/dist/runtime/annotation/engine/tools/form-field.js

@@ -0,0 +1,117 @@
+import Konva from "konva";
+import {
+  AnnotationType
+} from "../types.js";
+import { Editor } from "../editor/editor.js";
+const TOO_SMALL = 6;
+const DEFAULT_CHECKBOX = 18;
+const DEFAULT_RADIO = 18;
+const DEFAULT_SIGNATURE = { width: 200, height: 60 };
+export class EditorFormField extends Editor {
+  fieldType;
+  pageHeight;
+  onPlaceField;
+  preview = null;
+  vertex = { x: 0, y: 0 };
+  constructor(editorOptions, opts) {
+    super({
+      ...editorOptions,
+      editorType: opts.fieldType === "text" ? AnnotationType.FORM_TEXT : opts.fieldType === "checkbox" ? AnnotationType.FORM_CHECKBOX : opts.fieldType === "radio" ? AnnotationType.FORM_RADIO : AnnotationType.FORM_SIGNATURE
+    });
+    this.fieldType = opts.fieldType;
+    this.pageHeight = opts.pageHeight;
+    this.onPlaceField = opts.onPlaceField;
+  }
+  setPageHeight(pageHeight) {
+    this.pageHeight = pageHeight;
+  }
+  mouseDownHandler(e) {
+    if (e.currentTarget !== this.konvaStage) return;
+    const pos = this.konvaStage.getRelativePointerPosition();
+    if (!pos) return;
+    this.isPainting = true;
+    this.vertex = { x: pos.x, y: pos.y };
+    this.preview = new Konva.Rect({
+      x: pos.x,
+      y: pos.y,
+      width: 0,
+      height: 0,
+      stroke: "#1677ff",
+      strokeWidth: 1,
+      dash: [4, 4],
+      strokeScaleEnabled: false,
+      visible: false,
+      listening: false
+    });
+    this.getBgLayer().add(this.preview);
+    window.addEventListener("mouseup", this.globalPointerUpHandler);
+  }
+  mouseMoveHandler(e) {
+    if (!this.isPainting || !this.preview) return;
+    e.evt.preventDefault();
+    const pos = this.konvaStage.getRelativePointerPosition();
+    if (!pos) return;
+    this.preview.show();
+    this.preview.setAttrs({
+      x: Math.min(this.vertex.x, pos.x),
+      y: Math.min(this.vertex.y, pos.y),
+      width: Math.abs(pos.x - this.vertex.x),
+      height: Math.abs(pos.y - this.vertex.y)
+    });
+  }
+  mouseUpHandler() {
+    if (!this.isPainting) return;
+    this.isPainting = false;
+    window.removeEventListener("mouseup", this.globalPointerUpHandler);
+    const preview = this.preview;
+    if (!preview) return;
+    let x = preview.x();
+    let y = preview.y();
+    let w = preview.width();
+    let h = preview.height();
+    const dragged = preview.isVisible() && Math.max(w, h) >= TOO_SMALL;
+    if (!dragged) {
+      if (this.fieldType === "checkbox") {
+        w = DEFAULT_CHECKBOX;
+        h = DEFAULT_CHECKBOX;
+        x = this.vertex.x - w / 2;
+        y = this.vertex.y - h / 2;
+      } else if (this.fieldType === "radio") {
+        w = DEFAULT_RADIO;
+        h = DEFAULT_RADIO;
+        x = this.vertex.x - w / 2;
+        y = this.vertex.y - h / 2;
+      } else if (this.fieldType === "signature") {
+        w = DEFAULT_SIGNATURE.width;
+        h = DEFAULT_SIGNATURE.height;
+        x = this.vertex.x - w / 2;
+        y = this.vertex.y - h / 2;
+      } else {
+        preview.destroy();
+        this.preview = null;
+        return;
+      }
+    }
+    preview.destroy();
+    this.preview = null;
+    const x1 = x;
+    const x2 = x + w;
+    const y2 = this.pageHeight - y;
+    const y1 = this.pageHeight - (y + h);
+    this.onPlaceField({
+      pageNumber: this.pageNumber,
+      fieldType: this.fieldType,
+      rectPdf: [x1, y1, x2, y2]
+    });
+  }
+  globalPointerUpHandler = (e) => {
+    if (e.button !== 0) return;
+    this.mouseUpHandler();
+  };
+  changeStyle(_a, _s) {
+  }
+  // Placed fields are never re-drawn from a konva string; the form-field
+  // HTML layer owns their visual representation.
+  addSerializedGroupToLayer() {
+  }
+}

package/dist/runtime/annotation/engine/types.d.ts

@@ -53,7 +53,11 @@ export declare enum AnnotationType {
     STAMP = 10,
     NOTE = 11,
     ARROW = 12,
-    CLOUD = 13
+    CLOUD = 13,
+    FORM_TEXT = 14,
+    FORM_CHECKBOX = 15,
+    FORM_SIGNATURE = 16,
+    FORM_RADIO = 17
 }
 export interface IAnnotationType {
     name: string;
@@ -134,16 +138,42 @@ export interface IAnnotationStore {
     draggable: boolean;
 }
 export type FormFieldType = 'text' | 'checkbox' | 'radio' | 'dropdown' | 'signature' | 'button';
+/**
+ * Standard PDF checkbox glyph styles, per Acrobat's "Check Box Style"
+ * options. Each maps to a single ZapfDingbats character written to the
+ * widget's `/MK /CA` entry — see ISO 32000-1 §12.5.6.19.
+ */
+export type CheckboxStyle = 'check' | 'cross' | 'diamond' | 'circle' | 'star' | 'square';
+/**
+ * Where a form field came from. Export uses this to decide whether to
+ * update an existing PDF widget ('parsed') or create a new one ('placed',
+ * 'detected'). Missing = 'parsed' for backward compat.
+ */
+export type FormFieldOrigin = 'parsed' | 'detected' | 'placed';
 export interface FormFieldDefinition {
     id: string;
     pageNumber: number;
     fieldType: FormFieldType;
     fieldName: string;
     rect: [number, number, number, number];
+    /** The rect this field had when first parsed from the source PDF. Used
+     *  on export to detect that a parsed field has been moved/resized so
+     *  its existing widget can be updated in place. Unset for placed and
+     *  detected fields (their `rect` IS their original rect). */
+    originalRect?: [number, number, number, number];
     readOnly: boolean;
     required: boolean;
+    origin?: FormFieldOrigin;
     /** Visual shape hint for detected checkboxes (circle renders round, rectangle renders square). */
     shapeType?: DetectedShapeType;
+    /** Checkbox glyph style. Only used when fieldType === 'checkbox'.
+     *  Defaults to 'check' for placed checkboxes; populated from `/MK /CA`
+     *  for parsed checkboxes when the source PDF specifies a non-default. */
+    checkboxStyle?: CheckboxStyle;
+    /** The checkbox style this field had when first parsed from the source
+     *  PDF. Used on export to detect that a parsed checkbox's style was
+     *  changed in form-edit mode, so we know to overwrite its `/MK /CA`. */
+    originalCheckboxStyle?: CheckboxStyle;
     defaultValue?: string;
     maxLen?: number;
     multiLine?: boolean;
@@ -159,7 +189,23 @@ export interface FormFieldDefinition {
     multiSelect?: boolean;
     editable?: boolean;
     buttonLabel?: string;
+    /** Signature-only: placeholder text shown on the unsigned widget.
+     *  Defaults to 'Click to sign' when unset. */
+    promptText?: string;
+    /** Signature-only: when this signature is filled, lock other fields in
+     *  the form so they can no longer be edited. Mirrors PDF spec
+     *  /Lock /Action: 'all' locks every other field; 'include' locks only
+     *  fields listed in lockFieldNames; 'exclude' locks every field NOT
+     *  listed. Enforced inside the viewer (the viewer flattens signatures
+     *  to images on export, so this doesn't round-trip as a real /Sig
+     *  /Lock dict). */
+    lockAction?: 'all' | 'include' | 'exclude';
+    /** Field names referenced by lockAction = 'include' or 'exclude'. */
+    lockFieldNames?: string[];
     fontSize?: number;
+    /** PDF font name as parsed from `/DA` (e.g. "Helv", "HelvB", "Times-Bold").
+     *  Used to derive CSS font-family / font-weight / font-style. */
+    fontName?: string;
     color?: number[];
     backgroundColor?: number[];
     textAlignment?: number;
@@ -170,6 +216,13 @@ export interface FormFieldValue {
     fieldType: FormFieldType;
     value: string | boolean | string[];
 }
+/** Payload for placing a new form field via the drawing tool. */
+export interface PlaceFieldPayload {
+    pageNumber: number;
+    fieldType: FormFieldType;
+    /** PDF-space rect [x1, y1, x2, y2], bottom-left origin. */
+    rectPdf: [number, number, number, number];
+}
 export interface DetectedShapeRect {
     x: number;
     y: number;

package/dist/runtime/annotation/engine/types.js

@@ -54,6 +54,10 @@ export var AnnotationType = /* @__PURE__ */ ((AnnotationType2) => {
   AnnotationType2[AnnotationType2["NOTE"] = 11] = "NOTE";
   AnnotationType2[AnnotationType2["ARROW"] = 12] = "ARROW";
   AnnotationType2[AnnotationType2["CLOUD"] = 13] = "CLOUD";
+  AnnotationType2[AnnotationType2["FORM_TEXT"] = 14] = "FORM_TEXT";
+  AnnotationType2[AnnotationType2["FORM_CHECKBOX"] = 15] = "FORM_CHECKBOX";
+  AnnotationType2[AnnotationType2["FORM_SIGNATURE"] = 16] = "FORM_SIGNATURE";
+  AnnotationType2[AnnotationType2["FORM_RADIO"] = 17] = "FORM_RADIO";
   return AnnotationType2;
 })(AnnotationType || {});
 export var CommentStatus = /* @__PURE__ */ ((CommentStatus2) => {

package/dist/runtime/annotation/font-style.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Decode the font name parsed from a PDF widget's `/DA` (Default
+ * Appearance) string into CSS font properties.
+ *
+ * PDF /DA font names come in two flavours:
+ *  - PDF "abbreviations" used by Acrobat for the standard 14 fonts
+ *    (`Helv`, `HelvB`, `HelvO`, `HelvBO`, `TiRo`, `TiBo`, `TiIt`,
+ *    `TiBI`, `Cour`, `CoBo`, `CoOb`, `CoBO`, `ZaDb`, `Symb`).
+ *  - Full PostScript-style names (`Helvetica-Bold`, `Times-Italic`,
+ *    `Courier-BoldOblique`, etc.) — common in PDFs produced by other
+ *    tools.
+ *
+ * Anything we don't recognize falls back to sans-serif regular —
+ * exactly what pdf.js's annotation layer renders. Unrecognized names
+ * still keep weight/style detection via the `Bold`/`Italic`/`Oblique`
+ * substring check, so e.g. `MyFont-Bold` becomes `bold`.
+ */
+export interface DecodedFontStyle {
+    fontFamily: string;
+    fontWeight: 'normal' | 'bold';
+    fontStyle: 'normal' | 'italic';
+}
+export declare function decodeFontName(fontName: string | undefined): DecodedFontStyle;

package/dist/runtime/annotation/font-style.js

@@ -0,0 +1,57 @@
+const STANDARD_14 = {
+  // Helvetica family
+  Helv: { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "normal", fontStyle: "normal" },
+  HelvB: { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "bold", fontStyle: "normal" },
+  HelvO: { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "normal", fontStyle: "italic" },
+  HelvBO: { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "bold", fontStyle: "italic" },
+  Helvetica: { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "normal", fontStyle: "normal" },
+  "Helvetica-Bold": { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "bold", fontStyle: "normal" },
+  "Helvetica-Oblique": { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "normal", fontStyle: "italic" },
+  "Helvetica-BoldOblique": { fontFamily: '"Helvetica Neue", Helvetica, Arial, sans-serif', fontWeight: "bold", fontStyle: "italic" },
+  // Times family
+  TiRo: { fontFamily: '"Times New Roman", Times, serif', fontWeight: "normal", fontStyle: "normal" },
+  TiBo: { fontFamily: '"Times New Roman", Times, serif', fontWeight: "bold", fontStyle: "normal" },
+  TiIt: { fontFamily: '"Times New Roman", Times, serif', fontWeight: "normal", fontStyle: "italic" },
+  TiBI: { fontFamily: '"Times New Roman", Times, serif', fontWeight: "bold", fontStyle: "italic" },
+  "Times-Roman": { fontFamily: '"Times New Roman", Times, serif', fontWeight: "normal", fontStyle: "normal" },
+  "Times-Bold": { fontFamily: '"Times New Roman", Times, serif', fontWeight: "bold", fontStyle: "normal" },
+  "Times-Italic": { fontFamily: '"Times New Roman", Times, serif', fontWeight: "normal", fontStyle: "italic" },
+  "Times-BoldItalic": { fontFamily: '"Times New Roman", Times, serif', fontWeight: "bold", fontStyle: "italic" },
+  // Courier family
+  Cour: { fontFamily: '"Courier New", Courier, monospace', fontWeight: "normal", fontStyle: "normal" },
+  CoBo: { fontFamily: '"Courier New", Courier, monospace', fontWeight: "bold", fontStyle: "normal" },
+  CoOb: { fontFamily: '"Courier New", Courier, monospace', fontWeight: "normal", fontStyle: "italic" },
+  CoBO: { fontFamily: '"Courier New", Courier, monospace', fontWeight: "bold", fontStyle: "italic" },
+  Courier: { fontFamily: '"Courier New", Courier, monospace', fontWeight: "normal", fontStyle: "normal" },
+  "Courier-Bold": { fontFamily: '"Courier New", Courier, monospace', fontWeight: "bold", fontStyle: "normal" },
+  "Courier-Oblique": { fontFamily: '"Courier New", Courier, monospace', fontWeight: "normal", fontStyle: "italic" },
+  "Courier-BoldOblique": { fontFamily: '"Courier New", Courier, monospace', fontWeight: "bold", fontStyle: "italic" }
+};
+const DEFAULT_STYLE = {
+  fontFamily: "sans-serif",
+  fontWeight: "normal",
+  fontStyle: "normal"
+};
+export function decodeFontName(fontName) {
+  if (!fontName) return DEFAULT_STYLE;
+  const name = fontName.startsWith("/") ? fontName.slice(1) : fontName;
+  const standard = STANDARD_14[name];
+  if (standard) return standard;
+  const stripped = /^[A-Z]{6}\+/.test(name) ? name.slice(7) : name;
+  const lower = stripped.toLowerCase();
+  let fontFamily = "sans-serif";
+  if (/serif|times|roman|georgia|garamond|cambria/.test(lower)) {
+    fontFamily = '"Times New Roman", Times, serif';
+  } else if (/mono|courier|consolas|menlo|inconsolata/.test(lower)) {
+    fontFamily = '"Courier New", Courier, monospace';
+  } else if (/helvet|arial|verdana|tahoma|sans/.test(lower)) {
+    fontFamily = '"Helvetica Neue", Helvetica, Arial, sans-serif';
+  }
+  const isBold = /bold|black|heavy|semibold|demibold/i.test(stripped);
+  const isItalic = /italic|oblique/i.test(stripped);
+  return {
+    fontFamily,
+    fontWeight: isBold ? "bold" : "normal",
+    fontStyle: isItalic ? "italic" : "normal"
+  };
+}

package/dist/runtime/annotation/parsers/extractCheckboxStyles.d.ts

@@ -0,0 +1,21 @@
+import type { CheckboxStyle } from '../engine/types.js';
+/**
+ * Walk the AcroForm of a source PDF and extract the checkbox style hint
+ * (`/MK /CA`) for every checkbox widget. pdf.js does not surface this
+ * field, so without a side-channel parse we cannot know whether an
+ * existing checkbox should render as a check, cross, diamond, etc.
+ *
+ * Returns a Map keyed by field name. If multiple widgets share a name
+ * (uncommon for checkboxes, normal for radio groups), the first hit
+ * wins.
+ */
+export declare function extractCheckboxStyles(pdfBytes: Uint8Array | ArrayBuffer): Promise<Map<string, CheckboxStyle>>;
+/**
+ * Walk the AcroForm and extract push-button captions from `/MK /CA`.
+ * pdf.js exposes neither the caption nor a button label, so without this
+ * side-channel parse every push button would render with our generic
+ * "Button" fallback (e.g. a Reset button shows the wrong text).
+ *
+ * Returns a Map keyed by the button's fully qualified field name.
+ */
+export declare function extractButtonCaptions(pdfBytes: Uint8Array | ArrayBuffer): Promise<Map<string, string>>;