Skip to content
PDF Oxide

Referência da API JavaScript

O PDF Oxide oferece bindings WebAssembly para JavaScript e TypeScript. O pacote npm pdf-oxide-wasm funciona em Node.js, navegadores, bundlers, Deno e Cloudflare Workers.

npm install pdf-oxide-wasm

Empacotamento multi-target (v0.3.38)

O pdf-oxide-wasm agora distribui três builds lado a lado por meio de exports condicionais no package.json. Escolha o subcaminho que corresponde ao seu runtime — o import de nível superior, roteado automaticamente, também resolve corretamente pelo campo exports na maioria dos ambientes.

Subcaminho Target
pdf-oxide-wasm/nodejs Node.js (CommonJS + ESM)
pdf-oxide-wasm/bundler Vite, webpack, Rollup, esbuild, Bun
pdf-oxide-wasm/web Navegadores, Deno, Cloudflare Workers 
// Node.js
import { WasmPdfDocument } from "pdf-oxide-wasm/nodejs";

// Vite / webpack / Rollup
import init, { WasmPdfDocument } from "pdf-oxide-wasm/bundler";
await init();

// Browsers / Deno / Workers
import init, { WasmPdfDocument } from "pdf-oxide-wasm/web";
await init();

Isso corrige o ReferenceError: Can't find variable: __dirname lançado em bundlers de navegador antes da v0.3.38.

Para a API Rust, veja a Referência da API Rust. Para a API Python, veja a Referência da API Python. Para detalhes de tipos, veja Tipos e Enums.

Alguns métodos dependem de features de build do Rust (rendering, signatures, barcodes, ocr-tract). O pacote padrão pdf-oxide-wasm habilita o conjunto comum; o OCR é distribuído no build separado wasm-ocr. Veja Disponibilidade de recursos.

Funções de módulo

Funções livres exportadas no nível superior do pacote.

import {
  setLogLevel, disableLogging,
  generateBarcodeSvg, generateQrSvg,
  planSplitByBookmarks, splitByBookmarks,
  setCryptoPolicy, cryptoPolicy, cryptoInventory, cryptoCbom,
  modelManifest, prefetchAvailable,
  signPdfBytes, signPdfBytesPades, hasDocumentTimestamp,
} from "pdf-oxide-wasm";

Logging

setLogLevel(level)   // Define o nível de verbosidade do log: "off" | "error" | "warn" | "info" | "debug" | "trace"
disableLogging()     // Silencia toda a saída de log

Códigos de barras

generateBarcodeSvg(barcodeType, data) -> string  // Código de barras 1D em SVG; tipo 0–7 (Code128, Code39, Ean13, Ean8, UpcA, Itf, Code93, Codabar)
generateQrSvg(data, errorCorrection, size) -> string  // QR code em SVG; errorCorrection 0=Low 1=Medium 2=Quartile 3=High

Divisão por marcadores

planSplitByBookmarks(srcBytes, titlePrefix, ignoreCase, level, includeFrontMatter) -> Array  // Planeja uma divisão sem gerar PDFs; retorna descritores de segmento
splitByBookmarks(srcBytes, titlePrefix, ignoreCase, level, includeFrontMatter) -> Array       // Divide nos limites dos marcadores; retorna pares [segment, bytes] (level 0=todas as profundidades, 1=nível superior)

Governança de criptografia

setCryptoPolicy(spec)   // Instala a política de criptografia válida para todo o processo ("compat" | "strict" | "fips-strict"[;…]); fail-closed
cryptoPolicy() -> string  // A política de criptografia ativa como sua string canônica de gramática
cryptoInventory() -> string[]  // Tokens de algoritmos usados até agora neste processo
cryptoCbom() -> string  // Cryptographic Bill of Materials no formato CycloneDX 1.6 (string JSON)

Provisionamento de modelos de OCR

modelManifest() -> string   // Manifesto JSON com nomes de arquivo do cache de detector/recognizer de OCR e URLs de origem (fetch no lado do host)
prefetchAvailable() -> boolean  // Indica se este build pode baixar modelos de OCR para um cache local (sempre false no WASM)

Assinatura (funções livres)

signPdfBytes(pdfData, cert, reason?, location?) -> Uint8Array  // Assina bytes brutos de PDF com um WasmCertificate; retorna o PDF assinado
signPdfBytesPades(pdfData, cert, level, timestampToken?, revocation?, reason?, location?) -> Uint8Array  // Assina em um nível baseline PAdES (BB/BT/BLt); passe um token RFC 3161 pré-obtido para BT/BLt
hasDocumentTimestamp(pdfData) -> boolean  // Indica se o PDF carrega um /DocTimeStamp de escopo de documento (PAdES-B-LTA)

WasmPdfDocument

A classe principal para abrir, extrair, editar e salvar PDFs.

import { WasmPdfDocument } from "pdf-oxide-wasm";

Construtor

new WasmPdfDocument(data, password?)

Carrega um documento PDF a partir de bytes brutos.

Parâmetro Tipo Descrição
data Uint8Array O conteúdo do arquivo PDF
password string | undefined Senha opcional para PDFs criptografados

Lança: Error se o PDF for inválido ou não puder ser analisado.

const bytes = new Uint8Array(readFileSync("document.pdf"));
const doc = new WasmPdfDocument(bytes);

Construtores estáticos

WasmPdfDocument.openFromDocxBytes(data) -> WasmPdfDocument  // Converte bytes de DOCX em um documento PDF
WasmPdfDocument.openFromPptxBytes(data) -> WasmPdfDocument  // Converte bytes de PPTX em um documento PDF
WasmPdfDocument.openFromXlsxBytes(data) -> WasmPdfDocument  // Converte bytes de XLSX em um documento PDF

Núcleo somente leitura

pageCount() -> number

Obtém o número de páginas do documento.

version() -> Uint8Array

Obtém a versão do PDF como [major, minor].

const [major, minor] = doc.version();
console.log(`PDF ${major}.${minor}`);

authenticate(password) -> boolean

Descriptografa um PDF criptografado. Retorna true se a autenticação for bem-sucedida.

Parâmetro Tipo Descrição
password string A string da senha

hasStructureTree() -> boolean

Verifica se o documento é um Tagged PDF com árvore de estrutura.

Inspeção de assinaturas

signatureCount() -> number          // Número de assinaturas digitais no documento
signatures() -> WasmSignature[]     // Assinaturas analisadas (signer, reason, time, verify())
dss() -> Dss | null                 // Document Security Store (certs/CRLs/OCSP), ou null

Extração de texto

extractText(pageIndex, region?) -> string

Extrai texto puro de uma única página. Passe uma região opcional [x, y, w, h] para limitar a extração.

Parâmetro Tipo Descrição
pageIndex number Número da página (base zero)
region number[] | undefined Recorte opcional [x, y, width, height] 
const text = doc.extractText(0);

extractAllText() -> string

Extrai texto puro de todas as páginas, separadas por caracteres de form feed.

extractStructured(pageIndex) -> string

Extrai uma representação JSON estruturada da página (blocos, linhas, estilização).

extractChars(pageIndex, region?) -> Array

Extrai caracteres individuais com posicionamento preciso e metadados de fonte.

Parâmetro Tipo Descrição
pageIndex number Número da página (base zero)
region number[] | undefined Recorte opcional [x, y, width, height]

Retorna: Array de objetos com os campos:

Campo Tipo Descrição
char string O caractere
bbox {x, y, width, height} Caixa delimitadora
fontName string Nome da fonte
fontSize number Tamanho da fonte em pontos
fontWeight string Peso (Normal, Bold, etc.)
isItalic boolean Flag de itálico
color {r, g, b} Cor RGB (0.0–1.0) 
const chars = doc.extractChars(0);
for (const c of chars) {
  console.log(`'${c.char}' at (${c.bbox.x}, ${c.bbox.y})`);
}

extractPageText(pageIndex, readingOrder?) -> object

Obtém spans, caracteres e dimensões da página em uma única passagem de extração. Mais eficiente do que chamar extractSpans() + extractChars() separadamente. Passe "column_aware" para PDFs com múltiplas colunas.

Parâmetro Tipo Descrição
pageIndex number Número da página (base zero)
readingOrder string | undefined "column_aware" ou "top_to_bottom" (padrão)

Retorna: Um objeto com os campos:

Campo Tipo Descrição
spans Array Array de objetos span
chars Array Array de objetos de caractere
pageWidth number Largura da página em pontos PDF
pageHeight number Altura da página em pontos PDF
text string Conteúdo de texto completo 
const result = doc.extractPageText(0);
console.log(`Page: ${result.pageWidth}x${result.pageHeight} pt`);
for (const span of result.spans) {
  console.log(`'${span.text}' font=${span.fontName} size=${span.fontSize}`);
}

extractSpans(pageIndex, region?, readingOrder?) -> Array

Extrai spans de texto estilizado com metadados de fonte. Passe "column_aware" como readingOrder para PDFs com múltiplas colunas.

Parâmetro Tipo Descrição
pageIndex number Número da página (base zero)
region number[] | undefined Recorte opcional [x, y, width, height]
readingOrder string | undefined "column_aware" ou "top_to_bottom" (padrão)

Retorna: Array de objetos com os campos:

Campo Tipo Descrição
text string O conteúdo de texto
bbox {x, y, width, height} Caixa delimitadora
fontName string Nome da fonte
fontSize number Tamanho da fonte em pontos
fontWeight string Peso (Normal, Bold, etc.)
isItalic boolean Flag de itálico
isMonospace boolean Indica se a fonte é de largura fixa
charWidths number[] Larguras de avanço por glifo
color {r, g, b} Cor RGB (0.0–1.0) 
const spans = doc.extractSpans(0);
for (const span of spans) {
  console.log(`"${span.text}" size=${span.fontSize}`);
}

Palavras, linhas, tabelas

extractWords(pageIndex, region?) -> Array       // Caixas em nível de palavra com texto + metadados de fonte
extractTextLines(pageIndex, region?) -> Array   // Caixas em nível de linha, cada uma com suas palavras
extractTables(pageIndex, region?) -> Array      // Tabelas detectadas com linhas/células (texto + bboxes)

Artefatos de cabeçalho / rodapé

Detecte e remova ou apague cabeçalhos, rodapés e artefatos de elementos de página recorrentes.

removeHeaders(threshold) -> number     // Remove cabeçalhos detectados em todo o documento; retorna a quantidade removida
removeFooters(threshold) -> number     // Remove rodapés detectados; retorna a quantidade removida
removeArtifacts(threshold) -> number   // Remove artefatos de página detectados; retorna a quantidade removida
eraseHeader(pageIndex)                 // Agenda o apagamento da região de cabeçalho em uma página
editHeader(pageIndex)                  // Marca a região de cabeçalho para edição em uma página
eraseFooter(pageIndex)                 // Agenda o apagamento da região de rodapé em uma página
editFooter(pageIndex)                  // Marca a região de rodapé para edição em uma página
eraseArtifacts(pageIndex)              // Agenda o apagamento dos artefatos detectados em uma página

Extração por região

within(pageIndex, region) -> WasmPdfPageRegion

Restringe a extração subsequente a uma região retangular de uma página. region é [x, y, width, height]. Veja WasmPdfPageRegion.

const region = doc.within(0, [50, 600, 400, 150]);
const text = region.extractText();

Conversão de formato

toMarkdown(pageIndex, detectHeadings?, includeImages?, includeFormFields?) -> string

Converte uma única página em Markdown.

Parâmetro Tipo Padrão Descrição
pageIndex number – Número da página (base zero)
detectHeadings boolean true Detecta títulos pelo tamanho da fonte
includeImages boolean true Inclui imagens
includeFormFields boolean true Inclui valores de campos de formulário

toMarkdownAll(detectHeadings?, includeImages?, includeFormFields?) -> string

Converte todas as páginas em Markdown.

toHtml(pageIndex, preserveLayout?, detectHeadings?, includeFormFields?) -> string

Converte uma única página em HTML.

Parâmetro Tipo Padrão Descrição
pageIndex number – Número da página (base zero)
preserveLayout boolean false Preserva o layout visual
detectHeadings boolean true Detecta títulos
includeFormFields boolean true Inclui valores de campos de formulário

toHtmlAll(preserveLayout?, detectHeadings?, includeFormFields?) -> string

Converte todas as páginas em HTML.

toPlainText(pageIndex) -> string

Converte uma única página em texto puro.

toPlainTextAll() -> string

Converte todas as páginas em texto puro.

Round-trip do Office

toDocxBytes() -> Uint8Array   // Exporta o documento como arquivo DOCX
toPptxBytes() -> Uint8Array   // Exporta o documento como arquivo PPTX
toXlsxBytes() -> Uint8Array   // Exporta o documento como arquivo XLSX

Busca

search(pattern, caseInsensitive?, literal?, wholeWord?, maxResults?) -> Array

Busca texto em todas as páginas.

Parâmetro Tipo Padrão Descrição
pattern string – Padrão de busca (string ou regex)
caseInsensitive boolean false Busca sem diferenciar maiúsculas/minúsculas
literal boolean false Trata o padrão como string literal
wholeWord boolean false Corresponde apenas a palavras inteiras
maxResults number 0 Máximo de resultados (0 = ilimitado)

Retorna: Array de objetos com os campos:

Campo Tipo Descrição
page number Número da página
text string Texto correspondido
bbox object Caixa delimitadora
startIndex number Índice inicial no texto da página
endIndex number Índice final no texto da página

searchPage(pageIndex, pattern, caseInsensitive?, literal?, wholeWord?, maxResults?) -> Array

Busca texto dentro de uma única página.

Informações de imagem

extractImages(pageIndex) -> Array

Obtém metadados de imagem de uma página.

Campo Tipo Descrição
width number Largura da imagem em pixels
height number Altura da imagem em pixels
colorSpace string Espaço de cor (ex.: DeviceRGB)
bitsPerComponent number Bits por canal de cor
bbox object Posição na página

extractImageBytes(pageIndex) -> Array

Extrai os bytes brutos de imagem de uma página. Retorna um array de objetos:

Campo Tipo Descrição
width number Largura da imagem em pixels
height number Altura da imagem em pixels
data Uint8Array Bytes brutos da imagem
format string Formato da imagem

pageImages(pageIndex) -> Array

Obtém nomes e limites das imagens para operações de posicionamento.

Campo Tipo Descrição
name string Nome do XObject
bounds number[] [x, y, width, height]
matrix number[] Matriz de transformação [a, b, c, d, e, f]

Conteúdo vetorial

extractPaths(pageIndex, region?) -> Array   // Caminhos vetoriais (linhas, curvas, formas) em uma página
extractRects(pageIndex, region?) -> Array   // Retângulos alinhados aos eixos detectados a partir de segmentos de caminho
extractLines(pageIndex, region?) -> Array   // Segmentos de reta detectados a partir dos dados de caminho

Estrutura do documento

getOutline() -> Array | null

Obtém os marcadores / sumário do documento. Retorna null se não houver outline.

getAnnotations(pageIndex) -> Array

Obtém metadados de anotações (tipo, rect, conteúdo, etc.) de uma página.

pageLabels() -> Array

Obtém os intervalos de rótulos de página. Retorna um array de objetos:

Campo Tipo Descrição
startPage number Primeira página deste intervalo
style string Estilo de numeração
prefix string Prefixo do rótulo
startValue number Número inicial

xmpMetadata() -> object | null

Obtém os metadados XMP. Retorna null se não estiverem presentes. Os campos do objeto incluem:

Campo Tipo Descrição
dcTitle string | null Título do documento
dcCreator string[] | null Lista de criadores
dcDescription string | null Descrição
xmpCreatorTool string | null Ferramenta criadora
xmpCreateDate string | null Data de criação
xmpModifyDate string | null Data de modificação
pdfProducer string | null Produtor do PDF

Campos de formulário

getFormFields() -> Array

Obtém todos os campos de formulário com nome, tipo, valor e flags.

Campo Tipo Descrição
name string Nome do campo
fieldType string Tipo do campo (text, checkbox, etc.)
value string Valor atual
flags number Flags do campo 
const fields = doc.getFormFields();
for (const f of fields) {
  console.log(`${f.name} (${f.fieldType}) = ${f.value}`);
}

hasXfa() -> boolean

Verifica se o documento contém formulários XFA.

getFormFieldValue(name) -> any

Obtém o valor de um campo de formulário pelo nome. Retorna string, boolean ou null dependendo do tipo do campo.

setFormFieldValue(name, value) -> void

Define o valor de um campo de formulário pelo nome.

Parâmetro Tipo Descrição
name string Nome do campo
value string | boolean Novo valor do campo

exportFormData(format?) -> Uint8Array

Exporta os dados do formulário como FDF (padrão) ou XFDF.

Parâmetro Tipo Padrão Descrição
format string "fdf" Formato de exportação: "fdf" ou "xfdf"

Achatamento de formulários

flattenForms()                    // Achata todos os campos de formulário no conteúdo da página
flattenFormsOnPage(pageIndex)     // Achata os formulários de uma página específica
flattenWarnings() -> string[]     // Avisos produzidos pela última operação de achatamento

Edição

Metadados

Método Parâmetros Descrição
setTitle(title) string Define o título do documento
setAuthor(author) string Define o autor do documento
setSubject(subject) string Define o assunto do documento
setKeywords(keywords) string Define as palavras-chave do documento

Rotação de página

Método Parâmetros Descrição
pageRotation(pageIndex) number Obtém a rotação atual (0, 90, 180, 270)
setPageRotation(pageIndex, degrees) number, number Define a rotação absoluta
rotatePage(pageIndex, degrees) number, number Adiciona à rotação atual
rotateAllPages(degrees) number Rotaciona todas as páginas

Dimensões da página

Método Parâmetros Descrição
pageMediaBox(pageIndex) number Obtém o MediaBox [llx, lly, urx, ury]
setPageMediaBox(pageIndex, llx, lly, urx, ury) number, ... Define o MediaBox
pageCropBox(pageIndex) number Obtém o CropBox (pode ser nulo)
setPageCropBox(pageIndex, llx, lly, urx, ury) number, ... Define o CropBox
cropMargins(left, right, top, bottom) number, ... Recorta todas as margens das páginas

Operações de página

deletePage(index)                 // Exclui uma página pelo índice
movePage(fromIndex, toIndex)      // Move uma página para uma nova posição
extractPages(pages) -> Uint8Array // Cria um novo PDF a partir dos índices de página informados

Apagamento / Whiteout

Método Parâmetros Descrição
eraseRegion(pageIndex, llx, lly, urx, ury) number, ... Apaga uma região
eraseRegions(pageIndex, rects) number, Float32Array Apaga múltiplas regiões
clearEraseRegions(pageIndex) number Limpa os apagamentos pendentes

Anotações e Redação

Método Parâmetros Descrição
flattenPageAnnotations(pageIndex) number Achata as anotações da página
flattenAllAnnotations() – Achata todas as anotações
applyPageRedactions(pageIndex) number Aplica as redações da página
applyAllRedactions() – Aplica todas as redações
addRedaction(page, x0, y0, x1, y1, fill?) number, ... Enfileira uma caixa de redação (preenchimento [r,g,b] opcional)
redactionCount(page) number Conta as redações enfileiradas em uma página
applyRedactionsDestructive(scrubMetadata?) boolean Remove conteúdo de forma destrutiva; retorna um relatório de redação
sanitizeDocument(scrubMetadata?, removeJavascript?, removeEmbeddedFiles?) boolean, ... Remove metadados, scripts e arquivos embutidos; retorna um relatório

Mesclagem e incorporação

mergeFrom(data) -> number

Mescla páginas de outro PDF. Retorna o número de páginas mescladas.

Parâmetro Tipo Descrição
data Uint8Array Os bytes do arquivo PDF de origem

embedFile(name, data) -> void

Anexa um arquivo ao PDF.

Parâmetro Tipo Descrição
name string Nome de arquivo do anexo
data Uint8Array Conteúdo do arquivo

Manipulação de imagens

Método Parâmetros Descrição
repositionImage(pageIndex, name, x, y) number, string, number, number Move a imagem
resizeImage(pageIndex, name, w, h) number, string, number, number Redimensiona a imagem
setImageBounds(pageIndex, name, x, y, w, h) number, string, ... Define os limites da imagem

Classificação e Extração automática

classifyDocument() -> string                 // Classifica o documento inteiro (ex.: nascido digital vs digitalizado)
classifyPage(pageIndex) -> string            // Classifica uma única página
extractTextAuto(pageIndex) -> string         // Escolhe automaticamente extração nativa vs OCR para uma página
extractPageAuto(pageIndex, optionsJson?) -> string  // Extração automática retornando uma página JSON estruturada

Validação

validatePdfA(level) -> object        // Valida contra um nível de conformidade PDF/A (ex.: "2b")
convertToPdfA(level) -> object       // Converte rumo a um nível PDF/A; retorna um relatório
validatePdfUa(level?) -> object      // Valida contra a acessibilidade PDF/UA
validatePdfX(level?) -> object       // Valida contra um nível de impressão PDF/X

Renderização

Requer a feature rendering.

Método Parâmetros Retorna Descrição
renderPage(pageIndex, dpi?) number, number Uint8Array Renderiza uma página em bytes PNG (padrão 150 dpi)
flattenToImages(dpi?) number Uint8Array Achata todas as páginas em um PDF baseado em imagens

OCR

Requer o build wasm-ocr. Veja WasmOcrEngine.

extractTextOcr(pageIndex, engine) -> string

Executa o pipeline de OCR in-WASM em uma página usando um WasmOcrEngine construído pelo host. Retorna o texto reconhecido em ordem de leitura.

const text = doc.extractTextOcr(0, engine);

Salvar

save() -> Uint8Array

Salva o PDF editado como bytes. saveToBytes() está disponível como alias.

saveWithOptions(compress?, garbageCollect?, linearize?) -> Uint8Array

Salva com opções de serialização explícitas.

Parâmetro Tipo Padrão Descrição
compress boolean true Comprime object streams
garbageCollect boolean true Descarta objetos não referenciados
linearize boolean false Produz um PDF linearizado (“fast web view”)

saveEncryptedToBytes(password, ownerPassword?, allowPrint?, allowCopy?, allowModify?, allowAnnotate?) -> Uint8Array

Salva com criptografia AES-256.

Parâmetro Tipo Padrão Descrição
password string – Senha de usuário
ownerPassword string senha de usuário Senha de proprietário
allowPrint boolean true Permite impressão
allowCopy boolean true Permite cópia
allowModify boolean true Permite modificação
allowAnnotate boolean true Permite anotações

free()

Libera a memória WASM. Sempre chame isto ao terminar de usar o documento.

WasmPdfPageRegion

Um handle de região retornado por WasmPdfDocument.within(pageIndex, region). Os métodos de extração ficam restritos ao retângulo.

extractText() -> string       // Texto puro dentro da região
extractChars() -> Array       // Caracteres dentro da região
extractWords() -> Array       // Palavras dentro da região
extractTextLines() -> Array   // Linhas de texto dentro da região
extractTables() -> Array      // Tabelas dentro da região
extractImages() -> Array      // Imagens dentro da região
extractPaths() -> Array       // Caminhos vetoriais dentro da região
extractRects() -> Array       // Retângulos dentro da região
extractLines() -> Array       // Segmentos de reta dentro da região
extractTextOcr(engine?) -> string  // Texto por OCR dentro da região (build wasm-ocr)

WasmPdf

Classe de fábrica para criar novos PDFs.

import { WasmPdf } from "pdf-oxide-wasm";

Métodos estáticos

WasmPdf.fromMarkdown(content, title?, author?) -> WasmPdf  // Cria um PDF a partir de texto Markdown
WasmPdf.fromHtml(content, title?, author?) -> WasmPdf      // Cria um PDF a partir de HTML
WasmPdf.fromText(content, title?, author?) -> WasmPdf      // Cria um PDF a partir de texto puro
WasmPdf.fromBytes(data) -> WasmPdf                         // Abre um PDF existente a partir de bytes para modificação
WasmPdf.fromImageBytes(data) -> WasmPdf                    // PDF de página única a partir de uma imagem (JPEG/PNG)
WasmPdf.fromMultipleImageBytes(imagesArray) -> WasmPdf     // PDF de múltiplas páginas, uma página por imagem
WasmPdf.merge(pdfs) -> WasmPdf                             // Mescla um array de buffers de bytes de PDF em um só
WasmPdf.fromHtmlCss(html, css, fontBytes) -> WasmPdf       // HTML + CSS com uma única fonte embutida
WasmPdf.fromHtmlCssWithFonts(html, css, fonts) -> WasmPdf  // HTML + CSS com múltiplas fontes [name, bytes]
Parâmetro Tipo Descrição
content string Conteúdo de origem (Markdown / HTML / texto)
title string | undefined Título do documento
author string | undefined Autor do documento
data Uint8Array Bytes de arquivo PDF ou imagem
imagesArray Uint8Array[] Array de bytes de arquivos de imagem
pdfs Uint8Array[] Array de bytes de arquivos PDF para mesclar

Métodos de instância

toBytes() -> Uint8Array

Obtém o PDF como bytes.

size -> number

Tamanho do PDF em bytes (getter somente leitura).

const pdf = WasmPdf.fromMarkdown("# Hello World\n\nThis is a PDF.");
console.log(`PDF size: ${pdf.size} bytes`);
writeFileSync("output.pdf", pdf.toBytes());

WasmDocumentBuilder

Construtor fluente de baixo nível para compor PDFs página a página. Use em conjunto com WasmFluentPageBuilder.

import { WasmDocumentBuilder } from "pdf-oxide-wasm";
const builder = new WasmDocumentBuilder();

Configuração do documento

new WasmDocumentBuilder()          // Cria um builder vazio
title(title)                       // Define o título do documento
author(author)                     // Define o autor do documento
subject(subject)                   // Define o assunto do documento
keywords(keywords)                 // Define as palavras-chave do documento
creator(creator)                   // Define o nome da ferramenta criadora
onOpen(script)                     // Define uma ação JavaScript de abertura em nível de documento
taggedPdfUa1()                     // Habilita a saída Tagged PDF / PDF/UA-1
language(lang)                     // Define o idioma do documento (ex.: "en-US")
roleMap(custom, standard)          // Mapeia uma tag de estrutura personalizada para uma role padrão
registerEmbeddedFont(name, font)   // Registra uma WasmEmbeddedFont sob um nome

Criação de página e saída

a4Page() -> WasmFluentPageBuilder         // Inicia uma nova página A4
letterPage() -> WasmFluentPageBuilder     // Inicia uma nova página US Letter
page(width, height) -> WasmFluentPageBuilder  // Inicia uma página de tamanho personalizado (pontos)
commitPage(page)                          // Confirma um page builder concluído
build() -> Uint8Array                     // Finaliza e retorna os bytes do PDF
toBytesEncrypted(userPassword, ownerPassword?) -> Uint8Array  // Finaliza com criptografia AES-256

WasmFluentPageBuilder

Construtor por página retornado por a4Page() / letterPage() / page(). Enfileire operações e depois confirme com done(builder) (ou builder.commitPage(page)).

Texto e fluxo

font(name, size)                 // Define a fonte e o tamanho atuais
at(x, y)                         // Move o cursor para uma posição absoluta
text(text)                       // Desenha texto no cursor
heading(level, text)             // Desenha um título (nível 1–6)
paragraph(text)                  // Desenha um parágrafo com quebra de linha
space(points)                    // Avança o cursor verticalmente
horizontalRule()                 // Desenha uma régua horizontal
newline()                        // Avança para a próxima linha
columns(columnCount, gapPt, text)  // Distribui texto em N colunas balanceadas
footnote(refMark, noteText)      // Adiciona uma marca de nota de rodapé + nota no rodapé da página

Trechos inline

inline(text)                     // Acrescenta um trecho de texto inline
inlineBold(text)                 // Acrescenta um trecho inline em negrito
inlineItalic(text)               // Acrescenta um trecho inline em itálico
inlineColor(r, g, b, text)       // Acrescenta um trecho inline colorido (RGB 0.0–1.0)

linkUrl(url)                     // Envolve o último elemento em um link de URL
linkPage(page)                   // Vincula a outro índice de página
linkNamed(destination)           // Vincula a um destino nomeado
linkJavascript(script)           // Anexa uma ação JavaScript de link
onOpen(script)                   // Ação de abertura de página
onClose(script)                  // Ação de fechamento de página
fieldKeystroke(script)           // JavaScript de pressionamento de tecla para o último campo
fieldFormat(script)              // JavaScript de formatação para o último campo
fieldValidate(script)            // JavaScript de validação para o último campo
fieldCalculate(script)           // JavaScript de cálculo para o último campo

Anotações de marcação

highlight(r, g, b)               // Destaca o último trecho de texto (RGB 0.0–1.0)
underline(r, g, b)               // Sublinha o último trecho de texto
strikeout(r, g, b)               // Tacha o último trecho de texto
squiggly(r, g, b)                // Sublinha em ondulado o último trecho de texto
stickyNote(text)                 // Adiciona uma nota adesiva no cursor
stickyNoteAt(x, y, text)         // Adiciona uma nota adesiva em uma posição absoluta
stamp(name)                      // Adiciona uma anotação de carimbo (ex.: "Approved")
freeText(x, y, w, h, text)       // Adiciona uma caixa de anotação de texto livre
watermark(text)                  // Adiciona uma marca d'água de texto
watermarkConfidential()          // Adiciona uma marca d'água "CONFIDENTIAL"
watermarkDraft()                 // Adiciona uma marca d'água "DRAFT"

Widgets de AcroForm

textField(name, x, y, w, h, defaultValue?)            // Adiciona um campo de texto
checkbox(name, x, y, w, h, checked)                   // Adiciona uma caixa de seleção
comboBox(name, x, y, w, h, options, selected?)        // Adiciona uma caixa de combinação suspensa
radioGroup(name, values, xs, ys, ws, hs, selected?)   // Adiciona um grupo de botões de rádio (arrays paralelos)
pushButton(name, x, y, w, h, caption)                 // Adiciona um botão clicável
signatureField(name, x, y, w, h)                      // Adiciona um placeholder de assinatura não assinado

Códigos de barras e imagens

barcode1d(barcodeType, data, x, y, w, h)   // Desenha um código de barras 1D (tipo 0–7)
barcodeQr(data, x, y, size)                // Desenha um QR code
imageWithAlt(bytes, x, y, w, h, altText)   // Incorpora uma imagem com texto alternativo de acessibilidade
imageArtifact(bytes, x, y, w, h)           // Incorpora uma imagem decorativa como /Artifact

Primitivas gráficas

rect(x, y, w, h)                                  // Contorno de retângulo com traço de 1pt
filledRect(x, y, w, h, r, g, b)                   // Retângulo preenchido (RGB 0.0–1.0)
line(x1, y1, x2, y2)                              // Linha preta de 1pt
strokeRect(x, y, w, h, width, r, g, b)            // Retângulo com traço, largura + cor explícitas
strokeRectDashed(x, y, w, h, width, r, g, b, dash, phase)  // Borda de retângulo tracejada
strokeLine(x1, y1, x2, y2, width, r, g, b)        // Linha com largura + cor explícitas
strokeLineDashed(x1, y1, x2, y2, width, r, g, b, dash, phase)  // Linha tracejada
textInRect(x, y, w, h, text, align)               // Distribui texto dentro de um retângulo (align 0/1/2)

Auxiliares de layout e finalização

measure(text) -> number                  // Largura renderizada do texto na fonte atual (pontos)
remainingSpace() -> number               // Espaço vertical restante na página (pontos)
newPageSameSize()                        // Inicia uma nova página com as mesmas dimensões
table(spec)                              // Desenha uma tabela em buffer a partir de um objeto spec
streamingTable(spec) -> WasmStreamingTable  // Abre uma tabela em streaming para grandes conjuntos de dados
done(builder)                            // Confirma as operações enfileiradas desta página no document builder

Um objeto spec de table(spec) usa { columns: [{ header, width, align }], rows: [[...]], hasHeader }. Um spec de streamingTable(spec) adiciona { repeatHeader, mode, sampleRows, minColWidthPt, maxColWidthPt, maxRowspan, batchSize }.

WasmStreamingTable

Handle de tabela com streaming de linhas retornado por WasmFluentPageBuilder.streamingTable(spec). Empurre linhas incrementalmente e depois chame finish().

columnCount() -> number       // Número de colunas
pendingRowCount() -> number   // Linhas no lote atual ainda não descarregado
batchCount() -> number        // Número de lotes concluídos
pushRow(cells)                // Empurra uma linha (array de strings de célula)
pushRowSpan(cells)            // Empurra uma linha cujas células podem ter rowspans
flush()                       // Descarrega o lote atual
finish()                      // Finaliza a tabela e a reproduz na página

WasmEmbeddedFont

Uma fonte registrada para incorporação via WasmDocumentBuilder.registerEmbeddedFont.

WasmEmbeddedFont.fromBytes(data, name?) -> WasmEmbeddedFont  // Carrega uma fonte TTF/OTF a partir de bytes
font.name -> string                                          // O nome resolvido da fonte (getter)

Modelos de página

Elementos reutilizáveis de cabeçalho/rodapé aplicados em todas as páginas.

WasmArtifactStyle

new WasmArtifactStyle()        // Estilo padrão
font(name, size) -> this       // Define a família e o tamanho da fonte
bold() -> this                 // Deixa o texto em negrito
color(r, g, b) -> this         // Define a cor do texto (RGB 0.0–1.0)

WasmArtifact

new WasmArtifact()                       // Artefato vazio
WasmArtifact.left(text) -> WasmArtifact   // Texto de artefato alinhado à esquerda
WasmArtifact.center(text) -> WasmArtifact // Texto de artefato centralizado
WasmArtifact.right(text) -> WasmArtifact  // Texto de artefato alinhado à direita
withStyle(style) -> this                  // Aplica um WasmArtifactStyle
withOffset(offset) -> this                // Define o deslocamento vertical em relação à borda

WasmHeader / WasmFooter

new WasmHeader()                  // Cabeçalho vazio (WasmFooter é idêntico)
WasmHeader.left(text) -> WasmHeader     // Texto de cabeçalho alinhado à esquerda
WasmHeader.center(text) -> WasmHeader   // Texto de cabeçalho centralizado
WasmHeader.right(text) -> WasmHeader    // Texto de cabeçalho alinhado à direita

WasmPageTemplate

new WasmPageTemplate()         // Modelo vazio
header(header) -> this         // Define o artefato de cabeçalho da página
footer(footer) -> this         // Define o artefato de rodapé da página
skipFirstPage() -> this        // Omite cabeçalho/rodapé na primeira página

Assinaturas digitais

Requer a feature signatures.

WasmCertificate

WasmCertificate.load(data) -> WasmCertificate                  // Carrega um bundle de certificado DER + chave
WasmCertificate.loadPem(certPem, keyPem) -> WasmCertificate    // Carrega a partir de strings PEM de cert + chave
WasmCertificate.loadPkcs12(data, password) -> WasmCertificate  // Carrega a partir de um blob PKCS#12 (.p12/.pfx)
cert.subject -> string         // Distinguished name do sujeito (getter)
cert.issuer -> string          // Distinguished name do emissor (getter)
cert.serial -> string          // Número de série (getter)
cert.validity -> bigint[]      // [notBefore, notAfter] em segundos unix (getter)
cert.isValid -> boolean        // Indica se o certificado é válido no momento (getter)

WasmSignature

Retornado por WasmPdfDocument.signatures().

sig.signerName -> string | null          // Common name do signatário (getter)
sig.reason -> string | null              // Motivo da assinatura (getter)
sig.location -> string | null            // Local da assinatura (getter)
sig.contactInfo -> string | null         // Informações de contato do signatário (getter)
sig.signingTime -> bigint | null         // Horário da assinatura em segundos unix (getter)
sig.coversWholeDocument -> boolean       // Indica se a assinatura cobre o arquivo inteiro (getter)
sig.padesLevel -> PadesLevel             // Nível baseline PAdES da assinatura (getter)
sig.verify() -> boolean                  // Verifica a assinatura criptograficamente
sig.verifyDetached(pdfData) -> boolean   // Verifica incluindo uma checagem de messageDigest contra os bytes

WasmTimestamp

WasmTimestamp.parse(data) -> WasmTimestamp  // Analisa um TimeStampToken / TSTInfo DER
ts.time -> bigint              // Horário do timestamp em segundos unix (getter)
ts.serial -> string            // Número de série (getter)
ts.policyOid -> string         // OID de política da TSA (getter)
ts.tsaName -> string           // Nome da TSA (getter)
ts.hashAlgorithm -> number     // Id do algoritmo de hash do imprint (getter)
ts.messageImprint -> Uint8Array  // O digest do message imprint (getter)
ts.verify() -> boolean         // Verifica o token de timestamp

WasmRevocationMaterial

Material de validação offline PAdES-B-LT para signPdfBytesPades.

new WasmRevocationMaterial()   // Conjunto de material vazio
addCert(der)                   // Adiciona um certificado X.509 DER
addCrl(der)                    // Adiciona uma CRL DER
addOcsp(der)                   // Adiciona uma resposta OCSP DER

Dss

Um Document Security Store analisado, retornado por WasmPdfDocument.dss().

dss.certCount -> number        // Número de certificados DER (getter)
getCert(i) -> Uint8Array | undefined   // i-ésimo certificado DER
dss.crlCount -> number         // Número de CRLs DER (getter)
getCrl(i) -> Uint8Array | undefined    // i-ésima CRL DER
dss.ocspCount -> number        // Número de respostas OCSP DER (getter)
getOcsp(i) -> Uint8Array | undefined   // i-ésima resposta OCSP DER
dss.vri -> string[]            // Chaves VRI por assinatura (SHA-1 em hexadecimal maiúsculo de /Contents) (getter)

OCR

O OCR roda inteiramente in-WASM por meio do backend tract em Rust puro, no build separado wasm-ocr. Os modelos são fornecidos pelo lado do host — busque os arquivos ONNX de detector/recognizer e o dicionário (veja modelManifest()) e então entregue os bytes ao construtor.

WasmOcrEngine

new WasmOcrEngine(detModel, recModel, dict, config?)  // Constrói a partir de bytes de modelo fornecidos pelo host
engine.ocrImage(imageBytes) -> string                 // OCR de uma imagem bruta (PNG/JPEG/TIFF); retorna JSON {text, confidence, spans}
Parâmetro Tipo Descrição
detModel Uint8Array Bytes ONNX do detector DBNet
recModel Uint8Array Bytes ONNX do recognizer SVTR
dict string Dicionário de caracteres do recognizer, um caractere por linha
config WasmOcrConfig | undefined Reservado (são usados padrões ajustados)

WasmOcrConfig

new WasmOcrConfig()   // Objeto de configuração de OCR (reservado para ajustes futuros)

Enums

Align

Discriminante de alinhamento de texto/célula usado por textInRect e pelos specs de coluna de tabela.

Align.Left   // 0
Align.Center // 1
Align.Right  // 2

PadesLevel

Nível baseline PAdES, usado por signPdfBytesPades e WasmSignature.padesLevel.

PadesLevel.BB    // 0 — signed attrs incl. ESS signing-certificate-v2
PadesLevel.BT    // 1 — B-B + RFC 3161 signature-time-stamp
PadesLevel.BLt   // 2 — B-T + Document Security Store (DSS/VRI)
PadesLevel.BLta  // 3 — B-LT + document-scoped /DocTimeStamp

Disponibilidade de recursos

Alguns recursos dependem de features de build do Rust. O pacote padrão pdf-oxide-wasm habilita o conjunto comum; o OCR é distribuído no build separado wasm-ocr.

Recurso WASM Observações
Extração de texto Sim Suporte completo
Extração estruturada Sim Chars, spans, palavras, linhas, tabelas
Criação de PDF Sim Markdown, HTML, texto, imagens, DocumentBuilder
Edição de PDF Sim Metadados, rotação, dimensões, apagamento, páginas
Campos de formulário Sim Ler, escrever, exportar, achatar, construir
Busca Sim Suporte completo a regex
Criptografia Sim Leitura e escrita AES-256
Anotações Sim Ler, achatar, redigir, sanitizar
Mesclagem / divisão de PDFs Sim Mescla páginas e divide por marcadores
Arquivos embutidos Sim Anexa arquivos a PDFs
Rótulos de página / XMP Sim Lê rótulos de página e metadados XMP
Round-trip do Office Sim Importação e exportação DOCX/PPTX/XLSX
Validação Sim PDF/A, PDF/UA, PDF/X
Códigos de barras Sim (barcodes) 1D + QR como SVG ou imagens de página
Renderização Sim (rendering) Página → PNG, achatamento para imagens
Assinaturas digitais Sim (signatures) Assinar, PAdES B-LT, verificar, timestamps
OCR build wasm-ocr OCR tract in-WASM; modelos buscados pelo lado do host

Tratamento de erros

Todos os métodos que podem falhar lançam objetos Error do JavaScript:

try {
  const doc = new WasmPdfDocument(new Uint8Array([0, 1, 2]));
} catch (e) {
  console.error(`Failed to open: ${e.message}`);
}

TypeScript

Definições de tipos completas estão incluídas no pacote:

import { WasmPdfDocument, WasmPdf } from "pdf-oxide-wasm";

const doc: WasmPdfDocument = new WasmPdfDocument(bytes);
const text: string = doc.extractText(0);
const pdf: WasmPdf = WasmPdf.fromMarkdown("# Hello");

Other Language Bindings

O PDF Oxide oferece bindings nativos para todos os principais ecossistemas: Rust, Python, Node.js, C#, Golang, Java, PHP, Ruby, C++, Swift, Kotlin, Dart, R, Julia, Zig, Scala, Clojure, Objective-C e Elixir.

Próximos Passos