@thecodecodex/tools 0.0.0-stage → 0.1.0

package/src/state-holidays.ts

@@ -0,0 +1,94 @@
+// Feriados estaduais com base legal. Cada entrada cita a lei e a fonte consultada; só entram datas com folga
+// (pontos facultativos e datas comemorativas ficam de fora). Datas móveis usam `rule`.
+
+export const UFS = ["AC", "AL", "AM", "AP", "BA", "CE", "DF", "ES", "GO", "MA", "MG", "MS", "MT", "PA", "PB", "PE", "PI", "PR", "RJ", "RN", "RO", "RR", "RS", "SC", "SE", "SP", "TO"] as const
+export type Uf = (typeof UFS)[number]
+
+export interface StateHoliday {
+  uf: Uf
+  name: string
+  // "MM-DD" para datas fixas
+  date?: string
+  // datas móveis: devolve "YYYY-MM-DD" para o ano
+  rule?: (year: number) => string
+  // transferências pontuais publicadas por decreto/portaria para um ano específico
+  overrides?: Record<number, string>
+  law: string
+  source: string
+  note?: string
+}
+
+// Estados sem feriado estadual com folga além dos nacionais (verificado): MG, MT, PR.
+// Ainda sem documento oficial verificado (não incluídos): AP, RN, RO e o 05/10 de TO.
+const sundayOnOrAfter = (iso: string) => {
+  const date = new Date(`${iso}T00:00:00Z`)
+  date.setUTCDate(date.getUTCDate() + ((7 - date.getUTCDay()) % 7))
+  return date.toISOString().slice(0, 10)
+}
+const plusDays = (iso: string, days: number) => {
+  const date = new Date(`${iso}T00:00:00Z`)
+  date.setUTCDate(date.getUTCDate() + days)
+  return date.toISOString().slice(0, 10)
+}
+
+const TJAC = "https://webdev.tjac.jus.br/wp-content/uploads/2025/12/Portaria_PRESI_TJAC_6569_2025.pdf"
+const JFAL = "https://www.jfal.jus.br/noticias/6685/Portaria%20n.%20199-2025-feriados-2026.pdf"
+
+export const STATE_HOLIDAYS: StateHoliday[] = [
+  { uf: "AC", date: "01-20", overrides: { 2026: "2026-01-22" }, name: "Dia do Católico", law: "Lei 3.137/2016", source: TJAC, note: "A Lei 2.126/2009 transfere alguns feriados do AC; em 2026 foi para 22/01." },
+  { uf: "AC", date: "01-23", name: "Dia do Evangélico", law: "Lei 1.538/2004", source: TJAC },
+  { uf: "AC", date: "03-08", name: "Dia Internacional da Mulher", law: "Lei 1.411/2001", source: TJAC },
+  { uf: "AC", date: "06-15", name: "Aniversário do Estado do Acre", law: "Lei 14/1964", source: TJAC },
+  { uf: "AC", date: "09-05", name: "Dia da Amazônia", law: "Lei 243/1968", source: TJAC },
+  { uf: "AL", date: "06-24", name: "São João", law: "Lei 5.508/1993", source: JFAL },
+  { uf: "AL", date: "06-29", name: "São Pedro", law: "Lei 5.509/1993", source: JFAL },
+  { uf: "AL", date: "09-16", name: "Emancipação Política de Alagoas", law: "Decreto 106.093/2025", source: JFAL },
+  { uf: "AM", date: "09-05", name: "Elevação do Amazonas à categoria de Província", law: "Calendário oficial TJAM 2026", source: "https://www.tjam.jus.br/images/2026/CalendarioJudicial2026_alterado.pdf" },
+  { uf: "BA", date: "07-02", name: "Independência da Bahia", law: "Constituição da Bahia, art. 6º, §3º", source: "https://www.tjba.jus.br/portal/wp-content/uploads/2025/12/Decreto-1050-25_-expediente-forense-2026.pdf" },
+  { uf: "CE", date: "03-25", name: "Data Magna do Ceará", law: "EC estadual 73/2011", source: "https://portal.tjce.jus.br/uploads/2026/04/PORT-FERIADOS-E-PONTO-FACULTATIVO-2026-1776690769.pdf" },
+  { uf: "DF", date: "11-30", name: "Dia do Evangélico", law: "Lei distrital 963/1995", source: "https://www.lex.com.br/feriado-do-dia-do-evangelico-instituido-por-lei-distrital-nao-se-aplica-a-orgaos-publicos-federais-com-sede-no-df/", note: "Não vale para órgãos federais; há divergência no TST para o setor privado." },
+  { uf: "ES", rule: (year) => plusDays(easterSunday(year), 8), name: "Nossa Senhora da Penha (Data Magna)", law: "Lei 11.010/2019", source: "https://www.folhavitoria.com.br/geral/dia-de-nossa-senhora-da-penha-se-torna-feriado-em-todo-o-espirito-santo/", note: "Segunda-feira, 8 dias após a Páscoa." },
+  { uf: "GO", date: "07-26", name: "Fundação da Cidade de Goiás (Data Magna)", law: "Lei 20.756/2020, art. 269", source: "https://www.tjgo.jus.br/files/2026/01%20-%20Janeiro/Calendario%20do%20TJGO_2026_publicado-2.pdf", note: "Já foi transferido por decreto em anos anteriores." },
+  { uf: "MA", date: "07-28", name: "Adesão do Maranhão à Independência", law: "Lei 2.457/1964", source: "https://novogerenciador.tjma.jus.br/storage/portalweb/medida_provisoria_313_08_05_2020_26052020_1240.pdf" },
+  { uf: "MS", date: "10-11", name: "Criação do Estado de Mato Grosso do Sul", law: "Lei 10/1979", source: "https://web.trf3.jus.br/atos-normativos/atos-normativos-dir/Conselho%20da%20Justi%C3%A7a/Portarias/2020/Portaria0431.htm" },
+  { uf: "PA", date: "08-15", name: "Adesão do Pará à Independência", law: "Portaria MPF PR/PA 2/2026", source: "https://biblioteca.mpf.mp.br/repositorio/bitstreams/4b2d53d1-112c-4958-a8f6-3b318d7bcef7/download" },
+  { uf: "PB", date: "08-05", name: "Data Magna da Paraíba", law: "Lei 10.601/2015", source: "https://www.tjpb.jus.br/sites/default/files/legislacao/ATO_CONJUNTO_No_04_16102025.pdf" },
+  { uf: "PE", date: "03-06", name: "Data Magna de Pernambuco (Revolução de 1817)", law: "Lei 16.241/2017, art. 49", source: "https://portal.tjpe.jus.br/documents/d/portal/feriados-2026-pdf" },
+  { uf: "PI", date: "10-19", name: "Dia do Piauí", law: "Lei 176/1937", source: "https://www.legisweb.com.br/legislacao/?id=454668" },
+  { uf: "RJ", rule: (year) => plusDays(easterSunday(year), -47), name: "Carnaval (terça-feira)", law: "Lei 5.243/2008", source: "https://www.conjur.com.br/2008-set-02/confederacao_questiona_lei_amplia_feriado_rio", note: "Questionado em ADI no STF; cumprido na prática." },
+  { uf: "RJ", date: "04-23", name: "Dia de São Jorge", law: "Lei 5.198/2008", source: "https://www.coad.com.br/home/noticias-detalhe/12754/dia-de-sao-jorge-passa-a-ser-feriado-estadual", note: "Questionado em ADI no STF; cumprido na prática." },
+  { uf: "RR", date: "10-05", name: "Aniversário do Estado de Roraima", law: "Portaria TJRR/PR 1558/2025", source: "https://diario.tjrr.jus.br/dpj/dpj-20251222.pdf" },
+  { uf: "RS", date: "09-20", name: "Revolução Farroupilha (Data Magna)", law: "Constituição do RS, art. 6º, parágrafo único", source: "https://www.mprs.mp.br/legislacao/provimentos/12970/" },
+  { uf: "SC", rule: (year) => sundayOnOrAfter(`${year}-08-11`), name: "Data Magna de Santa Catarina", law: "Lei 18.531/2022", source: "https://www.nsctotal.com.br/noticias/data-magna-santa-catarina", note: "Celebrada no domingo seguinte ao 11/08 (ou no próprio dia, se for domingo)." },
+  { uf: "SE", date: "07-08", name: "Independência de Sergipe", law: "Constituição de Sergipe, art. 269", source: "https://www.gov.br/hubrasil/pt-br/hospitais-universitarios/regiao-nordeste/hu-ufs/acesso-a-informacao/boletim-de-servico/2026/boletim-servico-no-464-de-15-de-janeiro-de-2026.pdf" },
+  { uf: "SP", date: "07-09", name: "Revolução Constitucionalista de 1932", law: "Lei 9.497/1997", source: "https://www.al.sp.gov.br/repositorio/legislacao/lei/1997/lei-9497-05.03.1997.html" },
+  { uf: "TO", date: "09-08", name: "Nossa Senhora da Natividade", law: "Lei 627/1993", source: "https://trf1.jus.br/sjto/conteudo/files/FERIADOS%20SUBSE__O%20JUDICI_RIA%20DE%20GURUPI.pdf" },
+]
+
+export function stateHolidaysFor(uf: Uf, year: number): { date: string, name: string, law: string, source: string }[] {
+  return STATE_HOLIDAYS.filter((h) => h.uf === uf).map((h) => ({
+    date: h.overrides?.[year] ?? (h.rule ? h.rule(year) : `${year}-${h.date}`),
+    name: h.name,
+    law: h.law,
+    source: h.source,
+  }))
+}
+
+// Páscoa (Meeus/Jones/Butcher) — duplicada de vacation.ts para evitar import circular
+function easterSunday(year: number): string {
+  const a = year % 19
+  const b = Math.floor(year / 100)
+  const c = year % 100
+  const d = Math.floor(b / 4)
+  const e = b % 4
+  const f = Math.floor((b + 8) / 25)
+  const g = Math.floor((b - f + 1) / 3)
+  const h = (19 * a + b - d - g + 15) % 30
+  const i = Math.floor(c / 4)
+  const k = c % 4
+  const l = (32 + 2 * e + 2 * i - h - k) % 7
+  const m = Math.floor((a + 11 * h + 22 * l) / 451)
+  const month = Math.floor((h + l - 7 * m + 114) / 31)
+  const day = ((h + l - 7 * m + 114) % 31) + 1
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`
+}

package/src/table-convert/code.ts

@@ -0,0 +1,99 @@
+// Saída como código: a tabela vira um literal pronto para colar (Python, pandas, TypeScript, Go, PHP).
+// Os tipos vêm de columnKinds, os mesmos do JSON e do SQL.
+import { uniqueKeys, type Scalar, type Table } from "./model"
+import { columnKinds, typedRows, type ColumnKind, type SerializeOptions } from "./serialize"
+
+const typed = (t: Table, o: SerializeOptions) => {
+  const kinds = columnKinds(t, o)
+  const rows = typedRows(t, o, kinds)
+  const nullable = kinds.map((_, i) => rows.some((r) => r[i] === null))
+  return { kinds, rows, nullable }
+}
+
+// ---------- Python ----------
+
+const python = (v: Scalar) => (v === null ? "None" : v === true ? "True" : v === false ? "False" : typeof v === "number" ? String(v) : JSON.stringify(v))
+
+export function toPython(t: Table, o: SerializeOptions = {}): string {
+  const keys = uniqueKeys(t.columns).map((k) => JSON.stringify(k))
+  const { rows } = typed(t, o)
+  if (rows.length === 0) return "rows = []"
+  return `rows = [\n${rows.map((r) => `    {${keys.map((k, i) => `${k}: ${python(r[i] ?? null)}`).join(", ")}},`).join("\n")}\n]`
+}
+
+export function toPandas(t: Table, o: SerializeOptions = {}): string {
+  const keys = uniqueKeys(t.columns).map((k) => JSON.stringify(k))
+  const { rows } = typed(t, o)
+  const columns = keys.map((k, i) => `    ${k}: [${rows.map((r) => python(r[i] ?? null)).join(", ")}],`)
+  return `import pandas as pd\n\ndf = pd.DataFrame({\n${columns.join("\n")}\n})`
+}
+
+// ---------- TypeScript ----------
+
+const tsKey = (key: string) => (/^[A-Za-z_$][\w$]*$/.test(key) ? key : JSON.stringify(key))
+const TS_TYPE: Record<ColumnKind, string> = { number: "number", integer: "number", boolean: "boolean", text: "string" }
+const literal = (v: Scalar) => (v === null ? "null" : typeof v === "string" ? JSON.stringify(v) : String(v))
+
+export function identifier(name: string, fallback = "Row"): string {
+  const words = name
+    .normalize("NFD")
+    .replace(/\p{M}/gu, "")
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+  const joined = words.map((w) => w[0]?.toUpperCase() + w.slice(1)).join("")
+  return !joined ? fallback : /^\d/.test(joined) ? `${fallback}${joined}` : joined
+}
+
+export function toTypeScript(t: Table, o: SerializeOptions = {}): string {
+  const type = identifier(o.typeName ?? "", "Row")
+  const keys = uniqueKeys(t.columns).map(tsKey)
+  const { kinds, rows, nullable } = typed(t, o)
+  const fields = keys.map((k, i) => `  ${k}: ${TS_TYPE[kinds[i] ?? "text"]}${nullable[i] ? " | null" : ""}`)
+  const values = rows.map((r) => `  { ${keys.map((k, i) => `${k}: ${literal(r[i] ?? null)}`).join(", ")} },`)
+  return `export interface ${type} {\n${fields.join("\n")}\n}\n\nexport const rows: ${type}[] = [\n${values.join("\n")}\n]`
+}
+
+// ---------- Go ----------
+
+// Siglas em maiúsculas, como o gofmt/golint esperam (UserID, not UserId)
+const INITIALISMS = new Set(["Id", "Url", "Uri", "Api", "Http", "Https", "Json", "Sql", "Uuid", "Ip", "Html", "Xml", "Cpf", "Cnpj"])
+const GO_TYPE: Record<ColumnKind, string> = { number: "float64", integer: "int64", boolean: "bool", text: "string" }
+
+function goField(name: string, used: Set<string>): string {
+  const base = identifier(name, "Field").replace(/[A-Z][a-z]+|[a-z]+/g, (w) => (INITIALISMS.has(w[0]?.toUpperCase() + w.slice(1).toLowerCase()) ? w.toUpperCase() : w))
+  let field = base
+  for (let n = 2; used.has(field); n++) field = `${base}${n}`
+  used.add(field)
+  return field
+}
+
+export function toGo(t: Table, o: SerializeOptions = {}): string {
+  const type = identifier(o.typeName ?? "", "Row")
+  const keys = uniqueKeys(t.columns)
+  const used = new Set<string>()
+  const fields = keys.map((k) => goField(k, used))
+  const { kinds, rows, nullable } = typed(t, o)
+  // colunas com null viram ponteiro (nil = ausente); valores não nulos usam o helper ptr.
+  // No literal, campos nulos ou "" ficam de fora (já são o valor zero do Go).
+  const types = kinds.map((k, i) => `${nullable[i] ? "*" : ""}${GO_TYPE[k]}`)
+  const nameWidth = Math.max(...fields.map((f) => f.length), 0)
+  const typeWidth = Math.max(...types.map((f) => f.length), 0)
+  const struct = fields.map((f, i) => `\t${f.padEnd(nameWidth)} ${(types[i] ?? "").padEnd(typeWidth)} \`json:"${(keys[i] ?? "").replace(/[`"\\]/g, "_")}"\``)
+  const value = (v: Scalar, i: number) => {
+    const plain = typeof v === "string" ? JSON.stringify(v) : String(v)
+    return nullable[i] ? `ptr(${kinds[i] === "number" && typeof v === "number" && Number.isInteger(v) ? `float64(${plain})` : kinds[i] === "integer" ? `int64(${plain})` : plain})` : plain
+  }
+  const values = rows.map((r) => `\t{${fields.flatMap((f, i) => (r[i] === null || r[i] === undefined || r[i] === "" ? [] : [`${f}: ${value(r[i] as Scalar, i)}`])).join(", ")}},`)
+  const helper = nullable.some(Boolean) ? "\n\nfunc ptr[T any](v T) *T { return &v }" : ""
+  return `type ${type} struct {\n${struct.join("\n")}\n}\n\nvar rows = []${type}{\n${values.join("\n")}\n}${helper}`
+}
+
+// ---------- PHP ----------
+
+const php = (v: Scalar) => (v === null ? "null" : typeof v === "boolean" ? String(v) : typeof v === "number" ? String(v) : `'${v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`)
+
+export function toPhp(t: Table, o: SerializeOptions = {}): string {
+  const keys = uniqueKeys(t.columns).map(php)
+  const { rows } = typed(t, o)
+  return `<?php\n\n$rows = [\n${rows.map((r) => `    [${keys.map((k, i) => `${k} => ${php(r[i] ?? null)}`).join(", ")}],`).join("\n")}\n];`
+}

package/src/table-convert/index.ts

@@ -0,0 +1,42 @@
+// Conversor de tabelas: entrada (CSV/TSV, Excel, JSON, Markdown, HTML) → modelo único → transformações → saída.
+// Funções puras, usadas igualmente pela página e pelo comando de terminal.
+import { parseTable, type ParseOptions, type Parsed } from "./parse"
+import { serialize, type OutputFormat, type SerializeOptions } from "./serialize"
+import { transformTable, type TransformOptions, type Transformed } from "./transform"
+import { toXlsx } from "./xlsx"
+
+export * from "./model"
+export * from "./parse"
+export * from "./serialize"
+export * from "./transform"
+export * from "./code"
+export * from "./xlsx"
+
+export interface ConvertOptions extends ParseOptions, TransformOptions, SerializeOptions {
+  to?: OutputFormat
+  sheet?: string
+}
+
+export interface Conversion {
+  parsed: Parsed
+  result: Transformed
+  // texto da saída; para xlsx fica vazio e o arquivo vem em `file`
+  output: string
+  file?: Uint8Array
+}
+
+export function convertTable(text: string, options: ConvertOptions = {}): Conversion {
+  const parsed = parseTable(text, options)
+  const result = transformTable(parsed.table, options)
+  const to = options.to ?? "json"
+  if (!result.table.columns.length) return { parsed, result, output: "" }
+  if (to === "xlsx") return { parsed, result, output: "", file: toXlsx(result.table, options) }
+  return { parsed, result, output: serialize(result.table, to, options) }
+}
+
+export const SAMPLE = `id,name,email,city,salary,active
+1,Ana Souza,ana@example.com,São Paulo,8500.50,true
+2,Bruno Lima,bruno@example.com,Porto Alegre,7200,false
+3,Carla Dias,carla@example.com,Recife,9100,true
+4,"Diego, Jr.",diego@example.com,Curitiba,,true`
+

package/src/table-convert/model.ts

@@ -0,0 +1,72 @@
+// Modelo intermediário do conversor: todo formato de entrada vira isto, e todo formato de saída parte disto.
+// Células são sempre texto; a inferência de tipos (número, booleano, nulo) acontece só na saída.
+export interface Table {
+  columns: string[]
+  rows: string[][]
+}
+
+export class TableParseError extends Error {
+  constructor(readonly format: string, message: string) {
+    super(message)
+    this.name = "TableParseError"
+  }
+}
+
+export const EMPTY_TABLE: Table = { columns: [], rows: [] }
+
+// Iguala o número de células de todas as linhas (completa com vazio) e dá nome às colunas sem título
+export function normalize(grid: string[][], header: boolean): Table {
+  const width = grid.reduce((max, row) => Math.max(max, row.length), 0)
+  const pad = (row: string[]) => Array.from({ length: width }, (_, i) => row[i] ?? "")
+  const padded = grid.map(pad)
+  if (!header) return { columns: generatedColumns(width), rows: padded }
+  const [first = [], ...rows] = padded
+  return { columns: first.map((name, i) => name.trim() || `column${i + 1}`), rows }
+}
+
+export const generatedColumns = (width: number) => Array.from({ length: width }, (_, i) => `column${i + 1}`)
+
+// Chaves únicas para formatos com nomes (JSON, YAML, XML, SQL): repetidas ganham sufixo _2, _3…
+export function uniqueKeys(columns: string[]): string[] {
+  const seen = new Map<string, number>()
+  return columns.map((name) => {
+    const count = (seen.get(name) ?? 0) + 1
+    seen.set(name, count)
+    return count === 1 ? name : `${name}_${count}`
+  })
+}
+
+export type Scalar = string | number | boolean | null
+
+export const DECIMALS = ["dot", "comma"] as const
+// "dot": 1234.5 (padrão de programação); "comma": 1.234,5 (Excel e planilhas em português)
+export type Decimal = (typeof DECIMALS)[number]
+
+// Inferência conservadora: zeros à esquerda (CEP, CPF, "007") continuam texto
+const NUMBER = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?$/
+// vírgula decimal, com ou sem ponto de milhar bem formado (1.234.567,89)
+const NUMBER_COMMA = /^-?(0|[1-9]\d{0,2}(\.\d{3})+|[1-9]\d*)(,\d+)?$/
+
+// Converte o texto de uma célula em número, ou undefined se não for número no formato escolhido
+export function parseNumber(cell: string, decimal: Decimal = "dot"): number | undefined {
+  const text = cell.trim()
+  if (decimal === "comma") {
+    if (!NUMBER_COMMA.test(text)) return undefined
+    const n = Number(text.replace(/\./g, "").replace(",", "."))
+    return Number.isFinite(n) ? n : undefined
+  }
+  return NUMBER.test(text) && Number.isFinite(Number(text)) ? Number(text) : undefined
+}
+
+export function inferValue(cell: string, emptyAsNull = false, decimal: Decimal = "dot"): Scalar {
+  if (cell === "") return emptyAsNull ? null : ""
+  const n = parseNumber(cell, decimal)
+  if (n !== undefined) return n
+  const lower = cell.toLowerCase()
+  if (lower === "true") return true
+  if (lower === "false") return false
+  if (lower === "null") return null
+  return cell
+}
+
+export const isNumeric = (cell: string, decimal: Decimal = "dot") => parseNumber(cell, decimal) !== undefined

package/src/table-convert/parse.ts

@@ -0,0 +1,242 @@
+import { normalize, TableParseError, type Table } from "./model"
+
+export const INPUT_FORMATS = ["auto", "csv", "json", "markdown", "html"] as const
+export type InputFormat = (typeof INPUT_FORMATS)[number]
+export type ConcreteInput = Exclude<InputFormat, "auto">
+
+export const DELIMITERS = { comma: ",", semicolon: ";", tab: "\t", pipe: "|" } as const
+export type Delimiter = keyof typeof DELIMITERS
+export const DELIMITER_NAMES = Object.keys(DELIMITERS) as Delimiter[]
+
+export interface ParseOptions {
+  from?: InputFormat
+  delimiter?: Delimiter | "auto"
+  header?: boolean
+}
+
+export interface Parsed {
+  table: Table
+  format: ConcreteInput
+  delimiter?: Delimiter
+}
+
+// ---------- detecção ----------
+
+export function detectFormat(text: string): ConcreteInput {
+  const start = text.trimStart()
+  if (start.startsWith("[") || start.startsWith("{")) return "json"
+  if (/^<(!doctype|html|table|thead|tbody|tr|div|body)\b/i.test(start) || /<table[\s>]/i.test(start)) return "html"
+  const lines = start.split(/\r?\n/).filter((l) => l.trim())
+  if (lines.length >= 2 && lines[0]?.trim().startsWith("|") && isMarkdownSeparator(lines[1] ?? "")) return "markdown"
+  return "csv"
+}
+
+// Escolhe o separador que dá o mesmo número (> 1) de colunas no maior número de linhas.
+// Em empate vence a ordem: tab (colado do Excel/Sheets), ponto-e-vírgula (Excel em pt-BR), vírgula, barra.
+export function detectDelimiter(text: string): Delimiter {
+  const sample = text.split(/\r?\n/).slice(0, 30).join("\n")
+  let best: { name: Delimiter, score: number } = { name: "comma", score: 0 }
+  for (const name of ["tab", "semicolon", "comma", "pipe"] as const) {
+    const rows = parseDelimited(sample, DELIMITERS[name]).filter((r) => r.length > 1 || r[0] !== "")
+    if (rows.length === 0) continue
+    const counts = new Map<number, number>()
+    for (const r of rows) counts.set(r.length, (counts.get(r.length) ?? 0) + 1)
+    const [width, hits] = [...counts.entries()].sort((a, b) => b[1] - a[1] || b[0] - a[0])[0] ?? [1, 0]
+    if (width < 2) continue
+    const score = (hits / rows.length) * 1000 + width
+    if (score > best.score) best = { name, score }
+  }
+  return best.name
+}
+
+// ---------- CSV / TSV (RFC 4180) ----------
+
+export function parseDelimited(text: string, delimiter: string): string[][] {
+  const rows: string[][] = []
+  let row: string[] = []
+  let cell = ""
+  let quoted = false
+  let i = 0
+  const input = text.replace(/^/, "")
+  while (i < input.length) {
+    const ch = input[i] as string
+    if (quoted) {
+      if (ch === '"') {
+        if (input[i + 1] === '"') {
+          cell += '"'
+          i++
+        } else quoted = false
+      } else cell += ch
+    } else if (ch === '"' && cell === "") quoted = true
+    else if (ch === delimiter) {
+      row.push(cell)
+      cell = ""
+    } else if (ch === "\n" || ch === "\r") {
+      if (ch === "\r" && input[i + 1] === "\n") i++
+      row.push(cell)
+      rows.push(row)
+      row = []
+      cell = ""
+    } else cell += ch
+    i++
+  }
+  if (cell !== "" || row.length > 0) {
+    row.push(cell)
+    rows.push(row)
+  }
+  // linhas totalmente vazias (ex.: final do arquivo) não contam
+  return rows.filter((r) => r.some((c) => c !== ""))
+}
+
+// ---------- Markdown ----------
+
+const isMarkdownSeparator = (line: string) => /^\s*\|?\s*:?-{1,}:?\s*(\|\s*:?-{1,}:?\s*)*\|?\s*$/.test(line) && line.includes("-")
+
+function splitMarkdownRow(line: string): string[] {
+  let body = line.trim()
+  if (body.startsWith("|")) body = body.slice(1)
+  if (body.endsWith("|") && !body.endsWith("\\|")) body = body.slice(0, -1)
+  const cells: string[] = []
+  let cell = ""
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i]
+    if (ch === "\\" && body[i + 1] === "|") {
+      cell += "|"
+      i++
+    } else if (ch === "|") {
+      cells.push(cell)
+      cell = ""
+    } else cell += ch
+  }
+  cells.push(cell)
+  return cells.map((c) => c.trim().replace(/<br\s*\/?>/gi, "\n"))
+}
+
+export function parseMarkdown(text: string): string[][] {
+  return text
+    .split(/\r?\n/)
+    .filter((line) => line.includes("|") && !isMarkdownSeparator(line))
+    .map(splitMarkdownRow)
+}
+
+// ---------- HTML ----------
+
+const ENTITIES: Record<string, string> = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", copy: "©", reg: "®", hellip: "…", mdash: "—", ndash: "–" }
+
+export function decodeEntities(text: string): string {
+  return text.replace(/&(#x[\da-f]+|#\d+|[a-z]+);/gi, (match, code: string) => {
+    if (code[0] === "#") {
+      const n = code[1] === "x" || code[1] === "X" ? parseInt(code.slice(2), 16) : parseInt(code.slice(1), 10)
+      return Number.isFinite(n) ? String.fromCodePoint(n) : match
+    }
+    return ENTITIES[code.toLowerCase()] ?? match
+  })
+}
+
+// Parser leve de propósito (sem DOM): funciona igual no navegador e no terminal. Lê a primeira <table>;
+// colspan repete a célula vazia para manter as colunas alinhadas.
+export function parseHtml(text: string): string[][] {
+  const clean = text.replace(/<!--[\s\S]*?-->/g, "").replace(/<(script|style)\b[\s\S]*?<\/\1>/gi, "")
+  const table = /<table\b[\s\S]*?<\/table>/i.exec(clean)?.[0] ?? clean
+  const rows: string[][] = []
+  for (const tr of table.match(/<tr\b[\s\S]*?(?=<tr\b|<\/tbody|<\/thead|<\/tfoot|<\/table|$)/gi) ?? []) {
+    const cells: string[] = []
+    for (const match of tr.matchAll(/<(td|th)\b([^>]*)>([\s\S]*?)(?=<td\b|<th\b|<\/tr|$)/gi)) {
+      const value = decodeEntities(
+        (match[3] ?? "")
+          .replace(/<\/(td|th)>\s*$/i, "")
+          .replace(/<br\s*\/?>/gi, "\u0000")
+          .replace(/<[^>]+>/g, "")
+          .replace(/\s+/g, " "),
+      )
+        .split("\u0000")
+        .map((line) => line.trim())
+        .join("\n")
+        .trim()
+      cells.push(value)
+      const span = Number(/colspan\s*=\s*["']?(\d+)/i.exec(match[2] ?? "")?.[1] ?? 1)
+      for (let s = 1; s < Math.min(span, 1000); s++) cells.push("")
+    }
+    if (cells.length) rows.push(cells)
+  }
+  return rows
+}
+
+// ---------- JSON ----------
+
+const cellText = (value: unknown): string => (value === null || value === undefined ? "" : typeof value === "object" ? JSON.stringify(value) : String(value))
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value)
+
+function parseJsonValue(text: string): unknown {
+  try {
+    return JSON.parse(text)
+  } catch (error) {
+    // JSON Lines: um objeto por linha
+    const lines = text.split(/\r?\n/).filter((l) => l.trim())
+    if (lines.length > 1) {
+      try {
+        return lines.map((l) => JSON.parse(l))
+      } catch {
+        // mantém o erro original, mais útil
+      }
+    }
+    throw new TableParseError("json", error instanceof Error ? error.message : String(error))
+  }
+}
+
+// Aceita: array de objetos, array de arrays, objeto de colunas ({ nome: [...] }), objeto de objetos
+// ({ id: {...} } → coluna "key") e um objeto que embrulha um desses ({ "data": [...] }).
+export function parseJson(text: string, header = true): Table {
+  let value = parseJsonValue(text)
+  if (isRecord(value)) {
+    const entries = Object.entries(value)
+    const arrays = entries.filter(([, v]) => Array.isArray(v))
+    const scalarList = (v: unknown) => Array.isArray(v) && v.every((x) => !isRecord(x) && !Array.isArray(x))
+    if (entries.length > 1 && entries.every(([, v]) => scalarList(v))) {
+      const columns = entries.map(([k]) => k)
+      const lists = entries.map(([, v]) => v as unknown[])
+      const height = Math.max(...lists.map((l) => l.length))
+      return { columns, rows: Array.from({ length: height }, (_, i) => lists.map((l) => cellText(l[i]))) }
+    }
+    if (arrays.length === 1) value = arrays[0]?.[1]
+    else if (entries.length > 0 && entries.every(([, v]) => isRecord(v))) value = entries.map(([key, v]) => ({ key, ...(v as Record<string, unknown>) }))
+    else value = [value]
+  }
+  if (!Array.isArray(value)) throw new TableParseError("json", "expected an array or object")
+  if (value.length === 0) return { columns: [], rows: [] }
+  if (value.every(Array.isArray)) return normalize((value as unknown[][]).map((row) => row.map(cellText)), header)
+  const columns: string[] = []
+  const known = new Set<string>()
+  for (const item of value) {
+    for (const key of Object.keys(isRecord(item) ? item : { value: item })) {
+      if (!known.has(key)) {
+        known.add(key)
+        columns.push(key)
+      }
+    }
+  }
+  return { columns, rows: value.map((item) => columns.map((key) => cellText(isRecord(item) ? item[key] : key === "value" ? item : undefined))) }
+}
+
+// ---------- entrada única ----------
+
+export function parseTable(text: string, options: ParseOptions = {}): Parsed {
+  const header = options.header ?? true
+  if (!text.trim()) return { table: { columns: [], rows: [] }, format: options.from && options.from !== "auto" ? options.from : "csv" }
+  const format = !options.from || options.from === "auto" ? detectFormat(text) : options.from
+  switch (format) {
+    case "json":
+      return { table: parseJson(text, header), format }
+    case "markdown":
+      return { table: normalize(parseMarkdown(text), header), format }
+    case "html": {
+      const grid = parseHtml(text)
+      if (grid.length === 0) throw new TableParseError("html", "no <tr> rows found")
+      return { table: normalize(grid, header), format }
+    }
+    case "csv": {
+      const delimiter = !options.delimiter || options.delimiter === "auto" ? detectDelimiter(text) : options.delimiter
+      return { table: normalize(parseDelimited(text, DELIMITERS[delimiter]), header), format, delimiter }
+    }
+  }
+}