react-pdf-rtl 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,259 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import { Style } from '@react-pdf/types';
+
+interface RTLTextProps {
+    children: string | number;
+    style?: Style | Style[];
+    /** Force direction instead of auto-detecting */
+    direction?: "rtl" | "ltr" | "auto";
+    wrap?: boolean;
+    debug?: boolean;
+}
+/**
+ * Drop-in replacement for @react-pdf/renderer's <Text> with RTL support.
+ *
+ * Automatically:
+ * - Detects Hebrew/Arabic content and applies RLE bidi markers
+ * - Handles mixed content (Hebrew text + numbers) correctly
+ * - Preserves LTR content unchanged
+ *
+ * @example
+ * <RTLText style={{ fontSize: 14 }}>חפירה וביסוס - 3 מ"ק</RTLText>
+ * <RTLText>Item description in English</RTLText>
+ */
+declare function RTLText({ children, style, direction, wrap, debug }: RTLTextProps): react_jsx_runtime.JSX.Element;
+interface RTLViewProps {
+    children: React.ReactNode;
+    style?: Style | Style[];
+    debug?: boolean;
+}
+/**
+ * A <View> pre-configured for RTL layout.
+ * Sets flexDirection to "row-reverse" and textAlign to "right".
+ * Use as a wrapper for rows in RTL documents.
+ *
+ * @example
+ * <RTLView style={{ marginBottom: 8 }}>
+ *   <RTLText>תיאור עבודה</RTLText>
+ *   <Text>₪1,200</Text>
+ * </RTLView>
+ */
+declare function RTLView({ children, style, debug }: RTLViewProps): react_jsx_runtime.JSX.Element;
+/**
+ * Returns base styles for an RTL page layout.
+ * Pass your fontFamily to get consistent defaults.
+ *
+ * @example
+ * const pageStyle = getRTLPageStyle("Rubik");
+ */
+declare function getRTLPageStyle(fontFamily?: string): Style;
+interface RTLTableColumn {
+    /** Column header label */
+    header: string;
+    /** Key in the data row object */
+    key: string;
+    /** Flex width (like CSS flex) */
+    flex?: number;
+    /** Explicit width in pts */
+    width?: number;
+    /** Text alignment within the cell */
+    align?: "right" | "left" | "center";
+    /** If true, formats value as currency using formatCurrencyRTL */
+    isCurrency?: boolean;
+    /** Custom cell renderer */
+    render?: (value: unknown, row: Record<string, unknown>) => string;
+}
+interface RTLTableProps {
+    columns: RTLTableColumn[];
+    data: Record<string, unknown>[];
+    fontFamily?: string;
+    /** Header background color */
+    headerBg?: string;
+    /** Header text color */
+    headerColor?: string;
+    /** Row stripe color (alternating rows) */
+    stripeBg?: string;
+    /** Border color */
+    borderColor?: string;
+    /** Font size for table content */
+    fontSize?: number;
+}
+/**
+ * A fully RTL-aware table component for @react-pdf/renderer.
+ *
+ * Renders columns right-to-left, handles Hebrew text in cells,
+ * and supports currency formatting out of the box.
+ *
+ * @example
+ * <RTLTable
+ *   columns={[
+ *     { header: "תיאור", key: "description", flex: 3 },
+ *     { header: "כמות", key: "quantity", flex: 1, align: "center" },
+ *     { header: "מחיר יחידה", key: "unitPrice", flex: 1, isCurrency: true },
+ *     { header: 'סה"כ', key: "total", flex: 1, isCurrency: true },
+ *   ]}
+ *   data={boqItems}
+ *   headerBg="#1a1a1a"
+ *   headerColor="#EAB308"
+ * />
+ */
+declare function RTLTable({ columns, data, fontFamily, headerBg, headerColor, stripeBg, borderColor, fontSize, }: RTLTableProps): react_jsx_runtime.JSX.Element;
+interface RTLDividerProps {
+    color?: string;
+    thickness?: number;
+    marginVertical?: number;
+}
+/**
+ * A simple horizontal divider for RTL PDF documents.
+ */
+declare function RTLDivider({ color, thickness, marginVertical }: RTLDividerProps): react_jsx_runtime.JSX.Element;
+interface RTLSummaryRowProps {
+    label: string;
+    value: string | number;
+    isCurrency?: boolean;
+    bold?: boolean;
+    fontSize?: number;
+    color?: string;
+    fontFamily?: string;
+}
+/**
+ * A label + value row for totals/summaries in RTL layout.
+ * Label on the right, value on the left — as expected in Hebrew documents.
+ *
+ * @example
+ * <RTLSummaryRow label='סה"כ לפני מע"מ' value={12500} isCurrency bold />
+ * <RTLSummaryRow label='מע"מ 18%' value={2250} isCurrency />
+ * <RTLSummaryRow label="סכום סופי" value={14750} isCurrency bold color="#EAB308" />
+ */
+declare function RTLSummaryRow({ label, value, isCurrency, bold, fontSize, color, fontFamily, }: RTLSummaryRowProps): react_jsx_runtime.JSX.Element;
+
+type RTLFontWeight = "normal" | "bold" | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+interface RTLFontSource {
+    src: string;
+    fontWeight?: RTLFontWeight;
+    fontStyle?: "normal" | "italic";
+}
+interface RegisterRTLFontOptions {
+    /** Font family name, e.g. "Rubik" */
+    family: string;
+    /** Array of font sources (different weights/styles) */
+    fonts: RTLFontSource[];
+}
+/**
+ * Registers a font family with @react-pdf/renderer.
+ * Wraps Font.register with sensible defaults for RTL fonts.
+ *
+ * @example
+ * registerRTLFont({
+ *   family: "Rubik",
+ *   fonts: [
+ *     { src: "/fonts/Rubik-Regular.ttf", fontWeight: "normal" },
+ *     { src: "/fonts/Rubik-Bold.ttf", fontWeight: "bold" },
+ *   ],
+ * });
+ */
+declare function registerRTLFont(options: RegisterRTLFontOptions): void;
+/**
+ * Registers the Rubik font from Google Fonts CDN.
+ * Rubik is the recommended font for Hebrew PDFs — designed for Hebrew,
+ * supports all weights, and renders cleanly in @react-pdf/renderer.
+ *
+ * Weights registered: 300 (Light), 400 (Regular), 500 (Medium), 700 (Bold)
+ */
+declare function registerRubik(): void;
+/**
+ * Registers Noto Sans Hebrew from Google Fonts CDN.
+ * Good fallback if Rubik is not desired — extensive Hebrew glyph coverage.
+ */
+declare function registerNotoSansHebrew(): void;
+/**
+ * Disables font hyphenation — critical for Hebrew text.
+ * Hebrew words should never be hyphenated mid-word.
+ */
+declare function disableHyphenation(): void;
+/**
+ * One-shot setup: registers Rubik + disables hyphenation.
+ * This is the recommended setup for Hebrew PDFs.
+ *
+ * @example
+ * // At the top of your PDF component file:
+ * setupHebrewPDF();
+ */
+declare function setupHebrewPDF(fontFamily?: "Rubik" | "NotoSansHebrew"): void;
+
+/**
+ * Unicode bidi control characters
+ */
+declare const BIDI: {
+    /** Right-to-Left Embedding — forces RTL rendering for the embedded text */
+    readonly RLE: "‫";
+    /** Left-to-Right Embedding */
+    readonly LRE: "‪";
+    /** Pop Directional Formatting — ends the current embedding */
+    readonly PDF: "‬";
+    /** Right-to-Left Mark — invisible RTL directional mark */
+    readonly RLM: "‏";
+    /** Left-to-Right Mark */
+    readonly LRM: "‎";
+    /** Right-to-Left Override — strongly forces RTL */
+    readonly RLO: "‮";
+};
+/**
+ * Returns true if the string contains any RTL characters (Hebrew, Arabic, etc.)
+ * FIX: coerces input to string — safe when called from JS without types
+ */
+declare function hasRTLChars(str: unknown): boolean;
+/**
+ * Returns true if the MAJORITY of the string's alphabetic content is RTL.
+ * Useful for mixed strings like "מחיר: 120 ₪" — still considered RTL.
+ * FIX: coerces input to string — safe when called from JS without types
+ */
+declare function isRTLDominant(str: unknown): boolean;
+/**
+ * Wraps text in RLE...PDF bidi markers so @react-pdf/renderer
+ * renders it right-to-left correctly, including mixed content.
+ *
+ * FIX: idempotent — guards against double-wrapping (broken bidi nesting)
+ */
+declare function wrapRTL(text: string): string;
+/**
+ * Wraps text in LRE...PDF for explicit LTR segments inside an RTL document.
+ * FIX: idempotent — guards against double-wrapping
+ */
+declare function wrapLTR(text: string): string;
+/**
+ * Smart wrap: auto-detects direction and wraps accordingly.
+ * FIX: accepts string | number | null | undefined — BoQ fields are often numbers
+ */
+declare function smartWrap(text: string | number | null | undefined): string;
+/**
+ * Formats a currency amount for RTL display.
+ * Ensures the symbol (₪) and number don't get scrambled in bidi context.
+ *
+ * FIX: throws RangeError on NaN/Infinity with clear message
+ * FIX: handles negative amounts correctly (discounts, returns)
+ */
+declare function formatCurrencyRTL(amount: number, symbol?: string, locale?: string): string;
+/**
+ * Splits mixed RTL/LTR text into segments with direction metadata.
+ * Reconstructs exactly: splitBidiSegments(s).map(s => s.text).join('') === s
+ *
+ * FIX: uses Array.from() to correctly handle surrogate pairs (emoji, rare Unicode)
+ */
+type TextSegment = {
+    text: string;
+    direction: "rtl" | "ltr" | "neutral";
+};
+declare function splitBidiSegments(text: string): TextSegment[];
+/**
+ * Returns true if the string already contains bidi control characters.
+ */
+declare function hasBidiMarkers(text: string): boolean;
+/**
+ * Strips all bidi control characters from a string.
+ * Use for: extracting plain text for storage, search, or logging.
+ */
+declare function stripBidiMarkers(text: string): string;
+
+export { BIDI, RTLDivider, type RTLDividerProps, type RTLFontSource, type RTLFontWeight, RTLSummaryRow, type RTLSummaryRowProps, RTLTable, type RTLTableColumn, type RTLTableProps, RTLText, type RTLTextProps, RTLView, type RTLViewProps, type RegisterRTLFontOptions, type TextSegment, disableHyphenation, formatCurrencyRTL, getRTLPageStyle, hasBidiMarkers, hasRTLChars, isRTLDominant, registerNotoSansHebrew, registerRTLFont, registerRubik, setupHebrewPDF, smartWrap, splitBidiSegments, stripBidiMarkers, wrapLTR, wrapRTL };

package/dist/index.js

@@ -0,0 +1,367 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BIDI: () => BIDI,
+  RTLDivider: () => RTLDivider,
+  RTLSummaryRow: () => RTLSummaryRow,
+  RTLTable: () => RTLTable,
+  RTLText: () => RTLText,
+  RTLView: () => RTLView,
+  disableHyphenation: () => disableHyphenation,
+  formatCurrencyRTL: () => formatCurrencyRTL,
+  getRTLPageStyle: () => getRTLPageStyle,
+  hasBidiMarkers: () => hasBidiMarkers,
+  hasRTLChars: () => hasRTLChars,
+  isRTLDominant: () => isRTLDominant,
+  registerNotoSansHebrew: () => registerNotoSansHebrew,
+  registerRTLFont: () => registerRTLFont,
+  registerRubik: () => registerRubik,
+  setupHebrewPDF: () => setupHebrewPDF,
+  smartWrap: () => smartWrap,
+  splitBidiSegments: () => splitBidiSegments,
+  stripBidiMarkers: () => stripBidiMarkers,
+  wrapLTR: () => wrapLTR,
+  wrapRTL: () => wrapRTL
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/components/index.tsx
+var import_renderer = require("@react-pdf/renderer");
+
+// src/utils/rtl.ts
+var RTL_PATTERN = /[\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u08A0-\u08FF\uFB1D-\uFDFF\uFE70-\uFEFC]/;
+var NUMERIC_ONLY_PATTERN = /^[\d\s.,₪$€%+\-*/()]+$/;
+var BIDI = {
+  /** Right-to-Left Embedding — forces RTL rendering for the embedded text */
+  RLE: "\u202B",
+  /** Left-to-Right Embedding */
+  LRE: "\u202A",
+  /** Pop Directional Formatting — ends the current embedding */
+  PDF: "\u202C",
+  /** Right-to-Left Mark — invisible RTL directional mark */
+  RLM: "\u200F",
+  /** Left-to-Right Mark */
+  LRM: "\u200E",
+  /** Right-to-Left Override — strongly forces RTL */
+  RLO: "\u202E"
+};
+function hasRTLChars(str) {
+  if (str == null) return false;
+  return RTL_PATTERN.test(String(str));
+}
+function isRTLDominant(str) {
+  var _a, _b;
+  if (str == null) return false;
+  const s = String(str);
+  const rtlMatches = s.match(
+    /[\u0590-\u05FF\u0600-\u06FF\u0700-\u074F\u0750-\u077F\u08A0-\u08FF\uFB1D-\uFDFF\uFE70-\uFEFC]/g
+  );
+  const ltrMatches = s.match(/[a-zA-Z]/g);
+  const rtlCount = (_a = rtlMatches == null ? void 0 : rtlMatches.length) != null ? _a : 0;
+  const ltrCount = (_b = ltrMatches == null ? void 0 : ltrMatches.length) != null ? _b : 0;
+  return rtlCount > 0 && rtlCount >= ltrCount;
+}
+function wrapRTL(text) {
+  if (text.charCodeAt(0) === 8235) return text;
+  return `\u202B${text}\u202C`;
+}
+function wrapLTR(text) {
+  if (text.charCodeAt(0) === 8234) return text;
+  return `\u202A${text}\u202C`;
+}
+function smartWrap(text) {
+  if (text == null) return "";
+  const str = String(text);
+  if (!str) return str;
+  const trimmed = str.trim();
+  if (!trimmed) return "";
+  if (NUMERIC_ONLY_PATTERN.test(trimmed)) return trimmed;
+  return isRTLDominant(trimmed) ? wrapRTL(trimmed) : trimmed;
+}
+function formatCurrencyRTL(amount, symbol = "\u20AA", locale = "he-IL") {
+  if (!Number.isFinite(amount)) {
+    throw new RangeError(
+      `formatCurrencyRTL: expected a finite number, got ${amount}`
+    );
+  }
+  const abs = Math.abs(amount);
+  const formatted = abs.toLocaleString(locale, {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 2
+  });
+  const valueStr = amount < 0 ? `-${formatted}` : formatted;
+  return `\u200F${symbol}${wrapLTR(valueStr)}`;
+}
+function splitBidiSegments(text) {
+  if (!text) return [];
+  const segments = [];
+  let current = "";
+  let currentDir = "neutral";
+  for (const char of Array.from(text)) {
+    const charDir = RTL_PATTERN.test(char) ? "rtl" : /[a-zA-Z]/.test(char) ? "ltr" : "neutral";
+    if (charDir !== "neutral" && charDir !== currentDir && current) {
+      segments.push({ text: current, direction: currentDir });
+      current = char;
+      currentDir = charDir;
+    } else {
+      if (charDir !== "neutral") currentDir = charDir;
+      current += char;
+    }
+  }
+  if (current) segments.push({ text: current, direction: currentDir });
+  return segments;
+}
+function hasBidiMarkers(text) {
+  return /[\u202A-\u202E\u200E\u200F]/.test(text);
+}
+function stripBidiMarkers(text) {
+  return text.replace(/[\u202A-\u202E\u200E\u200F]/g, "");
+}
+
+// src/components/index.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function RTLText({ children, style, direction = "auto", wrap = true, debug }) {
+  const str = String(children);
+  let content;
+  if (direction === "rtl") {
+    content = wrapRTL(str);
+  } else if (direction === "ltr") {
+    content = str;
+  } else {
+    content = smartWrap(str);
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_renderer.Text, { style, wrap, debug, children: content });
+}
+function RTLView({ children, style, debug }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_renderer.View, { style: [styles.rtlView, style], debug, children });
+}
+function getRTLPageStyle(fontFamily = "Rubik") {
+  return {
+    fontFamily,
+    fontSize: 11,
+    direction: "rtl",
+    textAlign: "right",
+    paddingTop: 40,
+    paddingBottom: 60,
+    paddingHorizontal: 40
+  };
+}
+function RTLTable({
+  columns,
+  data,
+  fontFamily = "Rubik",
+  headerBg = "#1F2937",
+  headerColor = "#FFFFFF",
+  stripeBg = "#F9FAFB",
+  borderColor = "#E5E7EB",
+  fontSize = 10
+}) {
+  const colStyles = columns.map((col) => {
+    var _a;
+    return {
+      flex: (_a = col.flex) != null ? _a : 1,
+      width: col.width,
+      paddingHorizontal: 8,
+      paddingVertical: 6,
+      borderRightWidth: 1,
+      borderRightColor: borderColor
+    };
+  });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_renderer.View, { style: { borderWidth: 1, borderColor, fontFamily }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_renderer.View, { style: [styles.tableRow, { backgroundColor: headerBg, flexDirection: "row-reverse" }], children: columns.map((col, i) => {
+      var _a;
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_renderer.View, { style: colStyles[i], children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_renderer.Text,
+        {
+          style: {
+            fontSize,
+            fontWeight: "bold",
+            color: headerColor,
+            textAlign: (_a = col.align) != null ? _a : "right"
+          },
+          children: wrapRTL(col.header)
+        }
+      ) }, col.key);
+    }) }),
+    data.map((row, rowIndex) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_renderer.View,
+      {
+        style: [
+          styles.tableRow,
+          { flexDirection: "row-reverse", backgroundColor: rowIndex % 2 === 1 ? stripeBg : "#FFFFFF" }
+        ],
+        wrap: false,
+        children: columns.map((col, i) => {
+          var _a;
+          const raw = row[col.key];
+          let cellText;
+          if (col.render) {
+            cellText = col.render(raw, row);
+          } else if (col.isCurrency && typeof raw === "number") {
+            cellText = formatCurrencyRTL(raw);
+          } else {
+            const str = String(raw != null ? raw : "");
+            cellText = hasRTLChars(str) ? wrapRTL(str) : str;
+          }
+          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_renderer.View, { style: colStyles[i], children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            import_renderer.Text,
+            {
+              style: {
+                fontSize,
+                color: "#111827",
+                textAlign: (_a = col.align) != null ? _a : col.isCurrency ? "left" : "right"
+              },
+              children: cellText
+            }
+          ) }, col.key);
+        })
+      },
+      rowIndex
+    ))
+  ] });
+}
+function RTLDivider({ color = "#E5E7EB", thickness = 1, marginVertical = 8 }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_renderer.View,
+    {
+      style: {
+        borderBottomWidth: thickness,
+        borderBottomColor: color,
+        marginVertical
+      }
+    }
+  );
+}
+function RTLSummaryRow({
+  label,
+  value,
+  isCurrency = false,
+  bold = false,
+  fontSize = 11,
+  color = "#111827",
+  fontFamily = "Rubik"
+}) {
+  const displayValue = isCurrency && typeof value === "number" ? formatCurrencyRTL(value) : String(value);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_renderer.View, { style: [styles.summaryRow, { fontFamily }], children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_renderer.Text, { style: { fontSize, fontWeight: bold ? "bold" : "normal", color, textAlign: "right" }, children: wrapRTL(label) }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_renderer.Text, { style: { fontSize, fontWeight: bold ? "bold" : "normal", color, textAlign: "left" }, children: displayValue })
+  ] });
+}
+var styles = import_renderer.StyleSheet.create({
+  rtlView: {
+    flexDirection: "row-reverse",
+    textAlign: "right"
+  },
+  tableRow: {
+    flexDirection: "row-reverse",
+    alignItems: "center",
+    minHeight: 28
+  },
+  summaryRow: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+    paddingVertical: 4
+  }
+});
+
+// src/fonts/register.ts
+var import_renderer2 = require("@react-pdf/renderer");
+function registerRTLFont(options) {
+  import_renderer2.Font.register({
+    family: options.family,
+    fonts: options.fonts
+  });
+}
+function registerRubik() {
+  import_renderer2.Font.register({
+    family: "Rubik",
+    fonts: [
+      {
+        src: "https://fonts.gstatic.com/s/rubik/v28/iJWZBXyIfDnIV5PNhY1KTN7Z-Yh-B4i1UA.woff2",
+        fontWeight: 300
+      },
+      {
+        src: "https://fonts.gstatic.com/s/rubik/v28/iJWZBXyIfDnIV5PNhY1KTN7Z-Yh-NYi1UA.woff2",
+        fontWeight: 400
+      },
+      {
+        src: "https://fonts.gstatic.com/s/rubik/v28/iJWZBXyIfDnIV5PNhY1KTN7Z-Yh-B4i1UA.woff2",
+        fontWeight: 500
+      },
+      {
+        src: "https://fonts.gstatic.com/s/rubik/v28/iJWZBXyIfDnIV5PNhY1KTN7Z-Yh-0oi1UA.woff2",
+        fontWeight: 700
+      }
+    ]
+  });
+}
+function registerNotoSansHebrew() {
+  import_renderer2.Font.register({
+    family: "NotoSansHebrew",
+    fonts: [
+      {
+        src: "https://fonts.gstatic.com/s/notosanshebrew/v38/or3HQ7v33eiDljA1IufXTtVf7V6RvEEdhQlk0LlGxCyaeNKYZC0sqk3xXGJXag.woff2",
+        fontWeight: 400
+      },
+      {
+        src: "https://fonts.gstatic.com/s/notosanshebrew/v38/or3HQ7v33eiDljA1IufXTtVf7V6RvEEdhQlk0LlGxCyaeNKYZC0sqk3xXGJXag.woff2",
+        fontWeight: 700
+      }
+    ]
+  });
+}
+function disableHyphenation() {
+  import_renderer2.Font.registerHyphenationCallback((word) => [word]);
+}
+function setupHebrewPDF(fontFamily = "Rubik") {
+  if (fontFamily === "Rubik") {
+    registerRubik();
+  } else {
+    registerNotoSansHebrew();
+  }
+  disableHyphenation();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BIDI,
+  RTLDivider,
+  RTLSummaryRow,
+  RTLTable,
+  RTLText,
+  RTLView,
+  disableHyphenation,
+  formatCurrencyRTL,
+  getRTLPageStyle,
+  hasBidiMarkers,
+  hasRTLChars,
+  isRTLDominant,
+  registerNotoSansHebrew,
+  registerRTLFont,
+  registerRubik,
+  setupHebrewPDF,
+  smartWrap,
+  splitBidiSegments,
+  stripBidiMarkers,
+  wrapLTR,
+  wrapRTL
+});