Method breaksAt

packages/intl-segmenter/segmenter.ts:199–261

(
    position: number,
    input: string
  )

  }

  public breaksAt(
    position: number,
    input: string
  ): ReturnType<typeof breaksAtResult> {
    const ruleSortedKeys = this.ruleSortedKeys
    const rules = this.rules
    const mergedSegmentationTypeValue = this.mergedSegmentationTypeValue

    //artificial rule 0.2
    if (position === 0) {
      return breaksAtResult(true, '0.2')
    }

    if (position === input.length) {
      //rule 0.3
      return breaksAtResult(true, '0.3')
    }

    //artificial rule 0.1: js specific, due to es5 regex not being unicode aware
    //number 0.1 chosen to mimic java implementation, but needs to execute after 0.2 and 0.3 to be inside the string bounds
    if (isSurrogate(input, position)) {
      return breaksAtResult(false, '0.1')
    }

    const stringBeforeBreak = input.substring(0, position)
    const stringAfterBreak = input.substring(position)

    //artificial rule 0.4: handle suppressions
    if ('suppressions' in mergedSegmentationTypeValue) {
      for (const suppressions of mergedSegmentationTypeValue.suppressions) {
        if (stringBeforeBreak.trim().endsWith(suppressions)) {
          return breaksAtResult(false, '0.4')
        }
      }
    }

    // loop through rules and find a match
    for (const ruleKey of ruleSortedKeys) {
      const {before, after, breaks} = rules[ruleKey]
      // for debugging
      // if (ruleKey === '16' && position === 4) {
      //   console.log({before, after, stringBeforeBreak, stringAfterBreak})
      // }
      if (before) {
        if (!before.test(stringBeforeBreak)) {
          //didn't match the before part, therfore skipping
          continue
        }
      }

      if (after) {
        if (!after.test(stringAfterBreak)) {
          //didn't match the after part, therfore skipping
          continue
        }
      }

      return breaksAtResult(breaks, ruleKey)