Una manera fácil de obtener la representación del complemento a dos para BigInts negativos es usar BigInt.asUintN(bit_width, bigint) :

 > BigInt.asUintN(64, -42n).toString(2) '1111111111111111111111111111111111111111111111111111111111010110'

Tenga en cuenta que:

• Debe definir la cantidad de bits que desea (64 en mi ejemplo), no hay un valor "natural"/automático para eso.
• Dada solo esa cadena de dígitos binarios, no hay forma de saber si se trata de un BigInt positivo (con un valor cercano a 2n**64n) o una representación de complemento a dos de -42n. Entonces, si desea revertir la conversión más tarde, deberá proporcionar esta información de alguna manera (por ejemplo, escribiendo su código de manera que asuma implícitamente una u otra opción).
• De manera relacionada, no es así como -42n se almacena internamente en los navegadores actuales. (Pero eso no tiene por qué preocuparte, ya que puedes crear esta salida cuando quieras o necesites).
• Podría lograr el mismo resultado con una resta: ((2n ** 64n) - 42n).toString(2) -- nuevamente, puede especificar cuántos bits desea ver.

¿Hay algo como bitAtIndex para BigInt ?

No, porque no hay ninguna especificación sobre cómo se representan los BigInts. Los motores pueden optar por utilizar los bits de la forma que deseen, siempre que los BigInts resultantes se comporten como exige la especificación.

@Kyroath:

BigInts negativos se representan como complemento a dos de longitud infinita

No, no lo son: las implementaciones en los navegadores actuales representan BigInts como "signo + magnitud", no como complemento a dos. Sin embargo, este es un detalle de implementación no observable: las implementaciones podrían cambiar la forma en que almacenan BigInts internamente, y BigInts se comportaría de la misma manera.

Lo que probablemente quiso decir es que la representación en complemento a dos de cualquier número entero negativo (grande o no) es conceptualmente un flujo infinito de 1 bits, por lo que imprimir o almacenar eso en un espacio finito siempre requiere definir una cantidad de caracteres/bits después de los cuales la corriente simplemente se corta. Cuando tiene un tipo de ancho fijo, eso obviamente define este punto de corte; para BigInts conceptualmente ilimitados, debe definirlo usted mismo.

Esta es una forma de convertir BigInts de 64 bits en cadenas binarias:

 // take two's complement of a binary string const twosComplement = (binaryString) => { let complement = BigInt('0b' + binaryString.split('').map(e => e === "0" ? "1" : "0").join('')); return decToBinary(complement + BigInt(1)); } const decToBinary = (num) => { let result = "" const isNegative = num < 0; if (isNegative) num = -num; while (num > 0) { result = (num % BigInt(2)) + result; num /= BigInt(2); } if (result.length > 64) result = result.substring(result.length - 64); result = result.padStart(64, "0"); if (isNegative) result = twosComplement(result); return result; } console.log(decToBinary(BigInt(5))); // 0000000000000000000000000000000000000000000000000000000000000101 console.log(decToBinary(BigInt(-5))); // 1111111111111111111111111111111111111111111111111111111111111011

Sin embargo, este código no hace ninguna validación.