@zumer/snapdom-plugins 3.0.0 → 4.0.1

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Plugin changes
+
+## 4.0.1
+
+- Add GitHub Sponsors funding metadata.
+- Raise the SnapDOM peer dependency to ^3.3.0 and document the minimum supported core version.
+- Explicitly include the PDF README in the package and update packaging checks.
+
+Requires SnapDOM 3.3.0 or newer within 3.x.
+
+## 4.0.0
+
+- Replace pdf-image with the full PDF exporter previously distributed as PDF Pro. Import pdf from @zumer/snapdom-plugins/pdf; toPdf returns a Blob, with optional download, selectable text, links and pagination.
+- Add the MIT-licensed Vector plugin with internal SVD, editable SVG and Figma clipboard exports.
+- Add typed HTML, context, map, ASCII and recording result methods.
+- Add escaped title and language metadata to HTML snapshots.
+- Add optional colored HTML ASCII previews and contrast control while preserving plain-text defaults.
+- Handle Unicode code points in ASCII ramps and reject empty ramps.
+- Reject invalid semantic budgets, map widths and tint opacity with explicit errors.
+
+Requires SnapDOM 3.x. This version is published on npm.

package/README.md

@@ -2,20 +2,20 @@
 
 Official plugins for [SnapDOM](https://github.com/zumerlab/snapdom), a capture engine for
 web apps. Core exports images and canvases; this package adds HTML, structured context,
-element maps, PDF, ASCII, visual transforms and live GIF/video recording.
+element maps, PDF, editable vectors, ASCII, visual transforms and live GIF/video recording.
 
 Image, HTML and structured exports use captured state; GIF and video start a sequence of
 live captures when their export method is called.
 
 ## Install
 
-Install the plugins next to a matching core:
+Install the plugins next to a core supported by their peer dependency:
 
 ```bash
 npm install @zumer/snapdom@latest @zumer/snapdom-plugins@latest
 ```
 
-Plugins 3.x require a 3.x core. See the [migration guide](https://github.com/zumerlab/snapdom#migrating-from-v2) when upgrading from v2.
+Plugins 4.x in this checkout require SnapDOM 3.3.0 or newer within 3.x. The 4.x release replaces pdf-image with the full PDF exporter and adds Vector. Both are MIT-licensed and available on npm in `@zumer/snapdom-plugins` 4.x. The `@latest` command above installs the published release. See the [migration guide](https://github.com/zumerlab/snapdom#migrating-from-v2) when upgrading from v2.
 
 ## Usage
 
@@ -169,7 +169,7 @@ Use `blocks` to hide the subtree that paints visible content. A `value` attribut
 an input or textarea clears its displayed value and omits its structured `state.value`.
 Existing default field masks still apply when you add block or attribute rules.
 
-HTML exports use the sanitized clone. `agent-map` and `context-export` apply the same
+HTML exports use the prepared clone with the selected redaction rules. `agent-map` and `context-export` apply the same
 block, attribute and field rules to their source-derived data, regardless of official
 plugin order. The rules do not search arbitrary text or images for sensitive content.
 
@@ -206,7 +206,7 @@ snapdom(el, { plugins: [colorTint({ color: 'royalblue', opacity: 0.4 })] });
 
 ### `ascii-export`
 
-Adds a `toAscii()` export method that converts captures to ASCII art.
+Adds a `toAscii()` export method that converts captures to ASCII art. Plain text remains the default. Use `toAscii({ format: 'html', contrast: 0.8 })` for a colored, compact HTML preview; contrast defaults to zero and does not change existing text exports.
 
 ```js
 import { asciiExport } from '@zumer/snapdom-plugins/ascii-export';
@@ -226,23 +226,33 @@ console.log(art);
 
 ---
 
-### `pdf-image`
+### `pdf`
 
-Adds `toPdfImage()`, which downloads a single-page A4 PDF containing a JPEG of the capture.
-Text is part of the image. The method returns a temporary object URL, revoked after five seconds.
+Adds `toPdf()`, returning a PDF Blob with the capture's appearance, selectable text,
+links and pagination. This is the MIT-licensed full exporter formerly distributed as PDF Pro.
+It replaces `pdf-image`; there is no second image-only PDF implementation.
 
 ```js
-import { pdfImage } from '@zumer/snapdom-plugins/pdf-image';
+import { pdf } from '@zumer/snapdom-plugins/pdf';
 
-const result = await snapdom(el, { plugins: [pdfImage({ orientation: 'landscape' })] });
-await result.toPdfImage(); // triggers download
+const result = await snapdom(el, { plugins: [pdf()] });
+const blob = await result.toPdf({ page: 'a4', margin: 36 });
+await result.toPdf({ page: 'letter', download: 'report.pdf' });
 ```
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `orientation` | `string` | `'portrait'` | `'portrait'` \| `'landscape'` |
-| `quality` | `number` | `0.92` | JPEG quality (0–1) |
-| `filename` | `string` | `'capture.pdf'` | Download filename |
+Configure capture-time measurement on `pdf({ forms, outline, breakAvoid, shadow,
+formValues })`. Configure paper size, orientation, margins, tagging, metadata,
+headers, footers, compression or encryption on `toPdf()`. Downloads are opt-in;
+ordinary exports return a Blob. See [the PDF overview](pdf/README.md) and [full reference](pdf/REFERENCE.md).
+
+**Migration:** import `pdf` from `/pdf`, replace `pdfImage()` with `pdf()`, and
+replace `toPdfImage()` with `toPdf({ download: 'capture.pdf' })`. Put orientation
+on the export. The old temporary object-URL return becomes a persistent Blob.
+The default page sizing and pagination differ: choose `page: 'a4'` explicitly.
+
+Tagged output alone is not a PDF/UA conformance guarantee. The exporter reports
+eligibility and blockers. Redact source text structurally; covering pixels does
+not remove text from a searchable document.
 
 ---
 
@@ -385,6 +395,8 @@ await result.toHtml({ download: 'snapshot.html' });
 |--------|------|---------|-------------|
 | `fullDocument` | `boolean` | `true` | Wrap output in `<!DOCTYPE html>…`; if `false`, return just `<style>` + the fragment |
 | `filename` | `string` | `'capture.html'` | Download filename when `opts.download` is `true` |
+| `title` | `string` | `'Captured interface'` | Escaped document title |
+| `lang` | `string` | `'en'` | Escaped document language |
 
 Per-call `opts` accepts `fullDocument`, `filename` and `download`. Set `download: true` to
 download, or pass a filename string. The method returns the HTML string either way.
@@ -393,6 +405,24 @@ The document retains source markup, including event-handler attributes; it is no
 
 ---
 
+### `vector`
+
+Adds `toVector()` for standalone SVG with editable text and supported shapes, and
+`toFigma()` for Figma clipboard export. Its source and internal SVD format live in
+`vector/` under the MIT license. Both exporters are available on npm in `@zumer/snapdom-plugins` 4.x.
+
+```js
+import { vector } from '@zumer/snapdom-plugins/vector';
+const result = await snapdom(el, { plugins: [vector()] });
+const svg = await result.toVector({ exclude: '.private' });
+await result.toFigma(); // HTTPS or localhost, from a user action
+```
+
+Register per capture. Unsupported paint is diagnosed; the connected source and
+its styles must remain available during export. See [Vector](./vector/README.md).
+
+---
+
 ### `gif-export`
 
 Adds `toGif()`, which records the live element and returns an `image/gif` Blob. Its built-in
@@ -500,3 +530,7 @@ See [PLUGIN_SPEC.md](../../PLUGIN_SPEC.md) for the full hook specification and [
 ## License
 
 MIT
+
+## Live demos
+
+Run `npm run compile` and `npm run site` from the monorepo root, then open `/playground/`, `/pro/pdf/` or `/pro/vector/`. The demos generate actual files from editable DOM samples; the `/pro/` paths are retained for existing links and do not denote paid plugins.

package/agent-map.d.ts

@@ -29,3 +29,35 @@ export interface AgentMapOptions {
  * of the interactive elements and their bounding boxes. Published as `prompt-export` until 2.12.0 renamed it.
  */
 export declare function agentMap(options?: AgentMapOptions): SnapdomPlugin;
+
+export interface AgentMapEntry {
+  i: number;
+  n: string;
+  r: string;
+  b: [number, number, number, number];
+  s?: Record<string, string | number | boolean>;
+  t?: string;
+  a?: Record<string, string>;
+  isSemanticOnly?: true;
+}
+export interface AgentMapResult {
+  image?: string;
+  map: AgentMapEntry[];
+  dimensions: { width: number; height: number };
+}
+export interface ToAgentMapOptions {
+  image?: 'annotated' | 'raw' | false;
+  imageFormat?: 'png' | 'jpg' | 'webp';
+  imageQuality?: number;
+  maxImageWidth?: number;
+  width?: number;
+  height?: number;
+  scale?: number;
+  dpr?: number;
+  backgroundColor?: string;
+}
+declare module '@zumer/snapdom' {
+  interface CaptureResult {
+    toAgentMap(options?: ToAgentMapOptions): Promise<AgentMapResult>;
+  }
+}

package/agent-map.js

@@ -64,12 +64,12 @@ export function agentMap(options = {}) {
   // The map is read in afterClone: with no clone there is no map, only a plausible-looking
   // empty one.
   if (needs !== 'clone' && needs !== 'render') {
-    throw new Error(`[snapdom] agent-map cannot run at stage '${needs}': it supports clone, render`);
+    throw new Error(`[SnapDOM] agent-map cannot run at stage '${needs}': it supports clone, render`);
   }
   // A capture with no render can never carry an image, and asking for both is a
   // contradiction the caller should hear now, not at export time.
   if (needs === 'clone' && image !== false) {
-    throw new Error("[snapdom] agent-map: needs: 'clone' produces no image — pass image: false, or needs: 'render'");
+    throw new Error("[SnapDOM] agent-map: needs: 'clone' makes no image; pass image: false, or use needs: 'render'.");
   }
 
   return {
@@ -97,11 +97,13 @@ export function agentMap(options = {}) {
         agentMap: async (ctx, opts = {}) => {
           const meta = ctx.__agentMapMeta;
           const wantImage = opts.image !== undefined ? opts.image : image;
-          if (!meta) throw new Error('[snapdom] agent-map: this capture carries no frozen map.');
+          if (!meta) throw new Error('[SnapDOM] agent-map: this capture has no map to export.');
 
           const format = opts.imageFormat || imageFormat;
           const quality = opts.imageQuality ?? imageQuality;
           const maxWidth = opts.maxImageWidth ?? maxImageWidth;
+          if (!Number.isFinite(maxWidth) || maxWidth < 1) throw new RangeError('[SnapDOM] agent-map: maxImageWidth must be positive');
+          if (wantImage !== false && wantImage !== 'raw' && wantImage !== 'annotated') throw new TypeError('[SnapDOM] agent-map: image must be annotated, raw or false');
           const geometry = ctx.meta;
           const sourceW = geometry?.vbW || meta.dimensions.width || 1;
           const sourceH = geometry?.vbH || meta.dimensions.height || 1;

package/ascii-export.d.ts

@@ -14,7 +14,17 @@ export interface AsciiExportOptions {
   charset?: string;
   /** Invert the luminance mapping. */
   invert?: boolean;
+  /** Plain text (default) or colored HTML with preserved character spacing. */
+  format?: 'text' | 'html';
+  /** Non-negative luminance contrast boost. */
+  contrast?: number;
 }
 
 /** Adds `result.toAscii()`. */
 export declare function asciiExport(options?: AsciiExportOptions): SnapdomPlugin;
+
+declare module '@zumer/snapdom' {
+  interface CaptureResult {
+    toAscii(options?: AsciiExportOptions): Promise<string>;
+  }
+}

package/ascii-export.js

@@ -8,6 +8,8 @@
  * @param {number} [options.width=80] - Character width of output
  * @param {string} [options.charset=' .:-=+*#%@'] - Characters from lightest to darkest
  * @param {boolean} [options.invert=false] - Invert luminance mapping
+ * @param {'text'|'html'} [options.format='text'] - Plain text or colored HTML preview
+ * @param {number} [options.contrast=0] - Non-negative luminance contrast boost
  * @returns {Object} SnapDOM plugin
  */
 export function asciiExport(options = {}) {
@@ -15,6 +17,8 @@ export function asciiExport(options = {}) {
     width: charWidth = 80,
     charset = ' .:-=+*#%@',
     invert = false,
+    format = 'text',
+    contrast = 0,
   } = options;
 
   return {
@@ -26,12 +30,17 @@ export function asciiExport(options = {}) {
           // Capture width is a pixel size, not a character count. v3 merges it into opts.
           const width = Object.hasOwn(ctx.export.requestedOptions, 'width') || opts.width !== ctx.width
             ? opts.width : charWidth;
-          if (!Number.isFinite(width) || width < 1) throw new RangeError('[snapdom] ascii-export: width must be a positive number');
+          if (!Number.isFinite(width) || width < 1) throw new RangeError('[SnapDOM] ascii-export: width must be a positive number');
           const cols = Math.floor(width);
-          const chars = opts.charset || charset;
+          const value = opts.charset ?? charset;
+          if (typeof value !== 'string' || !value.length) throw new RangeError('[SnapDOM] ascii-export: charset must be a nonempty string');
+          const chars = Array.from(value);
           const inv = opts.invert ?? invert;
+          const outputFormat = ctx.export.requestedOptions.format ?? format;
+          if (outputFormat !== 'text' && outputFormat !== 'html') throw new TypeError('[SnapDOM] ascii-export: format must be text or html');
+          const gain = opts.contrast ?? contrast;
+          if (!Number.isFinite(gain) || gain < 0) throw new RangeError('[SnapDOM] ascii-export: contrast must be non-negative');
 
-          if (!chars.length) throw new RangeError('[snapdom] ascii-export: charset must not be empty');
           // Keep core's decoded-image/Safari path and captured originals without firing hooks again.
           const source = await exports.canvas({
             ...opts, width: ctx.width, height: ctx.height, scale: 1, dpr: 1, canvas: null,
@@ -46,18 +55,24 @@ export function asciiExport(options = {}) {
           c.drawImage(source, 0, 0, cols, rows);
           const data = c.getImageData(0, 0, cols, rows).data;
 
-          let ascii = '';
+          const colored = outputFormat === 'html';
+          let ascii = colored ? '<pre style="margin:0;font:7px/1 monospace;white-space:pre;overflow-wrap:normal;max-width:100%;overflow:auto;background:white">' : '';
           for (let y = 0; y < rows; y++) {
             for (let x = 0; x < cols; x++) {
               const i = (y * cols + x) * 4;
               let lum = 1 - (data[i] * 0.299 + data[i + 1] * 0.587 + data[i + 2] * 0.114) / 255;
+              lum = Math.max(0, Math.min(1, (1 + gain) * (lum - 0.5) + 0.5));
               if (inv) lum = 1 - lum;
               const ci = Math.min(Math.floor(lum * chars.length), chars.length - 1);
-              ascii += chars[ci];
+              const char = chars[ci];
+              if (colored) {
+                const safe = char.replace(/[&<>]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c]));
+                ascii += `<span style="color:rgb(${data[i]},${data[i + 1]},${data[i + 2]})">${safe}</span>`;
+              } else ascii += char;
             }
             ascii += '\n';
           }
-          return ascii;
+          return colored ? ascii + '</pre>' : ascii;
         }
       };
     }

package/capture-frames.js

@@ -50,12 +50,12 @@ export function frameOptions(ctx, opts, defaults, name) {
   const duration = exportOption(ctx, opts, 'duration', defaults.duration);
   const frames = exportOption(ctx, opts, 'frames', defaults.frames);
   const scale = exportOption(ctx, opts, 'scale', defaults.scale ?? ctx.scale ?? 1);
-  if (!Number.isFinite(fps) || fps <= 0) throw new RangeError(`[snapdom] ${name}: fps must be positive and finite`);
-  if (!Number.isFinite(scale) || scale <= 0) throw new RangeError(`[snapdom] ${name}: scale must be positive and finite`);
-  if (frames != null && (!Number.isInteger(frames) || frames < 1)) throw new RangeError(`[snapdom] ${name}: frames must be a positive integer`);
-  if (frames == null && (!Number.isFinite(duration) || duration <= 0)) throw new RangeError(`[snapdom] ${name}: duration must be positive and finite`);
+  if (!Number.isFinite(fps) || fps <= 0) throw new RangeError(`[SnapDOM] ${name}: fps must be positive and finite`);
+  if (!Number.isFinite(scale) || scale <= 0) throw new RangeError(`[SnapDOM] ${name}: scale must be positive and finite`);
+  if (frames != null && (!Number.isInteger(frames) || frames < 1)) throw new RangeError(`[SnapDOM] ${name}: frames must be a positive integer`);
+  if (frames == null && (!Number.isFinite(duration) || duration <= 0)) throw new RangeError(`[SnapDOM] ${name}: duration must be positive and finite`);
   const count = frames ?? Math.max(1, Math.round(duration / 1000 * fps));
-  if (!Number.isFinite(count)) throw new RangeError(`[snapdom] ${name}: frame count must be finite`);
+  if (!Number.isFinite(count)) throw new RangeError(`[SnapDOM] ${name}: frame count must be finite`);
 
   // Copy capture inputs, not released stage artifacts or export-session internals. In
   // particular createContext splits exclusion predicates out of exclude: put them back.

package/color-tint.js

@@ -16,6 +16,10 @@ export function colorTint(options = {}) {
     opacity = 1,
   } = options;
 
+  if (!Number.isFinite(opacity) || opacity < 0 || opacity > 1) {
+    throw new RangeError('[SnapDOM] color-tint: opacity must be between 0 and 1');
+  }
+
   return {
     name: 'color-tint',
     pure: true,

package/context-export.d.ts

@@ -23,3 +23,26 @@ export interface ContextExportOptions {
 export declare function contextExport(options?: ContextExportOptions): SnapdomPlugin;
 
 export default contextExport;
+
+export interface ContextNode {
+  tag: string;
+  id?: string;
+  class?: string;
+  box?: [number, number, number, number];
+  text?: string;
+  state?: Record<string, string | number | boolean>;
+  children?: ContextNode[];
+}
+export interface ContextResult {
+  root: ContextNode | null;
+  truncated: boolean;
+  nodes: number;
+}
+export type ToContextOptions = Pick<ContextExportOptions, 'format' | 'maxTextLength' | 'geometry'>;
+declare module '@zumer/snapdom' {
+  interface CaptureResult {
+    toContext(options: ToContextOptions & { format: 'json' }): Promise<ContextResult>;
+    toContext(options: ToContextOptions & { format: 'outline' }): Promise<string>;
+    toContext(options?: ToContextOptions): Promise<string | ContextResult>;
+  }
+}

package/context-export.js

@@ -73,6 +73,8 @@ export function contextExport(options = {}) {
     maxNodes = 800,
     geometry = true,
   } = options
+  if (!Number.isInteger(maxNodes) || maxNodes < 1) throw new RangeError('[SnapDOM] context-export: maxNodes must be a positive integer')
+  if (!Number.isInteger(maxTextLength) || maxTextLength < 1) throw new RangeError('[SnapDOM] context-export: maxTextLength must be a positive integer')
   // `needs` names how far the capture has to run. This export reads the live page in
   // beforeClone, so it does not need pixels: `contextExport({ needs: 'clone' })` skips the
   // render. It cannot go shallower than that any more, and it should not: a capture that
@@ -106,11 +108,12 @@ export function contextExport(options = {}) {
       return {
         context: async (ctx, opts = {}) => {
           const snap = ctx.__contextSnapshot
-          if (!snap) throw new Error('[snapdom] context-export: this capture carries no snapshot (it never ran beforeClone). It is not re-read on demand — that would be a different instant.')
+          if (!snap) throw new Error('[SnapDOM] context-export: this capture has no snapshot (the plugin did not run with it). It is not re-read later, since that would be a different instant.')
           // Core carries its image format in every normalized export bag. Only this
           // plugin's two formats override its factory default.
           const _format = opts.format === 'json' || opts.format === 'outline' ? opts.format : format
           const _maxText = opts.maxTextLength ?? maxTextLength
+          if (!Number.isInteger(_maxText) || _maxText < 1) throw new RangeError('[SnapDOM] context-export: maxTextLength must be a positive integer')
           const _geometry = opts.geometry ?? geometry
 
           const root = snap.root && project(snap.root, _maxText, _geometry)

package/filter.js

@@ -26,7 +26,7 @@ export function filter(options = {}) {
   } = options;
 
   // An unknown preset must not turn the plugin off when a filter string was also given.
-  if (preset && !presets[preset]) console.warn(`[snapdom] filter: unknown preset ${JSON.stringify(preset)}`);
+  if (preset && !presets[preset]) console.warn(`[SnapDOM] filter: unknown preset ${JSON.stringify(preset)}`);
   const cssFilter = presets[preset] || filterValue;
 
   return {

package/gif-export.d.ts

@@ -27,3 +27,9 @@ export interface GifExportOptions {
 /** Adds `result.toGif()`: records a sequence of captures into an animated GIF. */
 export declare function gifExport(options?: GifExportOptions): SnapdomPlugin;
 export default gifExport;
+
+declare module '@zumer/snapdom' {
+  interface CaptureResult {
+    toGif(options?: GifExportOptions & { download?: boolean | string }): Promise<Blob>;
+  }
+}

package/gif-export.js

@@ -39,15 +39,15 @@ export function gifExport(options = {}) {
       return {
         gif: async (ctx, opts = {}) => {
           const el = ctx.element;
-          if (!el) throw new Error('[snapdom] gif-export: no source element on context');
+          if (!el) throw new Error('[SnapDOM] gif-export: there is no element to record.');
 
           const recording = frameOptions(ctx, opts, { fps, duration, frames: frameOpt, scale, background }, 'gif-export');
           const { fps: _fps, count: _count, background: _bg } = recording;
           const colors = exportOption(ctx, opts, 'maxColors', maxColors);
-          if (!Number.isFinite(colors)) throw new RangeError('[snapdom] gif-export: maxColors must be finite');
+          if (!Number.isFinite(colors)) throw new RangeError('[SnapDOM] gif-export: maxColors must be finite');
           const _max = Math.min(256, Math.max(2, Math.floor(colors)));
           const _repeat = exportOption(ctx, opts, 'repeat', repeat);
-          if (!Number.isInteger(_repeat) || _repeat < -1 || _repeat > 65535) throw new RangeError('[snapdom] gif-export: repeat must be an integer from -1 to 65535');
+          if (!Number.isInteger(_repeat) || _repeat < -1 || _repeat > 65535) throw new RangeError('[SnapDOM] gif-export: repeat must be an integer from -1 to 65535');
           const delayCs = Math.max(2, Math.round(100 / _fps)); // GIF delay unit is 1/100 s
 
           let W = 0, H = 0;

package/html-export.d.ts

@@ -8,6 +8,8 @@
 import type { SnapdomPlugin } from '@zumer/snapdom';
 
 export interface HtmlExportOptions {
+  title?: string;
+  lang?: string;
   /** Wrap in a full `<!DOCTYPE html>` document; false returns `<style>` + fragment. */
   fullDocument?: boolean;
   /** Download filename when `toHtml({ download: true })` is used. */
@@ -29,3 +31,9 @@ export interface ToHtmlOptions extends HtmlExportOptions {
 export declare function htmlExport(options?: HtmlExportOptions): SnapdomPlugin;
 
 export default htmlExport;
+
+declare module '@zumer/snapdom' {
+  interface CaptureResult {
+    toHtml(options?: ToHtmlOptions): Promise<string>;
+  }
+}

package/html-export.js

@@ -20,6 +20,8 @@ export function htmlExport(options = {}) {
   const {
     fullDocument = true,
     filename = 'capture.html',
+    title = 'Captured interface',
+    lang = 'en',
   } = options;
 
   // Where the serialized markup is parked between afterRender and toHtml. It has to hang
@@ -72,9 +74,8 @@ export function htmlExport(options = {}) {
           const frozenBody = ctx[BODY];
           if (typeof frozenBody !== 'string') {
             throw new Error(
-              '[snapdom] html-export: this capture produced no render. The plugin\'s afterRender ' +
-              'hook never ran, so there is no markup to export (a capture stopped at ' +
-              'needs:\'clone\' never reaches the render stage).'
+              '[SnapDOM] html-export: this capture produced no render, so there is no HTML ' +
+              'to export (it stopped at needs: \'clone\').'
             );
           }
           const a = ctx.artifacts;
@@ -82,8 +83,9 @@ export function htmlExport(options = {}) {
           const body = frozenBody;
 
           const asDoc = opts.fullDocument ?? fullDocument;
+          const escape = value => String(value).replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
           const html = asDoc
-            ? `<!DOCTYPE html>\n<html>\n<head>\n<meta charset="utf-8">\n<style>${css}</style>\n</head>\n<body>\n${body}\n</body>\n</html>\n`
+            ? `<!DOCTYPE html>\n<html lang="${escape(opts.lang ?? lang)}">\n<head>\n<meta charset="utf-8">\n<title>${escape(opts.title ?? title)}</title>\n<style>${css}</style>\n</head>\n<body>\n${body}\n</body>\n</html>\n`
             : `<style>${css}</style>\n${body}\n`;
 
           const dl = opts.download;

package/index.d.ts

@@ -11,9 +11,10 @@ export * from './replace-text.js';
 export * from './timestamp-overlay.js';
 export * from './redact-inputs.js';
 export * from './ascii-export.js';
-export * from './pdf-image.js';
+export * from './pdf.js';
 export * from './html-export.js';
 export * from './gif-export.js';
 export * from './video-export.js';
 export * from './agent-map.js';
 export * from './context-export.js';
+export * from './vector.js';

package/index.js

@@ -12,9 +12,10 @@ export { replaceText } from './replace-text.js';
 export { redactInputs } from './redact-inputs.js';
 export { filter } from './filter.js';
 export { colorTint } from './color-tint.js';
-export { pdfImage } from './pdf-image.js';
+export { pdf } from './pdf.js';
 export { agentMap } from './agent-map.js';
 export { contextExport } from './context-export.js';
 export { htmlExport } from './html-export.js';
 export { gifExport } from './gif-export.js';
 export { videoExport } from './video-export.js';
+export { vector } from './vector.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zumer/snapdom-plugins",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "Official plugins for SnapDOM",
   "type": "module",
   "exports": {
@@ -11,18 +11,29 @@
     "./redact-inputs": "./redact-inputs.js",
     "./filter": "./filter.js",
     "./color-tint": "./color-tint.js",
-    "./pdf-image": "./pdf-image.js",
     "./agent-map": "./agent-map.js",
     "./context-export": "./context-export.js",
     "./html-export": "./html-export.js",
     "./gif-export": "./gif-export.js",
-    "./video-export": "./video-export.js"
+    "./video-export": "./video-export.js",
+    "./pdf": "./pdf.js",
+    "./vector": "./vector.js"
   },
   "files": [
     "*.js",
     "*.d.ts",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "pdf/src/",
+    "pdf/README.md",
+    "pdf/REFERENCE.md",
+    "pdf/LICENSE",
+    "CHANGELOG.md",
+    "vector/src/",
+    "vector/svd/",
+    "vector/CONTRACT.md",
+    "vector/LICENSE",
+    "vector/README.md"
   ],
   "types": "./index.d.ts",
   "keywords": [
@@ -42,10 +53,15 @@
     "url": "https://github.com/zumerlab/snapdom/issues"
   },
   "homepage": "https://snapdom.dev/",
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/tinchox5"
+  },
   "peerDependencies": {
-    "@zumer/snapdom": "^3.0.0"
+    "@zumer/snapdom": "^3.3.0"
   },
   "devDependencies": {
     "@zumer/snapdom": "file:../.."
-  }
+  },
+  "sideEffects": false
 }

package/pdf/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ZumerLab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/pdf/README.md

@@ -0,0 +1,22 @@
+# PDF plugin
+
+MIT-licensed PDF export for SnapDOM, replacing the former PDF Pro and `pdf-image` implementations. This source is part of `@zumer/snapdom-plugins` 4.x and requires core 3.x. The 4.x release is available on npm.
+
+```js
+import { snapdom } from '@zumer/snapdom';
+import { pdf } from '@zumer/snapdom-plugins/pdf';
+
+const result = await snapdom(element, { plugins: [pdf()] });
+const blob = await result.toPdf({ page: 'a4', margin: 36 });
+await result.toPdf({ page: 'letter', download: 'report.pdf' });
+```
+
+`toPdf()` returns a `Blob`; downloading is opt-in. The exporter preserves the captured appearance and supports selectable, searchable text, links, pagination, repeated table headers, Unicode, transparency and optional form fields. Export options also cover headers, footers, metadata, tagging and encryption. Tagged output alone does not guarantee PDF/UA conformance.
+
+Put capture-time measurement options on `pdf()` and paper/output options on `toPdf()`. Structurally redact sensitive source content before capture: covering pixels does not remove searchable text. See the [full reference](REFERENCE.md) and [public types](../pdf.d.ts).
+
+## Live demo and verification
+
+From the monorepo root, run `npm run compile` and `npm run site`, then open `/pro/pdf/` or `/playground/`. These demos generate real PDFs from editable DOM samples. The retained `/pro/` URL does not denote a paid product.
+
+Run `npm run test:pdf` for the PDF engine suites. See [verification notes](test/README.md).