Function getNumericToolTip

static/utils.ts:108–160

(value: string, digitSeparator?: string)

}

export function getNumericToolTip(value: string, digitSeparator?: string): string | null {
    const formatNumber = (num: bigInt.BigInteger, base: number, chunkSize: number) => {
        const numberString = num.toString(base).toUpperCase();
        if (digitSeparator !== undefined) {
            return addDigitSeparator(numberString, digitSeparator, chunkSize);
        }
        return numberString;
    };
    const numericValue = parseNumericValue(value);
    if (numericValue === null) return null;

    // PTX floats
    const view = new DataView(new ArrayBuffer(8));
    view.setBigUint64(0, BigInt(numericValue.toString()), true);
    if (ptxFloat32.test(value)) return view.getFloat32(0, true).toPrecision(9) + 'f';
    if (ptxFloat64.test(value)) return view.getFloat64(0, true).toPrecision(17);

    // Decimal representation.
    let result = formatNumber(numericValue, 10, 3);

    // Hexadecimal representation.
    if (numericValue.isNegative()) {
        const masked = bigInt('ffffffffffffffff', 16).and(numericValue);
        result += ' = 0x' + formatNumber(masked, 16, 4);
    } else {
        result += ' = 0x' + formatNumber(numericValue, 16, 4);
    }

    // Float32/64 representation.
    view.setBigUint64(0, BigInt(numericValue.toString()), true);
    if (numericValue.bitLength().lesserOrEquals(32)) result += ' = ' + view.getFloat32(0, true).toPrecision(9) + 'f';
    // only subnormal doubles and zero may have upper 32 bits all 0, assume unlikely to be double
    else result += ' = ' + view.getFloat64(0, true).toPrecision(17);

    // Printable UTF-8 characters.
    const bytes = numericValue.isNegative()
        ? // bytes of negative number without sign extension
          numericValue
              .add(1)
              .toArray(256)
              .value.map(byte => byte ^ 0xff)
        : numericValue.toArray(256).value;
    // This assumes that `numericValue` is encoded as little-endian.
    bytes.reverse();
    const decoder = new TextDecoder('utf-8', {fatal: true});
    try {
        result += ' = ' + JSON.stringify(decoder.decode(Uint8Array.from(bytes)));
    } catch {
        // ignore `TypeError` when the number is not valid UTF-8
    }

    return result;
}

// zip two arrays up until min(a.length, b.length)
export function* zip<T>(a: T[], b: T[]) {