peasy-pdf 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Peasy Tools
+
+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/README.md

@@ -0,0 +1,260 @@
+# peasy-pdf
+
+[![npm](https://img.shields.io/npm/v/peasy-pdf)](https://www.npmjs.com/package/peasy-pdf)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+PDF manipulation library for Node.js -- merge, split, rotate, reorder, extract pages, and manage metadata. TypeScript-first with full type safety, powered by [pdf-lib](https://pdf-lib.js.org/) for pure-JavaScript PDF processing with zero native dependencies.
+
+Built from [Peasy PDF](https://peasypdf.com), the developer tools platform for PDF processing, conversion, and optimization.
+
+> **Try the interactive tools at [peasypdf.com](https://peasypdf.com)** -- [Merge PDF](https://peasypdf.com/tools/merge-pdf/), [Split PDF](https://peasypdf.com/tools/split-pdf/), [Rotate PDF](https://peasypdf.com/tools/rotate-pdf/)
+
+## Table of Contents
+
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [What You Can Do](#what-you-can-do)
+  - [Merge and Split](#merge-and-split)
+  - [Rotate and Reorder](#rotate-and-reorder)
+  - [Page Management](#page-management)
+  - [Metadata](#metadata)
+- [TypeScript Types](#typescript-types)
+- [API Reference](#api-reference)
+- [Also Available for Python](#also-available-for-python)
+- [Peasy Developer Tools](#peasy-developer-tools)
+- [License](#license)
+
+## Install
+
+```bash
+npm install peasy-pdf
+```
+
+## Quick Start
+
+```typescript
+import { merge, split, rotate, info, setMetadata } from "peasy-pdf";
+import { readFileSync, writeFileSync } from "fs";
+
+// Merge two PDFs into one
+const pdf1 = readFileSync("report-q1.pdf");
+const pdf2 = readFileSync("report-q2.pdf");
+const merged = await merge(pdf1, pdf2);
+writeFileSync("annual-report.pdf", merged);
+
+// Split a PDF by page ranges
+const parts = await split(readFileSync("document.pdf"), "1-3,4-6");
+parts.forEach((part, i) => writeFileSync(`part-${i + 1}.pdf`, part));
+
+// Rotate all pages 90 degrees clockwise
+const rotated = await rotate(readFileSync("landscape.pdf"), 90);
+
+// Get PDF information
+const pdfInfo = await info(readFileSync("document.pdf"));
+console.log(`Pages: ${pdfInfo.pages}, Title: ${pdfInfo.title}`);
+
+// Set document metadata
+const tagged = await setMetadata(readFileSync("draft.pdf"), {
+  title: "Annual Report 2026",
+  author: "Finance Team",
+});
+```
+
+## What You Can Do
+
+### Merge and Split
+
+Combine multiple PDF documents into a single file, or split a large PDF into smaller parts by page ranges. The merge operation preserves all page content, annotations, and formatting from the source documents.
+
+| Operation | Function | Description |
+|-----------|----------|-------------|
+| Merge | `merge(...sources)` | Combine multiple PDFs into one document |
+| Split | `split(source, ranges)` | Split a PDF by page ranges (e.g. "1-3,4-6") |
+
+```typescript
+import { merge, split } from "peasy-pdf";
+
+// Merge three reports into one combined document
+const combined = await merge(q1Report, q2Report, q3Report);
+
+// Split a 10-page document into three parts
+const parts = await split(document, "1-3,4-7,8-10");
+console.log(parts.length); // 3 separate PDF byte arrays
+```
+
+Learn more: [Merge PDF Tool](https://peasypdf.com/tools/merge-pdf/) -- [Split PDF Tool](https://peasypdf.com/tools/split-pdf/)
+
+### Rotate and Reorder
+
+Rotate pages by 90, 180, or 270 degrees, reverse page order, or extract odd/even pages. Rotation can target all pages or a specific subset using page specifications.
+
+| Operation | Function | Description |
+|-----------|----------|-------------|
+| Rotate | `rotate(source, angle, pages?)` | Rotate pages by 90/180/270 degrees |
+| Reverse | `reverse(source)` | Reverse the page order |
+| Odd/Even | `oddEven(source, mode)` | Extract odd or even pages |
+
+```typescript
+import { rotate, reverse, oddEven } from "peasy-pdf";
+
+// Rotate all pages 90 degrees clockwise
+const rotated = await rotate(pdf, 90);
+
+// Rotate only pages 1 and 3
+const partial = await rotate(pdf, 180, "1,3");
+
+// Reverse page order (last page becomes first)
+const reversed = await reverse(pdf);
+
+// Extract only odd pages (1, 3, 5...) for duplex printing
+const oddPages = await oddEven(pdf, "odd");
+```
+
+Learn more: [Rotate PDF Tool](https://peasypdf.com/tools/rotate-pdf/)
+
+### Page Management
+
+Delete, extract, insert, or duplicate individual pages. All page specifications use 1-based page numbers and support ranges (e.g. "1-3,5,7-9") or the keyword "all".
+
+| Operation | Function | Description |
+|-----------|----------|-------------|
+| Delete | `deletePages(source, pages)` | Remove specific pages |
+| Extract | `extractPages(source, pages)` | Extract pages into a new PDF |
+| Insert blank | `insertBlank(source, after?, options?)` | Insert blank pages |
+| Duplicate | `duplicatePages(source, pages?, copies?)` | Duplicate pages in place |
+
+```typescript
+import { deletePages, extractPages, insertBlank, duplicatePages } from "peasy-pdf";
+
+// Remove the cover page and table of contents
+const trimmed = await deletePages(pdf, "1-2");
+
+// Extract pages 5 through 10 into a new document
+const excerpt = await extractPages(pdf, "5-10");
+
+// Insert a blank separator page after page 3
+const withSeparator = await insertBlank(pdf, "3");
+
+// Insert 2 blank A4 pages at the end
+const padded = await insertBlank(pdf, undefined, {
+  count: 2,
+  width: 595,   // A4 width in points
+  height: 842,  // A4 height in points
+});
+
+// Duplicate every page (useful for printing 2-up)
+const doubled = await duplicatePages(pdf);
+```
+
+Learn more: [PDF Page Tools](https://peasypdf.com/tools/)
+
+### Metadata
+
+Read, write, or strip PDF document metadata including title, author, subject, keywords, creator, and producer fields. The `info()` function provides a quick overview including page count and file size.
+
+| Operation | Function | Description |
+|-----------|----------|-------------|
+| Info | `info(source)` | Page count, metadata, file size |
+| Get | `getMetadata(source)` | Read all metadata fields |
+| Set | `setMetadata(source, metadata)` | Update metadata fields |
+| Strip | `stripMetadata(source)` | Remove all metadata |
+
+```typescript
+import { info, getMetadata, setMetadata, stripMetadata } from "peasy-pdf";
+
+// Quick document overview
+const pdfInfo = await info(pdf);
+console.log(`${pdfInfo.pages} pages, ${pdfInfo.sizeBytes} bytes`);
+console.log(`Title: ${pdfInfo.title}, Author: ${pdfInfo.author}`);
+
+// Set metadata before publishing
+const published = await setMetadata(pdf, {
+  title: "Q1 Financial Report",
+  author: "Finance Department",
+  subject: "Quarterly financials",
+  keywords: "finance, quarterly, 2026",
+});
+
+// Strip all metadata for privacy
+const clean = await stripMetadata(pdf);
+```
+
+Learn more: [PDF Metadata Tool](https://peasypdf.com/tools/pdf-metadata/)
+
+## TypeScript Types
+
+```typescript
+import type { PdfInfo, PdfMetadata, PageSize, OddEvenMode } from "peasy-pdf";
+
+// PdfInfo -- document overview from info()
+const pdfInfo: PdfInfo = {
+  pages: 10,
+  title: "Annual Report",
+  author: "Finance Team",
+  subject: "2026 Financials",
+  creator: "peasy-pdf",
+  producer: "pdf-lib",
+  sizeBytes: 245_760,
+};
+
+// PdfMetadata -- fields for get/set metadata
+const metadata: PdfMetadata = {
+  title: "My Document",
+  author: "John Doe",
+  subject: "Testing",
+  keywords: "test, pdf",
+};
+
+// OddEvenMode -- "odd" | "even" for page extraction
+const mode: OddEvenMode = "odd";
+
+// PageSize -- standard page sizes (planned for future use)
+const size: PageSize = "a4";
+```
+
+## API Reference
+
+| Function | Description |
+|----------|-------------|
+| `merge(...sources)` | Merge multiple PDFs into one |
+| `split(source, ranges)` | Split PDF by comma-separated page ranges |
+| `rotate(source, angle, pages?)` | Rotate pages by 90/180/270 degrees |
+| `reverse(source)` | Reverse page order |
+| `deletePages(source, pages)` | Remove specified pages |
+| `extractPages(source, pages)` | Extract pages into new PDF |
+| `oddEven(source, mode)` | Extract odd or even pages |
+| `insertBlank(source, after?, options?)` | Insert blank pages |
+| `duplicatePages(source, pages?, copies?)` | Duplicate pages in place |
+| `info(source)` | Get page count, metadata, file size |
+| `getMetadata(source)` | Read document metadata |
+| `setMetadata(source, metadata)` | Set document metadata |
+| `stripMetadata(source)` | Remove all metadata |
+| `parsePages(spec, total)` | Parse page specification to 0-based indices |
+
+All functions accept `Uint8Array` (PDF bytes) and return `Promise<Uint8Array>` or structured data. No filesystem access -- works in Node.js and browsers.
+
+## Also Available for Python
+
+```bash
+pip install peasy-pdf
+```
+
+The Python package provides PDF merge, split, rotate, compress, extract text, encrypt/decrypt, and 14 more operations with CLI, MCP server, and REST API client. See [peasy-pdf on PyPI](https://pypi.org/project/peasy-pdf/).
+
+## Peasy Developer Tools
+
+| Package | PyPI | npm | Description |
+|---------|------|-----|-------------|
+| peasytext | [PyPI](https://pypi.org/project/peasytext/) | [npm](https://www.npmjs.com/package/peasytext) | Text analysis -- readability, sentiment, keywords |
+| **peasy-pdf** | [PyPI](https://pypi.org/project/peasy-pdf/) | **[npm](https://www.npmjs.com/package/peasy-pdf)** | **PDF processing -- merge, split, rotate, metadata** |
+| peasy-image | [PyPI](https://pypi.org/project/peasy-image/) | -- | Image ops -- resize, crop, filter, watermark |
+| peasy-css | [PyPI](https://pypi.org/project/peasy-css/) | [npm](https://www.npmjs.com/package/peasy-css) | CSS generation -- gradients, shadows, flexbox, grid |
+| peasy-compress | [PyPI](https://pypi.org/project/peasy-compress/) | [npm](https://www.npmjs.com/package/peasy-compress) | Archive & compression -- ZIP, gzip, brotli, deflate |
+| peasy-document | [PyPI](https://pypi.org/project/peasy-document/) | [npm](https://www.npmjs.com/package/peasy-document) | Document conversion -- DOCX, HTML, Markdown |
+
+Part of the [Peasy](https://peasytools.com) developer tools ecosystem.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,160 @@
+/** Information about a PDF document. */
+interface PdfInfo {
+    /** Total number of pages. */
+    pages: number;
+    /** Document title from metadata. */
+    title: string;
+    /** Document author from metadata. */
+    author: string;
+    /** Document subject from metadata. */
+    subject: string;
+    /** Creator application from metadata. */
+    creator: string;
+    /** PDF producer from metadata. */
+    producer: string;
+    /** File size in bytes. */
+    sizeBytes: number;
+}
+/** Metadata fields that can be set on a PDF document. */
+interface PdfMetadata {
+    title?: string;
+    author?: string;
+    subject?: string;
+    keywords?: string;
+    creator?: string;
+    producer?: string;
+}
+/** Standard page sizes. */
+type PageSize = "a3" | "a4" | "a5" | "letter" | "legal" | "tabloid";
+/** Mode for odd/even page extraction. */
+type OddEvenMode = "odd" | "even";
+
+/**
+ * peasy-pdf — PDF manipulation engine powered by pdf-lib.
+ *
+ * All functions accept Uint8Array (PDF bytes) and return Uint8Array or
+ * structured data. No filesystem access — works in Node.js and browsers.
+ */
+
+/**
+ * Parse a page specification string into zero-based page indices.
+ *
+ * Supported formats:
+ *   - "all"        — every page
+ *   - "1,3,5"      — specific pages (1-based)
+ *   - "1-3,7-9"    — ranges (inclusive, 1-based)
+ *   - "2-4,6"      — mixed ranges and singles
+ *
+ * Out-of-range values are clamped to [1, total].
+ */
+declare function parsePages(spec: string, total: number): number[];
+/**
+ * Merge multiple PDF documents into a single PDF.
+ *
+ * @param sources - Two or more PDF byte arrays to merge in order.
+ * @returns The merged PDF as a Uint8Array.
+ */
+declare function merge(...sources: Uint8Array[]): Promise<Uint8Array>;
+/**
+ * Split a PDF into multiple PDFs by page ranges.
+ *
+ * @param source - The source PDF bytes.
+ * @param ranges - Comma-separated page ranges, e.g. "1-3,4-6,7".
+ *                 Each range becomes a separate output PDF.
+ * @returns An array of PDF byte arrays, one per range group.
+ */
+declare function split(source: Uint8Array, ranges: string): Promise<Uint8Array[]>;
+/**
+ * Rotate pages by the given angle (90, 180, or 270 degrees clockwise).
+ *
+ * @param source - The source PDF bytes.
+ * @param angle  - Rotation angle in degrees (90, 180, 270).
+ * @param pages  - Optional page spec (default: "all").
+ * @returns The PDF with rotated pages.
+ */
+declare function rotate(source: Uint8Array, angle: number, pages?: string): Promise<Uint8Array>;
+/**
+ * Reverse the page order of a PDF.
+ *
+ * @param source - The source PDF bytes.
+ * @returns The PDF with pages in reverse order.
+ */
+declare function reverse(source: Uint8Array): Promise<Uint8Array>;
+/**
+ * Delete specified pages from a PDF.
+ *
+ * @param source - The source PDF bytes.
+ * @param pages  - Page spec of pages to remove (e.g. "1,3,5-7").
+ * @returns The PDF with specified pages removed.
+ */
+declare function deletePages(source: Uint8Array, pages: string): Promise<Uint8Array>;
+/**
+ * Extract specified pages from a PDF into a new PDF.
+ *
+ * @param source - The source PDF bytes.
+ * @param pages  - Page spec of pages to extract (e.g. "1-3,5").
+ * @returns A new PDF containing only the specified pages.
+ */
+declare function extractPages(source: Uint8Array, pages: string): Promise<Uint8Array>;
+/**
+ * Extract odd or even pages from a PDF.
+ *
+ * @param source - The source PDF bytes.
+ * @param mode   - "odd" for pages 1, 3, 5... or "even" for pages 2, 4, 6...
+ * @returns A new PDF containing only the selected pages.
+ */
+declare function oddEven(source: Uint8Array, mode: OddEvenMode): Promise<Uint8Array>;
+/**
+ * Insert blank pages into a PDF.
+ *
+ * @param source  - The source PDF bytes.
+ * @param after   - Page spec for insertion point (e.g. "2" inserts after page 2).
+ *                  If omitted, blank pages are appended at the end.
+ * @param options - Optional: count (default 1), width/height in points.
+ * @returns The PDF with blank pages inserted.
+ */
+declare function insertBlank(source: Uint8Array, after?: string, options?: {
+    count?: number;
+    width?: number;
+    height?: number;
+}): Promise<Uint8Array>;
+/**
+ * Duplicate pages within a PDF.
+ *
+ * @param source - The source PDF bytes.
+ * @param pages  - Page spec of pages to duplicate (default: "all").
+ * @param copies - Number of copies of each page (default: 1, meaning 2 total).
+ * @returns The PDF with duplicated pages.
+ */
+declare function duplicatePages(source: Uint8Array, pages?: string, copies?: number): Promise<Uint8Array>;
+/**
+ * Get information about a PDF document.
+ *
+ * @param source - The PDF bytes.
+ * @returns PDF info including page count, metadata, and file size.
+ */
+declare function info(source: Uint8Array): Promise<PdfInfo>;
+/**
+ * Get document metadata from a PDF.
+ *
+ * @param source - The PDF bytes.
+ * @returns The document metadata fields.
+ */
+declare function getMetadata(source: Uint8Array): Promise<PdfMetadata>;
+/**
+ * Set document metadata on a PDF.
+ *
+ * @param source   - The PDF bytes.
+ * @param metadata - Metadata fields to set. Only provided fields are updated.
+ * @returns The PDF with updated metadata.
+ */
+declare function setMetadata(source: Uint8Array, metadata: PdfMetadata): Promise<Uint8Array>;
+/**
+ * Remove all metadata from a PDF.
+ *
+ * @param source - The PDF bytes.
+ * @returns The PDF with all metadata fields cleared.
+ */
+declare function stripMetadata(source: Uint8Array): Promise<Uint8Array>;
+
+export { type OddEvenMode, type PageSize, type PdfInfo, type PdfMetadata, deletePages, duplicatePages, extractPages, getMetadata, info, insertBlank, merge, oddEven, parsePages, reverse, rotate, setMetadata, split, stripMetadata };

package/dist/index.js

@@ -0,0 +1,224 @@
+// src/engine.ts
+import { PDFDocument, degrees } from "pdf-lib";
+function parsePages(spec, total) {
+  if (spec.trim().toLowerCase() === "all") {
+    return Array.from({ length: total }, (_, i) => i);
+  }
+  const indices = [];
+  for (const part of spec.split(",")) {
+    const trimmed = part.trim();
+    if (trimmed === "") continue;
+    if (trimmed.includes("-")) {
+      const [startStr, endStr] = trimmed.split("-", 2);
+      const start = Math.max(1, parseInt(startStr, 10));
+      const end = Math.min(total, parseInt(endStr, 10));
+      for (let i = start - 1; i < end; i++) {
+        indices.push(i);
+      }
+    } else {
+      const page = parseInt(trimmed, 10);
+      if (page >= 1 && page <= total) {
+        indices.push(page - 1);
+      }
+    }
+  }
+  return indices;
+}
+async function merge(...sources) {
+  if (sources.length === 0) {
+    throw new Error("merge requires at least one PDF");
+  }
+  const merged = await PDFDocument.create();
+  for (const src of sources) {
+    const doc = await PDFDocument.load(src);
+    const pages = await merged.copyPages(doc, doc.getPageIndices());
+    pages.forEach((p) => merged.addPage(p));
+  }
+  return merged.save();
+}
+async function split(source, ranges) {
+  const srcDoc = await PDFDocument.load(source);
+  const total = srcDoc.getPageCount();
+  const rangeGroups = ranges.split(",").reduce(
+    (groups, part) => {
+      const trimmed = part.trim();
+      if (trimmed === "") return groups;
+      groups.push([trimmed]);
+      return groups;
+    },
+    []
+  );
+  const results = [];
+  for (const group of rangeGroups) {
+    const spec = group.join(",");
+    const indices = parsePages(spec, total);
+    if (indices.length === 0) continue;
+    const newDoc = await PDFDocument.create();
+    const copiedPages = await newDoc.copyPages(srcDoc, indices);
+    copiedPages.forEach((p) => newDoc.addPage(p));
+    results.push(await newDoc.save());
+  }
+  return results;
+}
+async function rotate(source, angle, pages) {
+  const doc = await PDFDocument.load(source);
+  const indices = parsePages(pages || "all", doc.getPageCount());
+  for (const idx of indices) {
+    const page = doc.getPage(idx);
+    const current = page.getRotation().angle;
+    page.setRotation(degrees(current + angle));
+  }
+  return doc.save();
+}
+async function reverse(source) {
+  const srcDoc = await PDFDocument.load(source);
+  const total = srcDoc.getPageCount();
+  const reversed = await PDFDocument.create();
+  const indices = Array.from({ length: total }, (_, i) => total - 1 - i);
+  const pages = await reversed.copyPages(srcDoc, indices);
+  pages.forEach((p) => reversed.addPage(p));
+  return reversed.save();
+}
+async function deletePages(source, pages) {
+  const srcDoc = await PDFDocument.load(source);
+  const total = srcDoc.getPageCount();
+  const toDelete = new Set(parsePages(pages, total));
+  const keepIndices = Array.from({ length: total }, (_, i) => i).filter(
+    (i) => !toDelete.has(i)
+  );
+  if (keepIndices.length === 0) {
+    throw new Error("Cannot delete all pages from a PDF");
+  }
+  const newDoc = await PDFDocument.create();
+  const copiedPages = await newDoc.copyPages(srcDoc, keepIndices);
+  copiedPages.forEach((p) => newDoc.addPage(p));
+  return newDoc.save();
+}
+async function extractPages(source, pages) {
+  const srcDoc = await PDFDocument.load(source);
+  const indices = parsePages(pages, srcDoc.getPageCount());
+  if (indices.length === 0) {
+    throw new Error("No pages to extract");
+  }
+  const newDoc = await PDFDocument.create();
+  const copiedPages = await newDoc.copyPages(srcDoc, indices);
+  copiedPages.forEach((p) => newDoc.addPage(p));
+  return newDoc.save();
+}
+async function oddEven(source, mode) {
+  const srcDoc = await PDFDocument.load(source);
+  const total = srcDoc.getPageCount();
+  const indices = [];
+  for (let i = 0; i < total; i++) {
+    const pageNum = i + 1;
+    if (mode === "odd" && pageNum % 2 === 1) indices.push(i);
+    if (mode === "even" && pageNum % 2 === 0) indices.push(i);
+  }
+  if (indices.length === 0) {
+    throw new Error(`No ${mode} pages found`);
+  }
+  const newDoc = await PDFDocument.create();
+  const copiedPages = await newDoc.copyPages(srcDoc, indices);
+  copiedPages.forEach((p) => newDoc.addPage(p));
+  return newDoc.save();
+}
+async function insertBlank(source, after, options) {
+  const doc = await PDFDocument.load(source);
+  const total = doc.getPageCount();
+  const count = options?.count ?? 1;
+  const width = options?.width ?? 612;
+  const height = options?.height ?? 792;
+  if (after === void 0 || after === null) {
+    for (let i = 0; i < count; i++) {
+      doc.addPage([width, height]);
+    }
+  } else {
+    const indices = parsePages(after, total);
+    if (indices.length === 0) {
+      throw new Error("Invalid page specification for insertion point");
+    }
+    const insertAfter = Math.max(...indices);
+    for (let i = 0; i < count; i++) {
+      doc.insertPage(insertAfter + 1 + i, [width, height]);
+    }
+  }
+  return doc.save();
+}
+async function duplicatePages(source, pages, copies) {
+  const srcDoc = await PDFDocument.load(source);
+  const total = srcDoc.getPageCount();
+  const indices = parsePages(pages || "all", total);
+  const numCopies = copies ?? 1;
+  const newDoc = await PDFDocument.create();
+  for (let i = 0; i < total; i++) {
+    const [page] = await newDoc.copyPages(srcDoc, [i]);
+    newDoc.addPage(page);
+    if (indices.includes(i)) {
+      for (let c = 0; c < numCopies; c++) {
+        const [copy] = await newDoc.copyPages(srcDoc, [i]);
+        newDoc.addPage(copy);
+      }
+    }
+  }
+  return newDoc.save();
+}
+async function info(source) {
+  const doc = await PDFDocument.load(source);
+  return {
+    pages: doc.getPageCount(),
+    title: doc.getTitle() ?? "",
+    author: doc.getAuthor() ?? "",
+    subject: doc.getSubject() ?? "",
+    creator: doc.getCreator() ?? "",
+    producer: doc.getProducer() ?? "",
+    sizeBytes: source.byteLength
+  };
+}
+async function getMetadata(source) {
+  const doc = await PDFDocument.load(source);
+  return {
+    title: doc.getTitle() ?? void 0,
+    author: doc.getAuthor() ?? void 0,
+    subject: doc.getSubject() ?? void 0,
+    keywords: doc.getKeywords() ?? void 0,
+    creator: doc.getCreator() ?? void 0,
+    producer: doc.getProducer() ?? void 0
+  };
+}
+async function setMetadata(source, metadata) {
+  const doc = await PDFDocument.load(source);
+  if (metadata.title !== void 0) doc.setTitle(metadata.title);
+  if (metadata.author !== void 0) doc.setAuthor(metadata.author);
+  if (metadata.subject !== void 0) doc.setSubject(metadata.subject);
+  if (metadata.keywords !== void 0)
+    doc.setKeywords([metadata.keywords]);
+  if (metadata.creator !== void 0) doc.setCreator(metadata.creator);
+  if (metadata.producer !== void 0) doc.setProducer(metadata.producer);
+  return doc.save();
+}
+async function stripMetadata(source) {
+  const doc = await PDFDocument.load(source);
+  doc.setTitle("");
+  doc.setAuthor("");
+  doc.setSubject("");
+  doc.setKeywords([]);
+  doc.setCreator("");
+  doc.setProducer("");
+  return doc.save();
+}
+export {
+  deletePages,
+  duplicatePages,
+  extractPages,
+  getMetadata,
+  info,
+  insertBlank,
+  merge,
+  oddEven,
+  parsePages,
+  reverse,
+  rotate,
+  setMetadata,
+  split,
+  stripMetadata
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "peasy-pdf",
+  "version": "0.1.0",
+  "description": "PDF manipulation library for Node.js — merge, split, rotate, extract text, metadata. TypeScript-first.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "pdf",
+    "merge",
+    "split",
+    "rotate",
+    "extract",
+    "metadata",
+    "peasy"
+  ],
+  "author": "Peasy Tools",
+  "license": "MIT",
+  "repository": {
+    "url": "https://github.com/peasytools/peasy-pdf-js.git"
+  },
+  "homepage": "https://peasypdf.com",
+  "dependencies": {
+    "pdf-lib": "^1.17"
+  },
+  "devDependencies": {
+    "tsup": "^8.0",
+    "typescript": "^5.7",
+    "vitest": "^3.0"
+  }
+}