ICU_MAJOR=73

ICU_MAJOR=74

ICU_MINOR=2

ICU_MINOR=1

ICU_SHA256SUM := 818a80712ed3caacd9b652305e01afc7fa167e6f2e94996da44b90c2ab604ce1

ICU_SHA256SUM := 86ce8e60681972e60e4dcb2490c697463fcec60dd400a5f9bffba26d0b52b8d0

ICU_TARBALL := icu4c-73_2-src.tgz

ICU_TARBALL := icu4c-74_1-src.tgz

ICU_DATA_SHA256SUM := ca1ee076163b438461e484421a7679fc33a64cd0a54f9d4b401893fa1eb42701

ICU_DATA_SHA256SUM := 67d5ab39c5187e1dd0fed60a3fe52794dce9784b4c045cb85e19f5d317fd783f

ICU_DATA_TARBALL := icu4c-73_2-data.zip

ICU_DATA_TARBALL := icu4c-74_1-data.zip

# Copyright (c) 2002-2006  International Business Machines Corporation and

# Copyright (C) 2016 and later: Unicode, Inc. and others.

# License & terms of use: http://www.unicode.org/copyright.html

# Copyright (c) 2002-2016  International Business Machines Corporation and

#         Implement default line breaking as defined by Unicode Standard Annex #14 version 5.0.0

#         Implement default line breaking as defined by

#         http://www.unicode.org/reports/tr14/

#         Unicode Standard Annex #14 (https://www.unicode.org/reports/tr14/)

#         for Unicode 14.0, with the following modification:

#

#         Boundaries between hyphens and following letters are suppressed when

#         there is a boundary preceding the hyphen. See rule 20.9

#

#         This corresponds to CSS line-break=strict (BCP47 -u-lb-strict).

#         It sets characters of class CJ to behave like NS.

!!LBCMNoChain;

!!quoted_literals_only;

!!lookAheadHardBreak;

#

#  !!lookAheadHardBreak    Described here because it is (as yet) undocumented elsewhere

#                          and only used for the line break rules.

#

#           It is used in the implementation of the incredibly annoying rule LB 10

#           which says to treat any combining mark that is not attached to a base

#           character as if it were of class AL  (alphabetic).

#

#           The problem occurs in the reverse rules.

#

#           Consider a sequence like, with correct breaks as shown

#               LF  ID  CM  AL  AL

#                  ^       ^       ^

#           Then consider the sequence without the initial ID (ideographic)

#                 LF  CM  AL  AL

#                    ^           ^

#           Our CM, which in the first example was attached to the ideograph,

#           is now unattached, becomes an alpha, and joins in with the other

#           alphas.

#

#           When iterating forwards, these sequences do not present any problems

#           When iterating backwards, we need to look ahead when encountering

#           a CM to see whether it attaches to something further on or not.

#           (Look-ahead in a reverse rule is looking towards the start)

#

#           If the CM is unattached, we need to force a break.

#

#           !!lookAheadHardBreak forces the run time state machine to

#           stop immediately when a look ahead rule ( '/' operator) matches,

#           and set the match position to that of the look-ahead operator,

#           no matter what other rules may be in play at the time.

#

#           See rule LB 19 for an example.

#

$DG = \u00B0;

$AK = [:LineBreak =  Aksara:];

$AL = [[:LineBreak =  Alphabetic:] $DG];

$AL = [:LineBreak =  Alphabetic:];

$AP = [:LineBreak =  Aksara_Prebase:];

$AS = [:LineBreak =  Aksara_Start:];

$CL = [[:LineBreak =  Close_Punctuation:] [:LineBreak = Close_Parenthesis:]]; # tdf#31271

$CL = [:LineBreak =  Close_Punctuation:];

$CM = [:LineBreak =  Combining_Mark:];

# $CM = [:LineBreak =  Combining_Mark:];

$CP = [:LineBreak =  Close_Parenthesis:];

$ID = [[:LineBreak =  Ideographic:] - [\ufe30]];

$ID = [:LineBreak =  Ideographic:];

$IN = [:LineBreak =  Inseparable:];

$IN = [:LineBreak =  Inseperable:];

$IS = [[:LineBreak =  Infix_Numeric:] [\ufe30]];

$IS = [:LineBreak =  Infix_Numeric:];

$OP = [[:LineBreak =  Open_Punctuation:] - $DG];

$OP = [:LineBreak =  Open_Punctuation:];

$BS = \u005C;

$PR = [:LineBreak =  Prefix_Numeric:];

$PR = [[:LineBreak =  Prefix_Numeric:] - $BS];

$SY = [[:LineBreak =  Break_Symbols:] $BS];

$SY = [:LineBreak =  Break_Symbols:];

$VF = [:LineBreak =  Virama_Final:];

$VI = [:LineBreak =  Virama:];

#   limited to LineBreak=Complex_Context. Note that this set only works in Unicode

#   limited to LineBreak=Complex_Context (SA).

#   5.0 or later as the definition of Complex_Context was corrected to include all

#   characters requiring dictionary break.

$dictionary = [:LineBreak = Complex_Context:];

$dictionary = [$SA];

#                               SA  (South East Asian: Thai, Lao, Khmer)

#                               SA  (Dictionary chars, excluding Mn and Mc)

$ALPlus = [$AL $AI $SA $SG $XX];

$ALPlus = [$AL $AI $SG $XX [$SA-[[:Mn:][:Mc:]]]];

$AL_FOLLOW_NOCM = [$BK $CR $LF $NL $ZW $SP];

$AL_FOLLOW      = [$BK $CR $LF $NL $ZW $SP $CL $CP $EX $HL $IS $SY $WJ $GL $OP30 $QU $BA $HY $NS $IN $NU $PR $PO $ALPlus];

$AL_FOLLOW_CM   = [$CL $EX $HL $IS $SY $WJ $GL $QU $BA $HY $NS $IN $NU $ALPlus $OP];

$AL_FOLLOW      = [$AL_FOLLOW_NOCM $AL_FOLLOW_CM];

$LB4NonBreaks = [^$BK $CR $LF $NL];

$LB4NonBreaks = [^$BK $CR $LF $NL $CM];

$CM+            $LB4Breaks {100};

^$CM+           $LB4Breaks {100};

$CM+          [$SP $ZW];

^$CM+         [$SP $ZW];

# LB 9     Combining marks.      X   $CM needs to behave like X, where X is not $SP, $BK $CR $LF $NL 

# LB 9     Combining marks.      X   $CM needs to behave like X, where X is not $SP, $BK $CR $LF $NL

#                                $CM not covered by the above needs to behave like $AL   

#                                $CM not covered by the above needs to behave like $AL

$CM+;

^$CM+;

$CAN_CM $CM*  $WJcm;

$CAN_CM $CM*  $WJ;

$LB8NonBreaks $WJcm;

$LB8NonBreaks $WJ;

$CM+          $WJcm;

^$CM+         $WJ;

$WJcm [^$CAN_CM];

$WJ $CM* .;

$WJcm $CAN_CM $CM*;

# LB 12  Do not break before or after NBSP and related characters.

# LB 12  Do not break after NBSP and related characters.

#

#         (!SP) x GL

[$LB8NonBreaks-$SP] $CM* $GLcm;

$CM+               $GLcm;

$GLcm ($LB8Breaks | $SP);

#

$GLcm [$LB8NonBreaks-$SP] $CM*;     # Don't let a combining mark go onto $CR, $BK, etc.

$GL $CM* .;

                              #  TODO:  I don't think we need this rule.

                              #         All but $CM will chain off of preceding rule.

                              #         $GLcm will pick up the CM case by itself.

# LB 13   Don't break before ']' or '!' or ';' or '/', even after spaces.

# LB 12a  Do not break before NBSP and related characters ...

#            [^SP BA HY] x GL

#

[[$LB8NonBreaks] - [$SP $BA $HY]] $CM* $GL;

^$CM+ $GL;

# LB 13   Don't break before ']' or '!' or '/', even after spaces.

$CM+          $CL;              # by rule 10, stand-alone CM behaves as AL

^$CM+         $CL;              # by rule 10, stand-alone CM behaves as AL

$LB8NonBreaks $CP;

$CAN_CM $CM*  $CP;

^$CM+         $CP;              # by rule 10, stand-alone CM behaves as AL

$CM+          $EX;              # by rule 10, stand-alone CM behaves as AL

^$CM+         $EX;              # by rule 10, stand-alone CM behaves as AL

$LB8NonBreaks $IS;

$CAN_CM $CM*  $IS;

$CM+          $IS;              # by rule 10, stand-alone CM behaves as AL

$CM+          $SY;              # by rule 10, stand-alone CM behaves as AL

^$CM+         $SY;              # by rule 10, stand-alone CM behaves as AL

# LB 14  Do not break after OP, even after spaced

# LB 14  Do not break after OP, even after spaces

#        Note subtle interaction with "SP IS /" rules in LB14a.

#        This rule consumes the SP, chaining happens on the IS, effectivley overriding the  SP IS rules,

#        which is the desired behavior.

$OPcm $SP* $CAN_CM $CM*;

$OP $CM* $SP* .;

$OPcm $SP* $CANT_CM;

$OPcm $SP+ $CM+ $AL_FOLLOW?;    # by rule 10, stand-alone CM behaves as AL

$OP $CM* $SP+ $CM+ $AL_FOLLOW?;    # by rule 10, stand-alone CM behaves as AL

                                   # by rule 8, CM following a SP is stand-alone.

# LB 15

# $QUcm $SP* $OPcm;

# LB 15a

($OP $CM* $SP+ | [$OP $QU $GL] $CM*) ([\p{Pi} & $QU] $CM* $SP*)+ .;

($OP $CM* $SP+ | [$OP $QU $GL] $CM*) ([\p{Pi} & $QU] $CM* $SP*)+ $SP $CM+ $AL_FOLLOW?;

^([\p{Pi} & $QU] $CM* $SP*)+ .;

^([\p{Pi} & $QU] $CM* $SP*)+ $SP $CM+ $AL_FOLLOW?;

# LB 15b

$LB8NonBreaks [\p{Pf} & $QU] $CM* [$SP $GL $WJ $CL $QU $CP $EX $IS $SY $BK $CR $LF $NL $ZW {eof}];

$CAN_CM $CM*  [\p{Pf} & $QU] $CM* [$SP $GL $WJ $CL $QU $CP $EX $IS $SY $BK $CR $LF $NL $ZW {eof}];

^$CM+  [\p{Pf} & $QU] $CM* [$SP $GL $WJ $CL $QU $CP $EX $IS $SY $BK $CR $LF $NL $ZW {eof}];

# Messy interaction: manually chain between LB 15b and LB 15a on Pf Pi.

$LB8NonBreaks [\p{Pf} & $QU] $CM* ([\p{Pi} & $QU] $CM* $SP*)+ .;

$LB8NonBreaks [\p{Pf} & $QU] $CM* ([\p{Pi} & $QU] $CM* $SP*)+ $SP $CM+ $AL_FOLLOW?;

$CAN_CM $CM*  [\p{Pf} & $QU] $CM* ([\p{Pi} & $QU] $CM* $SP*)+ .;

$CAN_CM $CM*  [\p{Pf} & $QU] $CM* ([\p{Pi} & $QU] $CM* $SP*)+ $SP $CM+ $AL_FOLLOW?;

^$CM+  [\p{Pf} & $QU] $CM* ([\p{Pi} & $QU] $CM* $SP*)+ .;

^$CM+  [\p{Pf} & $QU] $CM* ([\p{Pi} & $QU] $CM* $SP*)+ $SP $CM+ $AL_FOLLOW?;

# LB 15c Force a break before start of a number with a leading decimal pt, e.g. " .23"

#        Note: would be simpler to express as "$SP / $IS $CM* $NU;", but ICU rules have limitations.

#        See issue ICU-20303

$CanFollowIS = [$BK $CR $LF $NL $SP $ZW $WJ $GL $CL $CP $EX $IS $SY $QU $BA $HY $NS $ALPlus $HL $IN];

$SP $IS           / [^ $CanFollowIS $NU $CM];

$SP $IS $CM* $CMX / [^ $CanFollowIS $NU $CM];

#

# LB 15d Do not break before numeric separators (IS), even after spaces.

[$LB8NonBreaks - $SP] $IS;

$SP $IS $CM* [$CanFollowIS {eof}];

$SP $IS $CM* $ZWJ [^$CM $NU];

$CAN_CM $CM*  $IS;

^$CM+         $IS;              # by rule 10, stand-alone CM behaves as AL

$CLcm $SP* $NScm;

($CL | $CP) $CM* $SP* $NS;

$B2cm $SP* $B2cm;

$B2 $CM* $SP* $B2;

$LB18NonBreaks $CM* $QUcm;

$LB18NonBreaks $CM* $QU;

$CM+                $QUcm;

^$CM+               $QU;

$QUcm .?;

$QU $CM* .;

$QUcm $LB18NonBreaks $CM*;    # Don't let a combining mark go onto $CR, $BK, etc.

                              #  TODO:  I don't think this rule is needed.

#

$LB20NonBreaks $CM* ($BAcm | $HYcm | $NScm); 

$LB20NonBreaks $CM* ($BA | $HY | $NS);

$BBcm [^$CB];                                  #  $BB  x

$BBcm $LB20NonBreaks $CM*;

^$CM+ ($BA | $HY | $NS);

$BB $CM* [^$CB];                                  #  $BB  x

$BB $CM* $LB20NonBreaks;

#  

#

$HLcm ($HYcm | $BAcm) [^$CB]?;

$HL $CM* ($HY | $BA) $CM* [^$CB]?;

# LB 22

# LB 21b (forward) Don't break between SY and HL

($ALcm | $HLcm) $INcm;

# (break between HL and SY already disallowed by LB 13 above)

$CM+     $INcm;     #  by rule 10, any otherwise unattached CM behaves as AL

$SY $CM* $HL;

$IDcm    $INcm;

$INcm    $INcm;

# LB 22  Do not break before ellipses

$NUcm    $INcm;

#

$LB20NonBreaks $CM*    $IN;

^$CM+ $IN;

# $LB 23

# LB 23

$IDcm  $POcm;

#

$ALcm  $NUcm;       # includes $LB19

($ALPlus | $HL) $CM* $NU;

$HLcm  $NUcm;

^$CM+  $NU;       # Rule 10, any otherwise unattached CM behaves as AL

$CM+   $NUcm;       # Rule 10, any otherwise unattached CM behaves as AL

$NU $CM* ($ALPlus | $HL);

$NUcm  $ALcm;

$NUcm  $HLcm;

# LB 23a

#

$PR $CM* ($ID | $EB | $EM);

($ID | $EB | $EM) $CM*  $PO;

$PRcm $IDcm;

($PR | $PO) $CM* ($ALPlus | $HL);

$ALcm $PRcm;

($ALPlus | $HL) $CM* ($PR | $PO);

$PRcm ($ALcm | $HLcm);

^$CM+ ($PR | $PO);       # Rule 10, any otherwise unattached CM behaves as AL

$POcm ($ALcm | $HLcm);

($PRcm | $POcm)? ($OPcm)? $NUcm ($NUcm | $SYcm | $IScm)* $CLcm? ($PRcm | $POcm)?;

(($PR | $PO) $CM*)? (($OP | $HY) $CM*)? ($IS $CM*)? $NU ($CM* ($NU | $SY | $IS))*

    ($CM* ($CL | $CP))? ($CM* ($PR | $PO))?;

$JLcm ($JLcm | $JVcm | $H2cm | $H3cm);

$JL $CM* ($JL | $JV | $H2 | $H3);

($JVcm | $H2cm) ($JVcm | $JTcm);

($JV | $H2) $CM* ($JV | $JT);

($JTcm | $H3cm) $JTcm;

($JT | $H3) $CM* $JT;

($JLcm | $JVcm | $JTcm | $H2cm | $H3cm) $INcm;

($JL | $JV | $JT | $H2 | $H3) $CM* $PO;

($JLcm | $JVcm | $JTcm | $H2cm | $H3cm) $POcm;

$PR $CM* ($JL | $JV | $JT | $H2 | $H3);

$PRcm ($JLcm | $JVcm | $JTcm | $H2cm | $H3cm);

($ALcm | $HLcm) ($ALcm | $HLcm);

($ALPlus | $HL) $CM* ($ALPlus | $HL);

$CM+ ($ALcm | $HLcm);      # The $CM+ is from rule 10, an unattached CM is treated as AL

^$CM+ ($ALPlus | $HL);      # The $CM+ is from rule 10, an unattached CM is treated as AL

#LB 28a  Do not break Orthographic syllables

($AP $CM*)? ($AS | $AK | [◌] ) ($CM* $VI $CM* ($AK | [◌] ))* ($CM* $VI | (($CM* ($AS | $AK | [◌] ) )? $CM* $VF))?;

$IScm ($ALcm | $NUcm);

$IS $CM* ($ALPlus | $HL);

#

# Rule 30   Do not break between letters, numbers or ordinary symbols

#           and opening or closing punctuation

#

($ALcm | $HLcm | $NUcm) $OPcm;

$CM+ $OPcm;

$CLcm ($ALcm | $HLcm | $NUcm);

#

#  Reverse Rules.

#

## -------------------------------------------------

!!reverse;

$CM+ $ALPlus;

$CM+ $BA;

$CM+ $BB;

$CM+ $B2;

$CM+ $CL;

$CM+ $EX;

$CM+ $GL;

$CM+ $HL;

$CM+ $HY;

$CM+ $H2;

$CM+ $H3;

$CM+ $ID;

$CM+ $IN;

$CM+ $IS;

$CM+ $JL;

$CM+ $JV;

$CM+ $JT;

$CM+ $NS;

$CM+ $NU;

$CM+ $OP;

$CM+ $PO;

$CM+ $PR;

$CM+ $QU;

$CM+ $SY;

$CM+ $WJ;

$CM+;

#

#  Sequences of the form  (shown forwards)

#      [CANT_CM]  <break>  [CM]  [whatever]

#  The CM needs to behave as an AL

#

$AL_FOLLOW $CM+ / (

          [$BK $CR $LF $NL $ZW {eof}] |

          $SP+ $CM+ $SP |

          $SP+ $CM* ([^$OP $CM $SP] | [$AL {eof}]));   # if LB 14 will match, need to suppress this break.

                                               #  LB14 says    OP SP* x .        

                                               #    becomes    OP SP* x AL

                                               #    becomes    OP SP* x CM+ AL_FOLLOW

                                               #

                                               # Further note:  the $AL in [$AL {eof}] is only to work around

                                               #                a rule compiler bug which complains about

                                               #                empty sets otherwise.

#

#  Sequences of the form  (shown forwards)

#      [CANT_CM]  <break> [CM]  <break>  [PR]

#  The CM needs to behave as an AL

#  This rule is concerned about getting the second of the two <breaks> in place.

#

[$PR   ] / $CM+ [$BK $CR $LF $NL $ZW $SP {eof}];

# LB 4, 5, 5

$LB4Breaks [$LB4NonBreaks-$CM];

$LB4Breaks $CM+ $CAN_CM;

$LF $CR;

# LB 7         x SP

#              x ZW

[$SP $ZW] [$LB4NonBreaks-$CM];

[$SP $ZW] $CM+ $CAN_CM;

# LB 8 Break after zero width space

# LB 9,10  Combining marks.

#    X   $CM needs to behave like X, where X is not $SP or controls.

#    $CM not covered by the above needs to behave like $AL

# Stick together any combining sequences that don't match other rules.

$CM+ $CAN_CM;

# LB 11

$CM* $WJ $CM* $CAN_CM;

$CM* $WJ      [$LB8NonBreaks-$CM];

     $CANT_CM $CM* $WJ;

$CM* $CAN_CM  $CM* $WJ;

# LB 12

#         x GL

#

$CM* $GL $CM* [$LB8NonBreaks-$CM-$SP];

#

#     GL  x

#

$CANT_CM $CM* $GL;

$CM* $CAN_CM $CM* $GL;

# LB 13

$CL $CM+ $CAN_CM;

$EX $CM+ $CAN_CM;

$IS $CM+ $CAN_CM;

$SY $CM+ $CAN_CM;

$CL [$LB8NonBreaks-$CM];

$EX [$LB8NonBreaks-$CM];

$IS [$LB8NonBreaks-$CM];

$SY [$LB8NonBreaks-$CM];

# Rule 13 & 14 taken together for an edge case.

#   Match this, shown forward

#     OP SP+  ($CM+ behaving as $AL) (CL | EX | IS | IY)

#   This really wants to chain at the $CM+ (which is acting as an $AL)

#   except for $CM chaining being disabled.

[$CL $EX $IS $SY] $CM+ $SP+ $CM* $OP;  

# LB 14    OP SP* x

#

$CM* $CAN_CM    $SP* $CM* $OP;

     $CANT_CM   $SP* $CM* $OP;

$AL_FOLLOW? $CM+  $SP $SP* $CM* $OP;     #  by LB 10, behaves like $AL_FOLLOW? $AL $SP* $CM* $OP

     $AL_FOLLOW_NOCM $CM+ $SP+ $CM* $OP;

$CM* $AL_FOLLOW_CM   $CM+ $SP+ $CM* $OP;

$SY $CM $SP+ $OP;   # TODO:  Experiment.  Remove.

# LB 15

# $CM* $OP $SP* $CM* $QU;

# LB 16

$CM* $NS $SP* $CM* $CL;

# LB 17

$CM* $B2 $SP* $CM* $B2;

# LB 18  break after spaces

#        Nothing explicit needed here.

#

# LB 19

#

$CM* $QU $CM* $CAN_CM;                                #   . x QU

$CM* $QU      $LB18NonBreaks;

$CM* $CAN_CM  $CM* $QU;                               #   QU x .

     $CANT_CM $CM* $QU;

#

#  LB 20  Break before and after CB.

#         nothing needed here.

#

# LB 21

$CM* ($BA | $HY | $NS) $CM* [$LB20NonBreaks-$CM];     #  . x (BA | HY | NS)

$CM* [$LB20NonBreaks-$CM] $CM* $BB;                   #  BB x .

[^$CB] $CM* $BB;                                      # 

# LB21a

[^$CB] $CM* ($HY | $BA) $CM* $HL;

# LB 22

$CM* $IN $CM* ($ALPlus | $HL);

$CM* $IN $CM* $ID;

$CM* $IN $CM* $IN;

$CM* $IN $CM* $NU;

# LB 23

$CM* $PO $CM* $ID;

$CM* $NU $CM* ($ALPlus | $HL);

$CM* ($ALPlus | $HL) $CM* $NU;

# LB 24

$CM* $ID $CM* $PR;

$CM* $PR $CM* $ALPlus;

$CM* ($ALPlus | $HL) $CM* $PR;

$CM* ($ALPlus | $HL) $CM* $PO;

$CM* $ALPlus $CM* ($IS | $SY | $HY)+ / $SP;

$CM* $NU+ $CM* $HY+ / $SP;

# LB 25

($CM* ($PR | $PO))? ($CM* $CL)? ($CM* ($NU | $IS | $SY))* $CM* $NU ($CM* ($OP))? ($CM* ($PR | $PO))?;

# LB 26

$CM* ($H3 | $H2 | $JV | $JL) $CM* $JL;

$CM* ($JT | $JV) $CM* ($H2 | $JV);

$CM* $JT $CM* ($H3 | $JT);

# LB 27

$CM* $IN $CM* ($H3 | $H2 | $JT | $JV | $JL);

$CM* $PO $CM* ($H3 | $H2 | $JT | $JV | $JL);

$CM* ($H3 | $H2 | $JT | $JV | $JL) $CM* $PR;

# LB 28

$CM* ($ALPlus | $HL) $CM* ($ALPlus | $HL);

# LB 29

$CM* ($NU | $ALPlus) $CM* $IS+ [^$SP];

$CM* $OP $CM* ($ALPlus | $HL | $NU);

($ALPlus | $HL | $NU) $CM* $OP30;

$CM* ($ALPlus | $HL | $NU) $CM* ($CL | $SY)+ [^$SP];

^$CM+ $OP30;         # The $CM+ is from rule 10, an unattached CM is treated as AL.

$CP30 $CM* ($ALPlus | $HL | $NU);

## -------------------------------------------------

# LB30b Do not break between an emoji base (or potential emoji) and an emoji modifier.

$EB $CM* $EM;

$ExtPictUnassigned $CM* $EM;

!!safe_reverse;

# LB 31 Break everywhere else.

#       Match a single code point if no other rule applies.

# LB 7

.;

$CM+ [^$CM $BK $CR $LF $NL $ZW $SP];

$CM+ $SP / .;

# LB 9

$SP+ $CM* $OP;

# LB 10

$SP+ $CM* $QU;

# LB 11

$SP+ $CM* $CL;

$SP+ $CM* $B2;

# LB 21

$CM* ($HY | $BA) $CM* $HL;

# LB 18

($CM* ($IS | $SY))+ $CM* $NU;

$CL $CM* ($NU | $IS | $SY);

# For dictionary-based break

$dictionary $dictionary;

## -------------------------------------------------

!!safe_forward;

# Skip forward over all character classes that are involved in

#   rules containing patterns with possibly more than one char

#   of context.

#

#  It might be slightly more efficient to have specific rules

#  instead of one generic one, but only if we could

#  turn off rule chaining.  We don't want to move more

#  than necessary.

#

[$CM $OP $QU $CL $B2 $PR $HY $BA $SP $dictionary]+ [^$CM $OP $QU $CL $B2 $PR $HY $BA $dictionary];

$dictionary $dictionary;

#   Copyright (C) 2002-2006, International Business Machines Corporation and others.

#   Copyright (C) 2002-2015, International Business Machines Corporation and others.

#      These rules are based on SA 29 version 5.0.0

#      These rules are based on UAX #29 Revision 34 for Unicode Version 12.0

#      Includes post 5.0 changes to treat Japanese half width voicing marks

#        as Grapheme Extend.

!!quoted_literals_only;

$VoiceMarks   = [\uff9e\uff9f];

$Thai         = [:Script = Thai:];

$OLetter   = [\p{Sentence_Break = OLetter}-$VoiceMarks];

$OLetter   = [\p{Sentence_Break = OLetter}];

#   incorporate grapheme cluster + format chars.

#   incorporate trailing Extend or Format chars.

#   Rules 4 and 5.  

#   Rules 4 and 5.

$CR         = \u000d;

$LF         = \u000a;

$Extend     = [[:Grapheme_Extend = TRUE:]$VoiceMarks];

[^$Sep]? ($Extend | $Format)*;

[^$Sep $CR $LF]? ($Extend | $Format)*;

$UpperEx $ATermEx $UpperEx;

($UpperEx | $LowerEx) $ATermEx $UpperEx;

#  Note:  follows errata for Unicode 5.0 boundary rules.

$NotLettersEx = [^$OLetter $Upper $Lower $Sep $CR $LF $ATerm $STerm] ($Extend | $Format)*;

$NotLettersEx = [^$OLetter $Upper $Lower $Sep $ATerm $STerm] ($Extend | $Format)*;

($STermEx | $ATermEx) $CloseEx* $SpEx* ($STermEx | $ATermEx);

($STermEx | $ATermEx) $CloseEx* $SpEx* ($SContinueEx | $STermEx | $ATermEx);

($STermEx | $ATermEx) $CloseEx* $SpEx* $Sep?;

($STermEx | $ATermEx) $CloseEx* $SpEx* ($Sep | $CR | $LF)?;

#Rule 12

#Rule 998

[[^$STerm $ATerm $Close $Sp $Sep $Format $Extend $Thai]{bof}] ($Extend | $Format | $Close | $Sp)* [^$Thai];

[[^$STerm $ATerm $Close $Sp $Sep $LF $CR $Format $Extend]{bof}] ($Extend | $Format | $Close | $Sp)* .;

[[^$STerm $ATerm $Close $Sp $Sep $Format $Extend]{bof}] ($Extend | $Format | $Close | $Sp)* ([$Sep{eof}] | $CR $LF){100};

[[^$STerm $ATerm $Close $Sp $Sep $LF $CR $Format $Extend]{bof}] ($Extend | $Format | $Close | $Sp)* ([$Sep $LF $CR {eof}] | $CR $LF){100};

## -------------------------------------------------

!!reverse;

$SpEx_R       = ($Extend | $Format)* $Sp;

$ATermEx_R    = ($Extend | $Format)* $ATerm;

$STermEx_R    = ($Extend | $Format)* $STerm;

$CloseEx_R    = ($Extend | $Format)* $Close;

#

#  Reverse rules.

#     For now, use the old style inexact reverse rules, which are easier

#     to write, but less efficient.

#     TODO:  exact reverse rules.  It appears that exact reverse rules

#            may require improving support for look-ahead breaks in the

#            builder.  Needs more investigation.

#

[{bof}] (.? | $LF $CR) [^$Sep]* [$Sep {eof}] ($SpEx_R* $CloseEx_R* ($STermEx_R | $ATermEx_R))*;

#.*;

# Explanation for this rule:

#

#    It needs to back over

#        The $Sep at which we probably begin

#        All of the non $Sep chars leading to the preceding $Sep

#        The preceding $Sep, which will be the second one that the rule matches.

#        Any immediately preceding STerm or ATerm sequences.  We need to see these

#              to get the correct rule status when moving forwards again.

#        

# [{bof}]           inhibit rule chaining.  Without this, rule would loop on itself and match

#                   the entire string.

#

# (.? | $LF $CR)    Match one $Sep instance.  Use .? rather than $Sep because position might be

#                   at the beginning of the string at this point, and we don't want to fail.

#                   Can only use {eof} once, and it is used later.

#