persian-data-grid 0.5.0 → 0.7.0

package/dist/chunk-VYJQ2HTA.cjs

@@ -0,0 +1,936 @@
+'use strict';
+
+var chunkIMPCRWYP_cjs = require('./chunk-IMPCRWYP.cjs');
+var chunkF6EMC75A_cjs = require('./chunk-F6EMC75A.cjs');
+var fflate = require('fflate');
+
+// packages/plugins/pdf/src/TextPdfRenderer.ts
+var TextPdfRenderer = class {
+  async render(source, options) {
+    const lines = [options?.title ?? "Export"];
+    const columns = source.columns.slice(0, 8);
+    lines.push(columns.map((c) => c.fieldCaption ?? c.fieldName).join(" | "));
+    for (const row of source.rows.slice(0, 40)) {
+      const prefix = row.kind === "group" ? "\u25B8 " : "";
+      lines.push(
+        prefix + columns.map((col) => {
+          const cell = row.cells[col.fieldName];
+          const raw = cell?.display ?? cell?.value ?? "";
+          return chunkF6EMC75A_cjs.formatExportValue(raw, col.fieldType).slice(0, 24);
+        }).join(" | ")
+      );
+    }
+    const content = lines.map((line, i) => {
+      const safe = line.replace(/[()\\]/g, " ");
+      const y = 750 - i * 14;
+      return `BT /F1 10 Tf 40 ${y} Td (${safe}) Tj ET`;
+    }).join("\n");
+    const stream = content;
+    const objects = [
+      "1 0 obj<< /Type /Catalog /Pages 2 0 R >>endobj\n",
+      "2 0 obj<< /Type /Pages /Kids [3 0 R] /Count 1 >>endobj\n",
+      "3 0 obj<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources<< /Font<< /F1 5 0 R >> >> >>endobj\n",
+      `4 0 obj<< /Length ${stream.length} >>stream
+${stream}
+endstream
+endobj
+`,
+      "5 0 obj<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>endobj\n"
+    ];
+    let body = "%PDF-1.1\n";
+    const offsets = [0];
+    for (const obj of objects) {
+      offsets.push(body.length);
+      body += obj;
+    }
+    const xrefStart = body.length;
+    body += `xref
+0 ${objects.length + 1}
+`;
+    body += "0000000000 65535 f \n";
+    for (let i = 1; i <= objects.length; i += 1) {
+      body += `${String(offsets[i]).padStart(10, "0")} 00000 n 
+`;
+    }
+    body += `trailer<< /Size ${objects.length + 1} /Root 1 0 R >>
+`;
+    body += `startxref
+${xrefStart}
+%%EOF
+`;
+    return new Blob([body], { type: "application/pdf" });
+  }
+};
+
+// packages/plugins/pdf/src/PdfExportPlugin.ts
+var PdfExportPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.name = "pdf-export";
+    this.unsub = null;
+    this.renderer = options.renderer ?? new TextPdfRenderer();
+  }
+  register(ctx) {
+    this.unsub = ctx.bus.subscribeAll((event) => {
+      void this.onEvent(ctx, event);
+    });
+  }
+  dispose() {
+    this.unsub?.();
+    this.unsub = null;
+  }
+  async onEvent(ctx, event) {
+    if (event.type !== "EXPORT_REQUESTED") return;
+    if (event.tableId !== ctx.tableId) return;
+    const payload = event.payload;
+    if (payload.format !== "pdf") return;
+    try {
+      const source = ctx.query.getExportSource(
+        payload.collectionScope ?? "active"
+      );
+      if (!source) {
+        throw new Error("NO_EXPORT_SOURCE");
+      }
+      const blob = await this.renderer.render(source, {
+        title: payload.fileName ?? "Export",
+        direction: payload.direction,
+        template: this.options.template
+      });
+      const fileName = payload.fileName ?? `export-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.pdf`;
+      const rowCount = source.rows.length;
+      if (this.options.download !== false) {
+        chunkIMPCRWYP_cjs.downloadBlob(blob, fileName);
+      }
+      this.options.onBlob?.(blob, { fileName, rowCount });
+      await ctx.bus.publish({
+        eventId: `${Date.now()}-pdf-ok`,
+        type: "PDF_EXPORT_COMPLETED",
+        tableId: ctx.tableId,
+        streamId: `table/${ctx.tableId}/view`,
+        version: 0,
+        occurredAt: Date.now(),
+        actorId: event.actorId,
+        correlationId: event.correlationId,
+        causationId: event.eventId,
+        payload: {
+          format: "pdf",
+          rowCount,
+          blobId: fileName
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      await ctx.bus.publish({
+        eventId: `${Date.now()}-pdf-fail`,
+        type: "PDF_EXPORT_FAILED",
+        tableId: ctx.tableId,
+        streamId: `table/${ctx.tableId}/view`,
+        version: 0,
+        occurredAt: Date.now(),
+        actorId: event.actorId,
+        correlationId: event.correlationId,
+        causationId: event.eventId,
+        payload: {
+          format: "pdf",
+          code: message === "NO_EXPORT_SOURCE" ? message : "EXPORT_FAILED",
+          message
+        }
+      });
+    }
+  }
+};
+var encoder = new TextEncoder();
+function concat(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const out = new Uint8Array(total);
+  let o = 0;
+  for (const c of chunks) {
+    out.set(c, o);
+    o += c.length;
+  }
+  return out;
+}
+function pad10(n) {
+  return String(n).padStart(10, "0");
+}
+var PdfBuilder = class {
+  constructor() {
+    this.objects = [];
+  }
+  addAscii(body) {
+    this.objects.push(encoder.encode(body));
+    return this.objects.length;
+  }
+  replaceAscii(objNum, body) {
+    this.objects[objNum - 1] = encoder.encode(body);
+  }
+  addFlate(uncompressed, extraDict = "") {
+    const compressed = fflate.deflateSync(uncompressed, { level: 9 });
+    const dict = `<< /Filter /FlateDecode /Length ${compressed.length} ${extraDict}>>`;
+    const header = encoder.encode(`${dict}stream
+`);
+    const tail = encoder.encode("\nendstream\n");
+    this.objects.push(concat([header, compressed, tail]));
+    return this.objects.length;
+  }
+  /** Raw stream (e.g. JPEG with `/Filter /DCTDecode`). `dict` is a full `<< … >>`. */
+  addRawStream(data, dict) {
+    const header = encoder.encode(`${dict}
+stream
+`);
+    const tail = encoder.encode("\nendstream\n");
+    this.objects.push(concat([header, data, tail]));
+    return this.objects.length;
+  }
+  build() {
+    const parts = [encoder.encode("%PDF-1.4\n%\x80\x80\x80\x80\n")];
+    const offsets = [0];
+    let pos = parts[0].length;
+    for (let i = 0; i < this.objects.length; i += 1) {
+      offsets.push(pos);
+      const head = encoder.encode(`${i + 1} 0 obj
+`);
+      const tail = encoder.encode("endobj\n");
+      const body = this.objects[i];
+      parts.push(head, body, tail);
+      pos += head.length + body.length + tail.length;
+    }
+    const xrefStart = pos;
+    let xref = `xref
+0 ${this.objects.length + 1}
+0000000000 65535 f 
+`;
+    for (let i = 1; i <= this.objects.length; i += 1) {
+      xref += `${pad10(offsets[i] ?? 0)} 00000 n 
+`;
+    }
+    xref += `trailer<< /Size ${this.objects.length + 1} /Root 1 0 R >>
+`;
+    xref += `startxref
+${xrefStart}
+%%EOF
+`;
+    parts.push(encoder.encode(xref));
+    return concat(parts);
+  }
+};
+function pdfEscapeTextHex(gids) {
+  return gids.map((g) => g.toString(16).padStart(4, "0")).join("");
+}
+
+// packages/plugins/pdf/src/parseTtf.ts
+function u16(buf, offset) {
+  return buf[offset] << 8 | buf[offset + 1];
+}
+function u32(buf, offset) {
+  return (buf[offset] << 24 | buf[offset + 1] << 16 | buf[offset + 2] << 8 | buf[offset + 3]) >>> 0;
+}
+function i16(buf, offset) {
+  const v = u16(buf, offset);
+  return v > 32767 ? v - 65536 : v;
+}
+function tagAt(buf, offset) {
+  return String.fromCharCode(buf[offset], buf[offset + 1], buf[offset + 2], buf[offset + 3]);
+}
+function tableMap(buf) {
+  const numTables = u16(buf, 4);
+  const tables = /* @__PURE__ */ new Map();
+  for (let i = 0; i < numTables; i += 1) {
+    const o = 12 + i * 16;
+    tables.set(tagAt(buf, o), { offset: u32(buf, o + 8), length: u32(buf, o + 12) });
+  }
+  return tables;
+}
+function parseCmap(buf, cmapOffset) {
+  const numTables = u16(buf, cmapOffset + 2);
+  let format4 = -1;
+  let format12 = -1;
+  for (let i = 0; i < numTables; i += 1) {
+    const rec = cmapOffset + 4 + i * 8;
+    const platform = u16(buf, rec);
+    const encoding = u16(buf, rec + 2);
+    const offset = cmapOffset + u32(buf, rec + 4);
+    const format = u16(buf, offset);
+    if (format === 12 && (platform === 3 || platform === 0)) format12 = offset;
+    if (format === 4 && (platform === 3 || platform === 0) && encoding <= 1) {
+      format4 = offset;
+    }
+  }
+  if (format12 >= 0) {
+    const nGroups = u32(buf, format12 + 12);
+    const groups = [];
+    for (let i = 0; i < nGroups; i += 1) {
+      const o = format12 + 16 + i * 12;
+      groups.push({
+        start: u32(buf, o),
+        end: u32(buf, o + 4),
+        glyph: u32(buf, o + 8)
+      });
+    }
+    return (code) => {
+      for (const g of groups) {
+        if (code >= g.start && code <= g.end) return g.glyph + (code - g.start);
+      }
+      return 0;
+    };
+  }
+  if (format4 < 0) {
+    return () => 0;
+  }
+  const segCount = u16(buf, format4 + 6) / 2;
+  const endCodes = format4 + 14;
+  const startCodes = endCodes + 2 + segCount * 2;
+  const idDeltas = startCodes + segCount * 2;
+  const idRangeOffsets = idDeltas + segCount * 2;
+  return (code) => {
+    for (let i = 0; i < segCount; i += 1) {
+      const end = u16(buf, endCodes + i * 2);
+      if (code > end) continue;
+      const start = u16(buf, startCodes + i * 2);
+      if (code < start) return 0;
+      const rangeOffset = u16(buf, idRangeOffsets + i * 2);
+      const delta = i16(buf, idDeltas + i * 2);
+      if (rangeOffset === 0) return code + delta & 65535;
+      const glyphOffset = idRangeOffsets + i * 2 + rangeOffset + (code - start) * 2;
+      const glyph = u16(buf, glyphOffset);
+      if (glyph === 0) return 0;
+      return glyph + delta & 65535;
+    }
+    return 0;
+  };
+}
+function parseTtf(bytes) {
+  const tables = tableMap(bytes);
+  const head = tables.get("head");
+  const hhea = tables.get("hhea");
+  const hmtx = tables.get("hmtx");
+  const maxp = tables.get("maxp");
+  const cmap = tables.get("cmap");
+  if (!head || !hhea || !hmtx || !maxp || !cmap) {
+    throw new Error("VAZIRMATN_TTF_TABLES");
+  }
+  const unitsPerEm = u16(bytes, head.offset + 18);
+  const metrics = {
+    unitsPerEm,
+    xMin: i16(bytes, head.offset + 36),
+    yMin: i16(bytes, head.offset + 38),
+    xMax: i16(bytes, head.offset + 40),
+    yMax: i16(bytes, head.offset + 42),
+    ascent: i16(bytes, hhea.offset + 4),
+    descent: i16(bytes, hhea.offset + 6),
+    italicAngle: 0,
+    numGlyphs: u16(bytes, maxp.offset + 4)
+  };
+  const numberOfHMetrics = u16(bytes, hhea.offset + 34);
+  const advances = new Uint16Array(metrics.numGlyphs);
+  for (let i = 0; i < numberOfHMetrics; i += 1) {
+    advances[i] = u16(bytes, hmtx.offset + i * 4);
+  }
+  const lastAdvance = advances[numberOfHMetrics - 1] ?? metrics.unitsPerEm;
+  for (let i = numberOfHMetrics; i < metrics.numGlyphs; i += 1) {
+    advances[i] = lastAdvance;
+  }
+  const glyphId = parseCmap(bytes, cmap.offset);
+  return {
+    bytes,
+    metrics,
+    glyphId,
+    advance: (gid) => advances[gid] ?? lastAdvance
+  };
+}
+function pdfWidth(advance, unitsPerEm) {
+  return advance * 1e3 / unitsPerEm;
+}
+
+// packages/plugins/pdf/src/shapeRtl.ts
+var FORMS = {
+  1575: [65165, 65166, 65165, 65166],
+  1576: [65167, 65168, 65169, 65170],
+  1662: [64342, 64343, 64344, 64345],
+  1578: [65173, 65174, 65175, 65176],
+  1579: [65177, 65178, 65179, 65180],
+  1580: [65181, 65182, 65183, 65184],
+  1670: [64378, 64379, 64380, 64381],
+  1581: [65185, 65186, 65187, 65188],
+  1582: [65189, 65190, 65191, 65192],
+  1583: [65193, 65194, 65193, 65194],
+  1584: [65195, 65196, 65195, 65196],
+  1585: [65197, 65198, 65197, 65198],
+  1586: [65199, 65200, 65199, 65200],
+  1688: [64394, 64395, 64394, 64395],
+  1587: [65201, 65202, 65203, 65204],
+  1588: [65205, 65206, 65207, 65208],
+  1589: [65209, 65210, 65211, 65212],
+  1590: [65213, 65214, 65215, 65216],
+  1591: [65217, 65218, 65219, 65220],
+  1592: [65221, 65222, 65223, 65224],
+  1593: [65225, 65226, 65227, 65228],
+  1594: [65229, 65230, 65231, 65232],
+  1601: [65233, 65234, 65235, 65236],
+  1602: [65237, 65238, 65239, 65240],
+  1705: [64398, 64399, 64400, 64401],
+  1603: [65241, 65242, 65243, 65244],
+  1711: [64402, 64403, 64404, 64405],
+  1604: [65245, 65246, 65247, 65248],
+  1605: [65249, 65250, 65251, 65252],
+  1606: [65253, 65254, 65255, 65256],
+  1607: [65257, 65258, 65259, 65260],
+  1608: [65261, 65262, 65261, 65262],
+  1740: [64508, 64509, 64510, 64511],
+  1610: [65265, 65266, 65267, 65268],
+  1570: [65153, 65154, 65153, 65154],
+  1577: [65171, 65172, 65171, 65172]
+};
+var RIGHT_ONLY = /* @__PURE__ */ new Set([
+  1570,
+  1575,
+  1577,
+  1583,
+  1584,
+  1585,
+  1586,
+  1688,
+  1608
+]);
+function canConnect(cp, side) {
+  if (!FORMS[cp]) return false;
+  if (RIGHT_ONLY.has(cp)) return side === "right";
+  return true;
+}
+function isLetter(cp) {
+  return cp in FORMS;
+}
+function shapeArabic(input) {
+  const cps = [...input].map((ch) => ch.codePointAt(0) ?? 0);
+  const out = [];
+  for (let i = 0; i < cps.length; i += 1) {
+    const cp = cps[i] ?? 0;
+    const forms = FORMS[cp];
+    if (!forms) {
+      out.push(cp);
+      continue;
+    }
+    let prev = i - 1;
+    while (prev >= 0 && (cps[prev] === 1600 || cps[prev] === 8204)) prev -= 1;
+    let next = i + 1;
+    while (next < cps.length && (cps[next] === 1600 || cps[next] === 8205)) next += 1;
+    const joinsPrev = prev >= 0 && isLetter(cps[prev] ?? 0) && canConnect(cps[prev] ?? 0, "left");
+    const joinsNext = next < cps.length && isLetter(cps[next] ?? 0) && canConnect(cp, "left");
+    const form = joinsPrev && joinsNext ? 3 : joinsNext ? 2 : joinsPrev ? 1 : 0;
+    out.push(forms[form] ?? cp);
+  }
+  return String.fromCodePoint(...out);
+}
+var LTR_RE = /^[0-9A-Za-z۰-۹.,:%/+-]+$/;
+function reverseGraphemes(s) {
+  return [...s].reverse().join("");
+}
+function rtlVisual(input) {
+  const shaped = shapeArabic(input);
+  const parts = shaped.split(/([0-9A-Za-z۰-۹.,:%/+-]+)/);
+  const visual = [];
+  for (let i = parts.length - 1; i >= 0; i -= 1) {
+    const part = parts[i] ?? "";
+    if (!part) continue;
+    visual.push(LTR_RE.test(part) ? part : reverseGraphemes(part));
+  }
+  return visual.join("");
+}
+
+// packages/plugins/pdf/src/VazirmatnPdfRenderer.ts
+var PAGE_W = 595;
+var PAGE_H = 842;
+var MARGIN = 36;
+var TITLE_SIZE = 12;
+var SUB_SIZE = 9;
+var CELL_SIZE = 8;
+var ROW_H = 16;
+var HEADER_H = 18;
+var FOOTER_H = 22;
+var SIGN_H = 56;
+function cellText(raw, fieldType) {
+  if (fieldType === "checkbox") {
+    return raw ? "\u0628\u0644\u0647" : "\u062E\u06CC\u0631";
+  }
+  return chunkF6EMC75A_cjs.formatExportValue(raw, fieldType);
+}
+function measure(font, text, size) {
+  let w = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    const gid = font.glyphId(cp);
+    w += pdfWidth(font.advance(gid), font.metrics.unitsPerEm);
+  }
+  return w * size / 1e3;
+}
+function fitText(font, text, size, maxWidth) {
+  if (measure(font, text, size) <= maxWidth) return text;
+  const ellipsis = "...";
+  let lo = 0;
+  let hi = [...text].length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    const slice = [...text].slice(0, mid).join("") + ellipsis;
+    if (measure(font, slice, size) <= maxWidth) lo = mid;
+    else hi = mid - 1;
+  }
+  if (lo <= 0) return ellipsis;
+  return [...text].slice(0, lo).join("") + ellipsis;
+}
+function toGids(font, text) {
+  const gids = [];
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    gids.push(font.glyphId(cp));
+  }
+  return gids;
+}
+function toUnicodeCmap(pairs) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const p of pairs) {
+    if (!unique.has(p.gid)) unique.set(p.gid, p.unicode);
+  }
+  const entries = [...unique.entries()];
+  const chunks = [];
+  for (let i = 0; i < entries.length; i += 100) {
+    const slice = entries.slice(i, i + 100);
+    chunks.push(`${slice.length} beginbfchar`);
+    for (const [gid, uni] of slice) {
+      const g = gid.toString(16).padStart(4, "0");
+      const u = uni.toString(16).padStart(uni > 65535 ? 8 : 4, "0");
+      chunks.push(`<${g}> <${u}>`);
+    }
+    chunks.push("endbfchar");
+  }
+  return `%!PS-Adobe-3.0 Resource-CMap
+%%BeginResource: CMap (Vazirmatn-UCS)
+/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def
+/CMapName /Vazirmatn-UCS def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+${chunks.join("\n")}
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end
+%%EndResource
+`;
+}
+function toSumNumber(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) return Math.trunc(raw);
+  if (typeof raw === "bigint") {
+    const n = Number(raw);
+    return Number.isSafeInteger(n) ? n : null;
+  }
+  if (typeof raw === "string") {
+    const n = Number(
+      raw.trim().replace(/[۰-۹]/g, (d) => String("\u06F0\u06F1\u06F2\u06F3\u06F4\u06F5\u06F6\u06F7\u06F8\u06F9".indexOf(d))).replace(/,/g, "")
+    );
+    return Number.isFinite(n) ? Math.trunc(n) : null;
+  }
+  return null;
+}
+function readJpegSize(bytes) {
+  if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) return null;
+  let i = 2;
+  while (i + 9 < bytes.length) {
+    if (bytes[i] !== 255) {
+      i += 1;
+      continue;
+    }
+    const marker = bytes[i + 1];
+    const len = bytes[i + 2] << 8 | bytes[i + 3];
+    if (marker === 192 || marker === 193 || marker === 194) {
+      const h = bytes[i + 5] << 8 | bytes[i + 6];
+      const w = bytes[i + 7] << 8 | bytes[i + 8];
+      return { w, h };
+    }
+    i += 2 + len;
+  }
+  return null;
+}
+var VazirmatnPdfRenderer = class {
+  constructor(fontBytes) {
+    this.fontBytes = fontBytes;
+    if (!fontBytes?.byteLength) {
+      throw new Error(
+        "VazirmatnPdfRenderer requires font bytes from persian-data-grid/plugins/pdf/fonts/vazirmatn"
+      );
+    }
+  }
+  async render(source, options) {
+    const font = parseTtf(this.fontBytes);
+    const rtl = options?.direction !== "ltr";
+    const template = options?.template;
+    const title = template?.header?.title ?? options?.title ?? "\u0627\u0642\u0644\u0627\u0645 \u0633\u0646\u062F";
+    const columns = source.columns.filter((c) => c.fieldName !== "index");
+    const colCount = Math.max(1, columns.length);
+    const tableWidth = PAGE_W - MARGIN * 2;
+    const colW = tableWidth / colCount;
+    const used = [];
+    const note = (text) => {
+      const visual = rtl ? rtlVisual(text) : text;
+      for (const ch of visual) {
+        const cp = ch.codePointAt(0) ?? 0;
+        used.push({ gid: font.glyphId(cp), unicode: cp });
+      }
+      return visual;
+    };
+    const titleVisual = note(title);
+    const subtitleVisual = template?.header?.subtitle ? note(template.header.subtitle) : null;
+    const metaVisuals = (template?.header?.meta ?? []).map((m) => note(m));
+    const footerTextVisual = template?.footer?.text ? note(template.footer.text) : null;
+    const pageFmt = template?.footer?.pageNumberFormat ?? "{page} / {pages}";
+    const showPageNumber = template != null && template.footer?.showPageNumber !== false;
+    const repeatHeader = template == null || template.repeatTableHeader !== false;
+    const totalsLabelVisual = template?.pageTotals ? note(template.pageTotals.label ?? "\u062C\u0645\u0639 \u0635\u0641\u062D\u0647") : null;
+    const signLabelVisual = template?.signature ? note(template.signature.label ?? "\u0627\u0645\u0636\u0627") : null;
+    const stampLabelVisual = template?.stamp ? note(template.stamp.label ?? "\u0645\u0647\u0631") : null;
+    note("0123456789 /");
+    const headers = columns.map(
+      (c) => note(c.fieldCaption ?? c.fieldName)
+    );
+    const body = source.rows.map(
+      (row) => columns.map((col) => {
+        const cell = row.cells[col.fieldName];
+        const raw = cell?.display ?? cell?.value ?? "";
+        return note(cellText(raw, col.fieldType));
+      })
+    );
+    const bodyNums = source.rows.map((row) => {
+      const map = /* @__PURE__ */ new Map();
+      for (const col of columns) {
+        const cell = row.cells[col.fieldName];
+        const raw = cell?.value ?? cell?.display ?? "";
+        map.set(col.fieldName, toSumNumber(raw));
+      }
+      return map;
+    });
+    let logoDrawW = template?.logo?.width ?? 64;
+    let logoDrawH = template?.logo?.height ?? 48;
+    if (template?.logo?.jpegBytes?.byteLength) {
+      const size = readJpegSize(template.logo.jpegBytes);
+      if (size && template.logo.height == null) {
+        logoDrawH = Math.round(logoDrawW * size.h / Math.max(1, size.w));
+      }
+    }
+    const headerBand = template ? Math.max(
+      logoDrawH,
+      28 + (subtitleVisual ? 14 : 0) + metaVisuals.length * 12
+    ) + 12 : TITLE_SIZE + 16;
+    const footerBand = template && (footerTextVisual || showPageNumber) ? FOOTER_H + 8 : 0;
+    const signBand = template && (signLabelVisual || stampLabelVisual) ? SIGN_H + 8 : 0;
+    const totalsBand = template?.pageTotals ? ROW_H + 4 : 0;
+    const usable = (withSign) => PAGE_H - MARGIN * 2 - headerBand - footerBand - (repeatHeader ? HEADER_H : 0) - totalsBand - (withSign ? signBand : 0);
+    const pageRowCounts = [];
+    let remaining = body.length;
+    if (remaining === 0) {
+      pageRowCounts.push(0);
+    } else {
+      while (remaining > 0) {
+        const isLikelyLast = remaining <= Math.floor(usable(false) / ROW_H);
+        const budget = Math.max(
+          1,
+          Math.floor(usable(isLikelyLast && signBand > 0) / ROW_H)
+        );
+        const take = Math.min(remaining, budget);
+        pageRowCounts.push(take);
+        remaining -= take;
+        if (pageRowCounts.length > 1e4) break;
+      }
+      if (signBand > 0) {
+        const lastBudget = Math.max(1, Math.floor(usable(true) / ROW_H));
+        const lastIdx = pageRowCounts.length - 1;
+        if ((pageRowCounts[lastIdx] ?? 0) > lastBudget) {
+          const overflow = (pageRowCounts[lastIdx] ?? 0) - lastBudget;
+          pageRowCounts[lastIdx] = lastBudget;
+          pageRowCounts.push(overflow);
+        }
+      }
+    }
+    const pageCount = Math.max(1, pageRowCounts.length);
+    const pageLabels = Array.from(
+      { length: pageCount },
+      (_, p) => note(
+        pageFmt.replace("{page}", String(p + 1)).replace("{pages}", String(pageCount))
+      )
+    );
+    const pageTotalCells = pageRowCounts.map((take, p) => {
+      if (!template?.pageTotals || !totalsLabelVisual) return [];
+      const start = pageRowCounts.slice(0, p).reduce((a, n) => a + n, 0);
+      const numSlice = bodyNums.slice(start, start + take);
+      const sums = /* @__PURE__ */ new Map();
+      for (const colId of template.pageTotals.columns) {
+        let s = 0;
+        for (const row of numSlice) {
+          const n = row.get(colId);
+          if (n != null) s += n;
+        }
+        sums.set(colId, s);
+      }
+      return columns.map((col, colIdx) => {
+        const isTotalCol = template.pageTotals.columns.includes(col.fieldName);
+        if (isTotalCol) return note(String(sums.get(col.fieldName) ?? 0));
+        const labelCol = columns.findIndex(
+          (c) => !template.pageTotals.columns.includes(c.fieldName)
+        );
+        if (colIdx === (labelCol >= 0 ? labelCol : 0)) return totalsLabelVisual;
+        return "";
+      });
+    });
+    const metrics = font.metrics;
+    const scale = 1e3 / metrics.unitsPerEm;
+    const bbox = [
+      Math.round(metrics.xMin * scale),
+      Math.round(metrics.yMin * scale),
+      Math.round(metrics.xMax * scale),
+      Math.round(metrics.yMax * scale)
+    ];
+    const ascent = Math.round(metrics.ascent * scale);
+    const descent = Math.round(metrics.descent * scale);
+    const usedGids = [...new Set(used.map((u) => u.gid))].sort((a, b) => a - b);
+    const wParts = usedGids.map((gid) => {
+      const w = Math.round(pdfWidth(font.advance(gid), metrics.unitsPerEm));
+      return `${gid} [${w}]`;
+    });
+    const pdf = new PdfBuilder();
+    pdf.addAscii("<< /Type /Catalog /Pages 2 0 R >>\n");
+    const pagesObj = 2;
+    pdf.addAscii("<< /Type /Pages /Kids [] /Count 0 >>\n");
+    const fontFile = pdf.addFlate(
+      font.bytes,
+      `/Length1 ${font.bytes.length} `
+    );
+    const descriptor = pdf.addAscii(
+      `<< /Type /FontDescriptor /FontName /Vazirmatn /Flags 32 /FontBBox [${bbox.join(" ")}] /ItalicAngle 0 /Ascent ${ascent} /Descent ${descent} /CapHeight ${ascent} /StemV 80 /FontFile2 ${fontFile} 0 R >>
+`
+    );
+    const cidFont = pdf.addAscii(
+      `<< /Type /Font /Subtype /CIDFontType2 /BaseFont /Vazirmatn /CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> /FontDescriptor ${descriptor} 0 R /DW 500 /W [${wParts.join(" ")}] /CIDToGIDMap /Identity >>
+`
+    );
+    const toUnicode = pdf.addFlate(
+      new TextEncoder().encode(toUnicodeCmap(used))
+    );
+    const type0 = pdf.addAscii(
+      `<< /Type /Font /Subtype /Type0 /BaseFont /Vazirmatn /Encoding /Identity-H /DescendantFonts [${cidFont} 0 R] /ToUnicode ${toUnicode} 0 R >>
+`
+    );
+    let logoXObject = null;
+    if (template?.logo?.jpegBytes?.byteLength) {
+      const jpeg = template.logo.jpegBytes;
+      const size = readJpegSize(jpeg) ?? { w: logoDrawW, h: logoDrawH };
+      logoXObject = pdf.addRawStream(
+        jpeg,
+        `<< /Type /XObject /Subtype /Image /Width ${size.w} /Height ${size.h} /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length ${jpeg.length} >>`
+      );
+    }
+    const pageObjNums = [];
+    const drawText = (ops, text, size, x, y) => {
+      ops.push("BT");
+      ops.push(`/F1 ${size} Tf`);
+      ops.push(`${x.toFixed(2)} ${y.toFixed(2)} Td`);
+      ops.push(`<${pdfEscapeTextHex(toGids(font, text))}> Tj`);
+      ops.push("ET");
+    };
+    const drawCell = (ops, col, top, height, text, header) => {
+      const x = rtl ? PAGE_W - MARGIN - (col + 1) * colW : MARGIN + col * colW;
+      if (header) {
+        ops.push("0.92 g");
+        ops.push(
+          `${x.toFixed(2)} ${(top - height).toFixed(2)} ${colW.toFixed(2)} ${height.toFixed(2)} re f`
+        );
+        ops.push("0 g");
+      }
+      ops.push("0.55 w 0.35 g");
+      ops.push(
+        `${x.toFixed(2)} ${(top - height).toFixed(2)} ${colW.toFixed(2)} ${height.toFixed(2)} re S`
+      );
+      ops.push("0 g");
+      if (!text) return;
+      const fitted = fitText(font, text, CELL_SIZE, colW - 6);
+      const tw = measure(font, fitted, CELL_SIZE);
+      const tx = rtl ? x + colW - 3 - tw : x + 3;
+      const ty = top - height + 4.5;
+      drawText(ops, fitted, CELL_SIZE, tx, ty);
+    };
+    let rowCursor = 0;
+    for (let p = 0; p < pageCount; p += 1) {
+      const ops = [];
+      const isLast = p === pageCount - 1;
+      let y = PAGE_H - MARGIN;
+      if (template) {
+        if (logoXObject != null) {
+          const lx = rtl ? PAGE_W - MARGIN - logoDrawW : MARGIN;
+          const ly = y - logoDrawH;
+          ops.push("q");
+          ops.push(
+            `${logoDrawW} 0 0 ${logoDrawH} ${lx.toFixed(2)} ${ly.toFixed(2)} cm /Im1 Do`
+          );
+          ops.push("Q");
+        }
+        const textOriginX = rtl ? PAGE_W - MARGIN - (logoXObject != null ? logoDrawW + 10 : 0) : MARGIN + (logoXObject != null ? logoDrawW + 10 : 0);
+        let ty = y - 12;
+        const tw = measure(font, titleVisual, TITLE_SIZE);
+        drawText(
+          ops,
+          titleVisual,
+          TITLE_SIZE,
+          rtl ? textOriginX - tw : textOriginX,
+          ty
+        );
+        ty -= 14;
+        if (subtitleVisual) {
+          const sw = measure(font, subtitleVisual, SUB_SIZE);
+          drawText(
+            ops,
+            subtitleVisual,
+            SUB_SIZE,
+            rtl ? textOriginX - sw : textOriginX,
+            ty
+          );
+          ty -= 12;
+        }
+        for (const meta of metaVisuals) {
+          const mw = measure(font, meta, SUB_SIZE);
+          drawText(
+            ops,
+            meta,
+            SUB_SIZE,
+            rtl ? textOriginX - mw : textOriginX,
+            ty
+          );
+          ty -= 12;
+        }
+        y = PAGE_H - MARGIN - headerBand;
+      } else {
+        const titleW = measure(font, titleVisual, TITLE_SIZE);
+        drawText(
+          ops,
+          titleVisual,
+          TITLE_SIZE,
+          rtl ? PAGE_W - MARGIN - titleW : MARGIN,
+          y - 12
+        );
+        y = PAGE_H - MARGIN - headerBand;
+      }
+      if (repeatHeader || p === 0) {
+        headers.forEach((h, col) => drawCell(ops, col, y, HEADER_H, h, true));
+        y -= HEADER_H;
+      }
+      const take = pageRowCounts[p] ?? 0;
+      const slice = body.slice(rowCursor, rowCursor + take);
+      for (const row of slice) {
+        row.forEach((cell, col) => drawCell(ops, col, y, ROW_H, cell, false));
+        y -= ROW_H;
+      }
+      const totalRow = pageTotalCells[p];
+      if (totalRow && totalRow.length > 0) {
+        totalRow.forEach(
+          (text, colIdx) => drawCell(ops, colIdx, y, ROW_H, text, true)
+        );
+        y -= ROW_H;
+      }
+      if (isLast && (signLabelVisual || stampLabelVisual)) {
+        const boxW = (tableWidth - 12) / 2;
+        const boxH = SIGN_H - 8;
+        const by = MARGIN + footerBand + 4;
+        const boxes = [];
+        if (rtl) {
+          if (signLabelVisual) {
+            boxes.push({ label: signLabelVisual, x: PAGE_W - MARGIN - boxW });
+          }
+          if (stampLabelVisual) {
+            boxes.push({
+              label: stampLabelVisual,
+              x: PAGE_W - MARGIN - boxW * 2 - 12
+            });
+          }
+        } else {
+          if (signLabelVisual) boxes.push({ label: signLabelVisual, x: MARGIN });
+          if (stampLabelVisual) {
+            boxes.push({ label: stampLabelVisual, x: MARGIN + boxW + 12 });
+          }
+        }
+        for (const box of boxes) {
+          ops.push("0.55 w 0.35 g");
+          ops.push(
+            `${box.x.toFixed(2)} ${by.toFixed(2)} ${boxW.toFixed(2)} ${boxH.toFixed(2)} re S`
+          );
+          ops.push("0 g");
+          const lw = measure(font, box.label, SUB_SIZE);
+          drawText(
+            ops,
+            box.label,
+            SUB_SIZE,
+            rtl ? box.x + boxW - 6 - lw : box.x + 6,
+            by + boxH - 14
+          );
+          const lineCount = template?.signature?.lines ?? 2;
+          for (let li = 0; li < lineCount; li += 1) {
+            const ly = by + 10 + li * 14;
+            ops.push("0.4 w 0.6 g");
+            ops.push(
+              `${(box.x + 8).toFixed(2)} ${ly.toFixed(2)} m ${(box.x + boxW - 8).toFixed(2)} ${ly.toFixed(2)} l S`
+            );
+            ops.push("0 g");
+          }
+        }
+      }
+      if (footerBand > 0) {
+        const fy = MARGIN + 6;
+        if (footerTextVisual) {
+          const fw = measure(font, footerTextVisual, SUB_SIZE);
+          drawText(
+            ops,
+            footerTextVisual,
+            SUB_SIZE,
+            rtl ? PAGE_W - MARGIN - fw : MARGIN,
+            fy
+          );
+        }
+        if (showPageNumber) {
+          const label = pageLabels[p];
+          const pw = measure(font, label, SUB_SIZE);
+          drawText(
+            ops,
+            label,
+            SUB_SIZE,
+            rtl ? MARGIN : PAGE_W - MARGIN - pw,
+            fy
+          );
+        }
+      }
+      const content = pdf.addFlate(
+        new TextEncoder().encode(ops.join("\n") + "\n")
+      );
+      const xobjRes = logoXObject != null ? `/XObject << /Im1 ${logoXObject} 0 R >>` : "";
+      const pageNo = pdf.addAscii(
+        `<< /Type /Page /Parent ${pagesObj} 0 R /MediaBox [0 0 ${PAGE_W} ${PAGE_H}] /Contents ${content} 0 R /Resources << /Font << /F1 ${type0} 0 R >> ${xobjRes} >> >>
+`
+      );
+      pageObjNums.push(pageNo);
+      rowCursor += take;
+    }
+    const kids = pageObjNums.map((n) => `${n} 0 R`).join(" ");
+    pdf.replaceAscii(
+      pagesObj,
+      `<< /Type /Pages /Kids [${kids}] /Count ${pageObjNums.length} >>
+`
+    );
+    const bytes = pdf.build();
+    return new Blob([bytes], { type: "application/pdf" });
+  }
+};
+
+exports.PdfExportPlugin = PdfExportPlugin;
+exports.TextPdfRenderer = TextPdfRenderer;
+exports.VazirmatnPdfRenderer = VazirmatnPdfRenderer;
+//# sourceMappingURL=chunk-VYJQ2HTA.cjs.map
+//# sourceMappingURL=chunk-VYJQ2HTA.cjs.map