let string = _syntax.floatingDigits.text

let isHexadecimal: Bool
let stringWithoutPrefix: String
switch string.prefix(2) {
    case "0x":
        isHexadecimal = true
        stringWithoutPrefix = String(string.dropFirst(2))
    default:
        isHexadecimal = false
        stringWithoutPrefix = string
}

let exponentSeparator: Character = isHexadecimal ? "p" : "e"
let parts = stringWithoutPrefix.lowercased().split(separator: exponentSeparator)
guard parts.count <= 2 else {
    fatalError("Float literal cannot contain more than one exponent separator")
}

let exponentValue: Int
if parts.count == 2 {
    // The exponent part is always decimal
    let exponentPart = parts[1]
    let exponentPartWithoutUnderscores = exponentPart.replacingOccurrences(of: "_", with: "")
    guard
        exponentPart.first != "_",
        !exponentPart.starts(with: "-_"),
        let exponent = Int(exponentPartWithoutUnderscores)
    else {
        fatalError("Float literal has invalid exponent part: \(string)")
    }
    exponentValue = exponent
} else {
    exponentValue = 0
}

let partsBeforeExponent = parts[0].split(separator: ".")
guard partsBeforeExponent.count <= 2 else {
    fatalError("Float literal cannot contain more than one decimal point: \(string)")
}

// The integer part can contain underscores anywhere except for the first character (which must be a digit).
let radix = isHexadecimal ? 16 : 10
let integerPart = partsBeforeExponent[0]
let integerPartWithoutUnderscores = integerPart.replacingOccurrences(of: "_", with: "")
guard
    integerPart.first != "_",
    let integerPartValue = Int(integerPartWithoutUnderscores, radix: radix).map(Double.init)
else {
    fatalError("Float literal has invalid integer part: \(string)")
}

let fractionalPartValue: Double
if partsBeforeExponent.count == 2 {
    // The fractional part can contain underscores anywhere except for the first character (which must be a digit).
    let fractionalPart = partsBeforeExponent[1]
    let fractionalPartWithoutUnderscores = fractionalPart.replacingOccurrences(of: "_", with: "")
    guard
        fractionalPart.first != "_",
        let fractionalPartDigitsValue = Int(fractionalPartWithoutUnderscores, radix: radix)
    else {
        fatalError("Float literal has invalid fractional part: \(string)")
    }

    fractionalPartValue = Double(fractionalPartDigitsValue) / pow(Double(radix), Double(fractionalPart.count - 1))
} else {
    fractionalPartValue = 0
}

let base: Double = isHexadecimal ? 2 : 10
let multiplier = pow(base, Double(exponentValue))
let sign: Double = _negationSyntax == nil ? 1 : -1

return (integerPartValue + fractionalPartValue) * multiplier * sign

let segments = _syntax.segments.compactMap { (segment) -> String? in
    guard case let .stringSegment(segment) = segment else {
        return nil
    }
    return segment.content.text
}
guard segments.count == _syntax.segments.count else {
    return nil
}

let map: [Character: Character] = [
    "\\": "\\",
    "n": "\n",
    "r": "\r",
    "t": "\t",
    "0": "\0",
    "\"": "\"",
    "'": "'"
]
let hexadecimalCharacters = "0123456789abcdefABCDEF"

// The length of the `\###...` sequence that starts an escape sequence (zero hashes if not a raw string)
let escapeSequenceDelimiterLength = (_syntax.openDelimiter?.text.count ?? 0) + 1
// Evaluate backslash escape sequences within each segment before joining them together
let transformedSegments = segments.map { segment in
    var characters: [Character] = []
    var inEscapeSequence = false
    var iterator = segment.makeIterator()
    var escapeSequenceDelimiterPosition = 0 // Tracks the current position in the delimiter if parsing one
    while let c = iterator.next() {
        if inEscapeSequence {
            if let replacement = map[c] {
                characters.append(replacement)
            } else if c == "u" {
                var count = 0
                var digits: [Character] = []
                var iteratorCopy = iterator

                guard iterator.next() == "{" else {
                    fatalError("Expected '{' in unicode scalar escape sequence")
                }

                var foundClosingBrace = false
                while let c = iterator.next() {
                    if c == "}" {
                        foundClosingBrace = true
                        break
                    }

                    guard hexadecimalCharacters.contains(c) else {
                        iterator = iteratorCopy
                        break
                    }
                    iteratorCopy = iterator

                    digits.append(c)
                    count += 1
                }

                guard foundClosingBrace else {
                    fatalError("Expected '}' in unicode scalar escape sequence")
                }

                if !(1...8).contains(count) {
                    fatalError("Invalid unicode character escape sequence (must be 1 to 8 digits)")
                }

                guard
                    let value = UInt32(digits.map(String.init).joined(separator: ""), radix: 16),
                    let scalar = Unicode.Scalar(value)
                else {
                    fatalError("Invalid unicode scalar hexadecimal value literal")
                }

                characters.append(Character(scalar))
            }
            inEscapeSequence = false
        } else if c == "\\" && escapeSequenceDelimiterPosition == 0 {
            escapeSequenceDelimiterPosition += 1
        } else if !inEscapeSequence && c == "#" && escapeSequenceDelimiterPosition != 0 {
            escapeSequenceDelimiterPosition += 1
        } else {
            if escapeSequenceDelimiterPosition != 0 {
                characters.append("\\")
                for _ in 0..<(escapeSequenceDelimiterPosition - 1) {
                    characters.append("#")
                }
                escapeSequenceDelimiterPosition = 0
            }
            characters.append(c)
        }
        if escapeSequenceDelimiterPosition == escapeSequenceDelimiterLength {
            inEscapeSequence = true
            escapeSequenceDelimiterPosition = 0
        }
    }
    return characters.map(String.init).joined(separator: "")
}

return transformedSegments.joined(separator: "")