@thecodecodex/tools 0.0.0-stage → 0.1.0

package/src/image-to-pdf.ts

@@ -0,0 +1,299 @@
+import { degrees, PDFDocument, rgb } from "pdf-lib"
+import { normalizeRotation, type Rotation } from "./pdf-studio"
+
+export const PAGE_SIZES = ["a4", "letter", "legal", "fit"] as const
+export type PageSize = (typeof PAGE_SIZES)[number]
+
+export const ORIENTATIONS = ["auto", "portrait", "landscape"] as const
+export type Orientation = (typeof ORIENTATIONS)[number]
+
+export const FIT_MODES = ["contain", "cover", "stretch"] as const
+export type FitMode = (typeof FIT_MODES)[number]
+
+export const BACKGROUNDS = ["white", "black", "transparent"] as const
+export type PageBackground = (typeof BACKGROUNDS)[number]
+
+export type ImageFormat = "png" | "jpeg" | "webp" | "gif" | "bmp" | "unknown"
+
+export interface PdfImageInput {
+  name: string
+  bytes: Uint8Array
+  rotation?: Rotation
+}
+
+export interface ImageToPdfOptions {
+  pageSize?: PageSize
+  orientation?: Orientation
+  fit?: FitMode
+  margin?: number
+  background?: PageBackground
+  title?: string
+  author?: string
+}
+
+export interface PageLayout {
+  pageWidth: number
+  pageHeight: number
+  boxX: number
+  boxY: number
+  boxWidth: number
+  boxHeight: number
+  anchorX: number
+  anchorY: number
+  drawWidth: number
+  drawHeight: number
+  rotation: Rotation
+  imageWidth: number
+  imageHeight: number
+}
+
+export const DEFAULT_IMAGE_PDF_OPTIONS: Required<ImageToPdfOptions> = {
+  pageSize: "a4",
+  orientation: "auto",
+  fit: "contain",
+  margin: 24,
+  background: "white",
+  title: "",
+  author: "",
+}
+
+const PAPER_DIMENSIONS: Record<Exclude<PageSize, "fit">, [number, number]> = {
+  a4: [595.28, 841.89],
+  letter: [612, 792],
+  legal: [612, 1008],
+}
+
+export function detectImageFormat(bytes: Uint8Array): ImageFormat {
+  if (bytes.length >= 8 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) return "png"
+  if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "jpeg"
+  if (
+    bytes.length >= 12 &&
+    bytes[0] === 0x52 &&
+    bytes[1] === 0x49 &&
+    bytes[2] === 0x46 &&
+    bytes[3] === 0x46 &&
+    bytes[8] === 0x57 &&
+    bytes[9] === 0x45 &&
+    bytes[10] === 0x42 &&
+    bytes[11] === 0x50
+  ) {
+    return "webp"
+  }
+  if (bytes.length >= 4 && bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38) return "gif"
+  if (bytes.length >= 2 && bytes[0] === 0x42 && bytes[1] === 0x4d) return "bmp"
+  return "unknown"
+}
+
+export function computePageLayout(imgWidth: number, imgHeight: number, rawOptions: ImageToPdfOptions = {}, rawRotation: Rotation = 0): PageLayout {
+  const opts = { ...DEFAULT_IMAGE_PDF_OPTIONS, ...rawOptions }
+  const rotation = normalizeRotation(rawRotation)
+  const swapped = rotation === 90 || rotation === 270
+  const effectiveW = Math.max(1, swapped ? imgHeight : imgWidth)
+  const effectiveH = Math.max(1, swapped ? imgWidth : imgHeight)
+  const margin = Math.max(0, Math.min(180, opts.margin))
+
+  let pageWidth: number
+  let pageHeight: number
+
+  if (opts.pageSize === "fit") {
+    pageWidth = effectiveW + margin * 2
+    pageHeight = effectiveH + margin * 2
+  } else {
+    const [baseW, baseH] = PAPER_DIMENSIONS[opts.pageSize]
+    const wantLandscape = opts.orientation === "landscape" || (opts.orientation === "auto" && effectiveW > effectiveH)
+    pageWidth = wantLandscape ? Math.max(baseW, baseH) : Math.min(baseW, baseH)
+    pageHeight = wantLandscape ? Math.min(baseW, baseH) : Math.max(baseW, baseH)
+  }
+
+  const availW = Math.max(1, pageWidth - margin * 2)
+  const availH = Math.max(1, pageHeight - margin * 2)
+
+  let boxWidth = availW
+  let boxHeight = availH
+
+  if (opts.pageSize === "fit") {
+    boxWidth = effectiveW
+    boxHeight = effectiveH
+  } else if (opts.fit === "contain") {
+    const scale = Math.min(availW / effectiveW, availH / effectiveH)
+    boxWidth = effectiveW * scale
+    boxHeight = effectiveH * scale
+  } else if (opts.fit === "cover") {
+    const scale = Math.max(availW / effectiveW, availH / effectiveH)
+    boxWidth = effectiveW * scale
+    boxHeight = effectiveH * scale
+  }
+
+  const boxX = (pageWidth - boxWidth) / 2
+  const boxY = (pageHeight - boxHeight) / 2
+
+  let anchorX = boxX
+  let anchorY = boxY
+  let drawWidth = boxWidth
+  let drawHeight = boxHeight
+
+  if (rotation === 90) {
+    anchorX = boxX + boxWidth
+    anchorY = boxY
+    drawWidth = boxHeight
+    drawHeight = boxWidth
+  } else if (rotation === 180) {
+    anchorX = boxX + boxWidth
+    anchorY = boxY + boxHeight
+  } else if (rotation === 270) {
+    anchorX = boxX
+    anchorY = boxY + boxHeight
+    drawWidth = boxHeight
+    drawHeight = boxWidth
+  }
+
+  return {
+    pageWidth: Math.round(pageWidth * 100) / 100,
+    pageHeight: Math.round(pageHeight * 100) / 100,
+    boxX: Math.round(boxX * 100) / 100,
+    boxY: Math.round(boxY * 100) / 100,
+    boxWidth: Math.round(boxWidth * 100) / 100,
+    boxHeight: Math.round(boxHeight * 100) / 100,
+    anchorX: Math.round(anchorX * 100) / 100,
+    anchorY: Math.round(anchorY * 100) / 100,
+    drawWidth: Math.round(drawWidth * 100) / 100,
+    drawHeight: Math.round(drawHeight * 100) / 100,
+    rotation,
+    imageWidth: imgWidth,
+    imageHeight: imgHeight,
+  }
+}
+
+export async function imagesToPdf(images: PdfImageInput[], rawOptions: ImageToPdfOptions = {}): Promise<{ bytes: Uint8Array, pages: PageLayout[] }> {
+  if (images.length === 0) throw new Error("Nenhuma imagem fornecida")
+  const opts = { ...DEFAULT_IMAGE_PDF_OPTIONS, ...rawOptions }
+  const doc = await PDFDocument.create()
+  if (opts.title.trim()) doc.setTitle(opts.title.trim())
+  if (opts.author.trim()) doc.setAuthor(opts.author.trim())
+  doc.setCreator("The Code Codex — Images to PDF")
+
+  const layouts: PageLayout[] = []
+
+  for (const item of images) {
+    const fmt = detectImageFormat(item.bytes)
+    if (fmt !== "png" && fmt !== "jpeg") {
+      throw new Error(`Formato ${fmt} requer conversão para PNG ou JPEG antes de embutir no PDF (${item.name})`)
+    }
+    const embedded = fmt === "png" ? await doc.embedPng(item.bytes) : await doc.embedJpg(item.bytes)
+    const layout = computePageLayout(embedded.width, embedded.height, opts, item.rotation ?? 0)
+    layouts.push(layout)
+
+    const page = doc.addPage([layout.pageWidth, layout.pageHeight])
+    if (opts.background !== "transparent") {
+      const color = opts.background === "black" ? rgb(0.05, 0.06, 0.08) : rgb(1, 1, 1)
+      page.drawRectangle({ x: 0, y: 0, width: layout.pageWidth, height: layout.pageHeight, color })
+    }
+
+    page.drawImage(embedded, {
+      x: layout.anchorX,
+      y: layout.anchorY,
+      width: layout.drawWidth,
+      height: layout.drawHeight,
+      rotate: degrees(layout.rotation),
+    })
+  }
+
+  const bytes = await doc.save()
+  return { bytes, pages: layouts }
+}
+
+// Gerador puro de PNG RGB (blocos DEFLATE sem compressão + CRC32 + Adler32) para imagens de exemplo em qualquer runtime
+function crc32(buf: Uint8Array): number {
+  let c = 0xffffffff
+  for (let i = 0; i < buf.length; i++) {
+    c ^= buf[i] ?? 0
+    for (let k = 0; k < 8; k++) c = (c >>> 1) ^ (c & 1 ? 0xedb88320 : 0)
+  }
+  return (c ^ 0xffffffff) >>> 0
+}
+
+function adler32(buf: Uint8Array): number {
+  let a = 1
+  let b = 0
+  for (let i = 0; i < buf.length; i++) {
+    a = (a + (buf[i] ?? 0)) % 65521
+    b = (b + a) % 65521
+  }
+  return ((b << 16) | a) >>> 0
+}
+
+function u32be(n: number): number[] {
+  return [(n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff]
+}
+
+function pngChunk(type: string, data: Uint8Array): Uint8Array {
+  const out = new Uint8Array(12 + data.length)
+  out.set(u32be(data.length), 0)
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i)
+  out.set(data, 8)
+  const crc = crc32(out.subarray(4, 8 + data.length))
+  out.set(u32be(crc), 8 + data.length)
+  return out
+}
+
+export function createGradientPng(width: number, height: number, topRgb: [number, number, number], bottomRgb: [number, number, number]): Uint8Array {
+  const rowSize = 1 + width * 3
+  const raw = new Uint8Array(rowSize * height)
+  for (let y = 0; y < height; y++) {
+    const t = height > 1 ? y / (height - 1) : 0
+    const rowOffset = y * rowSize
+    raw[rowOffset] = 0 // filtro None
+    for (let x = 0; x < width; x++) {
+      const s = width > 1 ? x / (width - 1) : 0
+      const border = x < 4 || x >= width - 4 || y < 4 || y >= height - 4
+      const p = rowOffset + 1 + x * 3
+      raw[p] = border ? 255 : Math.round(topRgb[0] * (1 - t) + bottomRgb[0] * t * (0.75 + 0.25 * s))
+      raw[p + 1] = border ? 255 : Math.round(topRgb[1] * (1 - t) + bottomRgb[1] * t)
+      raw[p + 2] = border ? 255 : Math.round(topRgb[2] * (1 - t * 0.5) + bottomRgb[2] * t * 0.5)
+    }
+  }
+
+  // Empacota em blocos zlib stored (máx. 65535 bytes por bloco)
+  const maxBlock = 65535
+  const numBlocks = Math.ceil(raw.length / maxBlock) || 1
+  const zlib = new Uint8Array(2 + raw.length + numBlocks * 5 + 4)
+  zlib[0] = 0x78
+  zlib[1] = 0x01
+  let zPos = 2
+  for (let b = 0; b < numBlocks; b++) {
+    const start = b * maxBlock
+    const slice = raw.subarray(start, Math.min(raw.length, start + maxBlock))
+    const len = slice.length
+    const nlen = (~len) & 0xffff
+    zlib[zPos++] = b === numBlocks - 1 ? 0x01 : 0x00
+    zlib[zPos++] = len & 0xff
+    zlib[zPos++] = (len >>> 8) & 0xff
+    zlib[zPos++] = nlen & 0xff
+    zlib[zPos++] = (nlen >>> 8) & 0xff
+    zlib.set(slice, zPos)
+    zPos += len
+  }
+  zlib.set(u32be(adler32(raw)), zPos)
+
+  const ihdr = new Uint8Array([...u32be(width), ...u32be(height), 8, 2, 0, 0, 0])
+  const sig = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10])
+  const cIhdr = pngChunk("IHDR", ihdr)
+  const cIdat = pngChunk("IDAT", zlib)
+  const cIend = pngChunk("IEND", new Uint8Array(0))
+
+  const png = new Uint8Array(sig.length + cIhdr.length + cIdat.length + cIend.length)
+  let offset = 0
+  for (const part of [sig, cIhdr, cIdat, cIend]) {
+    png.set(part, offset)
+    offset += part.length
+  }
+  return png
+}
+
+export function createSampleImages(): PdfImageInput[] {
+  return [
+    { name: "01-landscape-diagram.png", bytes: createGradientPng(160, 100, [30, 92, 198], [16, 165, 135]), rotation: 0 },
+    { name: "02-portrait-scan.png", bytes: createGradientPng(100, 150, [110, 48, 175], [215, 75, 115]), rotation: 0 },
+    { name: "03-square-chart.png", bytes: createGradientPng(120, 120, [210, 105, 30], [45, 65, 115]), rotation: 0 },
+  ]
+}

package/src/invoice-pdf.ts

@@ -0,0 +1,134 @@
+import { PDFDocument, rgb, StandardFonts, type PDFFont, type PDFPage } from "pdf-lib"
+import { lineTotal, totals, type Invoice } from "./invoice"
+
+// Gera o PDF do invoice (A4) sem navegador — usado pelo script de terminal. Layout espelha a prévia do site.
+const A4: [number, number] = [595.28, 841.89]
+const MARGIN = 50
+const INK = rgb(0.07, 0.08, 0.12)
+const MUTED = rgb(0.29, 0.33, 0.39)
+const RULE = rgb(0.9, 0.91, 0.92)
+
+// As fontes padrão do PDF usam WinAnsi: troca o que não existe nela (ex.: "−", "→") por equivalentes
+function safe(font: PDFFont, text: string): string {
+  return [...text.replace(/−/g, "-").replace(/→/g, "->")]
+    .map((char) => {
+      try {
+        font.encodeText(char)
+        return char
+      } catch {
+        return "?"
+      }
+    })
+    .join("")
+}
+
+function wrap(font: PDFFont, text: string, size: number, maxWidth: number): string[] {
+  return text.split("\n").flatMap((paragraph) => {
+    const words = paragraph.split(/\s+/)
+    const lines: string[] = []
+    let line = ""
+    for (const word of words) {
+      const candidate = line ? `${line} ${word}` : word
+      if (font.widthOfTextAtSize(safe(font, candidate), size) > maxWidth && line) {
+        lines.push(line)
+        line = word
+      } else line = candidate
+    }
+    lines.push(line)
+    return lines
+  })
+}
+
+const longDate = (iso: string) => (iso ? new Date(`${iso}T00:00:00Z`).toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric", timeZone: "UTC" }) : "-")
+
+export async function invoicePdf(invoice: Invoice): Promise<Uint8Array> {
+  const doc = await PDFDocument.create()
+  doc.setTitle(`Invoice ${invoice.number}`)
+  doc.setCreator("thecodecodex.com")
+  const page: PDFPage = doc.addPage(A4)
+  const regular = await doc.embedFont(StandardFonts.Helvetica)
+  const bold = await doc.embedFont(StandardFonts.HelveticaBold)
+  const money = new Intl.NumberFormat("en-US", { style: "currency", currency: invoice.currency })
+  const width = A4[0] - MARGIN * 2
+  let y = A4[1] - MARGIN
+
+  const text = (value: string, x: number, at: number, size = 10, font = regular, color = INK) => page.drawText(safe(font, value), { x, y: at, size, font, color })
+  const right = (value: string, xRight: number, at: number, size = 10, font = regular, color = INK) => text(value, xRight - font.widthOfTextAtSize(safe(font, value), size), at, size, font, color)
+
+  // cabeçalho: número à esquerda, emissor à direita
+  text("INVOICE", MARGIN, y, 9, bold, MUTED)
+  right(invoice.from.name || "-", MARGIN + width, y, 11, bold)
+  y -= 26
+  text(invoice.number || "-", MARGIN, y, 22, bold)
+  let ry = y + 12
+  for (const line of wrap(regular, invoice.from.details, 9, width / 2)) {
+    right(line, MARGIN + width, ry, 9, regular, MUTED)
+    ry -= 12
+  }
+  y = Math.min(y, ry) - 28
+
+  // cliente e datas
+  text("BILL TO", MARGIN, y, 8, bold, MUTED)
+  right(`Issue date   ${longDate(invoice.issued)}`, MARGIN + width, y, 9)
+  y -= 14
+  text(invoice.to.name || "-", MARGIN, y, 10, bold)
+  right(`Due date   ${longDate(invoice.due)}`, MARGIN + width, y, 9)
+  y -= 13
+  for (const line of wrap(regular, invoice.to.details, 9, width / 2)) {
+    text(line, MARGIN, y, 9, regular, MUTED)
+    y -= 12
+  }
+  y -= 18
+
+  // itens
+  const cols = { qty: MARGIN + width * 0.62, price: MARGIN + width * 0.8, amount: MARGIN + width }
+  text("DESCRIPTION", MARGIN, y, 8, bold)
+  right("QTY", cols.qty, y, 8, bold)
+  right("UNIT PRICE", cols.price, y, 8, bold)
+  right("AMOUNT", cols.amount, y, 8, bold)
+  y -= 6
+  page.drawLine({ start: { x: MARGIN, y }, end: { x: MARGIN + width, y }, thickness: 1.5, color: INK })
+  y -= 16
+  for (const item of invoice.items) {
+    const lines = wrap(regular, item.description || "-", 10, width * 0.5)
+    lines.forEach((line, i) => text(line, MARGIN, y - i * 12, 10))
+    right(String(item.quantity), cols.qty, y, 10)
+    right(money.format(item.unitPrice || 0), cols.price, y, 10)
+    right(money.format(lineTotal(item)), cols.amount, y, 10)
+    y -= lines.length * 12 + 6
+    page.drawLine({ start: { x: MARGIN, y: y + 2 }, end: { x: MARGIN + width, y: y + 2 }, thickness: 0.5, color: RULE })
+    y -= 10
+  }
+
+  // totais
+  const sum = totals(invoice.items, invoice.discount, invoice.tax)
+  const label = MARGIN + width * 0.55
+  const row = (name: string, value: string, strong = false) => {
+    text(name, label, y, strong ? 11 : 10, strong ? bold : regular, strong ? INK : MUTED)
+    right(value, cols.amount, y, strong ? 12 : 10, strong ? bold : regular)
+    y -= 16
+  }
+  y -= 4
+  row("Subtotal", money.format(sum.subtotal))
+  if (sum.discount > 0) row(`Discount (${+(invoice.discount * 100).toFixed(2)}%)`, `-${money.format(sum.discount)}`)
+  if (sum.tax > 0) row(`Tax (${+(invoice.tax * 100).toFixed(2)}%)`, money.format(sum.tax))
+  page.drawLine({ start: { x: label, y: y + 10 }, end: { x: MARGIN + width, y: y + 10 }, thickness: 1.5, color: INK })
+  y -= 4
+  row("Total due", money.format(sum.total), true)
+  y -= 22
+
+  // pagamento e observações
+  const block = (title: string, body: string, x: number, top: number) => {
+    let by = top
+    text(title, x, by, 8, bold, MUTED)
+    by -= 14
+    for (const line of wrap(regular, body, 9.5, width / 2 - 12)) {
+      text(line, x, by, 9.5)
+      by -= 12
+    }
+  }
+  if (invoice.payment) block("PAYMENT DETAILS", invoice.payment, MARGIN, y)
+  if (invoice.notes) block("NOTES", invoice.notes, MARGIN + width / 2 + 12, y)
+
+  return doc.save()
+}

package/src/invoice.ts

@@ -0,0 +1,94 @@
+import type { UrlCodec } from "./url-codec"
+
+// Invoice para clientes no exterior: totais e numeração sequencial
+
+export interface InvoiceItem {
+  description: string
+  quantity: number
+  unitPrice: number
+}
+
+export interface InvoiceTotals {
+  subtotal: number
+  discount: number
+  tax: number
+  total: number
+}
+
+const cents = (value: number) => Math.round(value * 100) / 100
+
+export function lineTotal(item: InvoiceItem): number {
+  return cents((Number.isFinite(item.quantity) ? item.quantity : 0) * (Number.isFinite(item.unitPrice) ? item.unitPrice : 0))
+}
+
+// desconto e imposto em fração (0.1 = 10%); o imposto incide depois do desconto
+export function totals(items: InvoiceItem[], discountRate = 0, taxRate = 0): InvoiceTotals {
+  const subtotal = cents(items.reduce((sum, item) => sum + lineTotal(item), 0))
+  const discount = cents(subtotal * discountRate)
+  const tax = cents((subtotal - discount) * taxRate)
+  return { subtotal, discount, tax, total: cents(subtotal - discount + tax) }
+}
+
+// Próximo número mantendo prefixo e zeros: "INV-2026-009" → "INV-2026-010"; sem número no fim → acrescenta "-2"
+export function nextInvoiceNumber(current: string): string {
+  const match = current.match(/^(.*?)(\d+)(\D*)$/)
+  if (!match) return current ? `${current}-2` : "1"
+  const [, prefix = "", digits = "0", suffix = ""] = match
+  const next = String(Number(digits) + 1).padStart(digits.length, "0")
+  return `${prefix}${next}${suffix}`
+}
+
+export function addDaysIso(iso: string, days: number): string {
+  const date = new Date(`${iso}T00:00:00Z`)
+  date.setUTCDate(date.getUTCDate() + days)
+  return date.toISOString().slice(0, 10)
+}
+
+// Modelo completo do invoice: o mesmo JSON do link do site (#invoice=...) e do parâmetro invoice= do script de terminal
+export const CURRENCIES = ["USD", "EUR", "GBP", "CAD", "AUD", "CHF", "BRL"] as const
+
+export interface Party {
+  name: string
+  details: string
+}
+
+export interface Invoice {
+  number: string
+  issued: string
+  due: string
+  currency: (typeof CURRENCIES)[number]
+  from: Party
+  to: Party
+  items: InvoiceItem[]
+  discount: number
+  tax: number
+  payment: string
+  notes: string
+}
+
+export const EMPTY_INVOICE: Invoice = {
+  number: "INV-001",
+  issued: "",
+  due: "",
+  currency: "USD",
+  from: { name: "", details: "" },
+  to: { name: "", details: "" },
+  items: [{ description: "Software development services", quantity: 1, unitPrice: 0 }],
+  discount: 0,
+  tax: 0,
+  payment: "",
+  notes: "Payment due within 15 days. Thank you for your business!",
+}
+
+// Invoice inteiro como JSON no fragmento (#) da URL
+export const invoiceCodec: UrlCodec<Invoice> = {
+  parse: (raw) => {
+    try {
+      const value = JSON.parse(raw) as Partial<Invoice>
+      return value && Array.isArray(value.items) ? { ...EMPTY_INVOICE, ...value } : undefined
+    } catch {
+      return undefined
+    }
+  },
+  format: (value) => JSON.stringify(value),
+}

package/src/jwt.ts

@@ -0,0 +1,44 @@
+import { decode } from "./base64"
+
+// Apenas decodifica: a assinatura NÃO é verificada (isso exige a chave do emissor)
+export interface DecodedJwt {
+  header: Record<string, unknown>
+  payload: Record<string, unknown>
+  signature: string
+  issuedAt?: Date
+  expiresAt?: Date
+  notBefore?: Date
+}
+
+export type JwtResult = { ok: true, jwt: DecodedJwt } | { ok: false, error: "format" | "json" }
+
+function part(value: string): Record<string, unknown> {
+  const parsed: unknown = JSON.parse(decode(value, "base64url"))
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new SyntaxError("not an object")
+  return parsed as Record<string, unknown>
+}
+
+const date = (value: unknown) => (typeof value === "number" ? new Date(value * 1000) : undefined)
+
+export function decodeJwt(token: string): JwtResult {
+  const parts = token.trim().replace(/^Bearer\s+/i, "").split(".")
+  if (parts.length !== 3 || parts.some((p, i) => i < 2 && !p)) return { ok: false, error: "format" }
+  try {
+    const header = part(parts[0] ?? "")
+    const payload = part(parts[1] ?? "")
+    const jwt: DecodedJwt = { header, payload, signature: parts[2] ?? "" }
+    const iat = date(payload["iat"])
+    const exp = date(payload["exp"])
+    const nbf = date(payload["nbf"])
+    if (iat) jwt.issuedAt = iat
+    if (exp) jwt.expiresAt = exp
+    if (nbf) jwt.notBefore = nbf
+    return { ok: true, jwt }
+  } catch {
+    return { ok: false, error: "json" }
+  }
+}
+
+export function isExpired(jwt: DecodedJwt, now: Date = new Date()): boolean | undefined {
+  return jwt.expiresAt ? jwt.expiresAt.getTime() < now.getTime() : undefined
+}

package/src/market.ts

@@ -0,0 +1,49 @@
+// Indicadores do Banco Central. Os dados vêm de fora (o site grava um JSON por dia no build) e são
+// carregados com setMarketData antes do uso. Se a API falhou na última atualização, `stale` é true
+// e o valor é o último conhecido.
+export interface MarketValue {
+  code: number
+  name: string
+  unit: string
+  value: number
+  date: string
+  stale: boolean
+}
+
+export type MarketKey = "cdi" | "ipca12m" | "savingsMonthly" | "usd" | "eur" | "gbp" | "cad"
+export type Currency = "USD" | "EUR" | "GBP" | "CAD"
+
+export interface MarketData {
+  fetchedAt: string
+  source: string
+  series: Record<MarketKey, MarketValue>
+}
+
+// `market` mantém a mesma referência; `marketFetchedAt` e `MARKET_SOURCE` são live bindings (ESM)
+export const market = {} as Record<MarketKey, MarketValue>
+export let marketFetchedAt = ""
+export let MARKET_SOURCE = ""
+
+export function setMarketData(data: MarketData) {
+  Object.assign(market, data.series)
+  marketFetchedAt = data.fetchedAt
+  MARKET_SOURCE = data.source
+}
+
+export const sgsUrl = (code: number) => `https://www3.bcb.gov.br/sgspub/consultarvalores/consultarValoresSeries.do?method=consultarValores&optSelecionaSerie=${code}`
+
+const value = (key: MarketKey) => {
+  const series = market[key]
+  if (!series) throw new Error("Dados de mercado não carregados: chame setMarketData() antes")
+  return series.value
+}
+
+// Taxas em fração (0.1365 = 13,65% a.a.)
+export const cdiAnnual = () => value("cdi") / 100
+export const ipca12m = () => value("ipca12m") / 100
+// Poupança: rendimento mensal composto para anual
+export const savingsAnnual = () => Math.pow(1 + value("savingsMonthly") / 100, 12) - 1
+
+const FX_KEY: Record<Currency, MarketKey> = { USD: "usd", EUR: "eur", GBP: "gbp", CAD: "cad" }
+export const fxKey = (currency: Currency) => FX_KEY[currency]
+export const fxRate = (currency: Currency) => value(FX_KEY[currency])

package/src/password.ts

@@ -0,0 +1,51 @@
+import { secureRandom, type Random } from "./random/index"
+
+export const CHARSETS = {
+  lower: "abcdefghijklmnopqrstuvwxyz",
+  upper: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  digits: "0123456789",
+  symbols: "!@#$%&*()-_=+[]{};:,.?/",
+} as const
+
+export type Charset = keyof typeof CHARSETS
+// Caracteres fáceis de confundir ao ler/digitar
+const AMBIGUOUS = /[Il1O0o]/g
+
+export interface PasswordOptions {
+  length: number
+  sets: Charset[]
+  excludeAmbiguous?: boolean
+}
+
+function alphabetFor(set: Charset, excludeAmbiguous: boolean): string {
+  return excludeAmbiguous ? CHARSETS[set].replace(AMBIGUOUS, "") : CHARSETS[set]
+}
+
+export function generatePassword({ length, sets, excludeAmbiguous = false }: PasswordOptions, random: Random = secureRandom): string {
+  const active = sets.length > 0 ? sets : (["lower"] as Charset[])
+  const alphabets = active.map((set) => alphabetFor(set, excludeAmbiguous))
+  const all = alphabets.join("")
+  const size = Math.max(length, alphabets.length)
+  // um caractere de cada conjunto escolhido, o resto aleatório, depois embaralha (Fisher–Yates)
+  const chars = [...alphabets.map((a) => a[random(a.length)] ?? ""), ...Array.from({ length: size - alphabets.length }, () => all[random(all.length)] ?? "")]
+  for (let i = chars.length - 1; i > 0; i--) {
+    const j = random(i + 1)
+    ;[chars[i], chars[j]] = [chars[j] ?? "", chars[i] ?? ""]
+  }
+  return chars.join("")
+}
+
+// Entropia em bits assumindo escolha uniforme no alfabeto completo
+export function entropyBits({ length, sets, excludeAmbiguous = false }: PasswordOptions): number {
+  const size = (sets.length > 0 ? sets : (["lower"] as Charset[])).reduce((acc, set) => acc + alphabetFor(set, excludeAmbiguous).length, 0)
+  return Math.round(length * Math.log2(size))
+}
+
+export type Strength = "weak" | "fair" | "strong" | "very-strong"
+
+export function strength(bits: number): Strength {
+  if (bits < 50) return "weak"
+  if (bits < 70) return "fair"
+  if (bits < 100) return "strong"
+  return "very-strong"
+}