cerfaparse 0.1.0

package/dist/cli.js

@@ -0,0 +1,620 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { program } from "commander";
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { basename, dirname, join as join2 } from "path";
+
+// src/poppler.ts
+import { execa } from "execa";
+import { access, mkdtemp, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+async function checkPoppler() {
+  const tools = ["pdftocairo", "pdftotext", "pdfinfo"];
+  const missing = [];
+  for (const tool of tools) {
+    try {
+      await execa(tool, ["-v"]);
+    } catch {
+      missing.push(tool);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Poppler tools not found: ${missing.join(", ")}. Install with:
+  macOS:  brew install poppler
+  Linux:  apt install poppler-utils`
+    );
+  }
+}
+async function getPageCount(pdfPath) {
+  await validateFileExists(pdfPath);
+  const { stdout } = await execa("pdfinfo", [pdfPath]);
+  const match = stdout.match(/^Pages:\s+(\d+)/m);
+  if (!match) throw new Error("Could not determine page count from pdfinfo");
+  return parseInt(match[1], 10);
+}
+async function extractSvg(pdfPath, page) {
+  const tmpDir = await mkdtemp(join(tmpdir(), "cerfaparse-"));
+  const outPath = join(tmpDir, `page-${page}.svg`);
+  try {
+    await execa("pdftocairo", [
+      "-svg",
+      "-f",
+      String(page),
+      "-l",
+      String(page),
+      pdfPath,
+      outPath
+    ]);
+    return await readFile(outPath, "utf-8");
+  } finally {
+    try {
+      await rm(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+async function extractBbox(pdfPath) {
+  const { stdout } = await execa("pdftotext", [
+    "-bbox-layout",
+    pdfPath,
+    "-"
+  ]);
+  return stdout;
+}
+async function validateFileExists(path) {
+  try {
+    await access(path);
+  } catch {
+    throw new Error(`File not found: ${path}`);
+  }
+}
+
+// src/extract-boxes.ts
+import * as cheerio from "cheerio";
+var WHITE_THRESHOLD = 0.95;
+var DARK_STROKE_THRESHOLD = 0.2;
+var MAX_BOX_WIDTH = 50;
+var MAX_BOX_HEIGHT = 50;
+var MIN_BOX_SIZE = 3;
+function extractBoxes(svgXml) {
+  const $ = cheerio.load(svgXml, { xml: true });
+  let pageHeight = 0;
+  const viewBox = $("svg").attr("viewBox") ?? "";
+  const vbParts = viewBox.split(/\s+/);
+  if (vbParts.length >= 4) {
+    pageHeight = parseFloat(vbParts[3]);
+  }
+  if (!Number.isFinite(pageHeight) || pageHeight <= 0) {
+    const heightAttr = $("svg").attr("height") ?? "";
+    pageHeight = parseFloat(heightAttr);
+  }
+  if (!Number.isFinite(pageHeight) || pageHeight <= 0) {
+    throw new Error("Could not extract page height from SVG viewBox or height attribute");
+  }
+  let transform = null;
+  const boxes = [];
+  $("path").each((_, el) => {
+    const path = $(el);
+    const d = path.attr("d");
+    const fill = path.attr("fill") ?? "";
+    const stroke = path.attr("stroke") ?? "";
+    const strokeWidth = parseFloat(path.attr("stroke-width") ?? "0");
+    if (!d || !isWhiteColor(fill)) return;
+    const rect = parseRectPath(d);
+    if (!rect) return;
+    if (rect.width > MAX_BOX_WIDTH || rect.height > MAX_BOX_HEIGHT) return;
+    if (rect.width < MIN_BOX_SIZE || rect.height < MIN_BOX_SIZE) return;
+    const type = classifyBox(stroke, strokeWidth);
+    if (!type) return;
+    const pathTransform = parseTransformFromAttr(path.attr("transform") ?? "");
+    if (!pathTransform) return;
+    const ancestorTransform = collectAncestorTransform($, el);
+    const effectiveTransform = ancestorTransform ? composeTransforms(ancestorTransform, pathTransform) : pathTransform;
+    if (!transform) {
+      transform = effectiveTransform;
+    } else if (!matricesEqual(transform, effectiveTransform)) {
+      console.warn(
+        "Warning: found input box with different transform matrix \u2014 skipping. This may indicate rotated sections."
+      );
+      return;
+    }
+    boxes.push({ ...rect, type });
+  });
+  return { boxes, transform, pageHeight };
+}
+function collectAncestorTransform($, el) {
+  const transforms = [];
+  let insideDefs = false;
+  let current = el.parent;
+  while (current) {
+    const tag = current.tagName ?? current.name ?? "";
+    if (tag === "svg") break;
+    if (tag === "defs") {
+      insideDefs = true;
+      break;
+    }
+    if (tag === "g") {
+      const t = $(current).attr("transform") ?? "";
+      const parsed = parseTransformAttr(t);
+      if (parsed) transforms.unshift(parsed);
+    }
+    current = current.parent;
+  }
+  if (insideDefs) {
+    const svgChildren = $("svg").children().toArray();
+    for (const child of svgChildren) {
+      const tag = child.tagName ?? "";
+      if (tag !== "use") continue;
+      const t = $(child).attr("transform") ?? "";
+      const parsed = parseTransformAttr(t);
+      if (parsed) return parsed;
+    }
+    return null;
+  }
+  if (transforms.length === 0) return null;
+  return transforms.reduce(composeTransforms);
+}
+function parseTransformAttr(attr) {
+  const matrixMatch = attr.match(MATRIX_RE);
+  if (matrixMatch) {
+    const m = {
+      a: parseFloat(matrixMatch[1]),
+      b: parseFloat(matrixMatch[2]),
+      c: parseFloat(matrixMatch[3]),
+      d: parseFloat(matrixMatch[4]),
+      e: parseFloat(matrixMatch[5]),
+      f: parseFloat(matrixMatch[6])
+    };
+    if (Object.values(m).some((v) => !Number.isFinite(v))) return null;
+    return m;
+  }
+  const translateMatch = attr.match(
+    /translate\(\s*([-\d.]+)(?:\s*,\s*([-\d.]+))?\s*\)/
+  );
+  if (translateMatch) {
+    const tx = parseFloat(translateMatch[1]);
+    const ty = parseFloat(translateMatch[2] ?? "0");
+    if (!Number.isFinite(tx) || !Number.isFinite(ty)) return null;
+    return { a: 1, b: 0, c: 0, d: 1, e: tx, f: ty };
+  }
+  return null;
+}
+function composeTransforms(m1, m2) {
+  return {
+    a: m1.a * m2.a + m1.c * m2.b,
+    b: m1.b * m2.a + m1.d * m2.b,
+    c: m1.a * m2.c + m1.c * m2.d,
+    d: m1.b * m2.c + m1.d * m2.d,
+    e: m1.a * m2.e + m1.c * m2.f + m1.e,
+    f: m1.b * m2.e + m1.d * m2.f + m1.f
+  };
+}
+var MATRIX_RE = /matrix\(\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*,\s*([-\d.]+)\s*\)/;
+function parseTransformFromAttr(attr) {
+  return parseTransformAttr(attr);
+}
+function matricesEqual(a, b) {
+  const tol = 1e-3;
+  return Math.abs(a.a - b.a) < tol && Math.abs(a.b - b.b) < tol && Math.abs(a.c - b.c) < tol && Math.abs(a.d - b.d) < tol && Math.abs(a.e - b.e) < tol && Math.abs(a.f - b.f) < tol;
+}
+function parseRectPath(d) {
+  const commands = d.trim().split(/\s*([MLHVCSQTAZ])\s*/i).filter(Boolean);
+  const points = [];
+  let i = 0;
+  while (i < commands.length) {
+    const cmd = commands[i];
+    if (cmd === "M" || cmd === "L") {
+      const coords = commands[i + 1]?.trim().split(/\s+/);
+      if (coords && coords.length >= 2) {
+        const x = parseFloat(coords[0]);
+        const y = parseFloat(coords[1]);
+        if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+        points.push([x, y]);
+      }
+      i += 2;
+    } else if (cmd === "Z") {
+      i += 1;
+    } else {
+      return null;
+    }
+  }
+  if (points.length < 4) return null;
+  const xs = points.slice(0, 4).map((p) => p[0]);
+  const ys = points.slice(0, 4).map((p) => p[1]);
+  const minX = Math.min(...xs);
+  const maxX = Math.max(...xs);
+  const minY = Math.min(...ys);
+  const maxY = Math.max(...ys);
+  const width = maxX - minX;
+  const height = maxY - minY;
+  if (width < 1 || height < 1) return null;
+  return { x: minX, y: minY, width, height };
+}
+function parseRgbPercent(color) {
+  const match = color.match(
+    /rgb\(\s*([\d.]+)%\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%\s*\)/
+  );
+  if (!match) return null;
+  return [
+    parseFloat(match[1]) / 100,
+    parseFloat(match[2]) / 100,
+    parseFloat(match[3]) / 100
+  ];
+}
+function isWhiteColor(color) {
+  const rgb = parseRgbPercent(color);
+  if (!rgb) return false;
+  return rgb[0] >= WHITE_THRESHOLD && rgb[1] >= WHITE_THRESHOLD && rgb[2] >= WHITE_THRESHOLD;
+}
+function isDarkColor(color) {
+  const rgb = parseRgbPercent(color);
+  if (!rgb) return false;
+  return rgb[0] < DARK_STROKE_THRESHOLD && rgb[1] < DARK_STROKE_THRESHOLD && rgb[2] < DARK_STROKE_THRESHOLD;
+}
+function classifyBox(stroke, strokeWidth) {
+  if (isWhiteColor(stroke) && strokeWidth >= 0.9) {
+    return "cell";
+  }
+  if (isDarkColor(stroke)) {
+    return "checkbox";
+  }
+  return null;
+}
+
+// src/extract-labels.ts
+import * as cheerio2 from "cheerio";
+var WORD_JOIN_GAP = 10;
+var LINE_Y_TOLERANCE = 2;
+function extractLabels(bboxHtml) {
+  const $ = cheerio2.load(bboxHtml, { xml: false });
+  const pageLabels = /* @__PURE__ */ new Map();
+  $("page").each((pageIdx, pageEl) => {
+    const pageNum = pageIdx + 1;
+    const words = [];
+    $(pageEl).find("word").each((_, wordEl) => {
+      const $w = $(wordEl);
+      words.push({
+        text: $w.text().trim(),
+        xMin: parseFloat($w.attr("xmin") ?? "0"),
+        yMin: parseFloat($w.attr("ymin") ?? "0"),
+        xMax: parseFloat($w.attr("xmax") ?? "0"),
+        yMax: parseFloat($w.attr("ymax") ?? "0")
+      });
+    });
+    const labels = assembleLabels(words, pageNum);
+    pageLabels.set(pageNum, labels);
+  });
+  return pageLabels;
+}
+function assembleLabels(words, page) {
+  if (words.length === 0) return [];
+  const sorted = [...words].sort((a, b) => {
+    const yDiff = a.yMin - b.yMin;
+    if (Math.abs(yDiff) > LINE_Y_TOLERANCE) return yDiff;
+    return a.xMin - b.xMin;
+  });
+  const lines = [[sorted[0]]];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = lines[lines.length - 1];
+    const lastWord = prev[prev.length - 1];
+    const curr = sorted[i];
+    if (Math.abs(curr.yMin - lastWord.yMin) <= LINE_Y_TOLERANCE) {
+      prev.push(curr);
+    } else {
+      lines.push([curr]);
+    }
+  }
+  const labels = [];
+  for (const line of lines) {
+    const sortedLine = line.sort((a, b) => a.xMin - b.xMin);
+    let current = [sortedLine[0]];
+    for (let i = 1; i < sortedLine.length; i++) {
+      const prev = current[current.length - 1];
+      const curr = sortedLine[i];
+      const gap = curr.xMin - prev.xMax;
+      if (gap <= WORD_JOIN_GAP) {
+        current.push(curr);
+      } else {
+        labels.push(wordsToLabel(current, page));
+        current = [curr];
+      }
+    }
+    labels.push(wordsToLabel(current, page));
+  }
+  return labels;
+}
+function wordsToLabel(words, page) {
+  const text = words.map((w) => w.text).join(" ");
+  let xMin = Infinity, yMin = Infinity, xMax = -Infinity, yMax = -Infinity;
+  for (const w of words) {
+    if (w.xMin < xMin) xMin = w.xMin;
+    if (w.yMin < yMin) yMin = w.yMin;
+    if (w.xMax > xMax) xMax = w.xMax;
+    if (w.yMax > yMax) yMax = w.yMax;
+  }
+  return { text, xMin, yMin, xMax, yMax, page };
+}
+
+// src/group-rows.ts
+var Y_TOLERANCE = 2;
+var FIELD_GAP_THRESHOLD = 10;
+function groupBoxesIntoFields(boxes, page) {
+  const rows = groupByY(boxes, page);
+  const fields = [];
+  for (const row of rows) {
+    const sorted = [...row.boxes].sort((a, b) => a.x - b.x);
+    const splits = splitByXGap(sorted, row);
+    fields.push(...splits);
+  }
+  fields.sort((a, b) => {
+    const yDiff = a.boxes[0].y - b.boxes[0].y;
+    if (Math.abs(yDiff) > Y_TOLERANCE) return yDiff;
+    return a.boxes[0].x - b.boxes[0].x;
+  });
+  return fields;
+}
+function groupByY(boxes, page) {
+  const sorted = [...boxes].sort((a, b) => a.y - b.y);
+  const rows = [];
+  for (const box of sorted) {
+    const existingRow = rows.find(
+      (r) => Math.abs(r.y - box.y) <= Y_TOLERANCE && r.type === box.type
+    );
+    if (existingRow) {
+      existingRow.boxes.push(box);
+      const avg = existingRow.boxes.reduce((sum, b) => sum + b.y, 0) / existingRow.boxes.length;
+      existingRow.y = avg;
+    } else {
+      rows.push({ boxes: [box], y: box.y, type: box.type, page });
+    }
+  }
+  return rows;
+}
+function splitByXGap(sortedBoxes, row) {
+  if (sortedBoxes.length === 0) return [];
+  const groups = [[sortedBoxes[0]]];
+  for (let i = 1; i < sortedBoxes.length; i++) {
+    const prev = sortedBoxes[i - 1];
+    const curr = sortedBoxes[i];
+    const gap = curr.x - (prev.x + prev.width);
+    if (gap > FIELD_GAP_THRESHOLD) {
+      groups.push([curr]);
+    } else {
+      groups[groups.length - 1].push(curr);
+    }
+  }
+  return groups.map((boxes) => ({
+    boxes,
+    row: { ...row, boxes },
+    boxCount: boxes.length
+  }));
+}
+
+// src/transform.ts
+function svgPointToViewport(svgX, svgY, matrix) {
+  return {
+    x: matrix.a * svgX + matrix.c * svgY + matrix.e,
+    y: matrix.b * svgX + matrix.d * svgY + matrix.f
+  };
+}
+function svgBoxToPdfRect(box, matrix, pageHeight) {
+  const corner1 = svgPointToViewport(box.x, box.y, matrix);
+  const corner2 = svgPointToViewport(
+    box.x + box.width,
+    box.y + box.height,
+    matrix
+  );
+  const vpLeft = Math.min(corner1.x, corner2.x);
+  const vpTop = Math.min(corner1.y, corner2.y);
+  const vpRight = Math.max(corner1.x, corner2.x);
+  const vpBottom = Math.max(corner1.y, corner2.y);
+  const width = vpRight - vpLeft;
+  const height = vpBottom - vpTop;
+  const pdfX = vpLeft;
+  const pdfY = pageHeight - vpBottom;
+  return { x: pdfX, y: pdfY, width, height };
+}
+
+// src/map-labels.ts
+function toFieldType(boxType) {
+  return boxType === "cell" ? "input" : "checkbox";
+}
+var LABEL_Y_MAX_DISTANCE = 25;
+function labelToPdfCoords(label, pageHeight) {
+  return {
+    xMin: label.xMin,
+    xMax: label.xMax,
+    yBottom: pageHeight - label.yMax,
+    // bottom edge in PDF
+    yTop: pageHeight - label.yMin
+    // top edge in PDF
+  };
+}
+function mapLabelsToFields(fieldGroups, labels, transform, page, pageHeight) {
+  const fields = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const group of fieldGroups) {
+    const pdfRect = computeGroupPdfRect(group, transform, pageHeight);
+    const bestLabel = findBestLabel(pdfRect, labels, pageHeight);
+    const labelText = bestLabel?.text ?? "";
+    const baseName = generateFieldName(labelText, group.row.type, page);
+    const name = deduplicateName(baseName, usedNames);
+    usedNames.add(name);
+    const field = {
+      key: name,
+      type: toFieldType(group.row.type),
+      props: {
+        label: labelText,
+        page,
+        pdfRect,
+        ...group.row.type === "cell" ? { maxLength: group.boxCount } : {}
+      }
+    };
+    fields.push(field);
+  }
+  return fields;
+}
+function computeGroupPdfRect(group, transform, pageHeight) {
+  const rects = group.boxes.map((box) => svgBoxToPdfRect(box, transform, pageHeight));
+  let x = Infinity, y = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const r of rects) {
+    if (r.x < x) x = r.x;
+    if (r.y < y) y = r.y;
+    const rx = r.x + r.width;
+    const ry = r.y + r.height;
+    if (rx > maxX) maxX = rx;
+    if (ry > maxY) maxY = ry;
+  }
+  return { x, y, width: maxX - x, height: maxY - y };
+}
+function findBestLabel(fieldRect, labels, pageHeight) {
+  const fieldTop = fieldRect.y + fieldRect.height;
+  const fieldLeft = fieldRect.x;
+  const fieldRight = fieldRect.x + fieldRect.width;
+  let bestLabel = null;
+  let bestScore = Infinity;
+  for (const label of labels) {
+    const pdfLabel = labelToPdfCoords(label, pageHeight);
+    const yDistance = pdfLabel.yBottom - fieldTop;
+    if (yDistance < 0 || yDistance > LABEL_Y_MAX_DISTANCE) continue;
+    const hasOverlap = pdfLabel.xMin < fieldRight && pdfLabel.xMax > fieldLeft;
+    const isLeftOf = pdfLabel.xMax <= fieldLeft && fieldLeft - pdfLabel.xMax < 50;
+    if (!hasOverlap && !isLeftOf) continue;
+    const score = yDistance + (hasOverlap ? 0 : 20);
+    if (score < bestScore) {
+      bestScore = score;
+      bestLabel = label;
+    }
+  }
+  return bestLabel;
+}
+function generateFieldName(labelText, _type, page) {
+  if (!labelText) {
+    return `p${page}_field`;
+  }
+  const cleaned = labelText.replace(/\s*:\s*$/, "").trim();
+  const camel = cleaned.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-zA-Z0-9\s]/g, "").trim().split(/\s+/).map(
+    (word, i) => i === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+  ).join("");
+  if (!camel) {
+    return `p${page}_field`;
+  }
+  return `p${page}_${camel}`;
+}
+function deduplicateName(baseName, used) {
+  if (!used.has(baseName)) return baseName;
+  let counter = 2;
+  while (used.has(`${baseName}_${counter}`)) counter++;
+  return `${baseName}_${counter}`;
+}
+
+// src/inject-fields.ts
+import { PDFDocument, PDFName, StandardFonts } from "pdf-lib";
+function clearWidgetAppearance(acroField) {
+  for (const widget of acroField.getWidgets()) {
+    const mk = widget.dict.lookup(PDFName.of("MK"));
+    if (mk && typeof mk.delete === "function") {
+      mk.delete(PDFName.of("BG"));
+      mk.delete(PDFName.of("BC"));
+    }
+  }
+}
+async function injectFields(pdfBytes, fields) {
+  const pdfDoc = await PDFDocument.load(pdfBytes);
+  const form = pdfDoc.getForm();
+  const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+  const pages = pdfDoc.getPages();
+  for (const field of fields) {
+    const pageIndex = field.props.page - 1;
+    if (pageIndex < 0 || pageIndex >= pages.length) continue;
+    const page = pages[pageIndex];
+    const { x, y, width, height } = field.props.pdfRect;
+    if (field.type === "input") {
+      const textField = form.createTextField(field.key);
+      textField.addToPage(page, { x, y, width, height, font, borderWidth: 0 });
+      if (field.props.maxLength) {
+        textField.setMaxLength(field.props.maxLength);
+        textField.enableCombing();
+      }
+      textField.setFontSize(0);
+      clearWidgetAppearance(textField.acroField);
+      textField.updateAppearances(font);
+    } else {
+      const checkbox = form.createCheckBox(field.key);
+      checkbox.addToPage(page, { x, y, width, height, borderWidth: 0 });
+      clearWidgetAppearance(checkbox.acroField);
+      checkbox.updateAppearances();
+    }
+  }
+  return pdfDoc.save();
+}
+
+// src/cli.ts
+async function convert(inputPath, outputPath) {
+  await checkPoppler();
+  const dir = dirname(inputPath);
+  const base = basename(inputPath, ".pdf");
+  const pdfOut = outputPath ?? join2(dir, `${base}-fillable.pdf`);
+  const jsonOut = join2(dirname(pdfOut), `${basename(pdfOut, ".pdf")}.fields.json`);
+  const pageCount = await getPageCount(inputPath);
+  console.log(`Processing ${pageCount} page(s)...`);
+  const bboxHtml = await extractBbox(inputPath);
+  const labelsByPage = extractLabels(bboxHtml);
+  const allFields = [];
+  for (let page = 1; page <= pageCount; page++) {
+    console.log(`  Page ${page}: extracting geometry...`);
+    const svgXml = await extractSvg(inputPath, page);
+    const { boxes, transform, pageHeight } = extractBoxes(svgXml);
+    if (!transform || boxes.length === 0) {
+      console.log(`  Page ${page}: no input boxes found, skipping`);
+      continue;
+    }
+    const fieldGroups = groupBoxesIntoFields(boxes, page);
+    const labels = labelsByPage.get(page) ?? [];
+    const fields = mapLabelsToFields(fieldGroups, labels, transform, page, pageHeight);
+    const cellCount = fields.filter((f) => f.type === "input").length;
+    const checkboxCount = fields.filter((f) => f.type === "checkbox").length;
+    console.log(`  Page ${page}: ${cellCount} text fields, ${checkboxCount} checkboxes`);
+    allFields.push(...fields);
+  }
+  console.log("Injecting AcroForm fields...");
+  const pdfBytes = new Uint8Array(await readFile2(inputPath));
+  const filledPdf = await injectFields(pdfBytes, allFields);
+  await writeFile(pdfOut, filledPdf);
+  const output = {
+    pages: Array.from({ length: pageCount }, (_, i) => ({
+      pageNumber: i + 1,
+      fields: allFields.filter((f) => f.props.page === i + 1)
+    }))
+  };
+  await writeFile(jsonOut, JSON.stringify(output, null, 2));
+  console.log(`
+Done!`);
+  console.log(`  PDF:  ${pdfOut}`);
+  console.log(`  JSON: ${jsonOut}`);
+  console.log(`  Total fields: ${allFields.length}`);
+  return { pdfOut, jsonOut, fields: allFields };
+}
+function main() {
+  program.name("cerfaparse").description("Convert flat CERFA PDFs into fillable AcroForm PDFs with field definitions").version("0.1.0");
+  program.command("convert").description("Convert a flat CERFA PDF to a fillable AcroForm PDF + JSON field definitions").argument("<input>", "Path to the input CERFA PDF").option("-o, --output <path>", "Output PDF path").action(async (input, opts) => {
+    try {
+      await convert(input, opts.output);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  program.parse();
+}
+var isMainModule = process.argv[1] && (import.meta.url.endsWith(process.argv[1]) || import.meta.url === `file://${process.argv[1]}`);
+if (isMainModule) {
+  main();
+}
+export {
+  convert
+};
+//# sourceMappingURL=cli.js.map