html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/rustix/src/fs/mod.rs

@@ -1,7 +1,6 @@
 //! Filesystem operations.
 
 mod abs;
-#[cfg(not(target_os = "redox"))]
 mod at;
 mod constants;
 #[cfg(linux_kernel)]
@@ -51,7 +50,7 @@ mod raw_dir;
 mod seek_from;
 #[cfg(target_os = "linux")]
 mod sendfile;
-#[cfg(not(any(target_os = "espidf", target_os = "redox")))]
+#[cfg(not(target_os = "espidf"))]
 mod special;
 #[cfg(linux_kernel)]
 mod statx;
@@ -67,7 +66,6 @@ mod sync;
 mod xattr;
 
 pub use abs::*;
-#[cfg(not(target_os = "redox"))]
 pub use at::*;
 pub use constants::*;
 #[cfg(linux_kernel)]
@@ -115,7 +113,7 @@ pub use raw_dir::{RawDir, RawDirEntry};
 pub use seek_from::SeekFrom;
 #[cfg(target_os = "linux")]
 pub use sendfile::sendfile;
-#[cfg(not(any(target_os = "espidf", target_os = "redox")))]
+#[cfg(not(target_os = "espidf"))]
 pub use special::*;
 #[cfg(linux_kernel)]
 pub use statx::*;

data/rust-vendor/rustix/src/process/types.rs

@@ -30,12 +30,25 @@ pub struct Flock {
 #[cfg(not(target_os = "horizon"))]
 impl Flock {
     pub(crate) const unsafe fn from_raw_unchecked(raw_fl: c::flock) -> Self {
-        Self {
-            start: raw_fl.l_start as _,
-            length: raw_fl.l_len as _,
-            pid: Pid::from_raw(raw_fl.l_pid),
-            typ: transmute::<i16, FlockType>(raw_fl.l_type),
-            offset_type: transmute::<i16, FlockOffsetType>(raw_fl.l_whence),
+        #[cfg(not(all(target_os = "hurd", target_arch = "x86")))]
+        {
+            Self {
+                start: raw_fl.l_start as _,
+                length: raw_fl.l_len as _,
+                pid: Pid::from_raw(raw_fl.l_pid),
+                typ: transmute::<i16, FlockType>(raw_fl.l_type),
+                offset_type: transmute::<i16, FlockOffsetType>(raw_fl.l_whence),
+            }
+        }
+        #[cfg(all(target_os = "hurd", target_arch = "x86"))]
+        {
+            Self {
+                start: raw_fl.l_start as _,
+                length: raw_fl.l_len as _,
+                pid: Pid::from_raw(raw_fl.l_pid),
+                typ: transmute::<i32, FlockType>(raw_fl.l_type),
+                offset_type: transmute::<i32, FlockOffsetType>(raw_fl.l_whence),
+            }
         }
     }
 
@@ -68,7 +81,8 @@ impl From<FlockType> for Flock {
 /// [`fcntl_getlk`]: crate::process::fcntl_getlk()
 #[cfg(not(target_os = "horizon"))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[repr(i16)]
+#[cfg_attr(not(all(target_os = "hurd", target_arch = "x86")), repr(i16))]
+#[cfg_attr(all(target_os = "hurd", target_arch = "x86"), repr(i32))]
 pub enum FlockType {
     /// `F_RDLCK`
     ReadLock = c::F_RDLCK as _,
@@ -83,7 +97,8 @@ pub enum FlockType {
 /// [`fcntl_getlk`]: crate::process::fcntl_getlk()
 #[cfg(not(target_os = "horizon"))]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-#[repr(i16)]
+#[cfg_attr(not(all(target_os = "hurd", target_arch = "x86")), repr(i16))]
+#[cfg_attr(all(target_os = "hurd", target_arch = "x86"), repr(i32))]
 pub enum FlockOffsetType {
     /// `F_SEEK_SET`
     Set = c::SEEK_SET as _,

data/rust-vendor/slab/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"6d1adf719e44ee93067b0d3a0e24c78ec7bfb26987a7a1fc308da0b4e0feee69","CHANGELOG.md":"3e974e6231455105f64f5a29abad2d7be9d9daed42e069cd7f71c591e289cd11","Cargo.lock":"1e2fa2ab50a2a9b82f283b95c4298ba075318db9d7d670a01c6968fc49dd2569","Cargo.toml":"11f31284be0c30b612f4e2c2e46aa14494a81639b12661f01f07394e270c0070","Cargo.toml.orig":"c572eef020f23edad422e12443382233319e2621c98a1ce4a6a9dd43d8cbf78c","LICENSE":"8ce0830173fdac609dfb4ea603fdc002c2f4af0dc9b1a005653f5da9cf534b18","README.md":"6e8d6d493aec6526593ae9b05e3b21d3f878c5816a94af9d372598e03406b35f","SECURITY.md":"047267a121d112f7078dbb9a70ecc4d918404b98fbe97c88245ebf129b9de707","src/builder.rs":"87e629b1f9853d910389635b27a42391f1681cd5638d81e386215211e8b67847","src/lib.rs":"b17602b85edd5f0617e910cc94b8a1cb2f8c6e2f9c9b64712b52ec5715f0060d","src/serde.rs":"e58650a04644cb732119f50eefe6a3066104b5b41be7074e12525e05e2ad21b7","tests/serde.rs":"bb28112509dbb6949528802d05a1b1e34d2e5ff9d3ba5f62aa801cfb3de7a78e","tests/slab.rs":"98688c5a5d67eaed7378b6ffa76bdf6b4f0c8d507def550574fef6630375f087"},"package":"0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"}

data/rust-vendor/slab/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "a1e4346070a48c936d808de75191dee5d01e433c"
+  },
+  "path_in_vcs": ""
+}

data/rust-vendor/slab/CHANGELOG.md

@@ -0,0 +1,71 @@
+# 0.4.12 (January 31, 2026)
+
+* Help the compiler elide copies in `try_remove()` (#160)
+* Add security policy (#154)
+
+# 0.4.11 (August 8, 2025)
+
+* Fix `Slab::get_disjoint_mut` out of bounds (#152)
+
+# 0.4.10 (June 15, 2025)
+
+* Add `Slab::get_disjoint_mut` (#149)
+* Drop build script and `autocfg` dependency (#150)
+* Fix redundant import warning in no_std builds (#143)
+* Fix `clippy::needless_lifetimes` warning (#147)
+* Internal CI improvements (#141, #146)
+
+# 0.4.9 (August 22, 2023)
+
+* Avoid reallocations in `Slab::clone_from` (#137)
+
+# 0.4.8 (January 20, 2023)
+
+* Fixed documentation about overflow (#124)
+* Document panic in `get2_mut` (#131)
+* Refactoring (#129, #132)
+
+# 0.4.7 (July 19, 2022)
+
+* Use `#[track_caller]` on Rust 1.46+ (#119)
+* Make `Slab::new` const on Rust 1.39+ (#119)
+
+# 0.4.6 (April 2, 2022)
+
+* Add `Slab::vacant_key` (#114)
+* Fix stacked borrows violation in `Slab::get2_unchecked_mut` (#115)
+
+# 0.4.5 (October 13, 2021)
+
+* Add alternate debug output for listing items in the slab (#108)
+* Fix typo in debug output of IntoIter (#109)
+* Impl 'Clone' for 'Iter' (#110)
+
+# 0.4.4 (August 06, 2021)
+
+* Fix panic in `FromIterator` impl (#102)
+* Fix compatibility with older clippy versions (#104)
+* Add `try_remove` method (#89)
+* Implement `ExactSizeIterator` and `FusedIterator` for iterators (#92)
+
+# 0.4.3 (April 20, 2021)
+
+* Add no_std support for Rust 1.36 and above (#71).
+* Add `get2_mut` and `get2_unchecked_mut` methods (#65).
+* Make `shrink_to_fit()` remove trailing vacant entries (#62).
+* Implement `FromIterator<(usize, T)>` (#62).
+* Implement `IntoIterator<Item = (usize, T)>` (#62).
+* Provide `size_hint()` of the iterators (#62).
+* Make all iterators reversible (#62).
+* Add `key_of()` method (#61)
+* Add `compact()` method (#60)
+* Add support for serde (#85)
+
+# 0.4.2 (January 11, 2019)
+
+* Add `Slab::drain` (#56).
+
+# 0.4.1 (July 15, 2018)
+
+* Improve `reserve` and `reserve_exact` (#37).
+* Implement `Default` for `Slab` (#43).

data/rust-vendor/slab/Cargo.lock

@@ -0,0 +1,83 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_test"
+version = "1.0.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f901ee573cab6b3060453d2d5f0bae4e6d628c23c0a962ff9b5f1d7c8d4f1ed"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+dependencies = [
+ "serde",
+ "serde_test",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"

data/rust-vendor/slab/Cargo.toml

@@ -0,0 +1,67 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+rust-version = "1.51"
+name = "slab"
+version = "0.4.12"
+authors = ["Carl Lerche <me@carllerche.com>"]
+build = false
+exclude = ["/.*"]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Pre-allocated storage for a uniform data type"
+readme = "README.md"
+keywords = [
+    "slab",
+    "allocator",
+    "no_std",
+]
+categories = [
+    "memory-management",
+    "data-structures",
+    "no-std",
+]
+license = "MIT"
+repository = "https://github.com/tokio-rs/slab"
+
+[features]
+default = ["std"]
+std = []
+
+[lib]
+name = "slab"
+path = "src/lib.rs"
+
+[[test]]
+name = "serde"
+path = "tests/serde.rs"
+
+[[test]]
+name = "slab"
+path = "tests/slab.rs"
+
+[dependencies.serde]
+version = "1.0.95"
+features = ["alloc"]
+optional = true
+default-features = false
+
+[dev-dependencies.serde]
+version = "1"
+features = ["derive"]
+
+[dev-dependencies.serde_test]
+version = "1"

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

@@ -0,0 +1,29 @@
+[package]
+
+name = "slab"
+# When releasing to crates.io:
+# - Update version number
+#   - README.md
+# - Update CHANGELOG.md
+# - Create git tag
+version = "0.4.12"
+authors = ["Carl Lerche <me@carllerche.com>"]
+edition = "2018"
+rust-version = "1.51"
+license = "MIT"
+description = "Pre-allocated storage for a uniform data type"
+repository = "https://github.com/tokio-rs/slab"
+keywords = ["slab", "allocator", "no_std"]
+categories = ["memory-management", "data-structures", "no-std"]
+exclude = ["/.*"]
+
+[features]
+std = []
+default = ["std"]
+
+[dependencies]
+serde = { version = "1.0.95", optional = true, default-features = false, features = ["alloc"] }
+
+[dev-dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_test = "1"

data/rust-vendor/slab/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2019 Carl Lerche
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

data/rust-vendor/slab/README.md

@@ -0,0 +1,51 @@
+# Slab
+
+Pre-allocated storage for a uniform data type.
+
+[![Crates.io][crates-badge]][crates-url]
+[![Build Status][ci-badge]][ci-url]
+
+[crates-badge]: https://img.shields.io/crates/v/slab
+[crates-url]: https://crates.io/crates/slab
+[ci-badge]: https://img.shields.io/github/actions/workflow/status/tokio-rs/slab/ci.yml?branch=master
+[ci-url]: https://github.com/tokio-rs/slab/actions
+
+[Documentation](https://docs.rs/slab)
+
+## Usage
+
+To use `slab`, first add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+slab = "0.4"
+```
+
+Next, add this to your crate:
+
+```rust
+use slab::Slab;
+
+let mut slab = Slab::new();
+
+let hello = slab.insert("hello");
+let world = slab.insert("world");
+
+assert_eq!(slab[hello], "hello");
+assert_eq!(slab[world], "world");
+
+slab[world] = "earth";
+assert_eq!(slab[world], "earth");
+```
+
+See [documentation](https://docs.rs/slab) for more details.
+
+## License
+
+This project is licensed under the [MIT license](LICENSE).
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in `slab` by you, shall be licensed as MIT, without any additional
+terms or conditions.

data/rust-vendor/slab/SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+Slab is part of the Tokio project and uses the same security policy as [Tokio][tokio-security].
+
+## Report a security issue
+
+The process for reporting an issue is the same as for [Tokio][tokio-security]. This includes private reporting via security@tokio.rs.
+
+[tokio-security]: https://github.com/tokio-rs/tokio/security/policy

data/rust-vendor/slab/src/builder.rs

@@ -0,0 +1,63 @@
+use crate::{Entry, Slab};
+
+// Building `Slab` from pairs (usize, T).
+pub(crate) struct Builder<T> {
+    slab: Slab<T>,
+    vacant_list_broken: bool,
+    first_vacant_index: Option<usize>,
+}
+
+impl<T> Builder<T> {
+    pub(crate) fn with_capacity(capacity: usize) -> Self {
+        Self {
+            slab: Slab::with_capacity(capacity),
+            vacant_list_broken: false,
+            first_vacant_index: None,
+        }
+    }
+    pub(crate) fn pair(&mut self, key: usize, value: T) {
+        let slab = &mut self.slab;
+        if key < slab.entries.len() {
+            // iterator is not sorted, might need to recreate vacant list
+            if let Entry::Vacant(_) = slab.entries[key] {
+                self.vacant_list_broken = true;
+                slab.len += 1;
+            }
+            // if an element with this key already exists, replace it.
+            // This is consistent with HashMap and BtreeMap
+            slab.entries[key] = Entry::Occupied(value);
+        } else {
+            if self.first_vacant_index.is_none() && slab.entries.len() < key {
+                self.first_vacant_index = Some(slab.entries.len());
+            }
+            // insert holes as necessary
+            while slab.entries.len() < key {
+                // add the entry to the start of the vacant list
+                let next = slab.next;
+                slab.next = slab.entries.len();
+                slab.entries.push(Entry::Vacant(next));
+            }
+            slab.entries.push(Entry::Occupied(value));
+            slab.len += 1;
+        }
+    }
+
+    pub(crate) fn build(self) -> Slab<T> {
+        let mut slab = self.slab;
+        if slab.len == slab.entries.len() {
+            // no vacant entries, so next might not have been updated
+            slab.next = slab.entries.len();
+        } else if self.vacant_list_broken {
+            slab.recreate_vacant_list();
+        } else if let Some(first_vacant_index) = self.first_vacant_index {
+            let next = slab.entries.len();
+            match &mut slab.entries[first_vacant_index] {
+                Entry::Vacant(n) => *n = next,
+                _ => unreachable!(),
+            }
+        } else {
+            unreachable!()
+        }
+        slab
+    }
+}