Unicode::LineBreak(3)

Hey bestie 💖 welcome to the Unicode::LineBreak(3) page — it’s from User Contributed Perl Documentation, and yes the manual name is literally Unicode::LineBreak(3). We’re about to get into the UAX #14 Unicode Line Breaking Algorithm together, and it’s giving iconic Unicode energy ✨.

🌸 NAME 🌸

Unicode::LineBreak — UAX #14 Unicode Line Breaking Algorithm 🎀

✨ SYNOPSIS ✨

use Unicode::LineBreak;
$lb = Unicode::LineBreak->new();
$broken = $lb->break($string);

💅 DESCRIPTION 💅

Unicode::LineBreak performs the Line Breaking Algorithm described in Unicode Standard Annex #14 [UAX #14]. The East_Asian_Width informative property defined by Annex #11 [UAX #11] will be concerned when determining breaking positions. ✨

🧚 Terminology 🧚

Okay so these terms are used here for convenience, periodt.

A Mandatory break is obligatory line breaking behavior defined by core rules and performed regardless of surrounding characters. An Arbitrary break is line breaking behavior allowed by core rules and chosen by the user to perform it. Arbitrary break includes direct break and indirect break defined by [UAX #14].

Alphabetic characters are characters where usually no line breaks are allowed between pairs of them, except that other characters provide break opportunities. Ideographic characters are characters that usually allow line breaks both before and after themselves. [UAX #14] classifies most alphabetic characters to AL and most ideographic ones to ID (and yeah, these terms are inaccurate from the point of view by grammatology 👀). On several scripts, breaking positions are not obvious by each character, so a heuristic based on a dictionary is used.

Number of columns of a string is not always equal to the number of characters it contains: each character is either wide, narrow or nonspacing; they occupy 2, 1 or 0 columns, respectively. Several characters may be both wide and narrow by the contexts they are used. Characters may have more various widths by customization. 🦋

🌈 PUBLIC INTERFACE 🌈

🫶 Line Breaking 🫶

• new ([KEY => VALUE, ...]) — Constructor. About KEY => VALUE pairs, see “Options”.
• break (STRING) — Instance method. Break Unicode string STRING and returns it. In array context, returns array of lines contained in the result.
• break_partial (STRING) — Instance method. Same as break() but accepts incremental inputs. Give undef as STRING argument to specify that input was completed.
• config (KEY) / config (KEY => VALUE, ...) — Instance method. Get or update configuration. About KEY => VALUE pairs, see “Options”.
• copy — Copy constructor. Create a copy of object instance.

🔎 Getting Informations 🔎

• breakingRule (BEFORESTR, AFTERSTR) — Instance method. Get possible line breaking behavior between strings BEFORESTR and AFTERSTR. See “Constants” for returned value.

Note: This method gives just approximate description of line breaking behavior. Use break() and so on to wrap actual texts.

• context ([Charset => CHARSET], [Language => LANGUAGE]) — Function. Get language/region context used by character set CHARSET or language LANGUAGE.

🎀 Options 🎀

new and config methods accept the following pairs. Some of them affect number of columns ([E]), grapheme cluster segmentation ([G]) (see also Unicode::GCString) or line breaking behavior ([L]). 💅

• BreakIndent => "YES" | "NO" — [L] Always allows break after SPACEs at beginning of line, a.k.a. indent. [UAX #14] does not take account of such usage of SPACE. Default is "YES".

Note: This option was introduced at release 1.011.

• CharMax => NUMBER — [L] Possible maximum number of characters in one line, not counting trailing SPACEs and newline sequence. Note that number of characters generally doesn’t represent length of line. Default is 998. 0 means unlimited (as of release 2012.01).
• ColMin => NUMBER — [L] Minimum number of columns which line broken arbitrarily may include, not counting trailing spaces and newline sequences. Default is 0.
• ColMax => NUMBER — [L] Maximum number of columns line may include not counting trailing spaces and newline sequence. In other words, maximum length of line. Default is 76.

See also the "Urgent" option and "User-Defined Breaking Behaviors".

• ComplexBreaking => "YES" | "NO" — [L] Performs heuristic breaking on South East Asian complex context. Default is, if word segmentation for South East Asian writing systems is enabled, "YES".
• Context => CONTEXT — [E][L] Specify language/region context. Currently available contexts are "EASTASIAN" and "NONEASTASIAN". Default context is "NONEASTASIAN".

In "EASTASIAN" context, characters with East_Asian_Width property ambiguous (A) are treated as "wide" and with Line Breaking Class AI as ideographic (ID).

In "NONEASTASIAN" context, characters with East_Asian_Width property ambiguous (A) are treated as "narrow" and with Line Breaking Class AI as alphabetic (AL).

• EAWidth => "[" ORD "=>" PROPERTY "]" / EAWidth => "undef" — [E] Tailor classification of East_Asian_Width property. ORD is UCS scalar value of character or array reference of them. PROPERTY is one of East_Asian_Width property values and extended values (see “Constants”). This option may be specified multiple times. If "undef" is specified, all tailoring assigned before will be canceled.

By default, no tailorings are available. See also “Tailoring Character Properties”.

• Format => METHOD — [L] Specify the method to format broken lines.
  • "SIMPLE" — Default method. Just only insert newline at arbitrary breaking positions.
  • "NEWLINE" — Insert or replace newline sequences with that specified by "Newline" option, remove SPACEs leading newline sequences or end-of-text. Then append newline at end of text if it does not exist.
  • "TRIM" — Insert newline at arbitrary breaking positions. Remove SPACEs leading newline sequences.
  • "undef" — Do nothing, even inserting any newlines.
  • Subroutine reference — See “Formatting Lines”.
• HangulAsAL => "YES" | "NO" — [L] Treat hangul syllables and conjoining jamos as alphabetic characters (AL). Default is "NO".
• LBClass => "[" ORD "=>" CLASS "]" / LBClass => "undef" — [G][L] Tailor classification of line breaking property. ORD is UCS scalar value of character or array reference of them. CLASS is one of line breaking classes (see “Constants”). This option may be specified multiple times. If "undef" is specified, all tailoring assigned before will be canceled.

By default, no tailorings are available. See also “Tailoring Character Properties”.

• LegacyCM => "YES" | "NO" — [G][L] Treat combining characters lead by a SPACE as an isolated combining character (ID). As of Unicode 5.0, such use of SPACE is not recommended. Default is "YES".
• Newline => STRING — [L] Unicode string to be used for newline sequence. Default is "\n".
• Prep => METHOD — [L] Add user-defined line breaking behavior(s). This option may be specified multiple times. Following methods are available.
  • "NONBREAKURI" — Won’t break URIs.
  • "BREAKURI" — Break URIs according to a rule suitable for printed materials. For more details see [CMOS], sections 6.17 and 17.11.
  • "[" REGEX, SUBREF "]" — The sequences matching regular expression REGEX will be broken by subroutine referred by SUBREF. For more details see “User-Defined Breaking Behaviors”.
  • "undef" — Cancel all methods assigned before.
• Sizing => METHOD — [L] Specify method to calculate size of string. Following options are available.
  • "UAX11" — Default method. Sizes are computed by columns of each characters according to built-in character database.
  • "undef" — Number of grapheme clusters (see Unicode::GCString) contained in the string.
  • Subroutine reference — See “Calculating String Size”.

See also "ColMax", "ColMin" and "EAWidth" options.

• Urgent => METHOD — [L] Specify method to handle excessing lines. Following options are available.
  • "CROAK" — Print error message and die.
  • "FORCE" — Force breaking excessing fragment.
  • "undef" — Default method. Won’t break excessing fragment.
  • Subroutine reference — See “User-Defined Breaking Behaviors”.
• ViramaAsJoiner => "YES" | "NO" — [G] Virama sign ("halant" in Hindi, "coeng" in Khmer) and its succeeding letter are not broken. Default is "YES".

Note: This option was introduced by release 2012.001_29. On previous releases, it was fixed to "NO". "Default" grapheme cluster defined by [UAX #29] does not include this feature.

🧮 Constants 🧮

• EA_Na, EA_N, EA_A, EA_W, EA_H, EA_F — Index values to specify six East_Asian_Width property values defined by [UAX #11]: narrow (Na), neutral (N), ambiguous (A), wide (W), halfwidth (H) and fullwidth (F).
• EA_Z — Index value to specify nonspacing characters.

Note: This "nonspacing" value is extension by this module, not a part of [UAX #11].

• LB_BK, LB_CR, LB_LF, LB_NL, LB_SP, LB_OP, LB_CL, LB_CP, LB_QU, LB_GL, LB_NS, LB_EX, LB_SY, LB_IS, LB_PR, LB_PO, LB_NU, LB_AL, LB_HL, LB_ID, LB_IN, LB_HY, LB_BA, LB_BB, LB_B2, LB_CB, LB_ZW, LB_CM, LB_WJ, LB_H2, LB_H3, LB_JL, LB_JV, LB_JT, LB_SG, LB_AI, LB_CJ, LB_SA, LB_XX, LB_RI — Index values to specify 40 line breaking property values (classes) defined by [UAX #14].

Note: Property value CP was introduced by Unicode 5.2.0. Property values HL and CJ were introduced by Unicode 6.1.0. Property value RI was introduced by Unicode 6.2.0.

• MANDATORY, DIRECT, INDIRECT, PROHIBITED — Four values to specify line breaking behaviors: Mandatory break; Both direct break and indirect break are allowed; Indirect break is allowed but direct break is prohibited; Prohibited break.
• Unicode::LineBreak::SouthEastAsian::supported — Flag to determin if word segmentation for South East Asian writing systems is enabled. If this feature was enabled, a non-empty string is set. Otherwise, undef is set.

N.B.: Current release supports Thai script of modern Thai language only.

• UNICODE_VERSION — A string to specify version of Unicode standard this module refers.

🦋 CUSTOMIZATION 🦋

✨ Formatting Lines ✨

If you specify subroutine reference as a value of "Format" option, it should accept three arguments:

$MODIFIED = &subroutine(SELF, EVENT, STR);

• "sot" — beginning of text — STR is the fragment of the first line 🌅
• "sop" — after a mandatory break — STR is the fragment of the next line
• "sol" — after an arbitrary break — STR is the fragment on the sequel of the line
• "" (empty string, yes really) — just before any breaks — STR is the complete line without trailing SPACEs
• "eol" — arbitrary break — STR is the SPACEs leading the breaking position
• "eop" — mandatory break — STR is the newline plus its leading SPACEs
• "eot" — end of text — STR is the SPACEs (and newline) at the end of the text

Your sub should return the modified text fragment, or it can return "undef" to say "nah, nothing changed, we're good" 💅

Heads up bestie: a modification made in the "sot", "sop" or "sol" context can affect the decision about successive breaking positions. In the other contexts, it won't. Lowkey important.

Note: those string arguments are actually sequences of grapheme clusters. See Unicode::GCString. 🦋

For example, this code folds lines and removes the trailing spaces:

sub fmt {
    if ($_[1] =~ /^eo/) {
        return "\n";
    }
    return undef;
}
my $lb = Unicode::LineBreak->new(Format => \&fmt);
$output = $lb->break($text);

---

🎀 User-Defined Breaking Behaviors

When a line that got generated by an arbitrary break is expected to go beyond the measure of either CharMax, ColMax or ColMin, an urgent break may be performed on the successive string. So if you hand a subroutine reference to the "Urgent" option, it needs to accept two arguments:

@BROKEN = &subroutine(SELF, STR);

SELF is a Unicode::LineBreak object and STR is a Unicode string that's gonna get broken. ✂️

The subroutine should return an array of the broken string STR.

Note: the string argument is actually a sequence of grapheme clusters. See Unicode::GCString.

For example, this code inserts a hyphen into the name of several chemical substances (Titin, we're looking at you 👀) so the thing can actually be folded:

sub hyphenize {
    return map {$_ =~ s/yl$/yl-/; $_} split /(\w+?yl(?=\w))/, $_[1];
}
my $lb = Unicode::LineBreak->new(Urgent => \&hyphenize);
$output = $lb->break("Methionylthreonylthreonylglutaminylarginyl...");

And if you pass a [REGEX, SUBREF] array reference as the value of any "Prep" option, the subroutine should accept two arguments too:

@BROKEN = &subroutine(SELF, STR);

SELF is a Unicode::LineBreak object and STR is the Unicode string that matched REGEX. The subroutine should return an array of the broken string STR.

For example, this code breaks HTTP URLs using the [CMOS] rule:

my $url = qr{http://[\x21-\x7E]+}i;
sub breakurl {
    my $self = shift;
    my $str = shift;
    return split m{(?<=[/]) (?=[^/]) |
                   (?<=[^-.]) (?=[-~.,_?\#%=&]) |
                   (?<=[=&]) (?=.)}x, $str;
}
my $lb = Unicode::LineBreak->new(Prep => [$url, \&breakurl]);
$output = $lb->break($string);

---

🧸 Preserving State

A Unicode::LineBreak object can literally behave like a hash reference — any items you stash in it get preserved for its whole life. Main character energy, honestly. 👑

For example, this code separates paragraphs with empty lines:

sub paraformat {
    my $self = shift;
    my $action = shift;
    my $str = shift;

    if ($action eq 'sot' or $action eq 'sop') {
        $self->{'line'} = '';
    } elsif ($action eq '') {
        $self->{'line'} = $str;
    } elsif ($action eq 'eol') {
        return "\n";
    } elsif ($action eq 'eop') {
        if (length $self->{'line'}) {
            return "\n\n";
        } else {
            return "\n";
        }
    } elsif ($action eq 'eot') {
        return "\n";
    }
    return undef;
}
my $lb = Unicode::LineBreak->new(Format => \&paraformat);
$output = $lb->break($string);

---

📐 Calculating String Size

If you give a subroutine reference as the value of the "Sizing" option, it gets called with five arguments:

$COLS = &subroutine(SELF, LEN, PRE, SPC, STR);

SELF is a Unicode::LineBreak object, LEN is the size of the preceding string, PRE is the preceding Unicode string, SPC is additional SPACEs, and STR is the Unicode string to be processed.

The subroutine should return the calculated number of columns of "PRE.SPC.STR". And plot twist: that number of columns doesn't have to be an integer — you can pick whatever unit you want, but it must be the same unit used by the "ColMin" and "ColMax" options. Consistency is the vibe. ✨

Note: string arguments are actually sequences of grapheme clusters. See Unicode::GCString.

For example, this code processes lines with tab stops every eight columns:

sub tabbedsizing {
    my ($self, $cols, $pre, $spc, $str) = @_;

    my $spcstr = $spc.$str;
    while ($spcstr->lbc == LB_SP) {
        my $c = $spcstr->item(0);
        if ($c eq "\t") {
            $cols += 8 - $cols % 8;
        } else {
            $cols += $c->columns;
        }
        $spcstr = $spcstr->substr(1);
    }
    $cols += $spcstr->columns;
    return $cols;
};
my $lb = Unicode::LineBreak->new(LBClass => [ord("\t") => LB_SP],
                                 Sizing => \&tabbedsizing);
$output = $lb->break($string);

---

🎨 Tailoring Character Properties

Character properties can be tailored using the "LBClass" and "EAWidth" options. And because nobody wants to type out a million code points, some constants are defined for your convenience. 🫶

🈁 Line Breaking Properties

🍡 Non-starters of Kana-like Characters

By default, several hiragana, katakana and characters corresponding to kana get treated as non-starters (NS or CJ). But when you specify the following pair(s) as the value of the "LBClass" option, those characters are treated as normal ideographic characters (ID).

• "KANA_NONSTARTERS() => LB_ID" — all of the characters below, in one go.
• "IDEOGRAPHIC_ITERATION_MARKS() => LB_ID" — the ideographic iteration marks: U+3005 IDEOGRAPHIC ITERATION MARK, U+303B VERTICAL IDEOGRAPHIC ITERATION MARK, U+309D HIRAGANA ITERATION MARK, U+309E HIRAGANA VOICED ITERATION MARK, U+30FD KATAKANA ITERATION MARK and U+30FE KATAKANA VOICED ITERATION MARK.

N.B. Some of them are neither hiragana nor katakana. Plot twist.

• "KANA_SMALL_LETTERS() => LB_ID"
• "KANA_PROLONGED_SOUND_MARKS() => LB_ID"

These cover hiragana or katakana small letters: hiragana small letters U+3041 A, U+3043 I, U+3045 U, U+3047 E, U+3049 O, U+3063 TU, U+3083 YA, U+3085 YU, U+3087 YO, U+308E WA, U+3095 KA, U+3096 KE. Katakana small letters U+30A1 A, U+30A3 I, U+30A5 U, U+30A7 E, U+30A9 O, U+30C3 TU, U+30E3 YA, U+30E5 YU, U+30E7 YO, U+30EE WA, U+30F5 KA, U+30F6 KE. Katakana phonetic extensions U+31F0 KU – U+31FF RO. Halfwidth katakana small letters U+FF67 A – U+FF6F TU.

Plus hiragana or katakana prolonged sound marks: U+30FC KATAKANA-HIRAGANA PROLONGED SOUND MARK and U+FF70 HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK.

N.B. These letters are optionally treated either as non-starter or as normal ideographic. See [JIS X 4051] 6.1.1, [JLREQ] 3.1.7 or [UAX14].

N.B. U+3095, U+3096, U+30F5, U+30F6 are considered to be neither hiragana nor katakana. They're just out here living their truth. 🙈

• "MASU_MARK() => LB_ID" — U+303C MASU MARK.

N.B. Even though this character is not kana, it's usually regarded as an abbreviation for the sequence of hiragana ま す or katakana マ ス, i.e. MA and SU.

N.B. This character is classified as non-starter (NS) by [UAX #14], and as the class corresponding to ID by [JIS X 4051] and [JLREQ]. She contains multitudes. 💅

💬 Ambiguous Quotation Marks

By default, some punctuations are ambiguous quotation marks (QU).

• "BACKWARD_QUOTES() => LB_OP, FORWARD_QUOTES() => LB_CL" — some languages (Dutch, English, Italian, Portugese, Spanish, Turkish and most East Asian) use rotated-9-style punctuations (‘ “) as opening and 9-style punctuations (’ ”) as closing quotation marks.
• "FORWARD_QUOTES() => LB_OP, BACKWARD_QUOTES() => LB_CL" — some others (Czech, German and Slovak) flip it: 9-style punctuations (’ ”) are opening and rotated-9-style punctuations (‘ “) are closing quotation marks.
• "BACKWARD_GUILLEMETS() => LB_OP, FORWARD_GUILLEMETS() => LB_CL" — French, Greek, Russian etc. use left-pointing guillemets (« ‹) as opening and right-pointing guillemets (» ›) as closing quotation marks.
• "FORWARD_GUILLEMETS() => LB_OP, BACKWARD_GUILLEMETS() => LB_CL" — German and Slovak use right-pointing guillemets (» ›) as opening and left-pointing guillemets (« ‹) as closing quotation marks.

And Danish, Finnish, Norwegian and Swedish? They use 9-style or right-pointing punctuations (’ ” » ›) as both opening and closing quotation marks. Ambidextrous queens. 👑

⬜ IDEOGRAPHIC SPACE

• "IDEOGRAPHIC_SPACE() => LB_BA" — U+3000 IDEOGRAPHIC SPACE won't be placed at the beginning of a line. This is the default behavior.
• "IDEOGRAPHIC_SPACE() => LB_ID" — IDEOGRAPHIC SPACE can be placed at the beginning of a line. This was the default behavior by Unicode 6.2 and earlier.
• "IDEOGRAPHIC_SPACE() => LB_SP" — IDEOGRAPHIC SPACE won't be placed at the beginning of a line, and will protrude from the end of the line. She's a little extra, we love her. 💖

🌏 East_Asian_Width Properties

Some particular letters of the Latin, Greek and Cyrillic scripts have the ambiguous (A) East_Asian_Width property. So by default these characters are treated as wide in the "EASTASIAN" context. But if you specify "EAWidth => [ AMBIGUOUS_"*"() => EA_N ]", those characters are always treated as narrow. Slay. ✨

• "AMBIGUOUS_ALPHABETICS() => EA_N" — treat all of the characters below as East_Asian_Width neutral (N).
• "AMBIGUOUS_CYRILLIC() => EA_N"
• "AMBIGUOUS_GREEK() => EA_N"
• "AMBIGUOUS_LATIN() => EA_N"

These treat letters having ambiguous (A) width of the Cyrillic, Greek and Latin scripts as neutral (N) respectively. 🧚

On the other hand — and this is the messy part — despite several characters being occasionally rendered as wide characters by a number of implementations for East Asian character sets, they're given the narrow (Na) East_Asian_Width property just because they have fullwidth (F) compatibility characters. So if you specify "EAWidth" as below, those characters get treated as ambiguous — i.e. wide in the "EASTASIAN" context. 🙃

• "QUESTIONABLE_NARROW_SIGNS() => EA_A" — U+00A2 CENT SIGN, U+00A3 POUND SIGN, U+00A5 YEN SIGN (or yuan sign), U+00A6 BROKEN BAR, U+00AC NOT SIGN, U+00AF MACRON.

🎛️ Configuration File 🎛️

okay so the built-in defaults for the option parameters of the new and config methods can be overridden by configuration files: Unicode/LineBreak/Defaults.pm. For the full tea, read Unicode/LineBreak/Defaults.pm.sample 💖.

---

🐛 BUGS 🐛

If you find bugs or buggy behavior, pls report them to the developer, bestie 🫶.

CPAN Request Tracker: <http://rt.cpan.org/Public/Dist/Display.html?Name=Unicode-LineBreak>.

---

📌 VERSION 📌

Consult the $VERSION variable ✨.

💥 Incompatible Changes 💥

🚨 Release 2012.06 🚨

• eawidth() method was deprecated. columns in Unicode::GCString may be used instead.
• lbclass() method was deprecated. Use lbc in Unicode::GCString or lbcext in Unicode::GCString.

🎯 Conformance to Standards 🎯

Character properties this module is based on are defined by Unicode Standard version 8.0.0. This module is intended to implement UAX14-C2 👑.

---

🛠️ IMPLEMENTATION NOTES 🛠️

• Some ideographic characters may be treated either as NS or as ID by choice.
• Hangul syllables and conjoining jamos may be treated as either ID or AL by choice.
• Characters assigned to AI may be resolved to either AL or ID by choice.
• Character(s) assigned to CB are not resolved.
• Characters assigned to CJ are always resolved to NS. More flexible tailoring mechanism is provided.
• When word segmentation for South East Asian writing systems is not supported, characters assigned to SA are resolved to AL, except that characters that have Grapheme_Cluster_Break property value Extend or SpacingMark be resolved to CM.
• Characters assigned to SG or XX are resolved to AL.
• Code points of following UCS ranges are given fixed property values even if they have not been assigned any characters.

Here's the fixed-property table, no cap:

               Ranges             | UAX #14    | UAX #11    | Description
               -------------------------------------------------------------
               U+20A0..U+20CF     | PR [*1]    | N [*2]     | Currency symbols
               U+3400..U+4DBF     | ID         | W          | CJK ideographs
               U+4E00..U+9FFF     | ID         | W          | CJK ideographs
               U+D800..U+DFFF     | AL (SG)    | N          | Surrogates
               U+E000..U+F8FF     | AL (XX)    | F or N (A) | Private use
               U+F900..U+FAFF     | ID         | W          | CJK ideographs
               U+20000..U+2FFFD   | ID         | W          | CJK ideographs
               U+30000..U+3FFFD   | ID         | W          | Old hanzi
               U+F0000..U+FFFFD   | AL (XX)    | F or N (A) | Private use
               U+100000..U+10FFFD | AL (XX)    | F or N (A) | Private use
               Other unassigned   | AL (XX)    | N          | Unassigned,
                                  |            |            | reserved or
                                  |            |            | noncharacters
               -------------------------------------------------------------
               [*1] Except U+20A7 PESETA SIGN (PO),
                 U+20B6 LIVRE TOURNOIS SIGN (PO), U+20BB NORDIC MARK SIGN (PO)
                 and U+20BE LARI SIGN (PO).
               [*2] Except U+20A9 WON SIGN (H) and U+20AC EURO SIGN
                 (F or N (A)).

• Characters belonging to General Category Mn, Me, Cc, Cf, Zl or Zp are treated as nonspacing by this module.

---

📚 REFERENCES 📚

• [CMOS] — The Chicago Manual of Style, 15th edition. University of Chicago Press, 2003.
• [JIS X 4051] — JIS X 4051:2004 日本語文書の組版方法 (Formatting Rules for Japanese Documents). Japanese Standards Association, 2004.
• [JLREQ] — Anan, Yasuhiro et al. Requirements for Japanese Text Layout, W3C Working Group Note 3 April 2012. <http://www.w3.org/TR/2012/NOTE-jlreq-20120403/>.
• [UAX #11] — A. Freytag (ed.) (2008-2009). Unicode Standard Annex #11: East Asian Width, Revisions 17-19. <http://unicode.org/reports/tr11/>.
• [UAX #14] — A. Freytag and A. Heninger (eds.) (2008-2015). Unicode Standard Annex #14: Unicode Line Breaking Algorithm, Revisions 22-35. <http://unicode.org/reports/tr14/>.
• [UAX #29] — Mark Davis (ed.) (2009-2013). Unicode Standard Annex #29: Unicode Text Segmentation, Revisions 15-23. <http://www.unicode.org/reports/tr29/>.

---

👀 SEE ALSO 👀

• Text::LineFold
• Text::Wrap
• Unicode::GCString

---

👑 AUTHOR 👑

Copyright (C) 2009-2018 Hatuka*nezumi - IKEDA Soji <hatuka(at)nezumi.nu>.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

---

Source/version perl v5.42.0 · date 2018-12-29 · page Unicode::LineBreak(3). That's the whole page, bestie — go forth and wrap some text 💖✨🦋