1Text::Table(3pm) User Contributed Perl Documentation Text::Table(3pm)
2
6 Text::Table - Organize Data in Tables
7
9 version 1.135
10
12 use Text::Table;
13 my $tb = Text::Table->new(
14 "Planet", "Radius\nkm", "Density\ng/cm^3"
15 );
16 $tb->load(
17 [ "Mercury", 2360, 3.7 ],
18 [ "Venus", 6110, 5.1 ],
19 [ "Earth", 6378, 5.52 ],
20 [ "Jupiter", 71030, 1.3 ],
21 );
22 print $tb;
23 This prints a table from the given title and data like this:
25 Planet Radius Density
27 km g/cm^3
28 Mercury 2360 3.7
29 Venus 6110 5.1
30 Earth 6378 5.52
31 Jupiter 71030 1.3
32 Note that two-line titles work, and that the planet names are aligned
34 differently than the numbers.
35
37 Organization of data in table form is a time-honored and useful method
38 of data representation. While columns of data are trivially generated
39 by computer through formatted output, even simple tasks like keeping
40 titles aligned with the data columns are not trivial, and the one-shot
41 solutions one comes up with tend to be particularly hard to maintain.
42 Text::Table allows you to create and maintain tables that adapt to
43 alignment requirements as you use them.
44 Overview
46 The process is simple: you create a table (a Text::Table object) by
47 describing the columns the table is going to have. Then you load lines
48 of data into the table, and finally print the resulting output lines.
49 Alignment of data and column titles is handled dynamically in
50 dependence on the data present.
51 Table Creation
53 In the simplest case, if all you want is a number of (untitled)
54 columns, you create an unspecified table and start adding data to it.
55 The number of columns is taken from the first line of data.
56 To specify a table you specify its columns. A column description can
58 contain a title and alignment requirements for the data, both optional.
59 Additionally, you can specify how the title is aligned with the body of
60 a column, and how the lines of a multiline title are aligned among
61 themselves.
62 The columns are collected in the table in the order they are given. On
64 data entry, each column corresponds to one data item, and in column
65 selection columns are indexed left to right, starting from 0.
66 Each title can be a multiline string which will be blank-filled to the
68 length of the longest partial line. The largest number of title lines
69 in a column determines how many title lines the table has as a whole,
70 including the case that no column has any titles.
71 On output, columns are separated by a single blank. You can control
73 what goes between columns by specifying separators between (or before,
74 or after) columns. Separators don't contain any data and don't count
75 in column indexing. They also don't accumulate: in a sequence of only
76 separators and no columns, only the last one counts.
77 Status Information
79 The width (in characters), height (in lines), number of columns, and
80 similar data about the table is available.
81 Data Loading
83 Table data is entered line-wise, each time specifying data entries for
84 all table columns. A bulk loader for many lines at once is also
85 available. You can clear the data from the table for re-use (though
86 you will more likely just create another table).
87 Data can contain colorizing escape sequences (as provided by
89 "Term::AnsiColor") without upsetting the alignment.
90 Table Output
92 The output area of a table is divided in the title and the body.
93 The title contains the combined titles from the table columns, if any.
95 Its content never changes with a given table, but it may be spread out
96 differently on the page through alignment with the data.
97 The body contains the data lines, aligned column-wise as specified, and
99 left-aligned with the column title.
100 Each of these is arranged like a Perl array (counting from 0) and can
102 be accessed in portions by specifying a first line and the number of
103 following lines. Also like an array, giving a negative first line
104 counts from the end of the area. The whole table, the title followed
105 by the body, can also be accessed in this manner.
106 The subdivisions are there so you can repeat the title (or parts of it)
108 along with parts of the body on output, whether for screen paging or
109 printout.
110 A rule line is also available, which is the horizontal counterpart to
112 the separator columns you specify with the table. It is basically a
113 table line as it would appear if all data entries in the line were
114 empty, that is, a blank line except for where the column separators
115 have non-blank entries. If you print it between data lines, it will
116 not disrupt the vertical separator structure as a plain blank line
117 would. You can also request a solid rule consisting of any character,
118 and even one with the non-blank column separators replaced by a
119 character of your choice. This way you can get the popular
120 representation of line-crossings like so:
121 |
123 ----+---
124 |
125 Warning Control
127 On table creation, some parameters are checked and warnings issued if
128 you allow warnings. You can also turn warnings into fatal errors.
129
131 version 1.135
132
134 Column Specification
135 Each column specification is a single scalar. Columns can be either
136 proper data columns or column separators. Both can be specified either
137 as (possibly multi-line) strings, or in a more explicit form as hash-
138 refs. In the string form, proper columns are given as plain strings,
139 and separators are given as scalar references to strings. In hash
140 form, separators have a true value in the field "is_sep" while proper
141 columns don't have this field.
142 Columns as strings
144 A column is given as a column title (any number of lines),
145 optionally followed by alignment requirements. Alignment
146 requirements start with a line that begins with an ampersand "&".
147 However, only the last such line counts as such, so if you have
148 title lines that begin with "&", just append an ampersand on a line
149 by itself as a dummy alignment section if you don't have one
150 anyway.
151 What follows the ampersand on its line is the alignment style (like
153 left, right, ... as described in "Alignment"), you want for the
154 data in this column. If nothing follows, the general default auto
155 is used. If you specify an invalid alignment style, it falls back
156 to left alignment.
157 The lines that follow can contain sample data for this column.
159 These are considered for alignment in the column, but never
160 actually appear in the output. The effect is to guarantee a
161 minimum width for the column even if the current data doesn't
162 require it. This helps dampen the oscillations in the appearance
163 of dynamically aligned tables.
164 Columns as Hashes
166 The format is
167 {
169 title => $title,
170 align => $align,
171 sample => $sample,
172 align_title => $align_title,
173 align_title_lines => $align_title_lines,
174 }
175 $title contains the title lines and $sample the sample data. Both
177 can be given as a string or as an array-ref to the list of lines.
178 $align contains the alignment style (without a leading ampersand),
179 usually as a string. You can also give a regular expression here,
180 which specifies regex alignment. A regex can only be specified in
181 the hash form of a column specification.
182 In hash form you can also specify how the title of a column is
184 aligned with its body. To do this, you specify the keyword
185 "align_title" with "left", "right" or "center". Other alignment
186 specifications are not valid here. The default is "left".
187 "align_title" also specifies how the lines of a multiline title are
189 aligned among themselves. If you want a different alignment, you
190 can specify it with the key "align_title_lines". Again, only
191 "left", "right" or "center" are allowed.
192 Do not put other keys than those mentioned above (title, align,
194 align_title, align_title_lines, and sample) into a hash that
195 specifies a column. Most would be ignored, but some would confuse
196 the interpreter (in particular, is_sep has to be avoided).
197 Separators as strings
199 A separator must be given as a reference to a string (often a
200 literal, like "\' | '"), any string that is given directly
201 describes a column.
202 It is usually just a (short) string that will be printed between
204 table columns on all table lines instead of the default single
205 blank. If you specify two separators (on two lines), the first one
206 will be used in the title and the other in the body of the table.
207 Separators as Hashes
209 The hash representation of a separator has the format
210 {
212 is_sep => 1,
213 title => $title,
214 body => $body,
215 }
216 $title is the separator to be used in the title area and $body the
218 one for the body. If only one is given, it will be used for both.
219 If none is given, a blank is used. If one is shorter than the
220 other, it is blank filled on the right.
221 The value of "is_sep" must be set to a true value, this is the
223 distinguishing feature of a separator.
224 Alignment
226 The original documentation to Text::Aligner contains all the details on
227 alignment specification, but here is the rundown:
228 The possible alignment specifications are left, right, center, num and
230 point (which are synonyms), and auto. The first three explain
231 themselves.
232 num (and point) align the decimal point in the data, which is assumed
234 to the right if none is present. Strings that aren't numbers are
235 treated the same way, that is, they appear aligned with the integers
236 unless they contain a ".". Instead of the decimal point ".", you can
237 also specify any other string in the form num(,), for instance. The
238 string in parentheses is aligned in the data. The synonym point for
239 num may be more appropriate in contexts that deal with arbitrary
240 strings, as in point(=>) (which might be used to align certain bits of
241 Perl code).
242 regex alignment is a more sophisticated form of point alignment. If
244 you specify a regular expression, as delivered by "qr//", the start of
245 the match is used as the alignment point. If the regex contains
246 capturing parentheses, the last submatch counts. [The usefulness of
247 this feature is under consideration.]
248 auto alignment combines numeric alignment with left alignment. Data
250 items that look like numbers, and those that don't, form two virtual
251 columns and are aligned accordingly: "num" for numbers and "left" for
252 other strings. These columns are left-aligned with each other (i.e.
253 the narrower one is blank-filled) to form the final alignment.
254 This way, a column that happens to have only numbers in the data gets
256 num alignment, a column with no numbers appears left-aligned, and mixed
257 data is presented in a reasonable way.
258 Column Selection
260 Besides creating tables from scratch, they can be created by selecting
261 columns from an existing table. Tables created this way contain the
262 data from the columns they were built from.
263 This is done by specifying the columns to select by their index (where
265 negative indices count backward from the last column). The same column
266 can be selected more than once and the sequence of columns can be
267 arbitrarily changed. Separators don't travel with columns, but can be
268 specified between the columns at selection time.
269 You can make the selection of one or more columns dependent on the data
271 content of one of them. If you specify some of the columns in angle
272 brackets [...], the whole group is only included in the selection if
273 the first column in the group contains any data that evaluates to
274 boolean true. That way you can de-select parts of a table if it
275 contains no interesting data. Any column separators given in brackets
276 are selected or deselected along with the rest of it.
277
279 Table Creation
280 new()
281 my $tb = Text::Table->new( $column, ... );
282 creates a table with the columns specified. A column can be proper
284 column which contains and displays data, or a separator which tells
285 how to fill the space between columns. The format of the
286 parameters is described under "Column Specification". Specifying an
287 invalid alignment for a column results in a warning if these are
288 allowed.
289 If no columns are specified, the number of columns is taken from
291 the first line of data added to the table. The effect is as if you
292 had specified "Text::Table->new( ( '') x $n)", where $n is the
293 number of columns.
294 select()
296 my $sub = $tb->select( $column, ...);
297 creates a table from the listed columns of the table $tb, including
299 the data. Columns are specified as integer indices which refer to
300 the data columns of $tb. Columns can be repeated and specified in
301 any order. Negative indices count from the last column. If an
302 invalid index is specified, a warning is issued, if allowed.
303 As with "new()", separators can be interspersed among the column
305 indices and will be used between the columns of the new table.
306 If you enclose some of the arguments (column indices or separators)
308 in angle brackets "[...]" (technically, you specify them inside an
309 arrayref), they form a group for conditional selection. The group
310 is only included in the resulting table if the first actual column
311 inside the group contains any data that evaluate to a boolean true.
312 This way you can exclude groups of columns that wouldn't contribute
313 anything interesting. Note that separators are selected and de-
314 selected with their group. That way, more than one separator can
315 appear between adjacent columns. They don't add up, but only the
316 rightmost separator is used. A group that contains only separators
317 is never selected. [Another feature whose usefulness is under
318 consideration.]
319 Status Information
321 n_cols()
322 $tb->n_cols
323 returns the number of columns in the table.
325 width()
327 $tb->width
328 returns the width (in characters) of the table. All table lines
330 have this length (not counting a final "\n" in the line), as well
331 as the separator lines returned by $tb->rule() and $b->body_rule().
332 The width of a table can potentially be influenced by any data item
333 in it.
334 height()
336 $tb->height
337 returns the total number of lines in a table, including title lines
339 and body lines. For orthogonality, the synonym table_height() also
340 exists.
341 table_height()
343 Same as "$table->height()".
344 title_height()
346 $tb->title_height
347 returns the number of title lines in a table.
349 body_height()
351 $tb->body_height
352 returns the number of lines in the table body.
354 colrange()
356 $tb->colrange( $i)
357 returns the start position and width of the $i-th column (counting
359 from 0) of the table. If $i is negative, counts from the end of
360 the table. If $i is larger than the greatest column index, an
361 imaginary column of width 0 is assumed right of the table.
362 Data Loading
364 add()
365 $tb->add( $col1, ..., $colN)
366 adds a data line to the table, returns the table.
368 $col1, ..., $colN are scalars that correspond to the table columns.
370 Undefined entries are converted to '', and extra data beyond the
371 number of table columns is ignored.
372 Data entries can be multi-line strings. The partial strings all go
374 into the same column. The corresponding fields of other columns
375 remain empty unless there is another multi-line entry in that
376 column that fills the fields. Adding a line with multi-line
377 entries is equivalent to adding multiple lines.
378 Every call to add() increases the body height of the table by the
380 number of effective lines, one in the absence of multiline entries.
381 load()
383 $tb->load( $line, ...)
384 loads the data lines given into the table, returns the table.
386 Every argument to load() represents a data line to be added to the
388 table. The line can be given as an array(ref) containing the data
389 items, or as a string, which is split on whitespace to retrieve the
390 data. If an undefined argument is given, it is treated as an empty
391 line.
392 clear()
394 $tb->clear;
395 deletes all data from the table and resets it to the state after
397 creation. Returns the table. The body height of a table is 0
398 after clear().
399 Table Output
401 The three methods table(), title(), and body() are very similar. They
402 access different parts of the printable output lines of a table with
403 similar methods. The details are described with the table() method.
404 table()
406 The table() method returns lines from the entire table, starting
407 with the first title line and ending with the last body line.
408 In array context, the lines are returned separately, in scalar
410 context they are joined together in a single string.
411 my @lines = $tb->table;
413 my $line = $tb->table( $line_number);
414 my @lines = $tb->table( $line_number, $n);
415 The first call returns all the lines in the table. The second call
417 returns one line given by $line_number. The third call returns $n
418 lines, starting with $line_number. If $line_number is negative, it
419 counts from the end of the array. Unlike the select() method,
420 table() (and its sister methods title() and body()) is protected
421 against large negative line numbers, it truncates the range
422 described by $line_number and $n to the existing lines. If $n is 0
423 or negative, no lines are returned (an empty string in scalar
424 context).
425 stringify()
427 Returns a string representation of the table. This method is called
428 for stringification by overload.
429 my @table_strings = map { $_->stringify() } @tables;
431 title()
433 Returns lines from the title area of a table, where the column
434 titles are rendered. Parameters and response to context are as
435 with table(), but no lines are returned from outside the title
436 area.
437 body()
439 Returns lines from the body area of a table, that is the part where
440 the data content is rendered, so that $tb->body( 0) is the first
441 data line. Parameters and response to context are as with table().
442 rule()
444 $tb->rule;
445 $tb->rule( $char);
446 $tb->rule( $char, $char1);
447 $tb->rule( sub { my ($index, $len) = @_; },
448 sub { my ($index, $len) = @_; },
449 );
450 Returns a rule for the table.
452 A rule is a line of table width that can be used between table
454 lines to provide visual horizontal divisions, much like column
455 separators provide vertical visual divisions. In its basic form
456 (returned by the first call) it looks like a table line with no
457 data, hence a blank line except for the non-blank parts of any
458 column-separators. If one character is specified (the second
459 call), it replaces the blanks in the first form, but non-blank
460 column separators are retained. If a second character is
461 specified, it replaces the non-blank parts of the separators. So
462 specifying the same character twice gives a solid line of table
463 width. Another useful combo is "$tb->rule( '-', '+')", together
464 with separators that contain a single nonblank "|", for a popular
465 representation of line crossings.
466 rule() uses the column separators for the title section if there is
468 a difference.
469 If callbacks are specified instead of the characters, then they
471 receive the index of the section of the rule they need to render
472 and its desired length in characters, and should return the string
473 to put there. The indexes given are 0 based (where 0 is either the
474 left column separator or the leftmost cell) and the strings will be
475 trimmed or extended in the replacement.
476 body_rule()
478 body_rule() works like <rule()>, except the rule is generated using
479 the column separators for the table body.
480 Warning Control
482 warnings()
483 Text::Table->warnings();
484 Text::Table->warnings( 'on');
485 Text::Table->warnings( 'off'):
486 Text::Table->warnings( 'fatal'):
487 The warnings() method is used to control the appearance of warning
489 messages while tables are manipulated. When Text::Table starts,
490 warnings are disabled. The default action of warnings() is to turn
491 warnings on. The other possible arguments are self-explanatory.
492 warnings() can also be called as an object method ("$tb->warnings(
493 ...)").
494
496 This document pertains to Text::Table version 1.127
497
499 o auto alignment doesn't support alternative characters for the
500 decimal point. This is actually a bug in the underlying
501 Text::Aligner by the same author.
502
504 MAINTAINER
505 Shlomi Fish, <http://www.shlomifish.org/> - CPAN ID: "SHLOMIF".
506 ORIGINAL AUTHOR
508 Anno Siegel
509 CPAN ID: ANNO
510 siegel@zrz.tu-berlin.de
511 http://www.tu-berlin.de/~siegel
512
514 Copyright (c) 2002 Anno Siegel. All rights reserved. This program is
515 free software; you can redistribute it and/or modify it under the terms
516 of the ISC license.
517 (This program had been licensed under the same terms as Perl itself up
519 to version 1.118 released on 2011, and was relicensed by permission of
520 its originator).
521 The full text of the license can be found in the LICENSE file included
523 with this module.
524
526 Text::Table::Tiny supports a simple model for generating text tables,
527 with some flexibility on the look of the table.
528 Text::Table::Manifold provides a much richer interface for defining
530 tables. The SEE ALSO section of its documentation lists a lot more
531 table modules on CPAN.
532 Text::Aligner can be used to align text on a line-by-line basis.
534
536 center align and Unicode output
537 #!/usr/bin/perl
538 use strict;
540 use warnings;
541 use utf8;
542 use Text::Table ();
544 binmode STDOUT, ':encoding(utf8)';
546 my @cols = qw/First Last/;
548 push @cols,
549 +{
550 title => "Country",
551 align => "center",
552 };
553 my $sep = \'│';
554 my $major_sep = \'║';
556 my $tb = Text::Table->new( $sep, " Number ", $major_sep,
557 ( map { +( ( ref($_) ? $_ : " $_ " ), $sep ) } @cols ) );
558 my $num_cols = @cols;
560 $tb->load( [ 1, "Mark", "Twain", "USA", ] );
562 $tb->load( [ 2, "Charles", "Dickens", "Great Britain", ] );
563 $tb->load( [ 3, "Jules", "Verne", "France", ] );
564 my $make_rule = sub {
566 my ($args) = @_;
567 my $left = $args->{left};
569 my $right = $args->{right};
570 my $main_left = $args->{main_left};
571 my $middle = $args->{middle};
572 return $tb->rule(
574 sub {
575 my ( $index, $len ) = @_;
576 return ( '─' x $len );
578 },
579 sub {
580 my ( $index, $len ) = @_;
581 my $char = (
583 ( $index == 0 ) ? $left
584 : ( $index == 1 ) ? $main_left
585 : ( $index == $num_cols + 1 ) ? $right
586 : $middle
587 );
588 return $char x $len;
590 },
591 );
592 };
593 my $start_rule = $make_rule->(
595 {
596 left => '┌',
597 main_left => '╥',
598 right => '┐',
599 middle => '┬',
600 }
601 );
602 my $mid_rule = $make_rule->(
604 {
605 left => '├',
606 main_left => '╫',
607 right => '┤',
608 middle => '┼',
609 }
610 );
611 my $end_rule = $make_rule->(
613 {
614 left => '└',
615 main_left => '╨',
616 right => '┘',
617 middle => '┴',
618 }
619 );
620 print $start_rule, $tb->title,
622 ( map { $mid_rule, $_, } $tb->body() ), $end_rule;
623 This emits the following output:
625 ┌────────╥───────┬───────┬─────────────┐
627 │ Number ║ First │ Last │Country │
628 ├────────╫───────┼───────┼─────────────┤
629 │1 ║Mark │Twain │ USA │
630 ├────────╫───────┼───────┼─────────────┤
631 │2 ║Charles│Dickens│Great Britain│
632 ├────────╫───────┼───────┼─────────────┤
633 │3 ║Jules │Verne │ France │
634 └────────╨───────┴───────┴─────────────┘
635
637 Websites
638 The following websites have more information about this module, and may
639 be of help to you. As always, in addition to those websites please use
640 your favorite search engine to discover more resources.
641 • MetaCPAN
643 A modern, open-source CPAN search engine, useful to view POD in
645 HTML format.
646 <https://metacpan.org/release/Text-Table>
648 • RT: CPAN's Bug Tracker
650 The RT ( Request Tracker ) website is the default bug/issue
652 tracking system for CPAN.
653 <https://rt.cpan.org/Public/Dist/Display.html?Name=Text-Table>
655 • CPANTS
657 The CPANTS is a website that analyzes the Kwalitee ( code metrics )
659 of a distribution.
660 <http://cpants.cpanauthors.org/dist/Text-Table>
662 • CPAN Testers
664 The CPAN Testers is a network of smoke testers who run automated
666 tests on uploaded CPAN distributions.
667 <http://www.cpantesters.org/distro/T/Text-Table>
669 • CPAN Testers Matrix
671 The CPAN Testers Matrix is a website that provides a visual
673 overview of the test results for a distribution on various
674 Perls/platforms.
675 <http://matrix.cpantesters.org/?dist=Text-Table>
677 • CPAN Testers Dependencies
679 The CPAN Testers Dependencies is a website that shows a chart of
681 the test results of all dependencies for a distribution.
682 <http://deps.cpantesters.org/?module=Text::Table>
684 Bugs / Feature Requests
686 Please report any bugs or feature requests by email to "bug-text-table
687 at rt.cpan.org", or through the web interface at
688 <https://rt.cpan.org/Public/Bug/Report.html?Queue=Text-Table>. You will
689 be automatically notified of any progress on the request by the system.
690 Source Code
692 The code is open to the world, and available for you to hack on. Please
693 feel free to browse it and play with it, or whatever. If you want to
694 contribute patches, please send me a diff or prod me to pull from your
695 repository :)
696 <https://github.com/shlomif/Text-Table>
698 git clone git://github.com/shlomif/Text-Table.git
700
702 Shlomi Fish <shlomif@cpan.org>
703
705 Please report any bugs or feature requests on the bugtracker website
706 <https://github.com/shlomif/Text-Table/issues>
707 When submitting a bug or request, please include a test-file or a patch
709 to an existing test-file that illustrates the bug or desired feature.
710
712 This software is Copyright (c) 2002 by Anno Siegel and others.
713 This is free software, licensed under:
715 The ISC License
717
719 Websites
720 The following websites have more information about this module, and may
721 be of help to you. As always, in addition to those websites please use
722 your favorite search engine to discover more resources.
723 • MetaCPAN
725 A modern, open-source CPAN search engine, useful to view POD in
727 HTML format.
728 <https://metacpan.org/release/Text-Table>
730 • RT: CPAN's Bug Tracker
732 The RT ( Request Tracker ) website is the default bug/issue
734 tracking system for CPAN.
735 <https://rt.cpan.org/Public/Dist/Display.html?Name=Text-Table>
737 • CPANTS
739 The CPANTS is a website that analyzes the Kwalitee ( code metrics )
741 of a distribution.
742 <http://cpants.cpanauthors.org/dist/Text-Table>
744 • CPAN Testers
746 The CPAN Testers is a network of smoke testers who run automated
748 tests on uploaded CPAN distributions.
749 <http://www.cpantesters.org/distro/T/Text-Table>
751 • CPAN Testers Matrix
753 The CPAN Testers Matrix is a website that provides a visual
755 overview of the test results for a distribution on various
756 Perls/platforms.
757 <http://matrix.cpantesters.org/?dist=Text-Table>
759 • CPAN Testers Dependencies
761 The CPAN Testers Dependencies is a website that shows a chart of
763 the test results of all dependencies for a distribution.
764 <http://deps.cpantesters.org/?module=Text::Table>
766 Bugs / Feature Requests
768 Please report any bugs or feature requests by email to "bug-text-table
769 at rt.cpan.org", or through the web interface at
770 <https://rt.cpan.org/Public/Bug/Report.html?Queue=Text-Table>. You will
771 be automatically notified of any progress on the request by the system.
772 Source Code
774 The code is open to the world, and available for you to hack on. Please
775 feel free to browse it and play with it, or whatever. If you want to
776 contribute patches, please send me a diff or prod me to pull from your
777 repository :)
778 <https://github.com/shlomif/Text-Table>
780 git clone git://github.com/shlomif/Text-Table.git
782
784 Shlomi Fish <shlomif@cpan.org>
785
787 Please report any bugs or feature requests on the bugtracker website
788 <https://github.com/shlomif/Text-Table/issues>
789 When submitting a bug or request, please include a test-file or a patch
791 to an existing test-file that illustrates the bug or desired feature.
792
794 This software is Copyright (c) 2002 by Anno Siegel and others.
795 This is free software, licensed under:
797 The ISC License
799perl v5.38.0 2023-07-21 Text::Table(3pm)