roo-oxide 0.0.2

data/ext/roo_oxide/src/lib.rs

@@ -0,0 +1,306 @@
+//! Native fast path for `roo-oxide`.
+//!
+//! [`reader`] turns worksheet XML into raw cell records without touching Ruby.
+//! [`convert`] turns those records into roo's cells,
+//! and [`store`] keeps them to build one cell at a time. [`shared_strings`]
+//! reads a workbook's shared strings the way roo does.
+
+pub mod archive;
+pub mod convert;
+pub mod numeric;
+pub mod reader;
+pub mod shared_strings;
+pub mod sheet_parts;
+pub mod store;
+
+use std::cell::{Cell as StdCell, RefCell};
+use std::ffi::c_void;
+use std::panic::{self, AssertUnwindSafe};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::{self, Receiver, RecvTimeoutError, TryRecvError};
+use std::time::Duration;
+
+use magnus::value::Lazy;
+use magnus::{function, method, prelude::*, Error, ExceptionClass, RArray, RHash, Ruby};
+
+use archive::Source;
+use convert::Converter;
+use reader::{Mode, RawRow, Unsupported};
+
+static UNSUPPORTED: Lazy<ExceptionClass> = Lazy::new(|r| {
+    r.eval("Roo::Oxide::UnsupportedError")
+        .expect("roo/oxide defines its error before the extension loads")
+});
+
+pub(crate) fn unsupported(ruby: &Ruby, error: Unsupported) -> Error {
+    Error::new(ruby.get_inner(&UNSUPPORTED), error.0)
+}
+
+/// Runs `work` with the GVL released. `work` must not touch any Ruby object,
+/// and should return soon after the flag it is given turns true: Ruby sets
+/// it when it has something to deliver to this thread (`Thread#raise`,
+/// `Timeout`, Ctrl-C). Such an exception comes back as `Err` instead of
+/// unwinding through the caller's Rust frames.
+pub(crate) fn without_gvl<F: FnOnce(&AtomicBool) -> R, R>(work: F) -> Result<R, Error> {
+    struct Call<'a, F, R> {
+        work: Option<F>,
+        interrupted: &'a AtomicBool,
+        result: Option<std::thread::Result<R>>,
+    }
+
+    unsafe extern "C" fn trampoline<F: FnOnce(&AtomicBool) -> R, R>(
+        data: *mut c_void,
+    ) -> *mut c_void {
+        let call = unsafe { &mut *(data as *mut Call<'_, F, R>) };
+        let work = call.work.take().expect("called once");
+        let interrupted = call.interrupted;
+        call.result = Some(panic::catch_unwind(AssertUnwindSafe(|| work(interrupted))));
+        std::ptr::null_mut()
+    }
+
+    unsafe extern "C" fn unblock(data: *mut c_void) {
+        unsafe { &*(data as *const AtomicBool) }.store(true, Ordering::Release);
+    }
+
+    let interrupted = AtomicBool::new(false);
+    let mut call = Call {
+        work: Some(work),
+        interrupted: &interrupted,
+        result: None,
+    };
+    let data = &mut call as *mut Call<'_, F, R> as *mut c_void;
+    let flag = &interrupted as *const AtomicBool as *mut c_void;
+    magnus::rb_sys::protect(|| unsafe {
+        rb_sys::rb_thread_call_without_gvl(Some(trampoline::<F, R>), data, Some(unblock), flag);
+        rb_sys::Qnil as rb_sys::VALUE
+    })?;
+    match call.result.expect("trampoline ran") {
+        Ok(result) => Ok(result),
+        Err(payload) => panic::resume_unwind(payload),
+    }
+}
+
+enum Wait {
+    Batch(Batch),
+    /// Ruby interrupted the wait without raising; wait again.
+    Interrupted,
+    /// The reading thread ended without sending a last batch.
+    Stopped,
+}
+
+/// Waits for the next batch with the GVL released.
+fn wait_for(batches: &Receiver<Batch>) -> Result<Wait, Error> {
+    without_gvl(|interrupted| loop {
+        match batches.recv_timeout(Duration::from_millis(20)) {
+            Ok(batch) => return Wait::Batch(batch),
+            Err(RecvTimeoutError::Disconnected) => return Wait::Stopped,
+            Err(RecvTimeoutError::Timeout) if interrupted.load(Ordering::Acquire) => {
+                return Wait::Interrupted
+            }
+            Err(RecvTimeoutError::Timeout) => {}
+        }
+    })
+}
+
+/// One streamed `<row>`, converted to cells only when roo asks for them.
+#[magnus::wrap(class = "Roo::Oxide::Native::Row", free_immediately, size)]
+pub struct Row(RawRow);
+
+impl Row {
+    pub fn raw(&self) -> &RawRow {
+        &self.0
+    }
+}
+
+type Batch = Result<Vec<RawRow>, Unsupported>;
+
+enum Batches {
+    Thread(Receiver<Batch>),
+    Inline {
+        sheet: Box<reader::SheetReader<archive::Input>>,
+        batch: usize,
+    },
+}
+
+/// Reads small ZIP entries on demand without the GVL. Large worksheets are
+/// read one batch ahead on a worker, so a busy Ruby thread does not slow
+/// every batch down.
+#[magnus::wrap(class = "Roo::Oxide::Native::Reader", free_immediately, size)]
+struct Reader {
+    /// `None` once closed.
+    batches: RefCell<Option<Batches>>,
+    /// The rows of the last batch not handed to Ruby yet.
+    pending: RefCell<std::vec::IntoIter<RawRow>>,
+    /// Set while a Ruby thread waits on `batches` without the GVL; the
+    /// receiver must not be used from two threads at once.
+    in_use: StdCell<bool>,
+    done: StdCell<bool>,
+    rows_read: StdCell<usize>,
+}
+
+impl Reader {
+    /// `batch` is the number of cells parsed per batch.
+    fn new(ruby: &Ruby, source: Source, stream: bool, batch: usize) -> Result<Self, Error> {
+        let mode = if stream { Mode::Stream } else { Mode::Document };
+        let mut sheet = source.open(ruby, mode)?;
+        let batches = if source.small() {
+            Batches::Inline {
+                sheet: Box::new(sheet),
+                batch,
+            }
+        } else {
+            let (sender, batches) = mpsc::sync_channel::<Batch>(1);
+            std::thread::Builder::new()
+                .name("roo-oxide".into())
+                .spawn(move || loop {
+                    let rows = sheet.next_rows(batch);
+                    let last = !matches!(&rows, Ok(rows) if !rows.is_empty());
+                    if sender.send(rows).is_err() || last {
+                        return;
+                    }
+                })
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+            Batches::Thread(batches)
+        };
+        Ok(Self {
+            batches: RefCell::new(Some(batches)),
+            pending: RefCell::new(Vec::new().into_iter()),
+            in_use: StdCell::new(false),
+            done: StdCell::new(false),
+            rows_read: StdCell::new(0),
+        })
+    }
+
+    fn read_batch(&self, ruby: &Ruby) -> Result<Vec<RawRow>, Error> {
+        if self.done.get() {
+            return Ok(Vec::new());
+        }
+        if self.in_use.replace(true) {
+            return Err(Error::new(
+                ruby.exception_runtime_error(),
+                "reader is already in use",
+            ));
+        }
+        let received = match self.batches.borrow_mut().as_mut() {
+            None => Ok(Wait::Batch(Ok(Vec::new()))),
+            Some(Batches::Inline { sheet, batch }) => {
+                without_gvl(|_| Wait::Batch(sheet.next_rows(*batch)))
+            }
+            Some(Batches::Thread(batches)) => match batches.try_recv() {
+                Ok(batch) => Ok(Wait::Batch(batch)),
+                Err(TryRecvError::Disconnected) => Ok(Wait::Stopped),
+                Err(TryRecvError::Empty) => loop {
+                    match wait_for(batches) {
+                        Ok(Wait::Interrupted) => continue,
+                        other => break other,
+                    }
+                },
+            },
+        };
+        self.in_use.set(false);
+        let rows = match received? {
+            Wait::Batch(batch) => batch.map_err(|e| unsupported(ruby, e))?,
+            Wait::Stopped | Wait::Interrupted => {
+                return Err(unsupported(
+                    ruby,
+                    Unsupported("the reader thread stopped".into()),
+                ));
+            }
+        };
+        if rows.is_empty() {
+            self.done.set(true);
+        }
+        Ok(rows)
+    }
+
+    /// Stops the reading thread, which closes the file and frees the rows it
+    /// read ahead, without waiting for garbage collection.
+    fn close(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
+        if rb_self.in_use.get() {
+            return Err(Error::new(
+                ruby.exception_runtime_error(),
+                "reader is already in use",
+            ));
+        }
+        rb_self.batches.borrow_mut().take();
+        rb_self.pending.replace(Vec::new().into_iter());
+        rb_self.done.set(true);
+        Ok(())
+    }
+
+    /// Document mode: adds the next batch of rows to `cells`. Returns
+    /// `false` once the sheet is exhausted.
+    fn fill_cells(
+        ruby: &Ruby,
+        rb_self: &Self,
+        cells: RHash,
+        converter: &Converter,
+    ) -> Result<bool, Error> {
+        let rows = rb_self.read_batch(ruby)?;
+        for row in &rows {
+            let row_number = rb_self.rows_read.get() + 1;
+            rb_self.rows_read.set(row_number);
+            converter.add_row(ruby, cells, row, row_number)?;
+        }
+        Ok(!rows.is_empty())
+    }
+
+    /// Stream mode: the next row of the sheet, `None` at its end. Rows wait
+    /// in their batch until asked for, so Ruby holds one at a time.
+    fn next_raw_row(&self, ruby: &Ruby) -> Result<Option<RawRow>, Error> {
+        if let Some(row) = self.pending.borrow_mut().next() {
+            return Ok(Some(row));
+        }
+        let mut rows = self.read_batch(ruby)?.into_iter();
+        let row = rows.next();
+        self.pending.replace(rows);
+        Ok(row)
+    }
+
+    /// Stream mode: the next row, or `nil` at the end of the sheet.
+    fn next_row(ruby: &Ruby, rb_self: &Self) -> Result<Option<Row>, Error> {
+        Ok(rb_self.next_raw_row(ruby)?.map(Row))
+    }
+
+    /// Stream mode: the values of the next row, as
+    /// [`Converter::row_values`] gives them, or `nil` at the end of the
+    /// sheet. Each row is converted only when asked for, as roo reads it,
+    /// and its parsed record is freed right after.
+    fn next_values(
+        ruby: &Ruby,
+        rb_self: &Self,
+        converter: &Converter,
+    ) -> Result<Option<RArray>, Error> {
+        match rb_self.next_raw_row(ruby)? {
+            Some(row) => converter.row_values(ruby, &row).map(Some),
+            None => Ok(None),
+        }
+    }
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let native = ruby
+        .define_module("Roo")?
+        .define_module("Oxide")?
+        .define_module("Native")?;
+
+    let reader = native.define_class("Reader", ruby.class_object())?;
+    reader.define_singleton_method("new", function!(Reader::new, 3))?;
+    reader.define_method("fill_cells", method!(Reader::fill_cells, 2))?;
+    reader.define_method("next_row", method!(Reader::next_row, 0))?;
+    reader.define_method("next_values", method!(Reader::next_values, 1))?;
+    reader.define_method("close", method!(Reader::close, 0))?;
+
+    native.define_class("Row", ruby.class_object())?;
+
+    let converter = native.define_class("Converter", ruby.class_object())?;
+    converter.define_singleton_method("new", function!(Converter::new, 2))?;
+    converter.define_method("row_cells", method!(Converter::row_cells, 2))?;
+
+    store::define(ruby, native)?;
+    shared_strings::define(native)?;
+    sheet_parts::define(native)?;
+    archive::define(ruby, native)?;
+    Ok(())
+}

data/ext/roo_oxide/src/numeric.rs

@@ -0,0 +1,174 @@
+//! roo's text-to-number conversions, for the plainly written numbers that
+//! worksheets store: `-?\d+(\.\d+)?([eE][-+]?\d+)?`. Any other text gives
+//! `None`, and the caller leaves the conversion to roo's own code.
+
+use magnus::{IntoValue, Ruby, Value};
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum Number {
+    Integer(i64),
+    Float(f64),
+}
+
+impl IntoValue for Number {
+    fn into_value_with(self, ruby: &Ruby) -> Value {
+        match self {
+            Number::Integer(integer) => ruby.integer_from_i64(integer).into_value_with(ruby),
+            Number::Float(float) => ruby.float_from_f64(float).into_value_with(ruby),
+        }
+    }
+}
+
+/// Plain number text, split where Ruby's conversions tell it apart.
+struct Plain<'a> {
+    /// The sign and the digits before any `.` or exponent.
+    integer: &'a str,
+    fraction: bool,
+    exponent: bool,
+    /// The digits before the exponent.
+    mantissa: &'a [u8],
+}
+
+impl<'a> Plain<'a> {
+    fn parse(text: &'a str) -> Option<Self> {
+        let bytes = text.as_bytes();
+        let mut at = usize::from(bytes.first() == Some(&b'-'));
+        let digits = |at: &mut usize| {
+            let start = *at;
+            while bytes.get(*at).is_some_and(u8::is_ascii_digit) {
+                *at += 1;
+            }
+            *at > start
+        };
+        if !digits(&mut at) {
+            return None;
+        }
+        let integer_end = at;
+        let fraction = bytes.get(at) == Some(&b'.');
+        if fraction {
+            at += 1;
+            if !digits(&mut at) {
+                return None;
+            }
+        }
+        let mantissa_end = at;
+        let exponent = matches!(bytes.get(at), Some(b'e' | b'E'));
+        if exponent {
+            at += 1;
+            if matches!(bytes.get(at), Some(b'+' | b'-')) {
+                at += 1;
+            }
+            if !digits(&mut at) {
+                return None;
+            }
+        }
+        (at == bytes.len()).then(|| Self {
+            integer: &text[..integer_end],
+            fraction,
+            exponent,
+            mantissa: &bytes[..mantissa_end],
+        })
+    }
+
+    /// The integer part, when it fits an `i64`.
+    fn integer(&self) -> Option<i64> {
+        self.integer.parse().ok()
+    }
+}
+
+/// `Cell::Number#create_numeric(text)` under a format that matches `/%/` or
+/// `/\.0/` (`always_float`) or one that does not.
+pub fn create_numeric(text: &str, always_float: bool) -> Option<Number> {
+    let plain = Plain::parse(text)?;
+    if always_float || plain.fraction || plain.exponent {
+        // Ruby's `strtod` stops reading fraction digits after about 60 digits,
+        // so a longer mantissa can round differently.
+        if plain.mantissa.len() > 40 {
+            return None;
+        }
+        let float: f64 = text.parse().ok()?;
+        // Ruby's `Float()` warns when the text is out of range (infinite, or
+        // zero although a digit is not); subnormal results are left to Ruby
+        // too.
+        let nonzero = plain.mantissa.iter().any(|b| matches!(b, b'1'..=b'9'));
+        let in_range = float.is_normal() || (float == 0.0 && !nonzero);
+        in_range.then_some(Number::Float(float))
+    } else {
+        plain.integer().map(Number::Integer)
+    }
+}
+
+/// Text that `Float()` and `Integer(text, 10)` both read as a finite number,
+/// and `String#to_f` reads whole.
+pub fn plain_number(text: &str) -> bool {
+    Plain::parse(text).is_some() && text.parse::<f64>().is_ok_and(f64::is_finite)
+}
+
+/// `String#to_i` of plain number text.
+pub fn leading_integer(text: &str) -> Option<i64> {
+    Plain::parse(text)?.integer()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{create_numeric, leading_integer, Number};
+
+    #[test]
+    fn integers_and_floats_follow_the_text_and_the_format() {
+        assert_eq!(create_numeric("12", false), Some(Number::Integer(12)));
+        assert_eq!(create_numeric("-0", false), Some(Number::Integer(0)));
+        assert_eq!(create_numeric("007", false), Some(Number::Integer(7)));
+        assert_eq!(create_numeric("12", true), Some(Number::Float(12.0)));
+        assert_eq!(create_numeric("1.5", false), Some(Number::Float(1.5)));
+        assert_eq!(create_numeric("1E3", false), Some(Number::Float(1000.0)));
+        assert_eq!(create_numeric("2.5e-3", false), Some(Number::Float(0.0025)));
+        let Some(Number::Float(negative_zero)) = create_numeric("-0", true) else {
+            panic!("-0 under a float format is a Float");
+        };
+        assert!(negative_zero.is_sign_negative());
+        assert_eq!(create_numeric("0e999", false), Some(Number::Float(0.0)));
+    }
+
+    #[test]
+    fn leaves_other_text_to_roo() {
+        for text in [
+            "",
+            "-",
+            "+5",
+            " 1",
+            "1 ",
+            "1_000",
+            "0x1A",
+            "1.",
+            ".5",
+            "1.e5",
+            "1e",
+            "1e+",
+            "inf",
+            "NaN",
+            "#N/A",
+            "1e400",
+            "1e-400",
+            "4.9e-324",
+            "12855504354071923631583389444689181878463593399757479065157632.5",
+        ] {
+            assert_eq!(create_numeric(text, false), None, "{text:?}");
+            assert_eq!(create_numeric(text, true), None, "{text:?}");
+        }
+        assert_eq!(create_numeric("9223372036854775808", false), None);
+        assert_eq!(
+            create_numeric("-9223372036854775808", false),
+            Some(Number::Integer(i64::MIN))
+        );
+    }
+
+    #[test]
+    fn leading_integer_is_string_to_i() {
+        assert_eq!(leading_integer("45000"), Some(45000));
+        assert_eq!(leading_integer("45000.9"), Some(45000));
+        assert_eq!(leading_integer("1E3"), Some(1));
+        assert_eq!(leading_integer("-0.5"), Some(0));
+        assert_eq!(leading_integer("#N/A"), None);
+        assert_eq!(leading_integer("12345678901234567890"), None);
+    }
+}

data/ext/roo_oxide/src/reader/attributes.rs

@@ -0,0 +1,199 @@
+//! The attributes of a start tag, read in one pass.
+//!
+//! quick-xml leaves most of an attribute list unchecked, so this reads it
+//! along the XML grammar `(S Name S? '=' S? AttValue)* S?` and rejects
+//! everything else, as libxml2 does: a missing `=` or quote, an unquoted
+//! value, `<` in a value, attributes without whitespace between them, and a
+//! name used twice.
+
+use std::borrow::Cow;
+use std::collections::HashSet;
+use std::ops::Range;
+
+use quick_xml::name::QName;
+use quick_xml::XmlVersion;
+
+use super::{check_chars, check_name, Result, Unsupported};
+
+/// An attribute as written, before references are resolved.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Attribute<'a> {
+    pub key: &'a str,
+    pub value: &'a str,
+}
+
+impl<'a> Attribute<'a> {
+    /// The value with references resolved and whitespace normalized, as
+    /// libxml2 reads it. Fails on a reference XML does not define.
+    pub fn normalized_value(&self) -> Result<Cow<'a, str>> {
+        if !self
+            .value
+            .bytes()
+            .any(|b| matches!(b, b'&' | b'\t' | b'\n' | b'\r'))
+        {
+            return Ok(Cow::Borrowed(self.value));
+        }
+        let attribute = quick_xml::events::attributes::Attribute {
+            key: QName(self.key),
+            value: Cow::Borrowed(self.value),
+        };
+        Ok(attribute.normalized_value(XmlVersion::Implicit1_0)?)
+    }
+}
+
+/// The attributes of the last start tag read, as byte ranges of its
+/// attribute list, so a tag is read once. The buffer is reused from tag to
+/// tag.
+#[derive(Default)]
+pub struct TagAttributes {
+    spans: Vec<(Range<usize>, Range<usize>)>,
+    prefixed: bool,
+    references: bool,
+}
+
+impl TagAttributes {
+    /// Reads and checks `raw`, what quick-xml's `BytesStart::attributes_raw`
+    /// returns, in place of the tag read before.
+    pub fn read(&mut self, raw: &str) -> Result<()> {
+        self.prefixed = false;
+        self.references = false;
+        if self.read_common(raw) {
+            return Ok(());
+        }
+        self.spans.clear();
+        check_chars(raw)?;
+        let bytes = raw.as_bytes();
+        let mut position = 0;
+        loop {
+            let start = skip_whitespace(bytes, position);
+            if start == bytes.len() {
+                break;
+            }
+            if start == position {
+                return Err(Unsupported(
+                    "attributes without whitespace between them".into(),
+                ));
+            }
+            let key_end = start
+                + bytes[start..]
+                    .iter()
+                    .position(|&b| b == b'=' || is_whitespace(b))
+                    .unwrap_or(bytes.len() - start);
+            let key = &raw[start..key_end];
+            check_name(key)?;
+            self.prefixed |= key.contains(':');
+            let equals = skip_whitespace(bytes, key_end);
+            if bytes.get(equals) != Some(&b'=') {
+                return Err(Unsupported(format!("no `=` after the attribute {key}")));
+            }
+            let quote_at = skip_whitespace(bytes, equals + 1);
+            let quote = match bytes.get(quote_at) {
+                Some(&quote @ (b'"' | b'\'')) => quote,
+                _ => return Err(Unsupported(format!("an unquoted value for {key}"))),
+            };
+            let value_start = quote_at + 1;
+            let mut value_end = value_start;
+            loop {
+                match bytes.get(value_end) {
+                    Some(&b) if b == quote => break,
+                    Some(b'<') => return Err(Unsupported("`<` in an attribute value".into())),
+                    Some(b'&') => self.references = true,
+                    Some(_) => {}
+                    None => return Err(Unsupported(format!("an unclosed value for {key}"))),
+                }
+                value_end += 1;
+            }
+            self.spans.push((start..key_end, value_start..value_end));
+            position = value_end + 1;
+        }
+        self.check_unique(bytes)
+    }
+
+    /// Reads `raw` when it holds only ` r="…"`, ` s="…"`, and ` t="…"`, each at most once,
+    /// with printable ASCII values without references.
+    pub(super) fn read_common(&mut self, raw: &str) -> bool {
+        self.spans.clear();
+        let bytes = raw.as_bytes();
+        let mut seen = 0u8;
+        let mut position = 0;
+        while position < bytes.len() {
+            let &[b' ', key, b'=', b'"', ..] = &bytes[position..] else {
+                return false;
+            };
+            let bit = match key {
+                b'r' => 1,
+                b's' => 2,
+                b't' => 4,
+                _ => return false,
+            };
+            if seen & bit != 0 {
+                return false;
+            }
+            seen |= bit;
+            let value_start = position + 4;
+            let Some(length) = bytes[value_start..].iter().position(|&b| b == b'"') else {
+                return false;
+            };
+            let value_end = value_start + length;
+            if !bytes[value_start..value_end]
+                .iter()
+                .all(|&b| matches!(b, b' '..=b'~') && b != b'&' && b != b'<')
+            {
+                return false;
+            }
+            self.spans
+                .push((position + 1..position + 2, value_start..value_end));
+            position = value_end + 1;
+        }
+        true
+    }
+
+    /// Whether a key has a namespace prefix.
+    pub fn prefixed(&self) -> bool {
+        self.prefixed
+    }
+
+    /// Whether a value holds a reference.
+    pub fn references(&self) -> bool {
+        self.references
+    }
+
+    /// The attributes [`read`](Self::read) found in `raw`.
+    pub fn iter<'a>(&'a self, raw: &'a str) -> impl Iterator<Item = Attribute<'a>> + 'a {
+        self.spans.iter().map(move |(key, value)| Attribute {
+            key: &raw[key.clone()],
+            value: &raw[value.clone()],
+        })
+    }
+
+    fn check_unique(&self, bytes: &[u8]) -> Result<()> {
+        let key = |(key, _): &(Range<usize>, Range<usize>)| &bytes[key.clone()];
+        let unique = if self.spans.len() <= 8 {
+            self.spans.iter().enumerate().all(|(i, span)| {
+                let key = key(span);
+                self.spans[..i]
+                    .iter()
+                    .all(|earlier| bytes[earlier.0.clone()] != *key)
+            })
+        } else {
+            let mut seen = HashSet::with_capacity(self.spans.len());
+            self.spans.iter().all(|span| seen.insert(key(span)))
+        };
+        if unique {
+            Ok(())
+        } else {
+            Err(Unsupported("an attribute named twice".into()))
+        }
+    }
+}
+
+fn is_whitespace(b: u8) -> bool {
+    matches!(b, b' ' | b'\t' | b'\r' | b'\n')
+}
+
+fn skip_whitespace(bytes: &[u8], from: usize) -> usize {
+    from + bytes[from..]
+        .iter()
+        .take_while(|&&b| is_whitespace(b))
+        .count()
+}