fix(bigint): treat empty octets as zero in BigInt::from_octets

An empty big-endian magnitude naturally denotes zero, and mainstream
bigint APIs agree: Java's BigInteger(signum, magnitude) permits a
zero-length magnitude for any signum, Python's int.from_bytes(b"")
returns 0, and Rust's num-bigint normalizes Sign::Minus with an empty
magnitude to zero. Previously MoonBit was the outlier, aborting with
"empty octet string" whenever signum != 0, while still accepting the
morally identical all-zero magnitude (e.g. b"\x00" with signum=-1).

Relax the panic on both backends to return zero, update the docs, and
replace the panic tests with value tests covering every signum.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: bobzhang

bigint/bigint_js.mbt

@@ -199,12 +199,15 @@ extern "js" fn hex2(b : Byte) -> String =
 /// Parameters:
 ///
 /// * `octets` : A sequence of bytes representing the magnitude of the number in
-/// big-endian order. It must not be empty unless `signum` is 0.
+/// big-endian order. An empty sequence represents a zero magnitude.
 /// * `signum` : The sign of the resulting number. A negative value creates a
 /// negative number, zero returns zero, and a positive value creates a positive
 /// number. Defaults to 1.
 ///
 /// Returns a `BigInt` value represented by the byte sequence and sign.
+///
+/// An empty byte sequence yields zero for any `signum`, matching the behavior
+/// of Java's `BigInteger`, Python's `int.from_bytes`, and Rust's `num-bigint`.
 pub fn BigInt::from_octets(octets : BytesView, signum? : Int = 1) -> BigInt {
   if signum < 0 {
     return -1N * BigInt::from_octets(octets, signum=1)
@@ -213,7 +216,7 @@ pub fn BigInt::from_octets(octets : BytesView, signum? : Int = 1) -> BigInt {
     return 0N
   }
   if octets.is_empty() {
-    abort("empty octet string")
+    return 0N
   }
   let str = StringBuilder()
   for octet in octets {

bigint/bigint_nonjs.mbt

@@ -1428,15 +1428,16 @@ pub fn BigInt::pow(self : BigInt, exp : BigInt, modulus? : BigInt) -> BigInt {
 /// Parameters:
 ///
 /// * `bytes` : A sequence of bytes representing the magnitude of the number in
-/// big-endian order. The sequence must not be empty unless `sign` is 0.
+/// big-endian order. An empty sequence represents a zero magnitude.
 /// * `sign` : An integer specifying the sign of the resulting number (default:
 /// 1). A value of 1 creates a positive number, -1 creates a negative number, and
 /// 0 returns zero regardless of the input bytes.
 ///
 /// Returns a `BigInt` value representing the number encoded in the byte sequence
 /// with the specified sign.
 ///
-/// Throws a panic if the input byte sequence is empty and the sign is not 0.
+/// An empty byte sequence yields zero for any `sign`, matching the behavior of
+/// Java's `BigInteger`, Python's `int.from_bytes`, and Rust's `num-bigint`.
 ///
 /// Example:
 ///
@@ -1447,6 +1448,7 @@ pub fn BigInt::pow(self : BigInt, exp : BigInt, modulus? : BigInt) -> BigInt {
 ///   let negative = @bigint.BigInt::from_octets(bytes, signum=-1)
 ///   inspect(positive, content="66051")
 ///   inspect(negative, content="-66051")
+///   inspect(@bigint.BigInt::from_octets(b""), content="0")
 /// }
 /// ```
 pub fn BigInt::from_octets(input : BytesView, signum? : Int = 1) -> BigInt {
@@ -1457,7 +1459,7 @@ pub fn BigInt::from_octets(input : BytesView, signum? : Int = 1) -> BigInt {
     return -BigInt::from_octets(input)
   }
   if len == 0 {
-    abort("empty octet string")
+    return zero
   }
   let div = len * 8 / RADIX_BIT_LEN
   let mod = len * 8 % RADIX_BIT_LEN // number of bits in the first limb

bigint/bigint_test.mbt

@@ -67,8 +67,10 @@ test "to_octets pads larger length" {
 }
 
 ///|
-test "from_octets accepts empty input with zero signum" {
+test "from_octets treats empty input as zero" {
+  inspect(@bigint.BigInt::from_octets(b""), content="0")
   inspect(@bigint.BigInt::from_octets(b"", signum=0), content="0")
+  inspect(@bigint.BigInt::from_octets(b"", signum=-1), content="0")
 }
 
 ///|

bigint/panic_test.mbt

@@ -85,16 +85,6 @@ test "panic pow negative exponent" {
   base.pow(exp) |> ignore
 }
 
-///|
-test "panic from_octets empty" {
-  @bigint.BigInt::from_octets(Bytes::new(0)) |> ignore
-}
-
-///|
-test "panic from_octets empty negative signum" {
-  @bigint.BigInt::from_octets(Bytes::new(0), signum=-1) |> ignore
-}
-
 ///|
 test "panic to_octets negative" {
   (-1N).to_octets() |> ignore

builtin/panic_test.mbt

@@ -158,11 +158,6 @@ test "panic to_octets coverage for negative number than required" {
   (-123456789N).to_octets() |> ignore
 }
 
-///|
-test "panic from_octets coverage for empty octets" {
-  BigInt::from_octets(b"") |> ignore
-}
-
 ///|
 test "panic sub_string with invalid byte_length" {
   let bytes = b"Hello, World!"