html-to-markdown 2.23.4 → 2.24.1

data/rust-vendor/zmij/Cargo.lock

@@ -46,9 +46,9 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.2.53"
+version = "1.2.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932"
+checksum = "6354c81bbfd62d9cfa9cb3c773c2b7b2a3a482d569de977fd0e961f6e7c00583"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -301,18 +301,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.105"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "535d180e0ecab6268a3e718bb9fd44db66bbbc256257165fc699dadf70d16fe7"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.43"
+version = "1.0.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc74d9a594b72ae6656596548f56f667211f8a97b3d4c3d467150794690dc40a"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
 dependencies = [
  "proc-macro2",
 ]
@@ -436,7 +436,7 @@ dependencies = [
  "memchr",
  "serde",
  "serde_core",
- "zmij 1.0.15",
+ "zmij 1.0.16",
 ]
 
 [[package]]
@@ -565,13 +565,13 @@ dependencies = [
 
 [[package]]
 name = "zmij"
-version = "1.0.15"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94f63c051f4fe3c1509da62131a678643c5b6fbdc9273b2b79d4378ebda003d2"
+checksum = "dfcd145825aace48cff44a8844de64bf75feec3080e0aa5cdbde72961ae51a65"
 
 [[package]]
 name = "zmij"
-version = "1.0.16"
+version = "1.0.17"
 dependencies = [
  "criterion",
  "no-panic",

data/rust-vendor/zmij/Cargo.toml

@@ -13,7 +13,7 @@
 edition = "2021"
 rust-version = "1.68"
 name = "zmij"
-version = "1.0.16"
+version = "1.0.17"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 build = "build.rs"
 exclude = ["*.png"]

data/rust-vendor/zmij/Cargo.toml.orig

@@ -1,6 +1,6 @@
 [package]
 name = "zmij"
-version = "1.0.16"
+version = "1.0.17"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 categories = ["value-formatting", "no-std", "no-std::no-alloc"]
 description = "A double-to-string conversion algorithm based on Schubfach and yy"

data/rust-vendor/zmij/README.md

@@ -11,7 +11,7 @@ numbers to decimal strings.
 This Rust implementation is a line-by-line port of Victor Zverovich's
 implementation in C++, [https://github.com/vitaut/zmij][upstream].
 
-[upstream]: https://github.com/vitaut/zmij/tree/964a4ad5597a4b67a45e92cca0e61521caeb511c
+[upstream]: https://github.com/vitaut/zmij/tree/25bd96ee970eadf94f08fbd6ff39b712c4f55e7e
 
 ## Example
 

data/rust-vendor/zmij/src/lib.rs

@@ -41,7 +41,7 @@
 //! ![performance](https://raw.githubusercontent.com/dtolnay/zmij/master/dtoa-benchmark.png)
 
 #![no_std]
-#![doc(html_root_url = "https://docs.rs/zmij/1.0.16")]
+#![doc(html_root_url = "https://docs.rs/zmij/1.0.17")]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(non_camel_case_types, non_snake_case)]
 #![allow(
@@ -77,8 +77,6 @@ mod traits;
 
 #[cfg(all(any(target_arch = "aarch64", target_arch = "x86_64"), not(miri)))]
 use core::arch::asm;
-#[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-use core::arch::x86_64::__m128i;
 #[cfg(not(zmij_no_select_unpredictable))]
 use core::hint;
 use core::mem::{self, MaybeUninit};
@@ -320,7 +318,7 @@ const fn do_compute_exp_shift(bin_exp: i32, dec_exp: i32) -> u8 {
 
 struct ExpShiftTable {
     data: [u8; if Self::ENABLE {
-        Self::NUM_EXPS as usize
+        f64::EXP_MASK as usize + 1
     } else {
         1
     }],
@@ -328,27 +326,24 @@ struct ExpShiftTable {
 
 impl ExpShiftTable {
     const ENABLE: bool = true;
-    const NUM_EXPS: i32 = f64::EXP_MASK + 1;
 }
 
 static EXP_SHIFTS: ExpShiftTable = {
     let mut data = [0u8; if ExpShiftTable::ENABLE {
-        ExpShiftTable::NUM_EXPS as usize
+        f64::EXP_MASK as usize + 1
     } else {
         1
     }];
 
-    if ExpShiftTable::ENABLE {
-        let mut raw_exp = 0;
-        while raw_exp < ExpShiftTable::NUM_EXPS {
-            let mut bin_exp = raw_exp - f64::EXP_OFFSET;
-            if raw_exp == 0 {
-                bin_exp += 1;
-            }
-            let dec_exp = compute_dec_exp(bin_exp, true);
-            data[raw_exp as usize] = do_compute_exp_shift(bin_exp, dec_exp) as u8;
-            raw_exp += 1;
+    let mut raw_exp = 0;
+    while raw_exp < data.len() && ExpShiftTable::ENABLE {
+        let mut bin_exp = raw_exp as i32 - f64::EXP_OFFSET;
+        if raw_exp == 0 {
+            bin_exp += 1;
         }
+        let dec_exp = compute_dec_exp(bin_exp, true);
+        data[raw_exp] = do_compute_exp_shift(bin_exp, dec_exp) as u8;
+        raw_exp += 1;
     }
 
     ExpShiftTable { data }
@@ -426,9 +421,11 @@ unsafe fn digits2(value: usize) -> &'static u16 {
 const DIV10K_EXP: i32 = 40;
 const DIV10K_SIG: u32 = ((1u64 << DIV10K_EXP) / 10000 + 1) as u32;
 const NEG10K: u32 = ((1u64 << 32) - 10000) as u32;
+
 const DIV100_EXP: i32 = 19;
 const DIV100_SIG: u32 = (1 << DIV100_EXP) / 100 + 1;
 const NEG100: u32 = (1 << 16) - 100;
+
 const DIV10_EXP: i32 = 10;
 const DIV10_SIG: u32 = (1 << DIV10_EXP) / 10 + 1;
 const NEG10: u32 = (1 << 8) - 10;
@@ -467,31 +464,16 @@ unsafe fn write8(buffer: *mut u8, value: u64) {
     }
 }
 
-#[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-const fn splat64(x: u64) -> __m128i {
-    unsafe { mem::transmute::<[u64; 2], __m128i>([x, x]) }
-}
-
-#[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-const fn splat32(x: u32) -> __m128i {
-    splat64(((x as u64) << 32) | x as u64)
-}
-
-#[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-const fn splat16(x: u16) -> __m128i {
-    splat32(((x as u32) << 16) | x as u32)
-}
-
-#[cfg(all(target_arch = "x86_64", target_feature = "sse4.1", not(miri)))]
-const fn pack8(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8, g: u8, h: u8) -> u64 {
-    ((h as u64) << 56)
-        | ((g as u64) << 48)
-        | ((f as u64) << 40)
-        | ((e as u64) << 32)
-        | ((d as u64) << 24)
-        | ((c as u64) << 16)
-        | ((b as u64) << 8)
-        | a as u64
+// Writes a significand consisting of up to 9 decimal digits (8-9 for normals)
+// and removes trailing zeros.
+#[cfg_attr(feature = "no-panic", no_panic)]
+unsafe fn write_significand9(mut buffer: *mut u8, value: u32, has9digits: bool) -> *mut u8 {
+    buffer = unsafe { write_if(buffer, value / 100_000_000, has9digits) };
+    let bcd = to_bcd8(u64::from(value % 100_000_000));
+    unsafe {
+        write8(buffer, bcd | ZEROS);
+        buffer.add(count_trailing_nonzeros(bcd))
+    }
 }
 
 // Writes a significand consisting of up to 17 decimal digits (16-17 for
@@ -510,11 +492,10 @@ unsafe fn write_significand17(
         all(target_arch = "x86_64", target_feature = "sse2", not(miri)),
     )))]
     {
-        let start = unsafe { buffer.add(1) };
-        // Each digits is denoted by a letter so value is abbccddeeffgghhii.
+        // Digits/pairs of digits are denoted by letters: value = abbccddeeffgghhii.
         let abbccddee = (value / 100_000_000) as u32;
         let ffgghhii = (value % 100_000_000) as u32;
-        buffer = unsafe { write_if(start, abbccddee / 100_000_000, has17digits) };
+        buffer = unsafe { write_if(buffer, abbccddee / 100_000_000, has17digits) };
         let bcd = to_bcd8(u64::from(abbccddee % 100_000_000));
         unsafe {
             write8(buffer, bcd | ZEROS);
@@ -563,7 +544,7 @@ unsafe fn write_significand17(
         let mut c = ptr::addr_of!(CONSTANTS);
 
         // Compiler barrier, or clang doesn't load from memory and generates 15
-        // more instructions
+        // more instructions.
         let c = unsafe {
             asm!("/*{0}*/", inout(reg) c);
             &*c
@@ -585,8 +566,7 @@ unsafe fn write_significand17(
         let a = (umul128(abbccddee, c.mul_const) >> 90) as u64;
         let bbccddee = abbccddee - a * hundred_million;
 
-        let start = unsafe { buffer.add(1) };
-        buffer = unsafe { write_if(start, a as u32, has17digits) };
+        buffer = unsafe { write_if(buffer, a as u32, has17digits) };
 
         unsafe {
             let ffgghhii_bbccddee_64: uint64x1_t =
@@ -639,7 +619,7 @@ unsafe fn write_significand17(
             buffer.cast::<uint16x8_t>().write_unaligned(str);
 
             let is_not_zero: uint16x8_t =
-                vreinterpretq_u16_u8(vcgtzq_s8(mem::transmute::<uint8x16_t, int8x16_t>(digits)));
+                vreinterpretq_u16_u8(vcgtzq_s8(vreinterpretq_s8_u8(digits)));
             let zeros: u64 = vget_lane_u64(vreinterpret_u64_u8(vshrn_n_u16(is_not_zero, 4)), 0);
 
             buffer.add(16 - (zeros.leading_zeros() as usize >> 2))
@@ -656,7 +636,7 @@ unsafe fn write_significand17(
         // zero. buffer points to the second place in the output buffer to allow
         // for the insertion of the decimal point, so we can use the first place
         // as scratch.
-        buffer = unsafe { buffer.add(usize::from(has17digits)) };
+        buffer = unsafe { buffer.offset(isize::from(has17digits) - 1) };
         unsafe {
             *buffer.add(16) = last_digit as u8 + b'0';
         }
@@ -665,64 +645,93 @@ unsafe fn write_significand17(
         let ijklmnop = (value_div10 % 100_000_000) as u32;
 
         #[repr(C, align(64))]
-        struct Consts {
-            div10k: __m128i,
-            neg10k: __m128i,
-            div100: __m128i,
-            div10: __m128i,
+        struct Constants {
+            div10k: u128,
+            neg10k: u128,
+            div100: u128,
+            div10: u128,
             #[cfg(target_feature = "sse4.1")]
-            neg100: __m128i,
+            neg100: u128,
             #[cfg(target_feature = "sse4.1")]
-            neg10: __m128i,
+            neg10: u128,
             #[cfg(target_feature = "sse4.1")]
-            bswap: __m128i,
+            bswap: u128,
             #[cfg(not(target_feature = "sse4.1"))]
-            hundred: __m128i,
+            hundred: u128,
             #[cfg(not(target_feature = "sse4.1"))]
-            moddiv10: __m128i,
-            zeros: __m128i,
+            moddiv10: u128,
+            zeros: u128,
+        }
+
+        impl Constants {
+            const fn splat64(x: u64) -> u128 {
+                ((x as u128) << 64) | x as u128
+            }
+
+            const fn splat32(x: u32) -> u128 {
+                Self::splat64(((x as u64) << 32) | x as u64)
+            }
+
+            const fn splat16(x: u16) -> u128 {
+                Self::splat32(((x as u32) << 16) | x as u32)
+            }
+
+            #[cfg(target_feature = "sse4.1")]
+            const fn pack8(a: u8, b: u8, c: u8, d: u8, e: u8, f: u8, g: u8, h: u8) -> u64 {
+                ((h as u64) << 56)
+                    | ((g as u64) << 48)
+                    | ((f as u64) << 40)
+                    | ((e as u64) << 32)
+                    | ((d as u64) << 24)
+                    | ((c as u64) << 16)
+                    | ((b as u64) << 8)
+                    | a as u64
+            }
         }
 
-        static CONSTS: Consts = Consts {
-            div10k: splat64(DIV10K_SIG as u64),
-            neg10k: splat64(NEG10K as u64),
-            div100: splat32(DIV100_SIG),
-            div10: splat16(((1u32 << 16) / 10 + 1) as u16),
+        static CONSTS: Constants = Constants {
+            div10k: Constants::splat64(DIV10K_SIG as u64),
+            neg10k: Constants::splat64(NEG10K as u64),
+            div100: Constants::splat32(DIV100_SIG),
+            div10: Constants::splat16(((1u32 << 16) / 10 + 1) as u16),
             #[cfg(target_feature = "sse4.1")]
-            neg100: splat32(NEG100),
+            neg100: Constants::splat32(NEG100),
             #[cfg(target_feature = "sse4.1")]
-            neg10: splat16((1 << 8) - 10),
+            neg10: Constants::splat16((1 << 8) - 10),
             #[cfg(target_feature = "sse4.1")]
-            bswap: unsafe {
-                mem::transmute::<[u64; 2], __m128i>([
-                    pack8(15, 14, 13, 12, 11, 10, 9, 8),
-                    pack8(7, 6, 5, 4, 3, 2, 1, 0),
-                ])
-            },
+            bswap: Constants::pack8(15, 14, 13, 12, 11, 10, 9, 8) as u128
+                | (Constants::pack8(7, 6, 5, 4, 3, 2, 1, 0) as u128) << 64,
             #[cfg(not(target_feature = "sse4.1"))]
-            hundred: splat32(100),
+            hundred: Constants::splat32(100),
             #[cfg(not(target_feature = "sse4.1"))]
-            moddiv10: splat16(10 * (1 << 8) - 1),
-            zeros: splat64(ZEROS),
+            moddiv10: Constants::splat16(10 * (1 << 8) - 1),
+            zeros: Constants::splat64(ZEROS),
         };
 
-        let div10k = unsafe { _mm_load_si128(&CONSTS.div10k) };
-        let neg10k = unsafe { _mm_load_si128(&CONSTS.neg10k) };
-        let div100 = unsafe { _mm_load_si128(&CONSTS.div100) };
-        let div10 = unsafe { _mm_load_si128(&CONSTS.div10) };
+        let mut c = ptr::addr_of!(CONSTS);
+        // Make the compiler forget where the constants came from to ensure they
+        // are loaded from memory.
+        unsafe {
+            asm!("/*{0}*/", inout(reg) c);
+        }
+
+        let div10k = unsafe { _mm_load_si128(ptr::addr_of!((*c).div10k).cast::<__m128i>()) };
+        let neg10k = unsafe { _mm_load_si128(ptr::addr_of!((*c).neg10k).cast::<__m128i>()) };
+        let div100 = unsafe { _mm_load_si128(ptr::addr_of!((*c).div100).cast::<__m128i>()) };
+        let div10 = unsafe { _mm_load_si128(ptr::addr_of!((*c).div10).cast::<__m128i>()) };
         #[cfg(target_feature = "sse4.1")]
-        let neg100 = unsafe { _mm_load_si128(&CONSTS.neg100) };
+        let neg100 = unsafe { _mm_load_si128(ptr::addr_of!((*c).neg100).cast::<__m128i>()) };
         #[cfg(target_feature = "sse4.1")]
-        let neg10 = unsafe { _mm_load_si128(&CONSTS.neg10) };
+        let neg10 = unsafe { _mm_load_si128(ptr::addr_of!((*c).neg10).cast::<__m128i>()) };
         #[cfg(target_feature = "sse4.1")]
-        let bswap = unsafe { _mm_load_si128(&CONSTS.bswap) };
+        let bswap = unsafe { _mm_load_si128(ptr::addr_of!((*c).bswap).cast::<__m128i>()) };
         #[cfg(not(target_feature = "sse4.1"))]
-        let hundred = unsafe { _mm_load_si128(&CONSTS.hundred) };
+        let hundred = unsafe { _mm_load_si128(ptr::addr_of!((*c).hundred).cast::<__m128i>()) };
         #[cfg(not(target_feature = "sse4.1"))]
-        let moddiv10 = unsafe { _mm_load_si128(&CONSTS.moddiv10) };
-        let zeros = unsafe { _mm_load_si128(&CONSTS.zeros) };
+        let moddiv10 = unsafe { _mm_load_si128(ptr::addr_of!((*c).moddiv10).cast::<__m128i>()) };
+        let zeros = unsafe { _mm_load_si128(ptr::addr_of!((*c).zeros).cast::<__m128i>()) };
 
-        // The BCD sequences are based on ones provided by Xiang JunBo.
+        // The BCD sequences are based on the ones provided by Xiang JunBo.
         unsafe {
             let x: __m128i = _mm_set_epi64x(i64::from(abcdefgh), i64::from(ijklmnop));
             let y: __m128i = _mm_add_epi64(
@@ -757,7 +766,7 @@ unsafe fn write_significand17(
 
             let digits = _mm_or_si128(bcd, zeros);
 
-            // determine number of leading zeros
+            // Count leading zeros.
             let mask128: __m128i = _mm_cmpgt_epi8(bcd, _mm_setzero_si128());
             let mask = _mm_movemask_epi8(mask128) as u32;
             // We don't need a zero-check here: if the mask were zero, either
@@ -773,18 +782,6 @@ unsafe fn write_significand17(
     }
 }
 
-// Writes a significand consisting of up to 9 decimal digits (8-9 for normals)
-// and removes trailing zeros.
-#[cfg_attr(feature = "no-panic", no_panic)]
-unsafe fn write_significand9(mut buffer: *mut u8, value: u32, has9digits: bool) -> *mut u8 {
-    buffer = unsafe { write_if(buffer, value / 100_000_000, has9digits) };
-    let bcd = to_bcd8(u64::from(value % 100_000_000));
-    unsafe {
-        write8(buffer, bcd | ZEROS);
-        buffer.add(count_trailing_nonzeros(bcd))
-    }
-}
-
 struct ToDecimalResult {
     sig: i64,
     exp: i32,
@@ -792,37 +789,8 @@ struct ToDecimalResult {
     sig_div10: i64,
 }
 
-fn normalize<UInt>(mut dec: ToDecimalResult, subnormal: bool) -> ToDecimalResult
-where
-    UInt: traits::UInt,
-{
-    if !subnormal {
-        return dec;
-    }
-    let num_bits = mem::size_of::<UInt>() * 8;
-    while dec.sig
-        < if num_bits == 64 {
-            10_000_000_000_000_000
-        } else {
-            100_000_000
-        }
-    {
-        dec.sig *= 10;
-        dec.exp -= 1;
-    }
-    #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
-    {
-        dec.sig_div10 = dec.sig / 10;
-    }
-    dec
-}
-
 #[cfg_attr(feature = "no-panic", no_panic)]
-fn to_decimal_schubfach<const SUBNORMAL: bool, UInt>(
-    bin_sig: UInt,
-    bin_exp: i64,
-    regular: bool,
-) -> ToDecimalResult
+fn to_decimal_schubfach<UInt>(bin_sig: UInt, bin_exp: i64, regular: bool) -> ToDecimalResult
 where
     UInt: traits::UInt,
 {
@@ -862,7 +830,7 @@ where
             #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
             sig_div10: div10.into() as i64,
         };
-        return normalize::<UInt>(result, SUBNORMAL);
+        return result;
     }
 
     let scaled_sig = umulhi_inexact_to_odd(pow10.hi, pow10.lo, bin_sig_shifted << exp_shift);
@@ -882,20 +850,19 @@ where
     } else {
         longer_above
     };
-    let result = ToDecimalResult {
+    ToDecimalResult {
         sig: dec_sig.into() as i64,
         exp: dec_exp,
         #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
         sig_div10: (dec_sig / UInt::from(10)).into() as i64,
-    };
-    normalize::<UInt>(result, SUBNORMAL)
+    }
 }
 
 // Here be 🐉s.
 // Converts a binary FP number bin_sig * 2**bin_exp to the shortest decimal
 // representation, where bin_exp = raw_exp - exp_offset.
 #[cfg_attr(feature = "no-panic", no_panic)]
-fn to_decimal_normal<Float, UInt>(bin_sig: UInt, raw_exp: i64, regular: bool) -> ToDecimalResult
+fn to_decimal_fast<Float, UInt>(bin_sig: UInt, raw_exp: i64, regular: bool) -> ToDecimalResult
 where
     Float: FloatTraits,
     UInt: traits::UInt,
@@ -1012,7 +979,7 @@ where
             sig_div10: div10 as i64 + i64::from(use_shorter) * i64::from(round_up),
         };
     }
-    to_decimal_schubfach::<false, UInt>(bin_sig, bin_exp, regular)
+    to_decimal_schubfach(bin_sig, bin_exp, regular)
 }
 
 /// Writes the shortest correctly rounded decimal representation of `value` to
@@ -1032,7 +999,13 @@ where
     }
     buffer = unsafe { buffer.add(usize::from(Float::is_negative(bits))) };
 
-    let mut dec = if bin_exp == 0 {
+    let mut dec;
+    let threshold = if Float::NUM_BITS == 64 {
+        10_000_000_000_000_000
+    } else {
+        100_000_000
+    };
+    if bin_exp == 0 {
         if bin_sig == Float::SigType::from(0) {
             return unsafe {
                 *buffer = b'0';
@@ -1041,41 +1014,43 @@ where
                 buffer.add(3)
             };
         }
-        to_decimal_schubfach::<true, Float::SigType>(
-            bin_sig,
-            i64::from(1 - Float::EXP_OFFSET),
-            true,
-        )
+        dec = to_decimal_schubfach(bin_sig, i64::from(1 - Float::EXP_OFFSET), true);
+        while dec.sig < threshold {
+            dec.sig *= 10;
+            dec.exp -= 1;
+        }
+        #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
+        {
+            dec.sig_div10 = dec.sig / 10;
+        }
     } else {
-        to_decimal_normal::<Float, Float::SigType>(
+        dec = to_decimal_fast::<Float, Float::SigType>(
             bin_sig | Float::IMPLICIT_BIT,
             bin_exp,
             bin_sig != Float::SigType::from(0),
-        )
-    };
+        );
+    }
     let mut dec_exp = dec.exp;
+    let extra_digit = dec.sig >= threshold;
+    dec_exp += Float::MAX_DIGITS10 as i32 - 2 + i32::from(extra_digit);
+    if Float::NUM_BITS == 32 && dec.sig < 10_000_000 {
+        dec.sig *= 10;
+        dec_exp -= 1;
+    }
 
     // Write significand.
     let end = if Float::NUM_BITS == 64 {
-        let has17digits = dec.sig >= 10_000_000_000_000_000;
-        dec_exp += Float::MAX_DIGITS10 as i32 - 2 + i32::from(has17digits);
         unsafe {
             write_significand17(
-                buffer,
+                buffer.add(1),
                 dec.sig as u64,
-                has17digits,
+                extra_digit,
                 #[cfg(all(target_arch = "x86_64", target_feature = "sse2", not(miri)))]
                 dec.sig_div10,
             )
         }
     } else {
-        if dec.sig < 10_000_000 {
-            dec.sig *= 10;
-            dec_exp -= 1;
-        }
-        let has9digits = dec.sig >= 100_000_000;
-        dec_exp += Float::MAX_DIGITS10 as i32 - 2 + i32::from(has9digits);
-        unsafe { write_significand9(buffer.add(1), dec.sig as u32, has9digits) }
+        unsafe { write_significand9(buffer.add(1), dec.sig as u32, extra_digit) }
     };
 
     let length = unsafe { end.offset_from(buffer.add(1)) } as usize;
@@ -1126,7 +1101,7 @@ where
     buffer = unsafe { buffer.add(1) };
     dec_exp = if dec_exp >= 0 { dec_exp } else { -dec_exp };
     buffer = unsafe { buffer.add(usize::from(dec_exp >= 10)) };
-    if Float::MIN_10_EXP >= -99 && Float::MAX_10_EXP <= 99 {
+    if Float::MIN_10_EXP > -100 && Float::MAX_10_EXP < 100 {
         unsafe {
             buffer
                 .cast::<u16>()
@@ -1135,7 +1110,6 @@ where
             return buffer.add(2);
         }
     }
-
     // digit = dec_exp / 100
     let digit = if USE_UMUL128_HI64 {
         umul128_hi64(dec_exp as u64, 0x290000000000000) as u32

data/rust-vendor/zune-jpeg/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{".cargo_vcs_info.json":"1b9cda44e931e26617eac75a137e709c2e0d6c7022205471560fd29c6dcb5206","Benches.md":"5e0a2292e9a2b6d5d7923f4b847a9aead7ab656326ef58018d30dfa46c53cf20","Cargo.lock":"66519b5c561ced64444623ca2057c9d271090b388406d70d6920e53a8cbe76de","Cargo.toml":"6c9d50ada0d4bba88775aee6137513881843638671b42b9632aef498ecce9a80","Cargo.toml.orig":"8427e11b9c26d0f4e172b138e0f5d845678aaa8ff4c347c4ed2a1c1f314c5ae9","Changelog.md":"296a9f6db2fbc8813357d0cafb9c041efce7177d1f7b6026a7af81031defb879","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","LICENSE-MIT":"d30047bca3b516639339a3c279bb84c3483124fb5a9dafe3c75056a85090e745","LICENSE-ZLIB":"d201d14804d3bcd3b944147173175e4abfbd838b7c8069b6bd3452496bf13e6c","README.md":"d58a4403ff2b9f7eba16f1284a9b4a4c7125bc92dacd8f0fac1ee112e3a8b8ee","src/bitstream.rs":"652cf824ee8b15249b026d7d27e1e08fad494ce3a3560abfe95beedde20eb6db","src/color_convert.rs":"e401a9c71beffd50a0b17330a5f64de82ad944e7f7cfe42a8a8bbf6b24ac245a","src/color_convert/avx.rs":"7be52b218a32ca06d8727dbd5d9ff18f0e09ee05c2147e2469e1b78f25e4f1f5","src/color_convert/neon64.rs":"d4b4b2ae87b57e857db6ade0b6c0a664182ebbad89aa5934e2959d06bf734d1d","src/color_convert/scalar.rs":"daf7a7595775ce00bec28997330bc72f0fd3cd113d764cf742a7b502ca93c108","src/components.rs":"4553c0bfad38aaf53af82db22a0f0fb5ab2b93125ab361f9b69485c5edd8f71d","src/decoder.rs":"73bacb4a8dbc42bda5319baf072920d722a29a138b646e5b2f0c9b72b816b02f","src/errors.rs":"106e9bca458efccd9b290ff5cf9365ad195d7afc3e414108111cc88b9c344e8f","src/headers.rs":"ffb94b9535259c37e8dff965949a0fe2e303e72ccc1c00292df915561c71fdbe","src/huffman.rs":"921649bd61aeeecb11bf91d7e76afad583e54717255824bf0c2d4bb6160d6b10","src/idct.rs":"be856aec47d17f28dfaa98072f2317eb78be0f6b9dc9535f5d309e97da5cf8e8","src/idct/avx2.rs":"126185cc71e1b72e0f37632633d3d0fee5c974fde203f332bb36e30487fd3c66","src/idct/neon.rs":"919aad93765a5f025974798e9068c3a5b4497d3da4fe9ae63c901cb52c9c123e","src/idct/scalar.rs":"c2a682081ef33dabe957b46075136119b28fef44cdfff4cffb044b38a6cabbf1","src/lib.rs":"3b35d5daf358b00997c36f173ef056b7c44c62233af1a035b2ec80d02e61cbe7","src/marker.rs":"10014f879004c0b1ca4bca66155eb2385820cce02ae6e48a9e9b37ca60ecd294","src/mcu.rs":"ac068a22c2509186d6b014804a81031da620479d9fe51b36053e4df9d81531b1","src/mcu_prog.rs":"1439d45fb116a1a0e377f764a0d6212e607e141c32f56c1a0325e98ac28b3c1e","src/misc.rs":"1ba8300b38095fc0cb2e91f615d401d7a6b45d20115f314df66153add7b776da","src/unsafe_utils.rs":"8fa830ca67b7f701461fe2382f8843faa33c98b5f83f1845f60c8ef788143c75","src/unsafe_utils_avx2.rs":"2e2a8294a8c8c6ca3e92356b47a088090c2c62853b37cfcadeba4ab55f545721","src/unsafe_utils_neon.rs":"b7087a9897c9e3c66a1bf7a910e7dab30e2a92ca3483c1b01101f69e07d05e87","src/upsampler.rs":"81ca309c31baf578b293abc6dbeb4d37b69f14b0e2811d15fe3bb9aa637cc01a","src/upsampler/avx2.rs":"75d0efea4ab67b482a9e8f0fb4ee64252d09bdbf6d184543a33c083a47c59ada","src/upsampler/neon.rs":"b8aefe165154227402282e66c9450d6d81c5e60c63b0626f979dc2b36dab71cb","src/upsampler/portable_simd.rs":"84b4f9756f00bcea68c4c7897a9cef6335bc3b96973f2328690d64f8f8e0011f","src/upsampler/scalar.rs":"c3a57d943b8df501feed9a4a59f3a2401d836383ce4dae2344ad518b002e201e","src/worker.rs":"6f939fa614844d11b826c196ea56ea13846ba7725025da0e2418b2d453fecc6d"},"package":"2959ca473aae96a14ecedf501d20b3608d2825ba280d5adb57d651721885b0c2"}
+{"files":{".cargo_vcs_info.json":"abe310693236ee14ba7f562a185c3bd9adce036e1b4105487feef7344fe14d8e","Benches.md":"5e0a2292e9a2b6d5d7923f4b847a9aead7ab656326ef58018d30dfa46c53cf20","Cargo.lock":"ffa6e3075058811ec19160e3a579c9d7bbf1f6f6f4edddfd86460c6ceefbeac7","Cargo.toml":"cb6d85ffc32137d211768c2103c39dd1e09a0884c5cb69d6d12befb4175090d7","Cargo.toml.orig":"0237e36d0108b88419949fd1d4021d92a7bb5229ca2c4da59a2c8f1d965bad90","Changelog.md":"296a9f6db2fbc8813357d0cafb9c041efce7177d1f7b6026a7af81031defb879","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","LICENSE-MIT":"d30047bca3b516639339a3c279bb84c3483124fb5a9dafe3c75056a85090e745","LICENSE-ZLIB":"d201d14804d3bcd3b944147173175e4abfbd838b7c8069b6bd3452496bf13e6c","README.md":"d58a4403ff2b9f7eba16f1284a9b4a4c7125bc92dacd8f0fac1ee112e3a8b8ee","src/bitstream.rs":"8150ccf37714ecd21d64201683d14a9d92e7e21acfe57e9bc502953a7537287a","src/color_convert.rs":"e401a9c71beffd50a0b17330a5f64de82ad944e7f7cfe42a8a8bbf6b24ac245a","src/color_convert/avx.rs":"7be52b218a32ca06d8727dbd5d9ff18f0e09ee05c2147e2469e1b78f25e4f1f5","src/color_convert/neon64.rs":"d4b4b2ae87b57e857db6ade0b6c0a664182ebbad89aa5934e2959d06bf734d1d","src/color_convert/scalar.rs":"daf7a7595775ce00bec28997330bc72f0fd3cd113d764cf742a7b502ca93c108","src/components.rs":"1699aab5b99818e51bdbfc43afb9567e4ac0ac67e68fbda9bfb3ac86b62489ea","src/decoder.rs":"a41695b5d8da610a446b08a4360f16d1b3d7f356ddf65a388aed73f0de0ec2f8","src/errors.rs":"106e9bca458efccd9b290ff5cf9365ad195d7afc3e414108111cc88b9c344e8f","src/headers.rs":"fb5df67412697435cad6d0ce32f259b8011dc658861dd426aa56401cf635d722","src/huffman.rs":"921649bd61aeeecb11bf91d7e76afad583e54717255824bf0c2d4bb6160d6b10","src/idct.rs":"be856aec47d17f28dfaa98072f2317eb78be0f6b9dc9535f5d309e97da5cf8e8","src/idct/avx2.rs":"126185cc71e1b72e0f37632633d3d0fee5c974fde203f332bb36e30487fd3c66","src/idct/neon.rs":"919aad93765a5f025974798e9068c3a5b4497d3da4fe9ae63c901cb52c9c123e","src/idct/scalar.rs":"c2a682081ef33dabe957b46075136119b28fef44cdfff4cffb044b38a6cabbf1","src/lib.rs":"31cfd2c21b47b86595dde3b39e93e2754031541f35deb35a43ee8a56488de68d","src/marker.rs":"10014f879004c0b1ca4bca66155eb2385820cce02ae6e48a9e9b37ca60ecd294","src/mcu.rs":"1a29ff009dbe731315f4a2868a1e9f0c4c2636b7cae3e000d80d09b3558dd526","src/mcu_prog.rs":"579d821e54b44f5429b1aded01672d23a7cfb7c8a66c32af2be3613a360a2df1","src/misc.rs":"1ba8300b38095fc0cb2e91f615d401d7a6b45d20115f314df66153add7b776da","src/unsafe_utils.rs":"8fa830ca67b7f701461fe2382f8843faa33c98b5f83f1845f60c8ef788143c75","src/unsafe_utils_avx2.rs":"2e2a8294a8c8c6ca3e92356b47a088090c2c62853b37cfcadeba4ab55f545721","src/unsafe_utils_neon.rs":"b7087a9897c9e3c66a1bf7a910e7dab30e2a92ca3483c1b01101f69e07d05e87","src/upsampler.rs":"81ca309c31baf578b293abc6dbeb4d37b69f14b0e2811d15fe3bb9aa637cc01a","src/upsampler/avx2.rs":"3416787605115cee9f7eb918b3dd05f6596c8ed15e4942d18a12d301f5d843bc","src/upsampler/neon.rs":"91cb03cd357c4308a14d5fe9a517e4efc6c338fd3e07b37d910f6d1ab65bdd70","src/upsampler/portable_simd.rs":"36bfef56cc9c36c796cfccca77c13c7e394042c9ebf53bb18ffaaeba2311913d","src/upsampler/scalar.rs":"cc86288e29db2d6cbb25f5238f3064e3ad30179d0c1cfdab35d51fd54b074710","src/worker.rs":"6f939fa614844d11b826c196ea56ea13846ba7725025da0e2418b2d453fecc6d"},"package":"410e9ecef634c709e3831c2cfdb8d9c32164fae1c67496d5b68fff728eec37fe"}

data/rust-vendor/zune-jpeg/.cargo_vcs_info.json

@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "3cdedbe15b78a0aeb1da003d533eeeb767b6d381"
+    "sha1": "7cb6c7d950c040b2198da553140e1b5e8b6ac682"
   },
   "path_in_vcs": "crates/zune-jpeg"
 }

data/rust-vendor/zune-jpeg/Cargo.lock

@@ -19,7 +19,7 @@ dependencies = [
 
 [[package]]
 name = "zune-jpeg"
-version = "0.5.11"
+version = "0.5.12"
 dependencies = [
  "zune-core",
 ]

data/rust-vendor/zune-jpeg/Cargo.toml

@@ -13,7 +13,7 @@
 edition = "2021"
 rust-version = "1.75.0"
 name = "zune-jpeg"
-version = "0.5.11"
+version = "0.5.12"
 authors = ["caleb <etemesicaleb@gmail.com>"]
 build = false
 exclude = [

data/rust-vendor/zune-jpeg/Cargo.toml.orig

@@ -1,6 +1,6 @@
 [package]
 name = "zune-jpeg"
-version = "0.5.11"
+version = "0.5.12"
 rust-version = "1.75.0"
 authors = ["caleb <etemesicaleb@gmail.com>"]
 edition = "2021"

data/rust-vendor/zune-jpeg/src/bitstream.rs

@@ -684,7 +684,7 @@ impl BitStream {
                                 }
                             }
                             if self.get_bit() == 1 && (*coefficient & bit) == 0 {
-                                if *coefficient >= 0 {
+                                if *coefficient > 0 {
                                     *coefficient += bit;
                                 } else {
                                     *coefficient -= bit;