icuSources/data/brkitr/line_loose_cj.txt

   1 # Copyright (c) 2002-2015  International Business Machines Corporation and
   2 # others. All Rights Reserved.
   3 #
   4 #  file:  line_loose_cj.txt
   5 #
   6 #         Line Breaking Rules
   7 #         Implement default line breaking as defined by
   8 #         Unicode Standard Annex #14 Revision 29 for Unicode 6.2
   9 #         http://www.unicode.org/reports/tr14/
  10 #         tailored as noted in 2nd paragraph below..
  11 #
  12 #         TODO:  Rule LB 8 remains as it was in Unicode 5.2
  13 #         This is only because of a limitation of ICU break engine implementation,
  14 #         not because the older behavior is desirable.
  15 #
  16 #         This tailors the line break behavior to correspond to CSS
  17 #         line-break=loose (BCP47 -u-lb-loose) as defined for Chinese & Japanese.
  18 #         It sets characters of class CJ to behave like ID.
  19 #         In addition, it allows breaks:
  20 #         * before hyphens 2010 & 2013 (both BA) and 301C, 30A0 (both NS)
  21 #         * before iteration marks 3005, 303B, 309D, 309E, 30FD, 30FE (all NS)
  22 #         * between characters of LineBreak class IN such as 2026
  23 #         * before some centered punct 203C, 2047, 2048, 2049, 30FB, FF1A, FF1B,
  24 #           FF65 (all NS) and FF01, FF1F (both EX).
  25 #         * before suffix characters with LineBreak class PO and EastAsianWidth A,F,W;
  26 #           this includes: 00B0 2030 2032 2033 2035 2103 2109 FE6A FF05 FFE0
  27 #         * after prefix characters with LineBreak class PR and EastAsianWidth A,F,W;
  28 #           this includes: 00A4 00B1 20AC 2116 FE69 FF04 FFE1 FFE5 FFE6
  29
  30
  31 #
  32 #  Character Classes defined by TR 14.
  33 #
  34
  35 !!chain;
  36 !!LBCMNoChain;
  37
  38
  39 !!lookAheadHardBreak;
  40 #
  41 #  !!lookAheadHardBreak    Described here because it is (as yet) undocumented elsewhere
  42 #                          and only used for the line break rules.
  43 #
  44 #           It is used in the implementation of rule LB 10
  45 #           which says to treat any combining mark that is not attached to a base
  46 #           character as if it were of class AL  (alphabetic).
  47 #
  48 #           The problem occurs in the reverse rules.
  49 #
  50 #           Consider a sequence like, with correct breaks as shown
  51 #               LF  ID  CM  AL  AL
  52 #                  ^       ^       ^
  53 #           Then consider the sequence without the initial ID (ideographic)
  54 #                 LF  CM  AL  AL
  55 #                    ^           ^
  56 #           Our CM, which in the first example was attached to the ideograph,
  57 #           is now unattached, becomes an alpha, and joins in with the other
  58 #           alphas.
  59 #
  60 #           When iterating forwards, these sequences do not present any problems
  61 #           When iterating backwards, we need to look ahead when encountering
  62 #           a CM to see whether it attaches to something further on or not.
  63 #           (Look-ahead in a reverse rule is looking towards the start)
  64 #
  65 #           If the CM is unattached, we need to force a break.
  66 #
  67 #           !!lookAheadHardBreak forces the run time state machine to
  68 #           stop immediately when a look ahead rule ( '/' operator) matches,
  69 #           and set the match position to that of the look-ahead operator,
  70 #           no matter what other rules may be in play at the time.
  71 #
  72 #           See rule LB 19 for an example.
  73 #
  74
  75 $AI = [:LineBreak =  Ambiguous:];
  76 $AL = [:LineBreak =  Alphabetic:];
  77 $BAX = [\u2010 \u2013];
  78 $BA = [[:LineBreak =  Break_After:] - $BAX];
  79 $BB = [:LineBreak =  Break_Before:];
  80 $BK = [:LineBreak =  Mandatory_Break:];
  81 $B2 = [:LineBreak =  Break_Both:];
  82 $CB = [:LineBreak =  Contingent_Break:];
  83 $CJ = [:LineBreak =  Conditional_Japanese_Starter:];
  84 $CL = [:LineBreak =  Close_Punctuation:];
  85 $CM = [:LineBreak =  Combining_Mark:];
  86 $CP = [:LineBreak =  Close_Parenthesis:];
  87 $CR = [:LineBreak =  Carriage_Return:];
  88 $EXX = [\uFF01 \uFF1F];
  89 $EX = [[:LineBreak =  Exclamation:] - $EXX];
  90 $GL = [:LineBreak =  Glue:];
  91 $HL = [:LineBreak =  Hebrew_Letter:];
  92 $HY = [:LineBreak =  Hyphen:];
  93 $H2 = [:LineBreak =  H2:];
  94 $H3 = [:LineBreak =  H3:];
  95 $ID = [[:LineBreak =  Ideographic:] $CJ];
  96 $IN = [:LineBreak =  Inseperable:];
  97 $IS = [:LineBreak =  Infix_Numeric:];
  98 $JL = [:LineBreak =  JL:];
  99 $JV = [:LineBreak =  JV:];
 100 $JT = [:LineBreak =  JT:];
 101 $LF = [:LineBreak =  Line_Feed:];
 102 $NL = [:LineBreak =  Next_Line:];
 103 $NSX = [\u301C \u30A0 \u3005 \u303B \u309D \u309E \u30FD \u30FE \u203C \u2047 \u2048 \u2049 \u30FB \uFF1A \uFF1B \uFF65];
 104 $NS = [[:LineBreak =  Nonstarter:] - $NSX];
 105 $NU = [:LineBreak =  Numeric:];
 106 $OP = [:LineBreak =  Open_Punctuation:];
 107 $POX = [\u00B0 \u2030 \u2032 \u2033 \u2035 \u2103 \u2109 \uFE6A \uFF05 \uFFE0];
 108 $PO = [[:LineBreak =  Postfix_Numeric:] - $POX];
 109 $PRX = [\u00A4 \u00B1 \u20AC \u2116 \uFE69 \uFF04 \uFFE1 \uFFE5 \uFFE6];
 110 $PR = [[:LineBreak =  Prefix_Numeric:] - $PRX];
 111 $QU = [:LineBreak =  Quotation:];
 112 $RI = [:LineBreak =  Regional_Indicator:];
 113 $SA = [:LineBreak =  Complex_Context:];
 114 $SG = [:LineBreak =  Surrogate:];
 115 $SP = [:LineBreak =  Space:];
 116 $SY = [:LineBreak =  Break_Symbols:];
 117 $WJ = [:LineBreak =  Word_Joiner:];
 118 $XX = [:LineBreak =  Unknown:];
 119 $ZW = [:LineBreak =  ZWSpace:];
 120
 121 # Special character classes for people & body part emoji:
 122 # Subsets of $CM:
 123 $ZWJ = \u200D;
 124 $EmojiVar = \uFE0F;
 125 # The following are subsets of $ID
 126 $EmojiForSeqs = [\u2764 \U0001F441 \U0001F466-\U0001F469 \U0001F48B \U0001F5E8];
 127 $EmojiForMods = [\u261D \u26F9 \u270A-\u270D \U0001F385 \U0001F3C3-\U0001F3C4 \U0001F3CA-\U0001F3CB \U0001F442-\U0001F443 \U0001F446-\U0001F450 \U0001F466-\U0001F469 \U0001F46E-\U0001F478 \U0001F47C \U0001F481-\U0001F483 \U0001F485-\U0001F487 \U0001F4AA \U0001F575 \U0001F590 \U0001F595 \U0001F596 \U0001F645-\U0001F647 \U0001F64B-\U0001F64F \U0001F6A3 \U0001F6B4-\U0001F6B6 \U0001F6C0 \U0001F918];
 128 $EmojiMods = [\U0001F3FB-\U0001F3FF];
 129
 130 #   Dictionary character set, for triggering language-based break engines. Currently
 131 #   limited to LineBreak=Complex_Context. Note that this set only works in Unicode
 132 #   5.0 or later as the definition of Complex_Context was corrected to include all
 133 #   characters requiring dictionary break.
 134
 135 $dictionary = [:LineBreak = Complex_Context:];
 136
 137 #
 138 #  Rule LB1.  By default, treat AI  (characters with ambiguous east Asian width),
 139 #                               SA  (South East Asian: Thai, Lao, Khmer)
 140 #                               SG  (Unpaired Surrogates)
 141 #                               XX  (Unknown, unassigned)
 142 #                         as $AL  (Alphabetic)
 143 #
 144 $ALPlus = [$AL $AI $SA $SG $XX];
 145
 146 #
 147 #  Combining Marks.   X $CM*  behaves as if it were X.  Rule LB6.
 148 #
 149 $ALcm = $ALPlus $CM*;
 150 $BAcm = $BA $CM*;
 151 $BAXcm = $BAX $CM*;
 152 $BBcm = $BB $CM*;
 153 $B2cm = $B2 $CM*;
 154 $CLcm = $CL $CM*;
 155 $CPcm = $CP $CM*;
 156 $EXcm = $EX $CM*;
 157 $EXXcm = $EXX $CM*;
 158 $GLcm = $GL $CM*;
 159 $HLcm = $HL $CM*;
 160 $HYcm = $HY $CM*;
 161 $H2cm = $H2 $CM*;
 162 $H3cm = $H3 $CM*;
 163 $IDcm = $ID $CM*;
 164 $INcm = $IN $CM*;
 165 $IScm = $IS $CM*;
 166 $JLcm = $JL $CM*;
 167 $JVcm = $JV $CM*;
 168 $JTcm = $JT $CM*;
 169 $NScm = $NS $CM*;
 170 $NSXcm = $NSX $CM*;
 171 $NUcm = $NU $CM*;
 172 $OPcm = $OP $CM*;
 173 $POcm = $PO $CM*;
 174 $POXcm = $POX $CM*;
 175 $PRcm = $PR $CM*;
 176 $PRXcm = $PRX $CM*;
 177 $QUcm = $QU $CM*;
 178 $RIcm = $RI $CM*;
 179 $SYcm = $SY $CM*;
 180 $WJcm = $WJ $CM*;
 181
 182 ## -------------------------------------------------
 183
 184 !!forward;
 185
 186 #
 187 #  Each class of character can stand by itself as an unbroken token, with trailing combining stuff
 188 #
 189 $ALPlus $CM+;
 190 $BA $CM+;
 191 $BAX $CM+;
 192 $BB $CM+;
 193 $B2 $CM+;
 194 $CL $CM+;
 195 $CP $CM+;
 196 $EX $CM+;
 197 $EXX $CM+;
 198 $GL $CM+;
 199 $HL $CM+;
 200 $HY $CM+;
 201 $H2 $CM+;
 202 $H3 $CM+;
 203 $ID $CM+;
 204 $IN $CM+;
 205 $IS $CM+;
 206 $JL $CM+;
 207 $JV $CM+;
 208 $JT $CM+;
 209 $NS $CM+;
 210 $NSX $CM+;
 211 $NU $CM+;
 212 $OP $CM+;
 213 $PO $CM+;
 214 $POX $CM+;
 215 $PR $CM+;
 216 $PRX $CM+;
 217 $QU $CM+;
 218 $RI $CM+;
 219 $SY $CM+;
 220 $WJ $CM+;
 221
 222 #
 223 # CAN_CM  is the set of characters that may combine with CM combining chars.
 224 #         Note that Linebreak UAX 14's concept of a combining char and the rules
 225 #         for what they can combine with are _very_ different from the rest of Unicode.
 226 #
 227 #         Note that $CM itself is left out of this set.  If CM is needed as a base
 228 #         it must be listed separately in the rule.
 229 #
 230 $CAN_CM  = [^$SP $BK $CR $LF $NL $ZW $CM];       # Bases that can   take CMs
 231 $CANT_CM = [ $SP $BK $CR $LF $NL $ZW $CM];       # Bases that can't take CMs
 232
 233 #
 234 # AL_FOLLOW  set of chars that can unconditionally follow an AL
 235 #            Needed in rules where stand-alone $CM s are treated as AL.
 236 #            Chaining is disabled with CM because it causes other failures,
 237 #            so for this one case we need to manually list out longer sequences.
 238 #
 239 $AL_FOLLOW_NOCM = [$BK $CR $LF $NL $ZW $SP];
 240 $AL_FOLLOW_CM   = [$CL $CP $EX $EXX $HL $IS $SY $WJ $GL $OP $QU $BA $BAX $HY $NS $NSX $IN $NU $ALPlus];
 241 $AL_FOLLOW      = [$AL_FOLLOW_NOCM $AL_FOLLOW_CM];
 242
 243
 244 #
 245 #  Rule LB 4, 5    Mandatory (Hard) breaks.
 246 #
 247 $LB4Breaks    = [$BK $CR $LF $NL];
 248 $LB4NonBreaks = [^$BK $CR $LF $NL];
 249 $CR $LF {100};
 250
 251 #
 252 #  LB 6    Do not break before hard line breaks.
 253 #
 254 $LB4NonBreaks?  $LB4Breaks {100};    # LB 5  do not break before hard breaks.
 255 $CAN_CM $CM*    $LB4Breaks {100};
 256 $CM+            $LB4Breaks {100};
 257
 258 # LB 7         x SP
 259 #              x ZW
 260 $LB4NonBreaks [$SP $ZW];
 261 $CAN_CM $CM*  [$SP $ZW];
 262 $CM+          [$SP $ZW];
 263
 264 #
 265 # LB 8         Break after zero width space
 266 #              TODO:  ZW SP* <break>
 267 #              An engine change is required to write the reverse rule for this.
 268 #              For now, leave the Unicode 5.2 rule, ZW <break>
 269 #
 270 $LB8Breaks    = [$LB4Breaks $ZW];
 271 $LB8NonBreaks = [[$LB4NonBreaks] - [$ZW]];
 272
 273
 274 # Special forward rule for people & body part emoji:
 275 # don't break $ZWJ from subsequent $EmojiForSeqs
 276 $EmojiForSeqs $EmojiVar? $EmojiMods? $ZWJ $EmojiForSeqs;
 277
 278 # LB 9     Combining marks.      X   $CM needs to behave like X, where X is not $SP, $BK $CR $LF $NL
 279 #                                $CM not covered by the above needs to behave like $AL
 280 #                                See definition of $CAN_CM.
 281
 282 $CAN_CM $CM+;                   #  Stick together any combining sequences that don't match other rules.
 283 $CM+;
 284
 285 #
 286 # LB 11  Do not break before or after WORD JOINER & related characters.
 287 #
 288 $CAN_CM $CM*  $WJcm;
 289 $LB8NonBreaks $WJcm;
 290 $CM+          $WJcm;
 291
 292 $WJcm $CANT_CM;
 293 $WJcm $CAN_CM $CM*;
 294
 295 #
 296 # LB 12  Do not break after NBSP and related characters.
 297 #         GL  x
 298 #
 299 $GLcm $CAN_CM $CM*;
 300 $GLcm $CANT_CM;
 301
 302 #
 303 # LB 12a  Do not break before NBSP and related characters ...
 304 #            [^SP BA HY] x GL
 305 #
 306 [[$LB8NonBreaks] - [$SP $BA $BAX $HY]] $CM* $GLcm;
 307 $CM+ GLcm;
 308
 309
 310
 311 #
 312 # LB 13   Don't break before ']' or '!' or ';' or '/', even after spaces.
 313 #
 314 # Do not include $EXX here
 315 $LB8NonBreaks $CL;
 316 $CAN_CM $CM*  $CL;
 317 $CM+          $CL;              # by rule 10, stand-alone CM behaves as AL
 318
 319 $LB8NonBreaks $CP;
 320 $CAN_CM $CM*  $CP;
 321 $CM+          $CP;              # by rule 10, stand-alone CM behaves as AL
 322
 323 $LB8NonBreaks $EX;
 324 $CAN_CM $CM*  $EX;
 325 $CM+          $EX;              # by rule 10, stand-alone CM behaves as AL
 326
 327 $LB8NonBreaks $IS;
 328 $CAN_CM $CM*  $IS;
 329 $CM+          $IS;              # by rule 10, stand-alone CM behaves as AL
 330
 331 $LB8NonBreaks $SY;
 332 $CAN_CM $CM*  $SY;
 333 $CM+          $SY;              # by rule 10, stand-alone CM behaves as AL
 334
 335
 336 #
 337 # LB 14  Do not break after OP, even after spaces
 338 #
 339 $OPcm $SP* $CAN_CM $CM*;
 340 $OPcm $SP* $CANT_CM;
 341
 342 $OPcm $SP+ $CM+ $AL_FOLLOW?;    # by rule 10, stand-alone CM behaves as AL
 343
 344 # LB 15
 345 $QUcm $SP* $OPcm;
 346
 347 # LB 16
 348 # Do not break between closing punctuation and $NS, even with intervening spaces
 349 # But DO allow a break between closing punctuation and $NSX, don't include it here
 350 ($CLcm | $CPcm) $SP* $NScm;
 351
 352 # LB 17
 353 $B2cm $SP* $B2cm;
 354
 355 #
 356 # LB 18  Break after spaces.
 357 #
 358 $LB18NonBreaks = [$LB8NonBreaks - [$SP]];
 359 $LB18Breaks    = [$LB8Breaks $SP];
 360
 361
 362 # LB 19
 363 #         x QU
 364 $LB18NonBreaks $CM* $QUcm;
 365 $CM+                $QUcm;
 366
 367 #         QU  x
 368 $QUcm .?;
 369 $QUcm $LB18NonBreaks $CM*;    # Don't let a combining mark go onto $CR, $BK, etc.
 370                               #  TODO:  I don't think this rule is needed.
 371
 372
 373 # LB 20
 374 #        <break>  $CB
 375 #        $CB   <break>
 376
 377 $LB20NonBreaks = [$LB18NonBreaks - $CB];
 378
 379 # LB 21        x   (BA | HY | NS)
 380 #           BB x
 381 #
 382 # DO allow breaks here before $BAXcm and $NSXcm, so don't include them
 383 $LB20NonBreaks $CM* ($BAcm | $HYcm | $NScm);
 384
 385 $BBcm [^$CB];                                  #  $BB  x
 386 $BBcm $LB20NonBreaks $CM*;
 387
 388 # LB 21a Don't break after Hebrew + Hyphen
 389 #   HL (HY | BA) x
 390 #
 391 $HLcm ($HYcm | $BAcm | $BAXcm) [^$CB]?;
 392
 393 # LB 21b (forward) Don't break between SY and HL
 394 # (break between HL and SY already disallowed by LB 13 above)
 395 $SYcm $HLcm;
 396
 397 # LB 22
 398 ($ALcm | $HLcm) $INcm;
 399 $CM+     $INcm;     #  by rule 10, any otherwise unattached CM behaves as AL
 400 $IDcm    $INcm;
 401 # $INcm  $INcm; # delete this rule for CSS loose
 402 $NUcm    $INcm;
 403
 404
 405 # LB 23
 406 # Do not include $POX here
 407 $IDcm  $POcm;
 408 $ALcm  $NUcm;       # includes $LB19
 409 $HLcm  $NUcm;
 410 $CM+   $NUcm;       # Rule 10, any otherwise unattached CM behaves as AL
 411 $NUcm  $ALcm;
 412 $NUcm  $HLcm;
 413
 414 #
 415 # LB 24
 416 #
 417 # Do not include $PRX here
 418 $PRcm $IDcm;
 419 $PRcm ($ALcm | $HLcm);
 420 ($POcm | $POXcm) ($ALcm | $HLcm);
 421
 422 #
 423 # LB 25   Numbers.
 424 #
 425 # Here do not include $PRX at the beginning or $POX at the end
 426 ($PRcm | $POcm | $POXcm)? ($OPcm | $HYcm)? $NUcm ($NUcm | $SYcm | $IScm)* ($CLcm | $CPcm)? ($PRcm | $PRXcm | $POcm)?;
 427
 428 # LB 26  Do not break a Korean syllable
 429 #
 430 $JLcm ($JLcm | $JVcm | $H2cm | $H3cm);
 431 ($JVcm | $H2cm) ($JVcm | $JTcm);
 432 ($JTcm | $H3cm) $JTcm;
 433
 434 # LB 27  Treat korean Syllable Block the same as ID  (don't break it)
 435 # Do not include $POX or $PRX here
 436 ($JLcm | $JVcm | $JTcm | $H2cm | $H3cm) $INcm;
 437 ($JLcm | $JVcm | $JTcm | $H2cm | $H3cm) $POcm;
 438 $PRcm ($JLcm | $JVcm | $JTcm | $H2cm | $H3cm);
 439
 440
 441 # LB 28   Do not break between alphabetics
 442 #
 443 ($ALcm | $HLcm) ($ALcm | $HLcm);
 444 $CM+ ($ALcm | $HLcm);      # The $CM+ is from rule 10, an unattached CM is treated as AL
 445
 446 # LB 29
 447 $IScm ($ALcm | $HLcm);
 448
 449 # LB 30
 450 ($ALcm | $HLcm | $NUcm) $OPcm;
 451 $CM+ $OPcm;         # The $CM+ is from rule 10, an unattached CM is treated as AL.
 452 $CPcm ($ALcm | $HLcm | $NUcm);
 453
 454 # LB 30a  Do not break between regional indicators.
 455 $RIcm $RIcm;
 456
 457 # Special forward rule for people & body part emoji:
 458 # don't break between relevant emoji and $EmojiMods
 459 $EmojiForMods $EmojiVar? $EmojiMods;
 460
 461 #
 462 #  Reverse Rules.
 463 #
 464 ## -------------------------------------------------
 465
 466 !!reverse;
 467
 468 $CM+ $ALPlus;
 469 $CM+ $BA;
 470 $CM+ $BAX;
 471 $CM+ $BB;
 472 $CM+ $B2;
 473 $CM+ $CL;
 474 $CM+ $CP;
 475 $CM+ $EX;
 476 $CM+ $EXX;
 477 $CM+ $GL;
 478 $CM+ $HL;
 479 $CM+ $HY;
 480 $CM+ $H2;
 481 $CM+ $H3;
 482 $CM+ $ID;
 483 $CM+ $IN;
 484 $CM+ $IS;
 485 $CM+ $JL;
 486 $CM+ $JV;
 487 $CM+ $JT;
 488 $CM+ $NS;
 489 $CM+ $NSX;
 490 $CM+ $NU;
 491 $CM+ $OP;
 492 $CM+ $PO;
 493 $CM+ $POX;
 494 $CM+ $PR;
 495 $CM+ $PRX;
 496 $CM+ $QU;
 497 $CM+ $RI;
 498 $CM+ $SY;
 499 $CM+ $WJ;
 500 $CM+;
 501
 502
 503 #
 504 #  Sequences of the form  (shown forwards)
 505 #      [CANT_CM]  <break>  [CM]  [whatever]
 506 #  The CM needs to behave as an AL
 507 #
 508 $AL_FOLLOW $CM+ / (
 509           [$BK $CR $LF $NL $ZW {eof}] |
 510           $SP+ $CM+ $SP |
 511           $SP+ $CM* ([^$OP $CM $SP] | [$AL {eof}]));   # if LB 14 will match, need to surpress this break.
 512                                                #  LB14 says    OP SP* x .
 513                                                #    becomes    OP SP* x AL
 514                                                #    becomes    OP SP* x CM+ AL_FOLLOW
 515                                                #
 516                                                # Further note:  the $AL in [$AL {eof}] is only to work around
 517                                                #                a rule compiler bug which complains about
 518                                                #                empty sets otherwise.
 519
 520 #
 521 #  Sequences of the form  (shown forwards)
 522 #      [CANT_CM]  <break> [CM]  <break>  [PR]
 523 #  The CM needs to behave as an AL
 524 #  This rule is concerned about getting the second of the two <breaks> in place.
 525 #
 526
 527 [$PR $PRX  ] / $CM+ [$BK $CR $LF $NL $ZW $SP {eof}];
 528
 529
 530
 531 # LB 4, 5, 5
 532
 533 $LB4Breaks [$LB4NonBreaks-$CM];
 534 $LB4Breaks $CM+ $CAN_CM;
 535 $LF $CR;
 536
 537
 538 # LB 7         x SP
 539 #              x ZW
 540 [$SP $ZW] [$LB4NonBreaks-$CM];
 541 [$SP $ZW] $CM+ $CAN_CM;
 542
 543 # LB 8 ZW SP* <break>
 544 #     TODO: to implement this, we need more than one look-ahead hard break in play at a time.
 545 #           Requires an engine enhancement.
 546 #   / $SP* $ZW
 547
 548 # Special reverse rule for people & body part emoji:
 549 # don't break $ZWJ from subsequent $EmojiForSeqs
 550 $EmojiForSeqs $ZWJ $EmojiMods? $EmojiVar? $EmojiForSeqs;
 551
 552 # LB 9,10  Combining marks.
 553 #    X   $CM needs to behave like X, where X is not $SP or controls.
 554 #    $CM not covered by the above needs to behave like $AL
 555 # Stick together any combining sequences that don't match other rules.
 556 $CM+ $CAN_CM;
 557
 558
 559 # LB 11
 560 $CM* $WJ $CM* $CAN_CM;
 561 $CM* $WJ      [$LB8NonBreaks-$CM];
 562
 563      $CANT_CM $CM* $WJ;
 564 $CM* $CAN_CM  $CM* $WJ;
 565
 566 # LB 12a
 567 #      [^SP BA HY] x GL
 568 #
 569 $CM* $GL $CM* [$LB8NonBreaks-[$CM $SP $BA $BAX $HY]];
 570
 571 # LB 12
 572 #     GL  x
 573 #
 574 $CANT_CM $CM* $GL;
 575 $CM* $CAN_CM $CM* $GL;
 576
 577
 578 # LB 13
 579 # Do not include $EXX here
 580 $CL $CM+ $CAN_CM;
 581 $CP $CM+ $CAN_CM;
 582 $EX $CM+ $CAN_CM;
 583 $IS $CM+ $CAN_CM;
 584 $SY $CM+ $CAN_CM;
 585
 586 $CL [$LB8NonBreaks-$CM];
 587 $CP [$LB8NonBreaks-$CM];
 588 $EX [$LB8NonBreaks-$CM];
 589 $IS [$LB8NonBreaks-$CM];
 590 $SY [$LB8NonBreaks-$CM];
 591
 592 # Rule 13 & 14 taken together for an edge case.
 593 #   Match this, shown forward
 594 #     OP SP+  ($CM+ behaving as $AL) (CL | CP | EX | IS | IY)
 595 #   This really wants to chain at the $CM+ (which is acting as an $AL)
 596 #   except for $CM chaining being disabled.
 597 [$CL $CP $EX $IS $SY] $CM+ $SP+ $CM* $OP;
 598
 599 # LB 14    OP SP* x
 600 #
 601 $CM* $CAN_CM    $SP* $CM* $OP;
 602      $CANT_CM   $SP* $CM* $OP;
 603 $AL_FOLLOW? $CM+  $SP $SP* $CM* $OP;     #  by LB 10, behaves like $AL_FOLLOW? $AL $SP* $CM* $OP
 604
 605      $AL_FOLLOW_NOCM $CM+ $SP+ $CM* $OP;
 606 $CM* $AL_FOLLOW_CM   $CM+ $SP+ $CM* $OP;
 607 $SY $CM $SP+ $OP;   # TODO:  Experiment.  Remove.
 608
 609
 610
 611 # LB 15
 612 $CM* $OP $SP* $CM* $QU;
 613
 614 # LB 16
 615 # Don't include $NSX here
 616 $CM* $NS $SP* $CM* ($CL | $CP);
 617
 618 # LB 17
 619 $CM* $B2 $SP* $CM* $B2;
 620
 621 # LB 18  break after spaces
 622 #        Nothing explicit needed here.
 623
 624
 625 #
 626 # LB 19
 627 #
 628 $CM* $QU $CM* $CAN_CM;                                #   . x QU
 629 $CM* $QU      $LB18NonBreaks;
 630
 631
 632 $CM* $CAN_CM  $CM* $QU;                               #   QU x .
 633      $CANT_CM $CM* $QU;
 634
 635 #
 636 #  LB 20  Break before and after CB.
 637 #         nothing needed here.
 638 #
 639
 640 # LB 21
 641 # Don't include $BAX or $NSX here
 642 $CM* ($BA | $HY | $NS) $CM* [$LB20NonBreaks-$CM];     #  . x (BA | HY | NS)
 643
 644 $CM* [$LB20NonBreaks-$CM] $CM* $BB;                   #  BB x .
 645 [^$CB] $CM* $BB;                                      #
 646
 647 # LB21a
 648 [^$CB] $CM* ($HY | $BA | $BAX) $CM* $HL;
 649
 650 # LB21b (reverse)
 651 $CM* $HL $CM* $SY;
 652
 653 # LB 22
 654 $CM* $IN $CM* ($ALPlus | $HL);
 655 $CM* $IN $CM* $ID;
 656 # $CM* $IN $CM* $IN; # delete this rule for CSS loose
 657 $CM* $IN $CM* $NU;
 658
 659 # LB 23
 660 # Do not include $POX here
 661 $CM* $PO $CM* $ID;
 662 $CM* $NU $CM* ($ALPlus | $HL);
 663 $CM* ($ALPlus | $HL) $CM* $NU;
 664
 665 # LB 24
 666 # Do not include $PRX here
 667 $CM* $ID $CM* $PR;
 668 $CM* ($ALPlus | $HL) $CM* $PR;
 669 $CM* ($ALPlus | $HL) $CM* ($PO | $POX);
 670
 671
 672 # LB 25
 673 # Here do not include $POX at the beginning or $PRX at the end
 674 ($CM* ($PR | $PRX | $PO))? ($CM* ($CL | $CP))? ($CM* ($NU | $IS | $SY))* $CM* $NU ($CM* ($OP | $HY))? ($CM* ($PR | $PO | $POX))?;
 675
 676 # LB 26
 677 $CM* ($H3 | $H2 | $JV | $JL) $CM* $JL;
 678 $CM* ($JT | $JV) $CM* ($H2 | $JV);
 679 $CM* $JT $CM* ($H3 | $JT);
 680
 681 # LB 27
 682 # Do not include $POX or $PRX here
 683 $CM* $IN $CM* ($H3 | $H2 | $JT | $JV | $JL);
 684 $CM* $PO $CM* ($H3 | $H2 | $JT | $JV | $JL);
 685 $CM* ($H3 | $H2 | $JT | $JV | $JL) $CM* $PR;
 686
 687 # LB 28
 688 $CM* ($ALPlus | $HL) $CM* ($ALPlus | $HL);
 689
 690
 691 # LB 29
 692 $CM* ($ALPlus | $HL) $CM* $IS;
 693
 694 # LB 30
 695 $CM* $OP $CM* ($ALPlus | $HL | $NU);
 696 $CM* ($ALPlus | $HL | $NU) $CM* $CP;
 697
 698 # LB 30a
 699 $CM* $RI $CM* $RI;
 700
 701 # Special reverse rule for people & body part emoji:
 702 # don't break between relevant emoji and $EmojiMods
 703 $EmojiMods $EmojiVar? $EmojiForMods;
 704
 705 ## -------------------------------------------------
 706
 707 !!safe_reverse;
 708
 709 # LB 9
 710 $CM+ [^$CM $BK $CR $LF $NL $ZW $SP];
 711 $CM+ $SP / .;
 712
 713 # LB 14
 714 $SP+ $CM* $OP;
 715
 716 # LB 15
 717 $SP+ $CM* $QU;
 718
 719 # LB 16
 720 $SP+ $CM* ($CL | $CP);
 721
 722 # LB 17
 723 $SP+ $CM* $B2;
 724
 725 # LB 21
 726 $CM* ($HY | $BA) $CM* $HL;
 727
 728 # LB 25
 729 ($CM* ($IS | $SY))+ $CM* $NU;
 730 ($CL | $CP) $CM* ($NU | $IS | $SY);
 731
 732 # For dictionary-based break
 733 $dictionary $dictionary;
 734
 735 ## -------------------------------------------------
 736
 737 !!safe_forward;
 738
 739 # Skip forward over all character classes that are involved in
 740 #   rules containing patterns with possibly more than one char
 741 #   of context.
 742 #
 743 #  It might be slightly more efficient to have specific rules
 744 #  instead of one generic one, but only if we could
 745 #  turn off rule chaining.  We don't want to move more
 746 #  than necessary.
 747 #
 748 [$CM $OP $QU $CL $CP $B2 $PR $PRX $HY $BA $SP $dictionary]+ [^$CM $OP $QU $CL $CP $B2 $PR $PRX $HY $BA $dictionary];
 749 $dictionary $dictionary;
 750