This one was the easiest. I noticed Viem was using numeric separators, so I did some quick Googling and found this Babel transform for it

Viem uses named capture groups. Through some digging, I found this GitHub comment that informed me of this Babel transform that allows us to support named capture groups

Our version of Hermes has a peculiar subset of BigInt supported: see here. We have most of BigInt, but no support for BigInt literals like 0n.

Babel doesn't support transforming BigInt literals to eg. BigInt(0) constructors:

I think that's because they don't expect BigInt constructors to work if BigInt literals don't.

Instead, they rewrite BigInt literals to JSBI.BigInt(0) syntax, which we don't want. They also do a bunch of other transforms to get around an assumed total lack of BigInt support.

In our case, we only really want a specific transform: BigInt literals to BigInt(0) syntax.

What I'm doing here with this patch is:

1. Removing almost the entirety of this Babel transform, as we don't need most of it. All that I left was the BigInt literal transform
2. For the BigInt literal transform, remove the JSBI. part

Here's all that's left in node_modules/babel-plugin-transform-bigint/index.js:

// see https://github.com/babel/babel/pull/6015

const syntaxBigInt = require('@babel/plugin-syntax-bigint').default;

module.exports = function (babel) {
  const types = babel.types;
  return {
    inherits: syntaxBigInt,
    visitor: {
      BigIntLiteral: function (path, state) {
        const value = path.node.value;
        const number = Number(value); //TODO:
        if (number >= Number.MIN_SAFE_INTEGER && number <= Number.MAX_SAFE_INTEGER) {
          // 1n -> JSBI.BigInt(1)
          path.replaceWith(types.callExpression(types.identifier('BigInt'), [types.numericLiteral(number)]));
        } else {
          // 9007199254740993n -> JSBI.BigInt('9007199254740993')
          path.replaceWith(types.callExpression(types.identifier('BigInt'), [types.StringLiteral(value)]));
        }
      },
    },
  };
};