package uniseg
import "unicode/utf8"
// The states of the line break parser.
const (
lbAny = iota
lbBK
lbCR
lbLF
lbNL
lbSP
lbZW
lbZWSP
lbWJ
lbGL
lbHH
lbHY
lbCL
lbCP
lbEX
lbIS
lbSY
lbOP
lbOPSP
lbQU
lbLB15a
lbNS
lbCLCPSP
lbB2
lbB2SP
lbCB
lbBB
lbLB20a
lbLB21a
lbHL
lbAL
lbNU
lbPR
lbEB
lbIDEM
lbNUSY
lbNUIS
lbNUCL
lbNUCP
lbPO
lbJL
lbJV
lbJT
lbH2
lbH3
lbAP
lbAKAS
lbDottedCircle // Dotted Circle is prAL.
lbAKCircleASVI
lbOddRI
lbEvenRI
lbZWJBit = 1 << 6
lbEastAsianBit = 1 << 7
lbQUAfterNoEastAsianBit = 1 << 8
lbExtPicCnBit = 1 << 9
lbPiPfBits = 1<<10 | 1<<11
lbIsPi = 0
lbIsntPi = 1 << 10
lbIsPf = 2 << 10
lbIsntPf = 3 << 10
)
// These constants define whether a given text may be broken into the next line.
// If the break is optional (LineCanBreak), you may choose to break or not based
// on your own criteria, for example, if the text has reached the available
// width.
const (
LineDontBreak = iota // You may not break the line here.
LineCanBreak // You may or may not break the line here.
LineMustBreak // You must break the line here.
)
// lbTransitions implements the line break parser's state transitions. It's
// anologous to [grTransitions], see comments there for details.
//
// Unicode version 18.0.0.
func lbTransitions(state, prop int) (newState, lineBreak, rule int) {
switch uint64(state)&uint64(1<<32-1) | uint64(prop)<<32 {
// LB4.
case lbBK | prAny<<32:
return lbAny, LineMustBreak, 40
// LB5.
case lbCR | prLF<<32:
return lbLF, LineDontBreak, 50
case lbCR | prAny<<32:
return lbAny, LineMustBreak, 50
case lbLF | prAny<<32:
return lbAny, LineMustBreak, 50
case lbNL | prAny<<32:
return lbAny, LineMustBreak, 50
// LB6.
case lbAny | prBK<<32:
return lbBK, LineDontBreak, 60
case lbAny | prCR<<32:
return lbCR, LineDontBreak, 60
case lbAny | prLF<<32:
return lbLF, LineDontBreak, 60
case lbAny | prNL<<32:
return lbNL, LineDontBreak, 60
// LB7.
case lbAny | prSP<<32:
return lbSP, LineDontBreak, 70
case lbAny | prZW<<32:
return lbZW, LineDontBreak, 70
// LB8.
case lbZW | prSP<<32:
return lbZWSP, LineDontBreak, 70
case lbZW | prAny<<32:
return lbAny, LineCanBreak, 80
case lbZWSP | prSP<<32:
return lbZWSP, LineDontBreak, 70
case lbZWSP | prAny<<32:
return lbAny, LineCanBreak, 80
// LB11.
case lbAny | prWJ<<32:
return lbWJ, LineDontBreak, 110
case lbWJ | prAny<<32:
return lbAny, LineDontBreak, 110
// LB12.
case lbAny | prGL<<32:
return lbGL, LineCanBreak, 310
case lbGL | prAny<<32:
return lbAny, LineDontBreak, 120
// LB13 (simple transitions).
case lbAny | prCL<<32:
return lbCL, LineDontBreak, 130
case lbAny | prCP<<32:
return lbCP, LineDontBreak, 130
case lbAny | prEX<<32:
return lbEX, LineDontBreak, 130
case lbAny | prSY<<32:
return lbSY, LineDontBreak, 130
// LB14.
case lbAny | prOP<<32:
return lbOP, LineCanBreak, 310
case lbOP | prSP<<32:
return lbOPSP, LineDontBreak, 70
case lbOP | prAny<<32:
return lbAny, LineDontBreak, 140
case lbOPSP | prSP<<32:
return lbOPSP, LineDontBreak, 70
case lbOPSP | prAny<<32:
return lbAny, LineDontBreak, 140
// LB15d.
case lbAny | prIS<<32:
return lbIS, LineDontBreak, 154
// LB16.
case lbCL | prSP<<32:
return lbCLCPSP, LineDontBreak, 70
case lbNUCL | prSP<<32:
return lbCLCPSP, LineDontBreak, 70
case lbCP | prSP<<32:
return lbCLCPSP, LineDontBreak, 70
case lbNUCP | prSP<<32:
return lbCLCPSP, LineDontBreak, 70
case lbCL | prNS<<32:
return lbNS, LineDontBreak, 160
case lbNUCL | prNS<<32:
return lbNS, LineDontBreak, 160
case lbCP | prNS<<32:
return lbNS, LineDontBreak, 160
case lbNUCP | prNS<<32:
return lbNS, LineDontBreak, 160
case lbCLCPSP | prNS<<32:
return lbNS, LineDontBreak, 160
// LB17.
case lbAny | prB2<<32:
return lbB2, LineCanBreak, 310
case lbB2 | prSP<<32:
return lbB2SP, LineDontBreak, 70
case lbB2 | prB2<<32:
return lbB2, LineDontBreak, 170
case lbB2SP | prB2<<32:
return lbB2, LineDontBreak, 170
// LB18.
case lbSP | prAny<<32:
return lbAny, LineCanBreak, 180
case lbCLCPSP | prAny<<32:
return lbAny, LineCanBreak, 180
case lbB2SP | prAny<<32:
return lbAny, LineCanBreak, 180
// LB20.
case lbAny | prCB<<32:
return lbCB, LineCanBreak, 200
case lbCB | prAny<<32:
return lbAny, LineCanBreak, 200
// LB21.
case lbAny | prBA<<32:
return lbAny, LineDontBreak, 210
case lbAny | prHH<<32:
return lbHH, LineDontBreak, 210
case lbAny | prHY<<32:
return lbHY, LineDontBreak, 210
case lbAny | prNS<<32:
return lbNS, LineDontBreak, 210
case lbAny | prBB<<32:
return lbBB, LineCanBreak, 310
case lbBB | prAny<<32:
return lbAny, LineDontBreak, 210
// LB21a (simple transitions).
case lbAny | prHL<<32:
return lbHL, LineCanBreak, 310
// LB21b.
case lbSY | prHL<<32:
return lbHL, LineDontBreak, 212
case lbNUSY | prHL<<32:
return lbHL, LineDontBreak, 212
// LB22.
case lbAny | prIN<<32:
return lbAny, LineDontBreak, 220
// LB23.
case lbAny | prAL<<32:
return lbAL, LineCanBreak, 310
case lbAny | prNU<<32:
return lbNU, LineCanBreak, 310
case lbAL | prNU<<32:
return lbNU, LineDontBreak, 230
case lbDottedCircle | prNU<<32:
return lbNU, LineDontBreak, 230
case lbHL | prNU<<32:
return lbNU, LineDontBreak, 230
case lbNU | prAL<<32:
return lbAL, LineDontBreak, 230
case lbNU | prHL<<32:
return lbHL, LineDontBreak, 230
// LB23a.
case lbAny | prPR<<32:
return lbPR, LineCanBreak, 310
case lbAny | prID<<32:
return lbIDEM, LineCanBreak, 310
case lbAny | prEB<<32:
return lbEB, LineCanBreak, 310
case lbAny | prEM<<32:
return lbIDEM, LineCanBreak, 310
case lbPR | prID<<32:
return lbIDEM, LineDontBreak, 231
case lbPR | prEB<<32:
return lbEB, LineDontBreak, 231
case lbPR | prEM<<32:
return lbIDEM, LineDontBreak, 231
case lbIDEM | prPO<<32:
return lbPO, LineDontBreak, 231
case lbEB | prPO<<32:
return lbPO, LineDontBreak, 231
// LB24.
case lbAny | prPO<<32:
return lbPO, LineCanBreak, 310
case lbPR | prAL<<32:
return lbAL, LineDontBreak, 240
case lbPR | prHL<<32:
return lbHL, LineDontBreak, 240
case lbPO | prAL<<32:
return lbAL, LineDontBreak, 240
case lbPO | prHL<<32:
return lbHL, LineDontBreak, 240
case lbAL | prPR<<32:
return lbPR, LineDontBreak, 240
case lbAL | prPO<<32:
return lbPO, LineDontBreak, 240
case lbDottedCircle | prPR<<32:
return lbPR, LineDontBreak, 240
case lbDottedCircle | prPO<<32:
return lbPO, LineDontBreak, 240
case lbHL | prPR<<32:
return lbPR, LineDontBreak, 240
case lbHL | prPO<<32:
return lbPO, LineDontBreak, 240
// LB25 (simple transitions).
case lbNU | prSY<<32:
return lbNUSY, LineDontBreak, 130
case lbNU | prIS<<32:
return lbNUIS, LineDontBreak, 154
case lbNU | prCL<<32:
return lbNUCL, LineDontBreak, 130
case lbNUSY | prCL<<32:
return lbNUCL, LineDontBreak, 130
case lbNUIS | prCL<<32:
return lbNUCL, LineDontBreak, 130
case lbNUCL | prPO<<32:
return lbPO, LineDontBreak, 250
case lbNU | prCP<<32:
return lbNUCP, LineDontBreak, 130
case lbNUSY | prCP<<32:
return lbNUCP, LineDontBreak, 130
case lbNUIS | prCP<<32:
return lbNUCP, LineDontBreak, 130
case lbNUCP | prPO<<32:
return lbPO, LineDontBreak, 250
case lbNUCL | prPR<<32:
return lbPR, LineDontBreak, 250
case lbNUCP | prPR<<32:
return lbPR, LineDontBreak, 250
case lbNU | prPO<<32:
return lbPO, LineDontBreak, 250
case lbNUSY | prPO<<32:
return lbPO, LineDontBreak, 250
case lbNUIS | prPO<<32:
return lbPO, LineDontBreak, 250
case lbNU | prPR<<32:
return lbPR, LineDontBreak, 250
case lbNUSY | prPR<<32:
return lbPR, LineDontBreak, 250
case lbNUIS | prPR<<32:
return lbPR, LineDontBreak, 250
case lbPO | prNU<<32:
return lbNU, LineDontBreak, 250
case lbPR | prNU<<32:
return lbNU, LineDontBreak, 250
case lbHY | prNU<<32:
return lbNU, LineDontBreak, 250
case lbIS | prNU<<32:
return lbNU, LineDontBreak, 250
case lbNU | prNU<<32:
return lbNU, LineDontBreak, 250
case lbNUSY | prNU<<32:
return lbNU, LineDontBreak, 250
case lbNUIS | prNU<<32:
return lbNU, LineDontBreak, 250
// LB26.
case lbAny | prJL<<32:
return lbJL, LineCanBreak, 310
case lbAny | prJV<<32:
return lbJV, LineCanBreak, 310
case lbAny | prJT<<32:
return lbJT, LineCanBreak, 310
case lbAny | prH2<<32:
return lbH2, LineCanBreak, 310
case lbAny | prH3<<32:
return lbH3, LineCanBreak, 310
case lbJL | prJL<<32:
return lbJL, LineDontBreak, 260
case lbJL | prJV<<32:
return lbJV, LineDontBreak, 260
case lbJL | prH2<<32:
return lbH2, LineDontBreak, 260
case lbJL | prH3<<32:
return lbH3, LineDontBreak, 260
case lbJV | prJV<<32:
return lbJV, LineDontBreak, 260
case lbJV | prJT<<32:
return lbJT, LineDontBreak, 260
case lbH2 | prJV<<32:
return lbJV, LineDontBreak, 260
case lbH2 | prJT<<32:
return lbJT, LineDontBreak, 260
case lbJT | prJT<<32:
return lbJT, LineDontBreak, 260
case lbH3 | prJT<<32:
return lbJT, LineDontBreak, 260
// LB27.
case lbJL | prPO<<32:
return lbPO, LineDontBreak, 270
case lbJV | prPO<<32:
return lbPO, LineDontBreak, 270
case lbJT | prPO<<32:
return lbPO, LineDontBreak, 270
case lbH2 | prPO<<32:
return lbPO, LineDontBreak, 270
case lbH3 | prPO<<32:
return lbPO, LineDontBreak, 270
case lbPR | prJL<<32:
return lbJL, LineDontBreak, 270
case lbPR | prJV<<32:
return lbJV, LineDontBreak, 270
case lbPR | prJT<<32:
return lbJT, LineDontBreak, 270
case lbPR | prH2<<32:
return lbH2, LineDontBreak, 270
case lbPR | prH3<<32:
return lbH3, LineDontBreak, 270
// LB28.
case lbAL | prAL<<32:
return lbAL, LineDontBreak, 280
case lbAL | prHL<<32:
return lbHL, LineDontBreak, 280
case lbHL | prAL<<32:
return lbAL, LineDontBreak, 280
case lbHL | prHL<<32:
return lbHL, LineDontBreak, 280
case lbDottedCircle | prAL<<32:
return lbAL, LineDontBreak, 280
case lbDottedCircle | prHL<<32:
return lbHL, LineDontBreak, 280
// LB28a (simple transitions).
case lbAny | prAP<<32:
return lbAP, LineCanBreak, 310
case lbAny | prAK<<32:
return lbAKAS, LineCanBreak, 310
case lbAny | prAS<<32:
return lbAKAS, LineCanBreak, 310
case lbAP | prAK<<32:
return lbAKAS, LineDontBreak, 281
case lbAP | prAS<<32:
return lbAKAS, LineDontBreak, 281
case lbAKAS | prVF<<32:
return lbAny, LineDontBreak, 281
case lbAKAS | prVI<<32:
return lbAKCircleASVI, LineDontBreak, 281
case lbAKCircleASVI | prAK<<32:
return lbAKAS, LineDontBreak, 281
// LB29.
case lbIS | prAL<<32:
return lbAL, LineDontBreak, 290
case lbIS | prHL<<32:
return lbHL, LineDontBreak, 290
case lbNUIS | prAL<<32:
return lbAL, LineDontBreak, 290
case lbNUIS | prHL<<32:
return lbHL, LineDontBreak, 290
// Transition into QU.
case lbAny | prQU<<32:
return lbQU, LineCanBreak, 310
default:
return -1, -1, -1
}
}
// transitionLineBreakState determines the new state of the line break parser
// given the current state and the next code point. It also returns the type of
// line break: LineDontBreak, LineCanBreak, or LineMustBreak. If more than one
// code point is needed to determine the new state, the byte slice or the string
// starting after rune "r" can be used (whichever is not nil or empty) for
// further lookups.
func transitionLineBreakState(state int, r rune, b []byte, str string) (newState int, lineBreak int) {
// Determine the property of the next character.
nextProperty, generalCategory := propertyLineBreak(r)
// Prepare.
const allBits = lbEastAsianBit | lbZWJBit | lbQUAfterNoEastAsianBit | lbExtPicCnBit | lbPiPfBits
originalBits := state & allBits
if state < 0 {
originalBits = 0
} else {
state &^= allBits
}
isEastAsian := originalBits&lbEastAsianBit != 0 // Used in LB19a and LB30.
forceNoBreak := originalBits&lbZWJBit != 0 // LB8a.
quAfterNoEastAsian := originalBits&lbQUAfterNoEastAsianBit != 0
extPicCn := originalBits&lbExtPicCnBit != 0
piPf := originalBits & lbPiPfBits
isEastAsianProperty := func(r rune) bool {
ea := propertyEastAsianWidth(r)
return ea == prF || ea == prW || ea == prH
}
nextIsEastAsian := isEastAsianProperty(r)
// LB1.
lb1 := func(pr int) int {
switch pr {
case prAI, prSG, prXX:
return prAL
case prSA:
if generalCategory == gcMn || generalCategory == gcMc {
return prCM
} else {
return prAL
}
case prCJ:
return prNS
}
return pr
}
nextProperty = lb1(nextProperty)
// Lookahead helper function. Returns a slice of properties and their runes
// for up to "max" code points from the beginning of b or str.
lookahead := func(max int) ([]int, []rune) {
strCopy := str
bCopy := b
props := make([]int, 0, max)
runes := make([]rune, 0, max)
for i := 0; i < max; i++ {
var (
r rune
size int
)
if bCopy != nil {
r, size = utf8.DecodeRune(bCopy)
} else {
r, size = utf8.DecodeRuneInString(strCopy)
}
if r == utf8.RuneError {
break
}
pr, _ := propertyLineBreak(r)
if bCopy != nil {
bCopy = bCopy[size:]
} else {
strCopy = strCopy[size:]
}
if pr == prCM || pr == prZWJ {
max++
continue // LB9.
}
props = append(props, lb1(pr))
runes = append(runes, r)
}
return props, runes
}
// Combining marks.
if nextProperty == prCM || nextProperty == prZWJ {
var bit int
if nextProperty == prZWJ {
bit = lbZWJBit
}
bit |= originalBits &^ lbZWJBit
mustBreakState := state < 0 || state == lbBK || state == lbCR || state == lbLF || state == lbNL
if !mustBreakState &&
state != lbSP && state != lbZW && state != lbCLCPSP && state != lbB2SP && state != lbZWSP {
// LB9.
return state | bit, LineDontBreak
} else {
// LB10.
if mustBreakState {
return lbAL | bit, LineMustBreak
}
return lbAL | bit, LineCanBreak
}
}
defer func() {
// Determine if the character is East Asian.
if nextIsEastAsian {
newState |= lbEastAsianBit
}
// Override break.
if forceNoBreak {
lineBreak = LineDontBreak
}
// Set Pi/Pf flags.
switch generalCategory {
case gcPi:
newState |= lbIsPi
case gcPf:
newState |= lbIsPf
default:
if generalCategory != gcPf {
newState |= lbIsntPf
} else if generalCategory != gcPi {
newState |= lbIsntPi
}
}
}()
// Find the applicable transition in the table.
var rule int
newState, lineBreak, rule = lbTransitions(state, nextProperty)
if newState < 0 {
// No specific transition found. Try the less specific ones.
anyPropNewState, anyPropLineBreak, anyPropRule := lbTransitions(state, prAny)
anyStateNewState, anyStateLineBreak, anyStateRule := lbTransitions(lbAny, nextProperty)
if anyPropNewState >= 0 && anyStateNewState >= 0 {
// Both apply. We'll use a mix (see comments for grTransitions).
newState, lineBreak, rule = anyStateNewState, anyStateLineBreak, anyStateRule
if anyPropRule < anyStateRule {
lineBreak, rule = anyPropLineBreak, anyPropRule
}
} else if anyPropNewState >= 0 {
// We only have a specific state.
newState, lineBreak, rule = anyPropNewState, anyPropLineBreak, anyPropRule
// This branch will probably never be reached because okAnyState will
// always be true given the current transition map. But we keep it here
// for future modifications to the transition map where this may not be
// true anymore.
} else if anyStateNewState >= 0 {
// We only have a specific property.
newState, lineBreak, rule = anyStateNewState, anyStateLineBreak, anyStateRule
} else {
// No known transition. LB31: ALL ÷ ALL.
newState, lineBreak, rule = lbAny, LineCanBreak, 310
}
}
// LB12a.
if rule > 121 &&
nextProperty == prGL &&
(state != lbSP &&
state != lbHY &&
state != lbHH &&
state != lbLB21a &&
state != lbCLCPSP &&
state != lbB2SP) {
return lbGL, LineDontBreak
}
// LB13.
if rule > 130 && state != lbNU {
switch nextProperty {
case prCL:
return lbCL, LineDontBreak
case prCP:
return lbCP, LineDontBreak
case prSY:
return lbSY, LineDontBreak
}
}
// LB15a.
if nextProperty == prQU &&
generalCategory == gcPi {
// Part 1.
newSt := lbLB15a | lbIsPi
if state < 0 {
return newSt | lbQUAfterNoEastAsianBit, LineDontBreak // LB2.
} else if !isEastAsian {
newSt |= lbQUAfterNoEastAsianBit
}
switch state {
case lbBK, lbCR, lbLF, lbNL:
return newSt, LineMustBreak // LB4, LB5.
case lbOP, lbOPSP, lbGL:
return newSt, LineDontBreak // LB14, LB12.
case lbQU:
if isEastAsian {
return newSt, LineCanBreak // LB31.
}
return newSt, LineDontBreak // LB19a.
case lbSP, lbZWSP, lbZW:
return newSt, LineCanBreak // LB18, LB8.
}
} else if state == lbLB15a {
if nextProperty == prSP {
// Part 2.
return lbLB15a, LineDontBreak // LB7.
} else {
// Part 3.
return newState, LineDontBreak
}
}
// LB15b.
if rule > 152 && nextProperty == prQU && generalCategory == gcPf {
applies := len(b) == 0 && str == ""
if !applies {
if la, _ := lookahead(1); len(la) > 0 {
after := la[0]
applies = after == prSP ||
after == prGL ||
after == prWJ ||
after == prCL ||
after == prQU ||
after == prCP ||
after == prEX ||
after == prIS ||
after == prSY ||
after == prBK ||
after == prCR ||
after == prLF ||
after == prNL ||
after == prZW
}
}
if applies {
newState = lbQU
if state < 0 || !isEastAsian {
newState |= lbQUAfterNoEastAsianBit
}
return newState, LineDontBreak
}
}
// LB15c.
if rule > 153 && (state == lbSP || state == lbZWSP || state == lbOPSP) && nextProperty == prIS {
if la, _ := lookahead(1); len(la) > 0 {
after := la[0]
if after == prNU {
return lbIS, LineCanBreak
}
}
}
// LB19.
if rule > 190 {
// First rule.
if nextProperty == prQU && generalCategory != gcPi {
newState = lbQU
if state < 0 || !isEastAsian {
newState |= lbQUAfterNoEastAsianBit
}
return newState, LineDontBreak
}
// Second rule.
if state == lbQU && (piPf == lbIsPi || piPf == lbIsntPf) {
return newState, LineDontBreak
}
}
// LB19a.
if rule > 191 {
if nextProperty == prQU {
// First rule.
if state < 0 || !isEastAsian {
return lbQU | lbQUAfterNoEastAsianBit, LineDontBreak
}
// Second rule (eot).
if len(b) == 0 && str == "" {
return lbQU, LineDontBreak
}
if _, la := lookahead(1); len(la) > 0 {
// Second rule (not EastAsian).
if !isEastAsianProperty(la[0]) {
return lbQU, LineDontBreak
}
}
}
// Third and fourth rule.
if state == lbQU && (!nextIsEastAsian || quAfterNoEastAsian) {
return newState, LineDontBreak
}
}
// LB20a.
if state == lbLB20a {
return newState, LineDontBreak
} else if nextProperty == prHY || nextProperty == prHH {
if la, _ := lookahead(1); len(la) > 0 {
after := la[0]
if after == prAL || after == prHL {
if state < 0 {
return lbLB20a, LineDontBreak // LB2.
}
switch state {
case lbBK, lbCR, lbLF, lbNL:
return lbLB20a, LineMustBreak // LB4, LB5.
case lbSP, lbZWSP, lbOPSP:
return lbLB20a, lineBreak // LB8, LB14, LB18.
case lbZW, lbCB:
return lbLB20a, LineCanBreak // LB8, LB20.
case lbGL:
return lbLB20a, LineDontBreak // LB12.
}
}
}
}
// LB21a.
if state == lbLB21a {
return newState, LineDontBreak
}
if state == lbHL && (nextProperty == prHY || nextProperty == prHH) {
if la, _ := lookahead(1); len(la) > 0 {
if la[0] != prHL {
return lbLB21a, LineDontBreak // LB21.
}
}
}
// LB25.
if rule > 250 &&
(state == lbPR || state == lbPO) &&
nextProperty == prOP {
la, _ := lookahead(2)
if len(la) > 0 {
switch la[0] {
case prNU:
return lbOP, LineDontBreak
case prIS:
if len(la) > 1 && la[1] == prNU {
return lbOP, LineDontBreak
}
}
}
}
// LB28a.
if rule > 281 {
const dottedCircle = '\u25cc'
if (state == lbAP || state == lbAKCircleASVI) && r == dottedCircle {
return lbDottedCircle, LineDontBreak
}
if state == lbDottedCircle {
if nextProperty == prVF {
return lbAny, LineDontBreak
}
if nextProperty == prVI {
return lbAKCircleASVI, LineDontBreak
}
}
if (state == lbAKAS || state == lbDottedCircle) &&
(nextProperty == prAK || r == dottedCircle || nextProperty == prAS) {
if la, _ := lookahead(1); len(la) > 0 {
if la[0] == prVF {
if r == dottedCircle {
return lbDottedCircle, LineDontBreak
} else {
return lbAKAS, LineDontBreak
}
}
}
}
if r == dottedCircle {
newState, rule = lbDottedCircle, 310
}
}
// LB30 (part one).
if rule > 300 {
if (state == lbAL || state == lbDottedCircle || state == lbHL || state == lbNU) &&
nextProperty == prOP && !nextIsEastAsian {
return lbOP, LineDontBreak
}
if (state == lbCP || state == lbNUCP) && !isEastAsian {
switch nextProperty {
case prAL:
return lbAL, LineDontBreak
case prHL:
return lbHL, LineDontBreak
case prNU:
return lbNU, LineDontBreak
}
}
}
// LB30a.
if newState == lbAny && nextProperty == prRI {
if state != lbOddRI && state != lbEvenRI { // Includes state == -1.
// Transition into the first RI.
return lbOddRI, lineBreak
}
if state == lbOddRI {
// Don't break pairs of Regional Indicators.
return lbEvenRI, LineDontBreak
}
return lbOddRI, lineBreak
}
// LB30b.
if rule > 302 {
if nextProperty == prEM {
if state == lbEB || extPicCn {
return lbAny, LineDontBreak
}
}
graphemeProperty := propertyGraphemes(r)
if graphemeProperty == prExtendedPictographic && generalCategory == gcCn {
return newState | lbExtPicCnBit, LineCanBreak
}
}
return
}