private static RuleResult LB25()

in src/Avalonia.Base/Media/TextFormatting/Unicode/LineBreakEnumerator.cs [903:1126]
185 lines of code
46 McCabe index (conditional complexity)

        private static RuleResult LB25(ReadOnlySpan<char> text, LineBreakState state)
        {
            switch (state.Next(text).LineBreakClass)
            {
                // [25.06] NU(SY|IS)* x PR
                case LineBreakClass.PrefixNumeric:
                    {
                        switch (state.Current.LineBreakClass)
                        {
                            // [25.04] NU(SY|IS)* CP × PR
                            case LineBreakClass.CloseParenthesis:
                                {
                                    switch (state.Previous.LineBreakClass)
                                    {
                                        case LineBreakClass.Numeric:
                                            {
                                                return RuleResult.NoBreak;
                                            }

                                        case LineBreakClass.BreakSymbols:
                                        case LineBreakClass.InfixNumeric:
                                            {
                                                if (LineBreakState.Before(text, state.Previous).LineBreakClass == LineBreakClass.Numeric)
                                                {
                                                    return RuleResult.NoBreak;
                                                }

                                                break;
                                            }
                                    }

                                    break;
                                }

                            case LineBreakClass.Numeric:
                                {
                                    return RuleResult.NoBreak;
                                }
                            case LineBreakClass.BreakSymbols:
                            case LineBreakClass.InfixNumeric:
                                {
                                    if (state.Previous.LineBreakClass == LineBreakClass.Numeric)
                                    {
                                        return RuleResult.NoBreak;
                                    }

                                    break;
                                }
                            // [25.03] NU(SY|IS)* CL × PR
                            case LineBreakClass.ClosePunctuation:
                                {
                                    switch (state.Previous.LineBreakClass)
                                    {
                                        case LineBreakClass.Numeric:
                                            {
                                                return RuleResult.NoBreak;
                                            }
                                        case LineBreakClass.BreakSymbols:
                                        case LineBreakClass.InfixNumeric:
                                            {
                                                if (state.Previous.LineBreakClass == LineBreakClass.Numeric)
                                                {
                                                    return RuleResult.NoBreak;
                                                }

                                                break;
                                            }
                                    }

                                    break;
                                }
                        }

                        break;
                    }
                // [25.15] NU(SY|IS)* ×	NU
                case LineBreakClass.Numeric:
                    {
                        switch (state.Current.LineBreakClass)
                        {
                            case LineBreakClass.Numeric:
                                {
                                    return RuleResult.NoBreak;
                                }
                            case LineBreakClass.BreakSymbols:
                            case LineBreakClass.InfixNumeric:
                                {
                                    if (state.Previous.LineBreakClass == LineBreakClass.Numeric)
                                    {
                                        return RuleResult.NoBreak;
                                    }

                                    break;
                                }
                        }

                        break;
                    }

                case LineBreakClass.PostfixNumeric:
                    {
                        switch (state.Current.LineBreakClass)
                        {
                            // [25.01] NU(SY|IS)* CL × PO
                            case LineBreakClass.ClosePunctuation:
                                {
                                    switch (state.Previous.LineBreakClass)
                                    {
                                        case LineBreakClass.Numeric:
                                            {
                                                return RuleResult.NoBreak;
                                            }
                                        case LineBreakClass.BreakSymbols:
                                        case LineBreakClass.InfixNumeric:
                                            {
                                                if (state.Previous.LineBreakClass == LineBreakClass.Numeric)
                                                {
                                                    return RuleResult.NoBreak;
                                                }

                                                break;
                                            }
                                    }

                                    break;
                                }
                            // [25.05] NU(SY|IS)* ×	PO
                            case LineBreakClass.Numeric:
                                {
                                    return RuleResult.NoBreak;
                                }
                            case LineBreakClass.BreakSymbols:
                            case LineBreakClass.InfixNumeric:
                                {
                                    if (state.Previous.LineBreakClass == LineBreakClass.Numeric)
                                    {
                                        return RuleResult.NoBreak;
                                    }

                                    break;
                                }
                        }

                        break;
                    }
            }

            if (state.Current.LineBreakClass == LineBreakClass.PrefixNumeric)
            {
                switch (state.Next(text).LineBreakClass)
                {
                    case LineBreakClass.OpenPunctuation:
                        {
                            var afterNext = LineBreakState.After(text, state.Next(text));

                            // [25.1] PR × OP NU
                            if (afterNext.LineBreakClass == LineBreakClass.Numeric)
                            {
                                return RuleResult.NoBreak;
                            }

                            // PR × OP IS NU
                            if (afterNext.LineBreakClass == LineBreakClass.InfixNumeric && LineBreakState.After(text, afterNext).LineBreakClass == LineBreakClass.Numeric)
                            {
                                return RuleResult.NoBreak;
                            }

                            break;
                        }
                    // PR × NU
                    case LineBreakClass.Numeric:
                        {
                            return RuleResult.NoBreak;
                        }
                }
            }

            if (state.Current.LineBreakClass == LineBreakClass.PostfixNumeric)
            {
                switch (state.Next(text).LineBreakClass)
                {
                    case LineBreakClass.OpenPunctuation:
                        {
                            var afterNext = LineBreakState.After(text, state.Next(text));

                            // PO × OP NU
                            if (afterNext.LineBreakClass == LineBreakClass.Numeric)
                            {
                                return RuleResult.NoBreak;
                            }

                            // PO × OP IS NU
                            if (afterNext.LineBreakClass == LineBreakClass.InfixNumeric && LineBreakState.After(text, afterNext).LineBreakClass == LineBreakClass.Numeric)
                            {
                                return RuleResult.NoBreak;
                            }

                            break;
                        }
                    // PO × NU
                    case LineBreakClass.Numeric:
                        {
                            return RuleResult.NoBreak;
                        }
                }
            }

            switch (state.Current.LineBreakClass)
            {
                // HY × NU
                // [25.14] IS × NU
                case LineBreakClass.Hyphen:
                case LineBreakClass.InfixNumeric:
                    {
                        if (state.Next(text).LineBreakClass == LineBreakClass.Numeric)
                        {
                            return RuleResult.NoBreak;
                        }
                        break;
                    }
            }

            return RuleResult.Pass;
        }