rpdfium 0.4.1 → 0.4.2

data/lib/rpdfium/table/cells.rb

@@ -2,32 +2,34 @@
 
 module Rpdfium
   module Table
-    # Costruisce celle da intersezioni e tabelle da celle.
-    # Algoritmi 1:1 con pdfplumber.intersections_to_cells e
+    # Builds cells from intersections and tables from cells.
+    # Algorithms 1:1 with pdfplumber.intersections_to_cells and
     # pdfplumber.cells_to_tables.
     module Cells
       module_function
 
-      # Ricerca della "smallest cell" per ogni intersezione: dato un punto
-      # `pt = (x, y)`, cerca il rettangolo minimo i cui 4 corner sono
-      # intersezioni e i cui 4 lati hanno edge che le connettono.
+      # "Smallest cell" search for each intersection: given a point
+      # `pt = (x, y)`, find the minimal rectangle whose 4 corners are
+      # intersections and whose 4 sides have edges connecting them.
       #
-      # Il vincolo "edge connect" è cruciale: due intersezioni con stessa
-      # x non bastano — devono CONDIVIDERE almeno un edge verticale (cioè
-      # appartenere a uno stesso segmento continuo). Idem orizzontale.
-      # Questo evita falsi positivi tipo "due colonne lontane allineate
-      # accidentalmente".
+      # The "edge connect" constraint is crucial: two intersections with
+      # the same x are not enough — they must SHARE at least one vertical
+      # edge (i.e. belong to the same continuous segment). Likewise
+      # horizontally. This avoids false positives such as "two distant
+      # columns accidentally aligned".
       #
-      # `intersections` è il Hash prodotto da Edges.edges_to_intersections,
-      # con chiavi `[x, y]` e valori `{ v: [edges...], h: [edges...] }`.
+      # `intersections` is the Hash produced by
+      # Edges.edges_to_intersections, with keys `[x, y]` and values
+      # `{ v: [edges...], h: [edges...] }`.
       def intersections_to_cells(intersections)
         return [] if intersections.empty?
 
-        # Indici di adiacenza: per ogni edge (oggetto Hash, identità di
-        # ruby), quali intersection points contiene? Pdfplumber lo fa
-        # confrontando bbox degli edge — noi abbiamo accesso diretto agli
-        # oggetti edge dentro `intersections[pt]`, basta usare l'identity.
-        # Per "stesso edge" usiamo `equal?` (identità d'oggetto).
+        # Adjacency indices: for each edge (a Hash object, ruby
+        # identity), which intersection points does it contain?
+        # Pdfplumber does this by comparing the bbox of the edges — we
+        # have direct access to the edge objects inside
+        # `intersections[pt]`, so it suffices to use identity. For "same
+        # edge" we use `equal?` (object identity).
         edge_ids = intersections.transform_values do |val|
           { v: val[:v].map(&:object_id).to_set,
             h: val[:h].map(&:object_id).to_set }
@@ -46,9 +48,9 @@ module Rpdfium
         points = intersections.keys.sort
         npoints = points.size
 
-        # Indici spaziali: precomputa punti per colonna (stessa x) e per riga
-        # (stessa y), già ordinati perché `points` è sorted.
-        # Permette lookup O(log n) via bsearch invece di O(n) via select.
+        # Spatial indices: precompute points by column (same x) and by
+        # row (same y), already ordered because `points` is sorted.
+        # Allows O(log n) lookup via bsearch instead of O(n) via select.
         by_x = Hash.new { |h, k| h[k] = [] }
         by_y = Hash.new { |h, k| h[k] = [] }
         points.each { |p| by_x[p[0]] << p; by_y[p[1]] << p }
@@ -57,18 +59,18 @@ module Rpdfium
         points.each_with_index do |pt, i|
           next if i == npoints - 1
 
-          # Punti direttamente sotto `pt` (stessa x, y maggiore)
+          # Points directly below `pt` (same x, greater y)
           col = by_x[pt[0]]
           below_start = col.bsearch_index { |q| q[1] > pt[1] } || col.size
           below = col[below_start..]
 
-          # Punti direttamente a destra di `pt` (stessa y, x maggiore)
+          # Points directly to the right of `pt` (same y, greater x)
           row_pts = by_y[pt[1]]
           right_start = row_pts.bsearch_index { |q| q[0] > pt[0] } || row_pts.size
           right = row_pts[right_start..]
 
-          # Cerca il PRIMO (== più piccolo per via dell'ordinamento) bottom-right
-          # i cui 4 corner sono presenti e gli edge connettono.
+          # Find the FIRST (== smallest, due to ordering) bottom-right
+          # whose 4 corners are present and whose edges connect.
           found = nil
           below.each do |b|
             next unless edge_connects.call(pt, b)
@@ -91,13 +93,14 @@ module Rpdfium
         cells
       end
 
-      # Raggruppa celle in tabelle in base ai corner condivisi.
+      # Groups cells into tables based on shared corners.
       #
-      # Algoritmo: Union-Find (disjoint set) sui corner — O(n α(n)) invece
-      # del greedy fixed-point O(n²) di pdfplumber. Il risultato è identico:
-      # due celle finiscono nello stesso gruppo se condividono almeno un corner.
+      # Algorithm: Union-Find (disjoint set) on the corners — O(n α(n))
+      # instead of pdfplumber's greedy fixed-point O(n²). The result is
+      # identical: two cells end up in the same group if they share at
+      # least one corner.
       #
-      # Filtro finale: scarta tabelle con UNA SOLA cella (rumore).
+      # Final filter: discard tables with a SINGLE cell (noise).
       def cells_to_tables(cells)
         return [] if cells.empty?
 
@@ -110,8 +113,8 @@ module Rpdfium
         end
         union = ->(a, b) { parent[find.call(a)] = find.call(b) }
 
-        # Per ogni corner, raccoglie gli indici delle celle che lo condividono
-        # e le unisce nel medesimo componente.
+        # For each corner, collect the indices of the cells that share it
+        # and union them into the same component.
         corner_to_cells = Hash.new { |h, k| h[k] = [] }
         cells.each_with_index do |cell, idx|
           x0, top, x1, bottom = cell
@@ -123,11 +126,11 @@ module Rpdfium
           idxs.each_cons(2) { |a, b| union.call(a, b) }
         end
 
-        # Raggruppa per root del Union-Find
+        # Group by the Union-Find root
         groups = Hash.new { |h, k| h[k] = [] }
         cells.each_with_index { |cell, i| groups[find.call(i)] << cell }
 
-        # Sort top-to-bottom, left-to-right; filtra single-cell.
+        # Sort top-to-bottom, left-to-right; filter out single-cell.
         groups.values
               .sort_by { |t| t.map { |c| [c[1], c[0]] }.min }
               .reject  { |t| t.size <= 1 }

data/lib/rpdfium/table/debugger.rb

@@ -2,12 +2,12 @@
 
 module Rpdfium
   module Table
-    # Genera una visualizzazione di debug: la pagina renderizzata in PNG con
-    # sovrapposti gli edges rilevati e i bbox delle celle. Equivalente di
+    # Generates a debug visualization: the page rendered to PNG with the
+    # detected edges and cell bboxes overlaid. Equivalent to
     # pdfplumber.Page.to_image().debug_tablefinder().
     #
-    # Implementato puro Ruby: rasterizza la pagina via render(), poi disegna
-    # sopra il bitmap manipolando i bytes RGBA, infine salva in PNG.
+    # Implemented in pure Ruby: rasterizes the page via render(), then draws
+    # over the bitmap by manipulating the RGBA bytes, and finally saves to PNG.
     module Debugger
       module_function
 
@@ -24,19 +24,19 @@ module Rpdfium
         w, h, bytes, _stride = page.render(scale: scale, output: :rgba)
         canvas = Canvas.new(w, h, bytes)
 
-        # Disegna edges. Nuovo formato: ogni edge ha orientation + x0/x1/top/bottom.
-        # Un edge orizzontale ha top == bottom; un verticale ha x0 == x1.
+        # Draws edges. New format: each edge has orientation + x0/x1/top/bottom.
+        # A horizontal edge has top == bottom; a vertical one has x0 == x1.
         edges.each do |e|
           canvas.line((e[:x0] * scale).to_i, (e[:top]    * scale).to_i,
                        (e[:x1] * scale).to_i, (e[:bottom] * scale).to_i, RED)
         end
 
-        # Disegna intersezioni (cerchi 4px). Sono Hash con chiave [x, y].
+        # Draws intersections (4px circles). They are Hashes keyed by [x, y].
         intersections.each_key do |(x, y)|
           canvas.dot((x * scale).to_i, (y * scale).to_i, GREEN, 4)
         end
 
-        # Riempie tabelle con blu trasparente. Table#bbox è tuple [x0, top, x1, bottom].
+        # Fills tables with transparent blue. Table#bbox is the tuple [x0, top, x1, bottom].
         tables.each do |t|
           x0, top, x1, bottom = t.bbox
           canvas.rect_fill((x0 * scale).to_i, (top    * scale).to_i,
@@ -48,15 +48,15 @@ module Rpdfium
       end
     end
 
-    # Mini canvas RGBA per disegnare sopra il rendering. Niente di sofisticato:
-    # linee Bresenham, dots, rect fill con alpha blending semplice.
+    # Minimal RGBA canvas for drawing over the rendering. Nothing sophisticated:
+    # Bresenham lines, dots, rect fill with simple alpha blending.
     class Canvas
       attr_reader :bytes, :width, :height
 
       def initialize(width, height, rgba_bytes)
         @width  = width
         @height = height
-        # Lavoriamo su una stringa mutabile (binstring)
+        # We work on a mutable string (binstring)
         @bytes = rgba_bytes.dup.force_encoding(Encoding::ASCII_8BIT)
       end
 
@@ -71,7 +71,7 @@ module Rpdfium
           @bytes.setbyte(idx + 2, b)
           @bytes.setbyte(idx + 3, 255)
         else
-          # Alpha blending semplice (over operator)
+          # Simple alpha blending (over operator)
           src_a = a / 255.0
           inv = 1 - src_a
           @bytes.setbyte(idx,     (r * src_a + @bytes.getbyte(idx)     * inv).to_i)

data/lib/rpdfium/table/edges.rb

@@ -2,25 +2,26 @@
 
 module Rpdfium
   module Table
-    # Operazioni su edges (segmenti orizzontali/verticali) usate dal
-    # TableFinder. Mappa diretta su `pdfplumber/table.py`.
+    # Operations on edges (horizontal/vertical segments) used by the
+    # TableFinder. A direct mapping onto `pdfplumber/table.py`.
     #
-    # Convenzioni interne (allineate a pdfplumber):
-    #   - Ogni edge è un Hash con :orientation ("v" | "h"),
-    #     :x0, :x1, :top, :bottom (in coordinate top-down).
-    #   - Edge orizzontale: top == bottom, x0 < x1.
-    #   - Edge verticale:   x0 == x1, top < bottom.
+    # Internal conventions (aligned with pdfplumber):
+    #   - Each edge is a Hash with :orientation ("v" | "h"),
+    #     :x0, :x1, :top, :bottom (in top-down coordinates).
+    #   - Horizontal edge: top == bottom, x0 < x1.
+    #   - Vertical edge:    x0 == x1, top < bottom.
     #
-    # Le edges possono provenire da:
-    #   - linee vettoriali del PDF (path segments)
-    #   - rettangoli (decomposti in 4 lati)
-    #   - line "implicite" dedotte dall'allineamento di words (strategia :text)
-    #   - line specificate dall'utente (strategia :explicit)
+    # The edges can come from:
+    #   - vector lines of the PDF (path segments)
+    #   - rectangles (decomposed into 4 sides)
+    #   - "implicit" lines inferred from word alignment (:text strategy)
+    #   - lines specified by the user (:explicit strategy)
     module Edges
       module_function
 
-      # Snap: cluster di edges quasi-collineari → coordinata media comune.
-      # Per orizzontali snappa la `top` (== `bottom`); per verticali la `x0`.
+      # Snap: cluster of near-collinear edges → common average coordinate.
+      # For horizontals it snaps the `top` (== `bottom`); for verticals the
+      # `x0`.
       def snap_edges(edges, x_tolerance: 3.0, y_tolerance: 3.0)
         v_edges, h_edges = edges.partition { |e| e[:orientation] == "v" }
 
@@ -42,13 +43,13 @@ module Rpdfium
         end
       end
 
-      # Join: dato un gruppo di edges sulla stessa retta infinita (stessa top
-      # per orizzontali, stessa x0 per verticali), fonde quelli i cui estremi
-      # sono entro `tolerance`.
+      # Join: given a group of edges on the same infinite line (same top
+      # for horizontals, same x0 for verticals), merges those whose
+      # endpoints are within `tolerance`.
       #
-      # Match esatto del comportamento di pdfplumber.join_edge_group: scorre
-      # sorted per minprop, estende il "current" se overlap/contiguità entro
-      # tolerance, altrimenti apre nuovo current.
+      # Exact match of pdfplumber.join_edge_group behavior: iterates sorted
+      # by minprop, extends the "current" if overlap/contiguity is within
+      # tolerance, otherwise opens a new current.
       def join_edge_group(edges, orientation, tolerance: 3.0)
         return [] if edges.empty?
 
@@ -68,7 +69,7 @@ module Rpdfium
         joined
       end
 
-      # Pipeline completa: snap + join. Fedele a pdfplumber.merge_edges.
+      # Complete pipeline: snap + join. Faithful to pdfplumber.merge_edges.
       def merge_edges(edges,
                       snap_x_tolerance: 3.0, snap_y_tolerance: 3.0,
                       join_x_tolerance: 3.0, join_y_tolerance: 3.0)
@@ -78,7 +79,7 @@ module Rpdfium
                               y_tolerance: snap_y_tolerance)
         end
 
-        # Raggruppa per (orientation, "valore della retta")
+        # Group by (orientation, "line value")
         # h → top, v → x0
         groups = edges.group_by do |e|
           e[:orientation] == "h" ? ["h", e[:top]] : ["v", e[:x0]]
@@ -89,7 +90,7 @@ module Rpdfium
         end
       end
 
-      # Filtra edges troppo corti.
+      # Filters out edges that are too short.
       def filter_edges(edges, orientation: nil, min_length: 1.0)
         edges.reject do |e|
           next true if orientation && e[:orientation] != orientation
@@ -110,11 +111,11 @@ module Rpdfium
       DEFAULT_MIN_WORDS_VERTICAL = 3
       DEFAULT_MIN_WORDS_HORIZONTAL = 1
 
-      # Per ogni cluster di word allineate "in alto" (stessa top, entro tol=1)
-      # con almeno `word_threshold` membri, emette DUE edges orizzontali (top
-      # e bottom della bbox di quel cluster). Avere il bottom oltre al top è
-      # critico: garantisce che l'ultima riga di ogni tabella abbia un edge
-      # orizzontale di chiusura.
+      # For each cluster of words aligned "at the top" (same top, within
+      # tol=1) with at least `word_threshold` members, it emits TWO
+      # horizontal edges (top and bottom of that cluster's bbox). Having
+      # the bottom in addition to the top is critical: it guarantees that
+      # the last row of each table has a closing horizontal edge.
       def words_to_edges_h(words, word_threshold: DEFAULT_MIN_WORDS_HORIZONTAL)
         by_top = Util::Cluster.cluster_objects(words, :top, tolerance: 1.0)
         large = by_top.select { |g| g.size >= word_threshold }
@@ -132,14 +133,14 @@ module Rpdfium
         end
       end
 
-      # Tre cluster di word per x: x0, x1, centerpoint. Cluster con almeno
-      # `word_threshold` membri sono candidati colonna. Le bbox di ciascun
-      # cluster vengono "condensate": se una bbox si sovrappone a un'altra
-      # già selezionata (più popolata), viene scartata.
+      # Three clusters of words by x: x0, x1, centerpoint. Clusters with at
+      # least `word_threshold` members are column candidates. The bboxes of
+      # each cluster are "condensed": if a bbox overlaps another already
+      # selected (more populated) one, it is discarded.
       #
-      # Per ogni bbox condensata emetto un edge verticale al suo x0 (left
-      # della colonna). In aggiunta, emetto un edge "right" finale al max
-      # x1 di tutte le bbox: chiude visivamente la tabella sulla destra.
+      # For each condensed bbox I emit a vertical edge at its x0 (left of
+      # the column). In addition, I emit a final "right" edge at the max x1
+      # of all the bboxes: it visually closes the table on the right.
       def words_to_edges_v(words, word_threshold: DEFAULT_MIN_WORDS_VERTICAL)
         by_x0 = Util::Cluster.cluster_objects(words, :x0, tolerance: 1.0)
         by_x1 = Util::Cluster.cluster_objects(words, :x1, tolerance: 1.0)
@@ -147,7 +148,7 @@ module Rpdfium
         by_center = Util::Cluster.cluster_objects(words, center_fn, tolerance: 1.0)
 
         clusters = by_x0 + by_x1 + by_center
-        # Più popolati prima
+        # More populated first
         sorted = clusters.sort_by { |c| -c.size }
         large = sorted.select { |c| c.size >= word_threshold }
         bboxes = large.map { |c| Util::Cluster.objects_to_bbox(c) }
@@ -157,7 +158,7 @@ module Rpdfium
         end
         return [] if condensed_bboxes.empty?
 
-        # Sort left-to-right per emettere edges in ordine geometrico.
+        # Sort left-to-right to emit edges in geometric order.
         condensed_rects = condensed_bboxes.map do |b|
           { x0: b[0], top: b[1], x1: b[2], bottom: b[3] }
         end.sort_by { |r| r[:x0] }
@@ -170,7 +171,7 @@ module Rpdfium
           acc[2] = r[:bottom] if r[:bottom] > acc[2]
         end
 
-        # Edge "left" di ogni colonna + un edge finale "right".
+        # "left" edge of each column + a final "right" edge.
         left_edges = condensed_rects.map do |r|
           { x0: r[:x0], x1: r[:x0], top: min_top, bottom: max_bottom, orientation: "v" }
         end
@@ -179,18 +180,19 @@ module Rpdfium
       end
 
       # ------------------------------------------------------------------
-      # intersezioni edges
+      # edge intersections
       # ------------------------------------------------------------------
 
-      # Per ogni coppia (h, v) che si interseca entro tolerance, registra
-      # un'intersezione `(v.x0, h.top)` con i puntatori agli edge sorgenti.
-      # Il valore in `intersections[(x, y)] = { v: [...], h: [...] }` permette
-      # poi al cell-builder di verificare "edge connect".
+      # For each (h, v) pair that intersects within tolerance, it records
+      # an intersection `(v.x0, h.top)` with pointers to the source edges.
+      # The value in `intersections[(x, y)] = { v: [...], h: [...] }` then
+      # allows the cell-builder to verify "edge connect".
       #
-      # Ottimizzazione rispetto al loop naïve O(|v|×|h|): sorted_h è ordinato
-      # per top; per ogni edge verticale si usa bsearch per trovare il primo h
-      # candidato e si esce appena h[:top] supera v[:bottom] + y_tolerance,
-      # riducendo le iterazioni al solo sottoinsieme verticalmente rilevante.
+      # Optimization over the naïve O(|v|×|h|) loop: sorted_h is ordered by
+      # top; for each vertical edge a bsearch is used to find the first
+      # candidate h and the loop exits as soon as h[:top] exceeds
+      # v[:bottom] + y_tolerance, reducing the iterations to only the
+      # vertically relevant subset.
       def edges_to_intersections(edges, x_tolerance: 1.0, y_tolerance: 1.0)
         v_edges, h_edges = edges.partition { |e| e[:orientation] == "v" }
         intersections = {}
@@ -202,11 +204,11 @@ module Rpdfium
           v_top_min = v[:top]    - y_tolerance
           v_top_max = v[:bottom] + y_tolerance
 
-          # Salta tutti gli h il cui top è ancora sotto la finestra verticale.
+          # Skip all the h whose top is still below the vertical window.
           start_idx = h_tops.bsearch_index { |t| t >= v_top_min } || sorted_h.size
 
           sorted_h[start_idx..].each do |h|
-            # Gli h rimanenti sono oltre la finestra: esci subito.
+            # The remaining h are beyond the window: exit immediately.
             break if h[:top] > v_top_max
 
             next unless v[:x0] >= h[:x0] - x_tolerance

data/lib/rpdfium/table/extractor.rb

@@ -2,25 +2,25 @@
 
 module Rpdfium
   module Table
-    # Trova tabelle su una pagina, fedele al `pdfplumber.TableFinder`.
+    # Finds tables on a page, faithful to `pdfplumber.TableFinder`.
     #
     # Pipeline:
-    #   1. raccogli edges candidati per ogni asse, secondo strategia
+    #   1. collect candidate edges for each axis, according to strategy
     #      (`:lines` / `:lines_strict` / `:text` / `:explicit`)
-    #   2. merge_edges (snap collineari + join contigui)
-    #   3. filter per lunghezza minima
-    #   4. edges_to_intersections con tolerance
-    #   5. intersections_to_cells (smallest cell per ogni punto)
-    #   6. cells_to_tables (grouping per corner condivisi)
+    #   2. merge_edges (snap collinear + join contiguous)
+    #   3. filter by minimum length
+    #   4. edges_to_intersections with tolerance
+    #   5. intersections_to_cells (smallest cell for each point)
+    #   6. cells_to_tables (grouping by shared corners)
     #
-    # API pubblica:
+    # Public API:
     #   ext = Rpdfium::Table::Extractor.new(page, **opts)
-    #   ext.tables           # => [Table, ...]   (oggetti Rpdfium::Table::Table)
-    #   ext.extract          # => [[[String]]]   (Array di tabelle, ogni tabella
-    #                                              è Array di righe, ogni riga
-    #                                              è Array di stringhe)
-    #   ext.find             # alias di .tables (compat back con 0.2.x)
-    #   ext.edges            # edges raffinati
+    #   ext.tables           # => [Table, ...]   (Rpdfium::Table::Table objects)
+    #   ext.extract          # => [[[String]]]   (Array of tables, each table
+    #                                              is an Array of rows, each row
+    #                                              is an Array of strings)
+    #   ext.find             # alias of .tables (back-compat with 0.2.x)
+    #   ext.edges            # refined edges
     #   ext.intersections    # Hash {[x,y] => {v:[],h:[]}}
     #   ext.cells            # Array<bbox>
     class Extractor
@@ -30,7 +30,7 @@ module Rpdfium
         explicit_vertical_lines:   [],
         explicit_horizontal_lines: [],
 
-        # Tolleranze. I `_x_` / `_y_` ereditano dal valore non-suffisso.
+        # Tolerances. The `_x_` / `_y_` inherit from the un-suffixed value.
         snap_tolerance:           3.0,
         snap_x_tolerance:         nil,
         snap_y_tolerance:         nil,
@@ -48,16 +48,17 @@ module Rpdfium
         intersection_x_tolerance: nil,
         intersection_y_tolerance: nil,
 
-        # Settings testo (passati a TextExtraction quando si chiama .extract).
-        # I default 3.0 sono quelli di pdfplumber.
+        # Text settings (passed to TextExtraction when .extract is called).
+        # The 3.0 defaults are those of pdfplumber.
         text_x_tolerance: Util::WordExtractor::DEFAULT_X_TOLERANCE,
         text_y_tolerance: Util::WordExtractor::DEFAULT_Y_TOLERANCE,
         text_keep_blank_chars: false,
 
-        # Auto-fallback: se :lines non produce edges, riprova con :text.
-        # Manteniamo il flag (era già in 0.2.x) ma SOLO come fallback,
-        # mai come "fix" su layout patologici — coerente con pdfplumber che
-        # non lo ha (chi usa pdfplumber sa che deve scegliere la strategia).
+        # Auto-fallback: if :lines produces no edges, retry with :text.
+        # We keep the flag (it was already in 0.2.x) but ONLY as a fallback,
+        # never as a "fix" for pathological layouts — consistent with
+        # pdfplumber, which does not have it (pdfplumber users know they
+        # must choose the strategy).
         auto_fallback: true
       }.freeze
 
@@ -71,14 +72,14 @@ module Rpdfium
         validate_strategies!
       end
 
-      # Pipeline completa, costruisce gli edges raffinati.
+      # Full pipeline, builds the refined edges.
       def edges
         @edges ||= build_edges(@settings[:vertical_strategy],
                                @settings[:horizontal_strategy]).then do |built|
           if built.empty? && @settings[:auto_fallback] &&
              (@settings[:vertical_strategy] != :text ||
               @settings[:horizontal_strategy] != :text)
-            # Fallback: l'auto-fallback è LASCO, riprova tutto a :text.
+            # Fallback: the auto-fallback is LOOSE, retry everything as :text.
             build_edges(:text, :text)
           else
             built
@@ -103,7 +104,7 @@ module Rpdfium
       end
       alias find tables
 
-      # Estrai i dati di tutte le tabelle: Array<Array<Array<String>>>.
+      # Extract the data of all tables: Array<Array<Array<String>>>.
       def extract(**text_opts)
         merged = {
           x_tolerance: @settings[:text_x_tolerance],
@@ -117,7 +118,7 @@ module Rpdfium
       private
 
       def resolve_settings(s)
-        # Cascata x/y dai non-suffissi
+        # Cascade x/y from the un-suffixed values
         s[:snap_x_tolerance] ||= s[:snap_tolerance]
         s[:snap_y_tolerance] ||= s[:snap_tolerance]
         s[:join_x_tolerance] ||= s[:join_tolerance]
@@ -164,10 +165,10 @@ module Rpdfium
       end
 
       def page_words
-        # Genera words usando il nostro WordExtractor (consistente con
-        # quello usato in Table#extract, così i thresholds combaciano).
-        # `lean: true`: vedi commento in Table#extract.
-        chars = @page.chars(lean: true)
+        # Generate words using our WordExtractor (consistent with the one
+        # used in Table#extract, so the thresholds match).
+        # `geometry: true`: see comment in Table#extract.
+        chars = @page.chars(lean: true, geometry: true)
         Util::WordExtractor.new(
           x_tolerance: @settings[:text_x_tolerance],
           y_tolerance: @settings[:text_y_tolerance],
@@ -187,11 +188,11 @@ module Rpdfium
         end
       end
 
-      # Converte i `vertical_lines` di Page (formato {x, top, bottom}) al
-      # formato pdfplumber-style atteso dalle Edges.
-      # Nota: in 0.3.0 NON includiamo i lati di rettangoli quando :strict
-      # (ma al momento Page non li espone separatamente, è una semplificazione
-      # che documenteremo).
+      # Converts Page's `vertical_lines` (format {x, top, bottom}) to the
+      # pdfplumber-style format expected by Edges.
+      # Note: in 0.3.0 we do NOT include rectangle sides when :strict
+      # (but at present Page does not expose them separately, a
+      # simplification that we will document).
       def page_vertical_edges(strict: false) # rubocop:disable Lint/UnusedMethodArgument
         prefilter = @settings[:edge_min_length_prefilter]
         @page.vertical_lines.filter_map do |s|