diff --git a/Cargo.lock b/Cargo.lock index 9adee9d..fbeb849 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -356,6 +356,12 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7" +[[package]] +name = "bitflags" +version = "1.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" + [[package]] name = "bitflags" version = "2.13.1" @@ -642,6 +648,37 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "be1e0bca6c3637f992fc1cc7cbc52a78c1ef6db076dbf1059c4323d6a2048376" +[[package]] +name = "defmt" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e2953bfe4f93bbd20cc71198842756f77d161884c99ebbabc41d80231ded88d1" +dependencies = [ + "bitflags 1.3.2", + "defmt-macros", +] + +[[package]] +name = "defmt-macros" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bad9c72e7ca2137e0dc3813245a0d282fd6daad32fd800af018306a9169b5fe8" +dependencies = [ + "defmt-parser", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "defmt-parser" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10d60334b3b2e7c9d91ef8150abfb6fa4c1c39ebbcf4a81c2e346aad939fee3e" +dependencies = [ + "thiserror 2.0.18", +] + [[package]] name = "der" version = "0.7.10" @@ -690,7 +727,7 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" dependencies = [ - "bitflags", + "bitflags 2.13.1", "objc2", ] @@ -1135,7 +1172,7 @@ version = "0.22.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ddbcf514bd1881fc1b960e4e52b4e82873f4da3bceddbd58d42827b508888100" dependencies = [ - "bitflags", + "bitflags 2.13.1", "futures-channel", "futures-core", "futures-executor", @@ -1568,6 +1605,42 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" +[[package]] +name = "jiff" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ab1baf72f08796de0260609515130699b890ac25f30e610ad894bc5856cafdb" +dependencies = [ + "defmt", + "jiff-core", + "jiff-static", + "portable-atomic", + "portable-atomic-util", + "serde_core", +] + +[[package]] +name = "jiff-core" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e52fe76043ccecc9005d2305ebaadf7d7fc0cc89ca6baa10a94d6bc68c7128c" +dependencies = [ + "defmt", + "log", +] + +[[package]] +name = "jiff-static" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "378268a1116ad67ae6228701118ac9f491d78fda38a40a1f1a9e1348de6f7212" +dependencies = [ + "jiff-core", + "proc-macro2", + "quote", + "syn 2.0.119", +] + [[package]] name = "jobserver" version = "0.1.35" @@ -1696,7 +1769,7 @@ version = "2.30.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "909eb3049e16e373680fe65afe6e2a722ace06b671250cc4849557bc57d6a397" dependencies = [ - "bitflags", + "bitflags 2.13.1", "libc", "libpulse-sys", "num-derive", @@ -1997,7 +2070,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" dependencies = [ - "bitflags", + "bitflags 2.13.1", "dispatch2", "objc2", ] @@ -2014,7 +2087,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" dependencies = [ - "bitflags", + "bitflags 2.13.1", "block2", "libc", "objc2", @@ -2195,7 +2268,7 @@ version = "0.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61" dependencies = [ - "bitflags", + "bitflags 2.13.1", "crc32fast", "fdeflate", "flate2", @@ -2225,6 +2298,21 @@ dependencies = [ "arrayvec", ] +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "portable-atomic-util" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715" +dependencies = [ + "portable-atomic", +] + [[package]] name = "potential_utf" version = "0.1.5" @@ -2377,7 +2465,7 @@ version = "0.5.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" dependencies = [ - "bitflags", + "bitflags 2.13.1", ] [[package]] @@ -2537,7 +2625,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c1c8e1e837dd547798d3a82dd335caa39ea8aae4609743c9c905e177a53c16c7" dependencies = [ "base64", - "bitflags", + "bitflags 2.13.1", "digest", "enum-display-derive", "enum-primitive-derive", @@ -2593,7 +2681,7 @@ version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" dependencies = [ - "bitflags", + "bitflags 2.13.1", "errno", "libc", "linux-raw-sys", @@ -2875,6 +2963,7 @@ dependencies = [ "http-body-util", "hyper", "hyper-util", + "jiff", "ksni", "libpulse-binding", "notify-rust", @@ -3372,7 +3461,7 @@ version = "0.6.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840" dependencies = [ - "bitflags", + "bitflags 2.13.1", "bytes", "futures-util", "http", @@ -3728,7 +3817,7 @@ version = "0.31.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144" dependencies = [ - "bitflags", + "bitflags 2.13.1", "rustix", "wayland-backend", "wayland-scanner", @@ -3740,7 +3829,7 @@ version = "0.32.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23d0c813de3daa2ed6520af85a3bd49b0e722a3078506899aa9686fea58dc4b6" dependencies = [ - "bitflags", + "bitflags 2.13.1", "wayland-backend", "wayland-client", "wayland-scanner", diff --git a/RUST_DEPENDENCY_NOTICES.txt b/RUST_DEPENDENCY_NOTICES.txt index 90a6a38..54ff81c 100644 --- a/RUST_DEPENDENCY_NOTICES.txt +++ b/RUST_DEPENDENCY_NOTICES.txt @@ -2713,6 +2713,32 @@ the License, but only in their entirety and only with respect to the Combined Software. +Copyright (c) Ferrous Systems + +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. + Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ diff --git a/crates/solstone-linux/Cargo.toml b/crates/solstone-linux/Cargo.toml index aa3f04c..79676e7 100644 --- a/crates/solstone-linux/Cargo.toml +++ b/crates/solstone-linux/Cargo.toml @@ -22,6 +22,7 @@ claxon = "0.4.3" flac-bound = { version = "0.5.0", default-features = false, features = ["libflac-noogg"] } libpulse-binding = "2.30.1" chrono = "0.4" +jiff = { version = "0.2.37", default-features = false, features = ["alloc"] } rustix = { version = "1", features = ["event", "fs", "process", "time"] } reqwest = { version = "0.12", default-features = false, features = ["cookies", "json", "multipart", "stream"] } spl-core.workspace = true diff --git a/crates/solstone-linux/src/observer.rs b/crates/solstone-linux/src/observer.rs index aa9ea32..799b6f8 100644 --- a/crates/solstone-linux/src/observer.rs +++ b/crates/solstone-linux/src/observer.rs @@ -13,8 +13,7 @@ use crate::{ scan_segment_progress, write_capture_zone, write_segment_metadata, }, segment::{ - capture_tz_name, clamp_duration, finalize_segment_dir, local_offset_seconds, segment_key, - timestamp_parts, + ZoneReading, ZoneSource, clamp_duration, finalize_segment_dir, segment_key, timestamp_parts, }, }; #[cfg(test)] @@ -229,6 +228,7 @@ pub struct Observer { pub config: Config, pub state: ObserverState, pub backends: Backends, + zone: Box, } impl Observer @@ -243,13 +243,18 @@ where Q: CaptureStatsSource, N: StateSink, { - pub fn new(config: Config, backends: Backends) -> Self { + pub(crate) fn new( + config: Config, + backends: Backends, + zone: Box, + ) -> Self { let wall = backends.clock.wall_seconds(); let mono = backends.clock.monotonic_seconds(); let paused = config.start_paused; Self { config, backends, + zone, state: ObserverState { mode: Mode::Idle, paused, @@ -447,7 +452,13 @@ where } fn start_segment(&mut self) -> Result { let wall = self.backends.clock.wall_seconds(); - let (date, time) = timestamp_parts(wall); + if let Some(ref dir) = self.state.segment_dir + && (wall.floor() as i64) == (self.state.segment_start_wall.floor() as i64) + { + return Ok(dir.clone()); + } + let reading = self.zone.read_zone(wall); + let (date, time) = self.choose_stem(&reading); let dir = self .config .captures_dir() @@ -465,8 +476,8 @@ where write_capture_zone( &dir, &CaptureZone { - tz: capture_tz_name(), - utc_offset_seconds: local_offset_seconds(wall), + tz: reading.tz, + utc_offset_seconds: reading.utc_offset_seconds, }, ); self.state.segment_start_wall = wall; @@ -475,6 +486,55 @@ where self.state.video_started = false; Ok(dir) } + fn choose_stem(&self, reading: &ZoneReading) -> (String, String) { + let mut curr_day = reading.day.clone(); + let mut curr_hms = reading.hms.clone(); + loop { + let dir = self + .config + .captures_dir() + .join(&curr_day) + .join(&self.config.stream); + match fs::read_dir(&dir) { + Ok(entries) => { + let mut taken = false; + for entry in entries { + let Ok(entry) = entry else { + tracing::warn!("could not list segment names; using the unbumped stem"); + return (reading.day.clone(), reading.hms.clone()); + }; + let path = entry.path(); + if self.state.segment_dir.as_ref() == Some(&path) { + continue; + } + if let Some(file_name) = path.file_name().and_then(|n| n.to_str()) + && file_name.starts_with(&curr_hms) + { + taken = true; + break; + } + } + if !taken { + return (curr_day, curr_hms); + } + } + Err(err) if err.kind() == io::ErrorKind::NotFound => { + return (curr_day, curr_hms); + } + Err(_) => { + tracing::warn!("could not list segment names; using the unbumped stem"); + return (reading.day.clone(), reading.hms.clone()); + } + } + + let (next_day, next_hms) = bump_stem(&curr_day, &curr_hms); + if next_day == curr_day && next_hms == curr_hms { + return (curr_day, curr_hms); + } + curr_day = next_day; + curr_hms = next_hms; + } + } fn finalize_segment(&mut self) -> Result<(), ObserverError> { let Some(dir) = self.state.segment_dir.take() else { return Ok(()); @@ -487,12 +547,20 @@ where let _ = fs::remove_dir(&dir); return Ok(()); } - let (_, time) = timestamp_parts(self.state.segment_start_wall); + let Some(time) = dir + .file_name() + .and_then(|name| name.to_str()) + .and_then(|name| name.strip_suffix(".incomplete")) + else { + return Err(ObserverError::Io( + "invalid incomplete directory name".into(), + )); + }; let duration = clamp_duration( self.backends.clock.wall_seconds() - self.state.segment_start_wall, self.config.segment_interval.max(1) as u64, ); - let key = segment_key(&time, duration); + let key = segment_key(time, duration); let final_dir = finalize_segment_dir(&dir, &key)?; let _ = fs::remove_file(final_dir.join(".metadata")); self.backends @@ -544,6 +612,44 @@ where }) } } + +fn bump_stem(day: &str, hms: &str) -> (String, String) { + if hms.len() != 6 { + return (day.to_string(), hms.to_string()); + } + let Ok(hh) = hms[0..2].parse::() else { + return (day.to_string(), hms.to_string()); + }; + let Ok(mm) = hms[2..4].parse::() else { + return (day.to_string(), hms.to_string()); + }; + let Ok(ss) = hms[4..6].parse::() else { + return (day.to_string(), hms.to_string()); + }; + + let (new_hh, new_mm, new_ss, rollover_day) = if ss < 59 { + (hh, mm, ss + 1, false) + } else if mm < 59 { + (hh, mm + 1, 0, false) + } else if hh < 23 { + (hh + 1, 0, 0, false) + } else { + (0, 0, 0, true) + }; + + let bumped_hms = format!("{new_hh:02}{new_mm:02}{new_ss:02}"); + if rollover_day { + if let Ok(date) = chrono::NaiveDate::parse_from_str(day, "%Y%m%d") + && let Some(next_date) = date.succ_opt() + { + return (next_date.format("%Y%m%d").to_string(), bumped_hms); + } + (day.to_string(), hms.to_string()) + } else { + (day.to_string(), bumped_hms) + } +} + fn mode(a: ActivityState) -> Mode { if a.screen_locked || a.power_save || (a.power_unreadable && a.user_idle) { Mode::Idle @@ -751,6 +857,25 @@ pub(crate) mod tests { FakeStats, States, >; + #[derive(Clone)] + struct CountingZone { + reads: Rc>, + } + impl ZoneSource for CountingZone { + fn read_zone(&mut self, wall_seconds: f64) -> ZoneReading { + self.reads.set(self.reads.get() + 1); + let dt = chrono::DateTime::from_timestamp(wall_seconds.floor() as i64, 0) + .expect("valid unix seconds") + .naive_utc(); + ZoneReading { + day: dt.format("%Y%m%d").to_string(), + hms: dt.format("%H%M%S").to_string(), + utc_offset_seconds: 46800, + tz: Some("Pacific/Auckland".into()), + } + } + } + struct Fixture { _temp: tempfile::TempDir, observer: TestObserver, @@ -761,6 +886,7 @@ pub(crate) mod tests { stops: Rc>, drains: Rc>, audio_stopped: Rc>, + zone_reads: Rc>, writes: Writes, events: Events, states: States, @@ -814,6 +940,19 @@ pub(crate) mod tests { } fn fixture(start_paused: bool) -> Fixture { let temp = tempfile::tempdir().unwrap(); + let zone_reads = Rc::new(Cell::new(0)); + let zone = Box::new(CountingZone { + reads: zone_reads.clone(), + }); + fixture_in(start_paused, temp, zone, zone_reads) + } + + fn fixture_in( + start_paused: bool, + temp: tempfile::TempDir, + zone: Box, + zone_reads: Rc>, + ) -> Fixture { let wall = Rc::new(Cell::new(1_700_000_000.0)); let mono = Rc::new(Cell::new(0.0)); let wall_step = Rc::new(Cell::new(0.0)); @@ -865,7 +1004,7 @@ pub(crate) mod tests { }; Fixture { _temp: temp, - observer: Observer::new(config, backends), + observer: Observer::new(config, backends, zone), wall, mono, wall_step, @@ -873,6 +1012,7 @@ pub(crate) mod tests { stops, drains, audio_stopped, + zone_reads, writes, events, states, @@ -886,7 +1026,9 @@ pub(crate) mod tests { #[test] fn existing_incomplete_segment_is_not_adopted_or_overwritten() { let mut f = fixture(false); - let (day, time) = timestamp_parts(f.wall.get()); + let reading = f.observer.zone.read_zone(f.wall.get()); + f.zone_reads.set(0); + let (day, time) = (reading.day, reading.hms); let dir = f .observer .config @@ -903,14 +1045,12 @@ pub(crate) mod tests { for (name, bytes) in files { fs::write(dir.join(name), bytes).unwrap(); } - assert!(matches!( - f.observer.start_segment(), - Err(ObserverError::Io(_)) - )); + let bumped_dir = f.observer.start_segment().unwrap(); + assert_ne!(bumped_dir, dir); for (name, bytes) in files { assert_eq!(fs::read(dir.join(name)).unwrap(), bytes); } - assert!(f.observer.state.segment_dir.is_none()); + assert_eq!(f.observer.state.segment_dir, Some(bumped_dir)); assert_eq!(f.starts.get(), 0); assert!(f.events.completed.borrow().is_empty()); } @@ -923,8 +1063,12 @@ pub(crate) mod tests { let metadata = fs::read(dir.join(".metadata")).unwrap(); let zone = fs::read(dir.join(CAPTURE_ZONE_FILENAME)).unwrap(); f.wall.set(f.wall.get() + 300.0); - let (_, time) = timestamp_parts(f.observer.state.segment_start_wall); - let destination = dir.with_file_name(segment_key(&time, 300)); + let stem = dir + .file_name() + .and_then(|n| n.to_str()) + .and_then(|n| n.strip_suffix(".incomplete")) + .unwrap(); + let destination = dir.with_file_name(segment_key(stem, 300)); fs::create_dir(&destination).unwrap(); fs::write(destination.join("screen.webm"), b"first hour").unwrap(); @@ -1233,7 +1377,8 @@ pub(crate) mod tests { .unwrap() .count(), 2 - ) + ); + assert_eq!(f.zone_reads.get(), 2); } // tests/test_observer.py::test_async_run_returns_1_when_audio_recorder_has_fatal_error #[test] @@ -1618,11 +1763,8 @@ pub(crate) mod tests { initialize(&mut f); let dir = f.observer.state.segment_dir.clone().unwrap(); let zone = crate::recovery::read_capture_zone(&dir).expect("capture zone exists"); - assert_eq!( - zone.utc_offset_seconds, - local_offset_seconds(1_700_000_000.0) - ); - assert_eq!(zone.tz, capture_tz_name()); + assert_eq!(zone.utc_offset_seconds, 46800); + assert_eq!(zone.tz, Some("Pacific/Auckland".into())); let initial_bytes = fs::read(dir.join(CAPTURE_ZONE_FILENAME)).unwrap(); // Advance wall clock and tick @@ -1634,6 +1776,7 @@ pub(crate) mod tests { assert_eq!(meta["start_timestamp"], 1_700_000_000.0); let updated_bytes = fs::read(dir.join(CAPTURE_ZONE_FILENAME)).unwrap(); assert_eq!(initial_bytes, updated_bytes); + assert_eq!(f.zone_reads.get(), 1); } #[test] @@ -1673,4 +1816,258 @@ pub(crate) mod tests { assert!(!dir.join(CAPTURE_ZONE_FILENAME).exists()); assert_eq!(f.events.completed.borrow().len(), 0); } + + #[test] + fn repeated_hour_preserves_planted_and_finalizes_bumped() { + use crate::segment::DeviceZoneReader; + let temp = tempfile::tempdir().unwrap(); + let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("testdata/zoneinfo"); + let link = temp.path().join("localtime"); + let reader = DeviceZoneReader::new( + Some(std::ffi::OsString::from("Europe/Berlin")), + link, + vec![root], + ); + let zone_reads = Rc::new(Cell::new(0)); + let mut f = fixture_in(false, temp, Box::new(reader), zone_reads); + + let planted_dir = f + .observer + .config + .captures_dir() + .join("20261025/desk/023000_300"); + fs::create_dir_all(&planted_dir).unwrap(); + fs::write(planted_dir.join("screen.webm"), b"planted media").unwrap(); + + f.wall.set(1792891800.0); + let dir = f.observer.start_segment().unwrap(); + assert_eq!( + dir.file_name().unwrap().to_str().unwrap(), + "023001.incomplete" + ); + fs::write(dir.join("screen.webm"), b"new video").unwrap(); + + f.wall.set(1792891800.0 + 300.0); + f.observer.finalize_segment().unwrap(); + + assert_eq!( + fs::read(planted_dir.join("screen.webm")).unwrap(), + b"planted media" + ); + + let final_dir = f + .observer + .config + .captures_dir() + .join("20261025/desk/023001_300"); + assert!(final_dir.exists()); + let zone = crate::recovery::read_capture_zone(&final_dir).unwrap(); + assert_eq!(zone.tz, Some("Europe/Berlin".into())); + assert_eq!(zone.utc_offset_seconds, 3600); + + assert!(f.observer.start_segment().is_ok()); + } + + #[test] + fn travel_link_retargeting() { + use crate::segment::DeviceZoneReader; + let temp = tempfile::tempdir().unwrap(); + let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("testdata/zoneinfo"); + let link = temp.path().join("localtime"); + std::os::unix::fs::symlink(root.join("Asia/Kolkata"), &link).unwrap(); + + let reader = DeviceZoneReader::new(None, link.clone(), vec![root.clone()]); + let zone_reads = Rc::new(Cell::new(0)); + let mut f = fixture_in(false, temp, Box::new(reader), zone_reads); + + f.wall.set(1790706000.0); + let dir1 = f.observer.start_segment().unwrap(); + assert_eq!( + dir1.file_name().unwrap().to_str().unwrap(), + "235000.incomplete" + ); + fs::write(dir1.join("screen.webm"), b"video1").unwrap(); + f.wall.set(1790706000.0 + 300.0); + f.observer.finalize_segment().unwrap(); + + let final_dir1 = f + .observer + .config + .captures_dir() + .join("20260929/desk/235000_300"); + assert!(final_dir1.exists()); + let zone1 = crate::recovery::read_capture_zone(&final_dir1).unwrap(); + assert_eq!(zone1.tz, Some("Asia/Kolkata".into())); + assert_eq!(zone1.utc_offset_seconds, 19800); + + fs::remove_file(&link).unwrap(); + std::os::unix::fs::symlink(root.join("Pacific/Auckland"), &link).unwrap(); + + f.wall.set(1790706300.0); + let dir2 = f.observer.start_segment().unwrap(); + let expected_dir2 = f + .observer + .config + .captures_dir() + .join("20260930/desk/072500.incomplete"); + assert_eq!(dir2, expected_dir2); + let zone2 = crate::recovery::read_capture_zone(&dir2).unwrap(); + assert_eq!(zone2.tz, Some("Pacific/Auckland".into())); + assert_eq!(zone2.utc_offset_seconds, 46800); + } + + #[test] + fn one_read_per_new_segment() { + let mut f = fixture(false); + assert_eq!(f.zone_reads.get(), 0); + + let _dir1 = f.observer.start_segment().unwrap(); + assert_eq!(f.zone_reads.get(), 1); + + let _dir1_again = f.observer.start_segment().unwrap(); + assert_eq!(f.zone_reads.get(), 1); + + f.observer.finalize_segment().unwrap(); + f.wall.set(f.wall.get() + 10.0); + let _dir2 = f.observer.start_segment().unwrap(); + assert_eq!(f.zone_reads.get(), 2); + } + + #[test] + fn chained_stem_bump() { + let mut f = fixture(false); + f.wall.set(1704076200.0); + let base = f.observer.config.captures_dir().join("20240101/desk"); + fs::create_dir_all(&base).unwrap(); + fs::create_dir(base.join("023000_300")).unwrap(); + fs::create_dir(base.join("023001_300")).unwrap(); + + let dir = f.observer.start_segment().unwrap(); + assert_eq!( + dir.file_name().unwrap().to_str().unwrap(), + "023002.incomplete" + ); + } + + #[test] + fn failed_dir_alone_bumps() { + let mut f = fixture(false); + f.wall.set(1704076200.0); + let base = f.observer.config.captures_dir().join("20240101/desk"); + fs::create_dir_all(&base).unwrap(); + fs::create_dir(base.join("023000.failed")).unwrap(); + + let dir = f.observer.start_segment().unwrap(); + assert_eq!( + dir.file_name().unwrap().to_str().unwrap(), + "023001.incomplete" + ); + + let mut f2 = fixture(false); + f2.wall.set(1704076200.0); + let base2 = f2.observer.config.captures_dir().join("20240101/desk"); + fs::create_dir_all(&base2).unwrap(); + fs::create_dir(base2.join("023000_300.failed")).unwrap(); + + let dir2 = f2.observer.start_segment().unwrap(); + assert_eq!( + dir2.file_name().unwrap().to_str().unwrap(), + "023001.incomplete" + ); + } + + #[test] + fn midnight_rollover_bump() { + let mut f = fixture(false); + f.wall.set(1798761599.0); + let base = f.observer.config.captures_dir().join("20261231/desk"); + fs::create_dir_all(&base).unwrap(); + fs::create_dir(base.join("235959_300")).unwrap(); + + let dir = f.observer.start_segment().unwrap(); + let expected_dir = f + .observer + .config + .captures_dir() + .join("20270101/desk/000000.incomplete"); + assert_eq!(dir, expected_dir); + let meta = sidecar(&dir); + assert_eq!(meta["start_timestamp"], 1798761599.0); + let zone = crate::recovery::read_capture_zone(&dir).unwrap(); + assert_eq!(zone.tz, Some("Pacific/Auckland".into())); + assert_eq!(zone.utc_offset_seconds, 46800); + + fs::write(dir.join("screen.webm"), b"video").unwrap(); + f.wall.set(1798761599.0 + 300.0); + f.observer.finalize_segment().unwrap(); + + let final_dir = f + .observer + .config + .captures_dir() + .join("20270101/desk/000000_300"); + assert!(final_dir.exists()); + } + + #[test] + fn negative_twin_different_stream_or_day_does_not_bump() { + let mut f = fixture(false); + f.wall.set(1704076200.0); + let other_stream = f.observer.config.captures_dir().join("20240101/room"); + fs::create_dir_all(&other_stream).unwrap(); + fs::create_dir(other_stream.join("023000_300")).unwrap(); + + let other_day = f.observer.config.captures_dir().join("20240102/desk"); + fs::create_dir_all(&other_day).unwrap(); + fs::create_dir(other_day.join("023000_300")).unwrap(); + + let dir = f.observer.start_segment().unwrap(); + assert_eq!( + dir.file_name().unwrap().to_str().unwrap(), + "023000.incomplete" + ); + } + + #[test] + fn resume_reopen_bumped_stem_same_second() { + let mut f = fixture(true); + initialize(&mut f); + f.observer.resume(); + + let (day, time) = ("20231114", "221320"); + let base = f.observer.config.captures_dir().join(day).join("desk"); + fs::create_dir_all(&base).unwrap(); + fs::create_dir(base.join(format!("{time}_300"))).unwrap(); + + f.observer.backends.video.fail_start = true; + f.wall_step.set(0.0); + f.observer.tick().unwrap(); + + assert_eq!(f.starts.get(), 1); + assert!(f.observer.state.segment_dir.is_some()); + let seg_dir = f.observer.state.segment_dir.clone().unwrap(); + assert_eq!( + seg_dir.file_name().unwrap().to_str().unwrap(), + "221321.incomplete" + ); + assert_eq!( + fs::read_dir(seg_dir.parent().unwrap()) + .unwrap() + .filter(|e| e + .as_ref() + .unwrap() + .file_name() + .to_str() + .unwrap() + .ends_with(".incomplete")) + .count(), + 1 + ); + let zone_path = seg_dir.join(".capture_zone"); + let zone_bytes = fs::read(&zone_path).unwrap(); + let reopened = f.observer.start_segment().unwrap(); + assert_eq!(reopened, seg_dir); + assert_eq!(fs::read(&zone_path).unwrap(), zone_bytes); + assert_eq!(f.zone_reads.get(), 1); + } } diff --git a/crates/solstone-linux/src/run.rs b/crates/solstone-linux/src/run.rs index d4c1f8a..4d5e2f6 100644 --- a/crates/solstone-linux/src/run.rs +++ b/crates/solstone-linux/src/run.rs @@ -340,7 +340,15 @@ fn run_capture( stats: BackgroundCaptureStats::new(), states, }; - let mut observer = Observer::new(config, backends); + let zone = Box::new(crate::segment::DeviceZoneReader::new( + std::env::var_os("TZ"), + std::path::PathBuf::from("/etc/localtime"), + crate::segment::ZONE_INFO_DIRECTORIES + .iter() + .map(std::path::PathBuf::from) + .collect(), + )); + let mut observer = Observer::new(config, backends, zone); let initialized = !stopped.load(Ordering::Acquire); let mut run_result = if initialized { observer.initialize() @@ -1031,7 +1039,18 @@ mod tests { stats: TestStats, states, }; - let mut observer = Observer::new(Config::default(), backends); + struct DummyZone; + impl crate::segment::ZoneSource for DummyZone { + fn read_zone(&mut self, _: f64) -> crate::segment::ZoneReading { + crate::segment::ZoneReading { + day: "20260101".into(), + hms: "000000".into(), + utc_offset_seconds: 0, + tz: None, + } + } + } + let mut observer = Observer::new(Config::default(), backends, Box::new(DummyZone)); let open_journal = crate::private_link::OpenJournalAccess::default(); let menu_items = tray.menu(); diff --git a/crates/solstone-linux/src/segment.rs b/crates/solstone-linux/src/segment.rs index 0a91111..2add2de 100644 --- a/crates/solstone-linux/src/segment.rs +++ b/crates/solstone-linux/src/segment.rs @@ -3,11 +3,12 @@ use chrono::{DateTime, Local, LocalResult, Offset, TimeZone}; use std::{ + ffi::OsString, fs, io, - path::{Path, PathBuf}, + path::{Component, Path, PathBuf}, }; -const ZONE_INFO_DIRECTORIES: [&str; 4] = [ +pub(crate) const ZONE_INFO_DIRECTORIES: [&str; 4] = [ "/usr/share/zoneinfo", "/share/zoneinfo", "/etc/zoneinfo", @@ -34,6 +35,7 @@ pub fn timestamp_parts(timestamp: f64) -> (String, String) { ) } +#[cfg(test)] pub(crate) fn local_offset_seconds(timestamp: f64) -> i32 { local_datetime(timestamp).offset().fix().local_minus_utc() } @@ -58,7 +60,7 @@ fn is_valid_iana_component(component: &str) -> bool { .all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '+' || c == '-') } -fn iana_zone_name(raw: &str) -> Option { +fn is_valid_iana_shape(raw: &str) -> Option<&str> { if raw.is_empty() || raw.starts_with(':') || raw.contains(',') { return None; } @@ -71,6 +73,12 @@ fn iana_zone_name(raw: &str) -> Option { if !stripped.contains('/') && !is_slashless_allowed { return None; } + Some(stripped) +} + +#[cfg(test)] +fn iana_zone_name(raw: &str) -> Option { + let stripped = is_valid_iana_shape(raw)?; let file_exists = ZONE_INFO_DIRECTORIES.iter().any(|&dir| { let path = Path::new(dir).join(stripped); path.is_file() @@ -81,42 +89,43 @@ fn iana_zone_name(raw: &str) -> Option { Some(stripped.to_owned()) } +fn normalize_path(path: &Path) -> PathBuf { + let mut components = Vec::new(); + for comp in path.components() { + match comp { + Component::CurDir => {} + Component::ParentDir => { + if let Some(Component::Normal(_)) = components.last() { + components.pop(); + } else { + components.push(comp); + } + } + _ => components.push(comp), + } + } + components.iter().collect() +} + +#[cfg(test)] fn zone_name_from_localtime_target(target: &Path) -> Option { let resolved = if target.is_relative() { - Path::new("/etc").join(target) + normalize_path(&Path::new("/etc").join(target)) } else { - target.to_path_buf() + normalize_path(target) }; - let resolved_str = resolved.to_str()?; for &dir in &ZONE_INFO_DIRECTORIES { - let prefix = if dir.ends_with('/') { - dir.to_string() - } else { - format!("{dir}/") - }; - if let Some(remainder) = resolved_str.strip_prefix(&prefix) { - return iana_zone_name(remainder); + let norm_root = normalize_path(Path::new(dir)); + if let Ok(rel) = resolved.strip_prefix(&norm_root) + && let Some(rel_str) = rel.to_str() + && let Some(name) = is_valid_iana_shape(rel_str) + { + return Some(name.to_owned()); } } None } -pub(crate) fn capture_tz_name() -> Option { - match std::env::var_os("TZ") { - None => { - let target = fs::read_link("/etc/localtime").ok()?; - zone_name_from_localtime_target(&target) - } - Some(val) => { - let s = val.to_str()?; - if s.is_empty() { - return None; - } - iana_zone_name(s) - } - } -} - pub fn clamp_duration(elapsed: f64, ceiling: u64) -> u64 { if ceiling == 0 { return 1; @@ -135,6 +144,204 @@ pub fn finalize_segment_dir(incomplete: &Path, key: &str) -> io::Result Ok(destination) } +#[derive(Clone, Debug, PartialEq, Eq)] +pub(crate) struct ZoneReading { + pub day: String, + pub hms: String, + pub utc_offset_seconds: i32, + pub tz: Option, +} + +pub(crate) trait ZoneSource { + fn read_zone(&mut self, wall_seconds: f64) -> ZoneReading; +} + +pub(crate) struct DeviceZoneReader { + tz_env: Option, + localtime: PathBuf, + roots: Vec, + resolved_name: bool, + warned: bool, +} + +impl DeviceZoneReader { + pub(crate) fn new(tz_env: Option, localtime: PathBuf, roots: Vec) -> Self { + Self { + tz_env, + localtime, + roots, + resolved_name: false, + warned: false, + } + } + + fn warn_fallback(&mut self) { + if !self.warned { + tracing::warn!("capture zone fallback"); + self.warned = true; + } + } +} + +impl ZoneSource for DeviceZoneReader { + fn read_zone(&mut self, wall_seconds: f64) -> ZoneReading { + let unix_secs = wall_seconds.floor() as i64; + + let make_reading = + |tz: &jiff::tz::TimeZone, tz_name: Option| -> Option { + let ts = jiff::Timestamp::from_second(unix_secs).ok()?; + let dt = tz.to_datetime(ts); + let offset = tz.to_offset(ts); + Some(ZoneReading { + day: format!("{:04}{:02}{:02}", dt.year(), dt.month(), dt.day()), + hms: format!("{:02}{:02}{:02}", dt.hour(), dt.minute(), dt.second()), + utc_offset_seconds: offset.seconds(), + tz: tz_name, + }) + }; + + if let Some(ref val) = self.tz_env { + // Rows 1-3. Never consult localtime. + let Some(raw_str) = val.to_str() else { + if self.resolved_name { + self.warn_fallback(); + } + let dt = local_datetime(wall_seconds); + return ZoneReading { + day: dt.format("%Y%m%d").to_string(), + hms: dt.format("%H%M%S").to_string(), + utc_offset_seconds: dt.offset().fix().local_minus_utc(), + tz: None, + }; + }; + + if raw_str.is_empty() { + if self.resolved_name { + self.warn_fallback(); + } + let dt = local_datetime(wall_seconds); + return ZoneReading { + day: dt.format("%Y%m%d").to_string(), + hms: dt.format("%H%M%S").to_string(), + utc_offset_seconds: dt.offset().fix().local_minus_utc(), + tz: None, + }; + } + + if let Some(shape_name) = is_valid_iana_shape(raw_str) { + for root in &self.roots { + let p = root.join(shape_name); + if p.is_file() { + if let Ok(bytes) = fs::read(&p) + && let Ok(tz) = jiff::tz::TimeZone::tzif(shape_name, &bytes) + && let Some(reading) = make_reading(&tz, Some(shape_name.to_owned())) + { + self.resolved_name = true; + return reading; + } + // File exists but tzif failed + self.resolved_name = true; + self.warn_fallback(); + let dt = local_datetime(wall_seconds); + return ZoneReading { + day: dt.format("%Y%m%d").to_string(), + hms: dt.format("%H%M%S").to_string(), + utc_offset_seconds: dt.offset().fix().local_minus_utc(), + tz: None, + }; + } + } + // Shape-valid but file does not exist + if self.resolved_name { + self.warn_fallback(); + } + let dt = local_datetime(wall_seconds); + return ZoneReading { + day: dt.format("%Y%m%d").to_string(), + hms: dt.format("%H%M%S").to_string(), + utc_offset_seconds: dt.offset().fix().local_minus_utc(), + tz: None, + }; + } + + // Not a shape-valid IANA name. Try POSIX + if let Ok(tz) = jiff::tz::TimeZone::posix(raw_str) + && let Some(reading) = make_reading(&tz, None) + { + return reading; + } + + // POSIX rejected + if self.resolved_name { + self.warn_fallback(); + } + let dt = local_datetime(wall_seconds); + return ZoneReading { + day: dt.format("%Y%m%d").to_string(), + hms: dt.format("%H%M%S").to_string(), + utc_offset_seconds: dt.offset().fix().local_minus_utc(), + tz: None, + }; + } + + // TZ unset: Rows 4-6 + let mut link_resolved_name: Option<(String, PathBuf)> = None; + if let Ok(target) = fs::read_link(&self.localtime) { + let resolved = if target.is_relative() { + let parent = self.localtime.parent().unwrap_or_else(|| Path::new("")); + normalize_path(&parent.join(target)) + } else { + normalize_path(&target) + }; + + for root in &self.roots { + let normalized_root = normalize_path(root); + if let Ok(rel) = resolved.strip_prefix(&normalized_root) + && let Some(rel_str) = rel.to_str() + && let Some(shape_name) = is_valid_iana_shape(rel_str) + { + link_resolved_name = Some((shape_name.to_owned(), resolved.clone())); + break; + } + } + } + + if let Some((name, resolved_path)) = link_resolved_name { + if resolved_path.is_file() + && let Ok(bytes) = fs::read(&resolved_path) + && let Ok(tz) = jiff::tz::TimeZone::tzif(&name, &bytes) + && let Some(reading) = make_reading(&tz, Some(name.clone())) + { + self.resolved_name = true; + return reading; + } + // Name matched but tzif failed + self.resolved_name = true; + } + + // Try reading localtime path directly (Row 5) + if let Ok(bytes) = fs::read(&self.localtime) + && let Ok(tz) = jiff::tz::TimeZone::tzif("localtime", &bytes) + && let Some(reading) = make_reading(&tz, None) + { + if self.resolved_name { + self.warn_fallback(); + } + return reading; + } + + // Row 6 + self.warn_fallback(); + let dt = local_datetime(wall_seconds); + ZoneReading { + day: dt.format("%Y%m%d").to_string(), + hms: dt.format("%H%M%S").to_string(), + utc_offset_seconds: dt.offset().fix().local_minus_utc(), + tz: None, + } + } +} + #[cfg(test)] #[derive(Clone, Debug, PartialEq, Eq)] pub(crate) struct CivilTime { @@ -296,6 +503,41 @@ pub(crate) fn civil_time_in_zoneinfo(zone: &str, unix_seconds: i64) -> Option>>); + impl io::Write for LogBuffer { + fn write(&mut self, buf: &[u8]) -> io::Result { + self.0.lock().unwrap().extend_from_slice(buf); + Ok(buf.len()) + } + fn flush(&mut self) -> io::Result<()> { + Ok(()) + } + } + + fn capture_logs(f: F) -> (R, Vec) + where + F: FnOnce() -> R, + { + let buffer = Arc::new(Mutex::new(Vec::new())); + let writer = LogBuffer(Arc::clone(&buffer)); + let subscriber = tracing_subscriber::fmt() + .without_time() + .with_ansi(false) + .with_writer(move || writer.clone()) + .finish(); + let result = tracing::subscriber::with_default(subscriber, f); + let raw = buffer.lock().unwrap().clone(); + let text = String::from_utf8_lossy(&raw).to_string(); + let lines: Vec = text + .lines() + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) + .collect(); + (result, lines) + } // observer.py::_get_timestamp_parts shape contract. #[test] @@ -396,4 +638,299 @@ mod tests { assert_eq!(kolkata_jan.hms, "120000"); assert_eq!(kolkata_jan.utc_offset_seconds, 19800); } + + fn testdata_root() -> PathBuf { + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("testdata/zoneinfo") + } + + fn check_utc_host() { + if local_offset_seconds(1790706000.0) == 0 { + panic!("host is UTC; can't tell the fallback from Etc/Unknown"); + } + } + + #[test] + fn berlin_slim_dst_instants() { + let root = testdata_root(); + let bytes = fs::read(root.join("Europe/Berlin")).unwrap(); + let tz = jiff::tz::TimeZone::tzif("Europe/Berlin", &bytes).unwrap(); + + let ts1 = jiff::Timestamp::from_second(1792888200).unwrap(); + let dt1 = tz.to_datetime(ts1); + let off1 = tz.to_offset(ts1).seconds(); + assert_eq!( + format!("{:04}{:02}{:02}", dt1.year(), dt1.month(), dt1.day()), + "20261025" + ); + assert_eq!( + format!("{:02}{:02}{:02}", dt1.hour(), dt1.minute(), dt1.second()), + "023000" + ); + assert_eq!(off1, 7200); + + let ts2 = jiff::Timestamp::from_second(1792891800).unwrap(); + let dt2 = tz.to_datetime(ts2); + let off2 = tz.to_offset(ts2).seconds(); + assert_eq!( + format!("{:04}{:02}{:02}", dt2.year(), dt2.month(), dt2.day()), + "20261025" + ); + assert_eq!( + format!("{:02}{:02}{:02}", dt2.hour(), dt2.minute(), dt2.second()), + "023000" + ); + assert_eq!(off2, 3600); + } + + #[test] + fn zone_table_row_1_tz_set_and_loads() { + let temp = tempfile::tempdir().unwrap(); + let root = testdata_root(); + let link = temp.path().join("localtime"); + std::os::unix::fs::symlink(root.join("Pacific/Auckland"), &link).unwrap(); + + let mut reader = + DeviceZoneReader::new(Some(OsString::from("Asia/Kolkata")), link, vec![root]); + let (reading, lines) = capture_logs(|| reader.read_zone(1790706000.0)); + assert_eq!(reading.day, "20260929"); + assert_eq!(reading.hms, "235000"); + assert_eq!(reading.utc_offset_seconds, 19800); + assert_eq!(reading.tz, Some("Asia/Kolkata".into())); + assert!(lines.is_empty()); + } + + #[test] + fn zone_table_row_1_file_is_the_roots() { + let temp = tempfile::tempdir().unwrap(); + let temp_root = temp.path().join("zoneinfo"); + fs::create_dir_all(temp_root.join("Pacific")).unwrap(); + let root = testdata_root(); + fs::copy( + root.join("Asia/Kathmandu"), + temp_root.join("Pacific/Auckland"), + ) + .unwrap(); + + let link = temp.path().join("localtime"); + let mut reader = DeviceZoneReader::new( + Some(OsString::from("Pacific/Auckland")), + link, + vec![temp_root], + ); + let (reading, lines) = capture_logs(|| reader.read_zone(1790706000.0)); + assert_eq!(reading.day, "20260930"); + assert_eq!(reading.hms, "000500"); + assert_eq!(reading.utc_offset_seconds, 20700); + assert_eq!(reading.tz, Some("Pacific/Auckland".into())); + assert!(lines.is_empty()); + } + + #[test] + fn zone_table_row_2_posix_string() { + let temp = tempfile::tempdir().unwrap(); + let root = testdata_root(); + let link = temp.path().join("localtime"); + + let mut reader = DeviceZoneReader::new(Some(OsString::from("IST-5:30")), link, vec![root]); + let (reading, lines) = capture_logs(|| reader.read_zone(1790706000.0)); + assert_eq!(reading.day, "20260929"); + assert_eq!(reading.hms, "235000"); + assert_eq!(reading.utc_offset_seconds, 19800); + assert_eq!(reading.tz, None); + assert!(lines.is_empty()); + } + + #[test] + fn zone_table_row_3_unparseable_tz() { + check_utc_host(); + let temp = tempfile::tempdir().unwrap(); + let root = testdata_root(); + let link = temp.path().join("localtime"); + std::os::unix::fs::symlink(root.join("Pacific/Auckland"), &link).unwrap(); + + let mut reader = + DeviceZoneReader::new(Some(OsString::from("not a zone")), link, vec![root]); + let (reading, lines) = capture_logs(|| reader.read_zone(1790706000.0)); + let dt = local_datetime(1790706000.0); + assert_eq!(reading.day, dt.format("%Y%m%d").to_string()); + assert_eq!(reading.hms, dt.format("%H%M%S").to_string()); + assert_eq!( + reading.utc_offset_seconds, + dt.offset().fix().local_minus_utc() + ); + assert_ne!(reading.utc_offset_seconds, 46800); + assert_eq!(reading.tz, None); + assert!( + !lines.iter().any(|l| l.contains("capture zone fallback")), + "unexpected warn: {lines:?}" + ); + } + + #[test] + fn zone_table_row_3_file_corrupt() { + check_utc_host(); + let temp = tempfile::tempdir().unwrap(); + let temp_root = temp.path().join("zoneinfo"); + fs::create_dir_all(temp_root.join("Asia")).unwrap(); + fs::write(temp_root.join("Asia/Kolkata"), b"garbage_bytes").unwrap(); + + let root = testdata_root(); + let link = temp.path().join("localtime"); + std::os::unix::fs::symlink(root.join("Pacific/Auckland"), &link).unwrap(); + + let mut reader = + DeviceZoneReader::new(Some(OsString::from("Asia/Kolkata")), link, vec![temp_root]); + let (reading1, lines1) = capture_logs(|| reader.read_zone(1790706000.0)); + let dt = local_datetime(1790706000.0); + assert_eq!(reading1.day, dt.format("%Y%m%d").to_string()); + assert_eq!(reading1.hms, dt.format("%H%M%S").to_string()); + assert_eq!( + reading1.utc_offset_seconds, + dt.offset().fix().local_minus_utc() + ); + assert_ne!(reading1.utc_offset_seconds, 46800); + assert_eq!(reading1.tz, None); + assert_eq!( + lines1 + .iter() + .filter(|l| l.contains("capture zone fallback")) + .count(), + 1 + ); + + let (_reading2, lines2) = capture_logs(|| reader.read_zone(1790706000.0)); + assert!( + !lines2.iter().any(|l| l.contains("capture zone fallback")), + "second read logged warn again" + ); + } + + #[test] + fn zone_table_row_4_link_moves_between_reads() { + let temp = tempfile::tempdir().unwrap(); + let root = testdata_root(); + let link = temp.path().join("localtime"); + std::os::unix::fs::symlink(root.join("Asia/Kolkata"), &link).unwrap(); + + let mut reader = DeviceZoneReader::new(None, link.clone(), vec![root.clone()]); + let (reading1, lines1) = capture_logs(|| reader.read_zone(1790706000.0)); + assert_eq!(reading1.day, "20260929"); + assert_eq!(reading1.hms, "235000"); + assert_eq!(reading1.utc_offset_seconds, 19800); + assert_eq!(reading1.tz, Some("Asia/Kolkata".into())); + assert!(lines1.is_empty()); + + fs::remove_file(&link).unwrap(); + std::os::unix::fs::symlink(root.join("Pacific/Auckland"), &link).unwrap(); + + let (reading2, lines2) = capture_logs(|| reader.read_zone(1790706000.0)); + assert_eq!(reading2.day, "20260930"); + assert_eq!(reading2.hms, "072000"); + assert_eq!(reading2.utc_offset_seconds, 46800); + assert_eq!(reading2.tz, Some("Pacific/Auckland".into())); + assert!(lines2.is_empty()); + } + + #[test] + fn zone_table_row_4_relative_link() { + let temp = tempfile::tempdir().unwrap(); + let fixture_root = temp.path(); + let etc_dir = fixture_root.join("etc"); + let zoneinfo_dir = fixture_root.join("usr/share/zoneinfo"); + fs::create_dir_all(&etc_dir).unwrap(); + fs::create_dir_all(zoneinfo_dir.join("Asia")).unwrap(); + + let root = testdata_root(); + fs::copy(root.join("Asia/Kolkata"), zoneinfo_dir.join("Asia/Kolkata")).unwrap(); + + let link = etc_dir.join("localtime"); + std::os::unix::fs::symlink("../usr/share/zoneinfo/Asia/Kolkata", &link).unwrap(); + + let mut reader = DeviceZoneReader::new(None, link, vec![zoneinfo_dir]); + let (reading, lines) = capture_logs(|| reader.read_zone(1790706000.0)); + assert_eq!(reading.day, "20260929"); + assert_eq!(reading.hms, "235000"); + assert_eq!(reading.utc_offset_seconds, 19800); + assert_eq!(reading.tz, Some("Asia/Kolkata".into())); + assert!(lines.is_empty()); + } + + #[test] + fn zone_table_row_5_regular_file() { + let temp = tempfile::tempdir().unwrap(); + let root = testdata_root(); + let localtime = temp.path().join("localtime"); + fs::copy(root.join("Asia/Kathmandu"), &localtime).unwrap(); + + let mut reader = DeviceZoneReader::new(None, localtime, vec![root]); + let (reading, lines) = capture_logs(|| reader.read_zone(1790706000.0)); + assert_eq!(reading.day, "20260930"); + assert_eq!(reading.hms, "000500"); + assert_eq!(reading.utc_offset_seconds, 20700); + assert_eq!(reading.tz, None); + assert!(lines.is_empty()); + } + + #[test] + fn zone_table_row_5_corrupt_resolved_link() { + check_utc_host(); + let temp = tempfile::tempdir().unwrap(); + let temp_root = temp.path().join("zoneinfo"); + fs::create_dir_all(temp_root.join("Asia")).unwrap(); + let corrupt_target = temp_root.join("Asia/Kolkata"); + fs::write(&corrupt_target, b"corrupt").unwrap(); + + let link = temp.path().join("localtime"); + std::os::unix::fs::symlink(&corrupt_target, &link).unwrap(); + + let mut reader = DeviceZoneReader::new(None, link, vec![temp_root]); + let (reading, lines) = capture_logs(|| reader.read_zone(1790706000.0)); + let dt = local_datetime(1790706000.0); + assert_eq!(reading.day, dt.format("%Y%m%d").to_string()); + assert_eq!(reading.hms, dt.format("%H%M%S").to_string()); + assert_eq!( + reading.utc_offset_seconds, + dt.offset().fix().local_minus_utc() + ); + assert_eq!(reading.tz, None); + assert_eq!( + lines + .iter() + .filter(|l| l.contains("capture zone fallback")) + .count(), + 1 + ); + } + + #[test] + fn zone_table_row_6_missing_localtime() { + check_utc_host(); + let temp = tempfile::tempdir().unwrap(); + let root = testdata_root(); + let link = temp.path().join("nonexistent_localtime"); + + let mut reader = DeviceZoneReader::new(None, link, vec![root]); + let (reading1, lines1) = capture_logs(|| reader.read_zone(1790706000.0)); + let dt = local_datetime(1790706000.0); + assert_eq!(reading1.day, dt.format("%Y%m%d").to_string()); + assert_eq!(reading1.hms, dt.format("%H%M%S").to_string()); + assert_eq!( + reading1.utc_offset_seconds, + dt.offset().fix().local_minus_utc() + ); + assert_eq!(reading1.tz, None); + assert_eq!( + lines1 + .iter() + .filter(|l| l.contains("capture zone fallback")) + .count(), + 1 + ); + + let (_reading2, lines2) = capture_logs(|| reader.read_zone(1790706000.0)); + assert!( + !lines2.iter().any(|l| l.contains("capture zone fallback")), + "second read logged warn again" + ); + } } diff --git a/crates/solstone-linux/testdata/zoneinfo/Asia/Kathmandu b/crates/solstone-linux/testdata/zoneinfo/Asia/Kathmandu new file mode 100644 index 0000000000000000000000000000000000000000..3a0d330ffd2f08396290960527fc8fc186356161 GIT binary patch literal 161 zcmWHE%1kq2AP5*47#Khpq>uu0*#)9c z-R=R4pJ6SO0P)XEHCh3pFO>+*U}R!uVP;`wUuW%_E)wrmx=m0HWvI zTsHwk&t0+=OwZdn0Zh+tnGU8;a2A5;Gta#RK`ehCMr6ng=0QkgaqMgc2A&R3xXCCmvM@042{3RnFlZSt q^7{COFgUvgg9s4z4PoGNb`8-r1c~YR8ta+r8R+;L8h~hhV=e$VmE(s1 literal 0 HcmV?d00001 diff --git a/crates/solstone-linux/testdata/zoneinfo/Pacific/Auckland b/crates/solstone-linux/testdata/zoneinfo/Pacific/Auckland new file mode 100644 index 0000000000000000000000000000000000000000..afb3929318475d4f0ea9d6c9e94d0f5f81d8b82e GIT binary patch literal 1043 zcmWHE%1kq2AP5*47#Khpq>ukBNxoyb!Iu3 zzx#$in7`-o3ow80x^H0n_8mS2=I`&j0p=fAyavoan70eeKh)d@<{$Q(1Lhw|E&%h7 z>eYey$9#Ih_8;d<0P|1iHQfEoiq0Obb<{gK1&87BDRm;R&JtrGaTN3vCGf zycukdgrWz8KAsAur5Lp!^m2DFE&Y%OOv|)uf@#?U@4&QNIyab>UvL3TE4aM{(~1q7 zz_gM9C)gh4%yVE`h5t2}R@Gw!%d0Utf%)pZkHLKPM=D^x#@nM{zUCn|FkkEJaxh^$OmFGu=x0fF!)6Ug9tFoC4_+s#Md=6@{4i_(ebs^ SGu1QD@ioyi)HBdG<^lliDM^q3 literal 0 HcmV?d00001 diff --git a/licensing/overrides/defmt-parser/1.0.0/LICENSE-APACHE b/licensing/overrides/defmt-parser/1.0.0/LICENSE-APACHE new file mode 100644 index 0000000..11069ed --- /dev/null +++ b/licensing/overrides/defmt-parser/1.0.0/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/licensing/overrides/defmt-parser/1.0.0/LICENSE-MIT b/licensing/overrides/defmt-parser/1.0.0/LICENSE-MIT new file mode 100644 index 0000000..e68a7ab --- /dev/null +++ b/licensing/overrides/defmt-parser/1.0.0/LICENSE-MIT @@ -0,0 +1,25 @@ +Copyright (c) Ferrous Systems + +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. \ No newline at end of file diff --git a/licensing/rust-dependency-notices.index.json b/licensing/rust-dependency-notices.index.json index 178dc2b..2eb787b 100644 --- a/licensing/rust-dependency-notices.index.json +++ b/licensing/rust-dependency-notices.index.json @@ -1,11 +1,11 @@ { "schema": "solstone-linux.rust-dependency-notices.v1", - "cargo_lock_sha256": "ba71d957d5de435d688bbdae40461e2dadfffe822ec513afdb17f9763397cd25", - "notices_sha256": "9543d6d2b62c2ccc21bf900f7a84a151c9e9e0126e9e5b5d3a96ca123fb98682", + "cargo_lock_sha256": "f27f7e1293ba57ea699d3e1802ed773079ef7d5356ebf202462402635f6a83ed", + "notices_sha256": "330607a08a161840b0f795b31cd8bbd3b12883f5376fb10d1592a8cf34698206", "population_query": "cargo metadata --locked --offline --format-version 1 --filter-platform x86_64-unknown-linux-gnu", "root_package": "solstone-linux", "filter_platform": "x86_64-unknown-linux-gnu", - "external_package_count": 319, + "external_package_count": 325, "packages": [ { "name": "adler2", @@ -15,15 +15,15 @@ "members": [ { "sha256": "861399f8c21c042b110517e76dc6b63a2b334276c8cf17412fc3c8908ca8dc17", - "start": 459919, - "end": 460584, + "start": 460974, + "end": 461639, "origin": "crate-archive", "path": "LICENSE-0BSD" }, { "sha256": "8ada45cd9f843acf64e4722ae262c622a2b3b3007c7310ef36ac1061a30f6adb", - "start": 474056, - "end": 484916, + "start": 475111, + "end": 485971, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -51,8 +51,8 @@ }, { "sha256": "36516aefdc84c5d5a1e7485425913a22dbda69eb1930c5e84d6ae4972b5194b9", - "start": 205178, - "end": 206224, + "start": 206233, + "end": 207279, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -66,15 +66,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -88,15 +88,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -110,15 +110,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -132,15 +132,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -154,15 +154,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "33f702959c0ea91c08b21b65cf1f08b6c122ec9e6db0b5db784a7b367d942330", - "start": 193304, - "end": 194386, + "start": 194359, + "end": 195441, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -191,15 +191,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "4da95ec4ecb65b738d470b7d762894ad9c97da93e6cbfb18b570fc2c96f4b871", - "start": 267219, - "end": 268290, + "start": 268274, + "end": 269345, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -213,8 +213,8 @@ "members": [ { "sha256": "ae26bc7b1bc91fb8648f6a298decbb1a77090a56c9d04e2c23b8365e5f54acb5", - "start": 583098, - "end": 584172, + "start": 584153, + "end": 585227, "origin": "crate-archive", "path": "LICENSE" } @@ -228,15 +228,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a5c61b93b6ee1d104af9920cf020ff3c7efe818e31fe562c72261847a728f513", - "start": 533942, - "end": 535002, + "start": 534997, + "end": 536057, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -250,15 +250,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a5c61b93b6ee1d104af9920cf020ff3c7efe818e31fe562c72261847a728f513", - "start": 533942, - "end": 535002, + "start": 534997, + "end": 536057, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -272,15 +272,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "committed-override", "path": "LICENSE-APACHE" }, { "sha256": "a5c61b93b6ee1d104af9920cf020ff3c7efe818e31fe562c72261847a728f513", - "start": 533942, - "end": 535002, + "start": 534997, + "end": 536057, "origin": "committed-override", "path": "LICENSE-MIT" } @@ -294,8 +294,8 @@ "members": [ { "sha256": "e4705ddab847449a2cdcb3c88b005ea10330aa249d9148ca2eef9c84c5d29895", - "start": 708732, - "end": 719489, + "start": 709787, + "end": 720544, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -316,8 +316,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -338,8 +338,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -360,8 +360,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -382,8 +382,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -404,8 +404,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -426,15 +426,15 @@ "members": [ { "sha256": "769f80b5bcb42ed0af4e4d2fd74e1ac9bf843cb80c5a29219d1ef3544428a6bb", - "start": 394776, - "end": 405622, + "start": 395831, + "end": 406677, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "30fefc3a7d6a0041541858293bcbea2dde4caa4c0a5802f996a7f7e8c0085652", - "start": 191398, - "end": 192420, + "start": 192453, + "end": 193475, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -448,8 +448,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -470,8 +470,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -492,8 +492,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -514,8 +514,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -528,8 +528,8 @@ }, { "sha256": "6226d0632e2e1a80c23597e964da9812ae193c535fe058154afb034e94167aa5", - "start": 330875, - "end": 332724, + "start": 331930, + "end": 333779, "origin": "crate-archive", "path": "LICENSE-THIRD-PARTY" } @@ -543,15 +543,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "27995d58ad5c1145c1a8cd86244ce844886958a35eb2b78c6b772748669999ac", - "start": 169893, - "end": 170947, + "start": 170948, + "end": 172002, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -565,8 +565,8 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -587,8 +587,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -609,15 +609,37 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "2d1c57bff28344b9e698f51063bc8509799cc4c99a4e0cf2aa3f7e7c3e1f9a9d", - "start": 176439, - "end": 177587, + "start": 177494, + "end": 178642, + "origin": "crate-archive", + "path": "LICENSE-MIT" + } + ] + }, + { + "name": "bitflags", + "version": "1.3.2", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "license": "MIT/Apache-2.0", + "members": [ + { + "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", + "start": 536058, + "end": 546905, + "origin": "crate-archive", + "path": "LICENSE-APACHE" + }, + { + "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -631,15 +653,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", - "start": 342449, - "end": 343520, + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -653,15 +675,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "9c768944eb4a0422ca2efc25ea9fb2fb9e7fbd3fdb04e86b87366339cb7466db", - "start": 517598, - "end": 518719, + "start": 518653, + "end": 519774, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -675,15 +697,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "d5c22aa3118d240e877ad41c5d9fa232f9c77d757d4aac0c2f943afc0a95e0ef", - "start": 683569, - "end": 684651, + "start": 684624, + "end": 685706, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -697,8 +719,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -719,22 +741,22 @@ "members": [ { "sha256": "e3ba223bb1423f0aad8c3dfce0fe3148db48926d41e6fbc3afbbf5ff9e1c89cb", - "start": 698333, - "end": 708731, + "start": 699388, + "end": 709786, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "9df9ba60a11af705f2e451b53762686e615d86f76b169cf075c3237730dbd7e2", - "start": 530071, - "end": 531181, + "start": 531126, + "end": 532236, "origin": "crate-archive", "path": "LICENSE-MIT" }, { "sha256": "84b34dd7608f7fb9b17bd588a6bf392bf7de504e2716f024a77d89f1b145a151", - "start": 457581, - "end": 458432, + "start": 458636, + "end": 459487, "origin": "crate-archive", "path": "LICENSE-ZLIB" } @@ -748,8 +770,8 @@ "members": [ { "sha256": "45f522cacecb1023856e46df79ca625dfc550c94910078bd8aec6e02880b3d42", - "start": 240784, - "end": 241839, + "start": 241839, + "end": 242894, "origin": "crate-archive", "path": "LICENSE" } @@ -763,15 +785,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397", - "start": 217928, - "end": 218985, + "start": 218983, + "end": 220040, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -785,8 +807,8 @@ "members": [ { "sha256": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90", - "start": 427361, - "end": 438211, + "start": 428416, + "end": 439266, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -807,15 +829,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397", - "start": 217928, - "end": 218985, + "start": 218983, + "end": 220040, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -829,8 +851,8 @@ "members": [ { "sha256": "946c9835d8034d24404f8cfec5f4654cee5dad17e944afc3d06d742cf2882831", - "start": 504838, - "end": 517145, + "start": 505893, + "end": 518200, "origin": "crate-archive", "path": "LICENSE.txt" } @@ -844,15 +866,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -866,15 +888,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -888,15 +910,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -910,15 +932,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -932,8 +954,8 @@ "members": [ { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "license" } @@ -947,15 +969,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397", - "start": 217928, - "end": 218985, + "start": 218983, + "end": 220040, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -969,15 +991,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -991,8 +1013,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1013,15 +1035,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "bada9e7ed8dc00d63502053c455d7c8d7575dfb7e8277a2a832531844d900682", - "start": 606666, - "end": 607748, + "start": 607721, + "end": 608803, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1035,15 +1057,15 @@ "members": [ { "sha256": "2773e20df8f4c52a026b5b578c7f2457341f5aa3fb6612fd87e1d2e1bd8f48ad", - "start": 159029, - "end": 169892, + "start": 160084, + "end": 170947, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "f28420c1906af38be726cd7842798f0194b27c41d6051c0d1e9ee348b8a4a0ea", - "start": 740871, - "end": 741962, + "start": 741926, + "end": 743017, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1057,15 +1079,15 @@ "members": [ { "sha256": "b40930bbcf80744c86c46a12bc9da056641d722716c378f5659b9e555ef833e1", - "start": 589816, - "end": 601173, + "start": 590871, + "end": 602228, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "afb11426e09da40a1ae4f8fa17ddcc6b6a52d14df04c29bc5bcd06eb8730624d", - "start": 585256, - "end": 586313, + "start": 586311, + "end": 587368, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1079,15 +1101,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "ae9baa7beea910273c2f384c2a6b721fb7bd02bda3436074a1072e4ee689f985", - "start": 584173, - "end": 585255, + "start": 585228, + "end": 586310, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1101,15 +1123,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "61d383b05b87d78f94d2937e2580cce47226d17823c0430fbcad09596537efcf", - "start": 328709, - "end": 329806, + "start": 329764, + "end": 330861, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1123,15 +1145,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "5734ed989dfca1f625b40281ee9f4530f91b2411ec01cb748223e7eb87e201ab", - "start": 286155, - "end": 287254, + "start": 287210, + "end": 288309, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1145,15 +1167,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "90c503b61dee04e1449c323ec34c229dfb68d7adcb96c7e140ee55f70fce2d8e", - "start": 501057, - "end": 502134, + "start": 502112, + "end": 503189, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1167,15 +1189,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "3521672491a3479422d5fe1aca6645dd2984090f85da6e5205abfb18fb7a6897", - "start": 194387, - "end": 195452, + "start": 195442, + "end": 196507, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1189,8 +1211,8 @@ "members": [ { "sha256": "b68ad1a3367b825447089e1f8d6829b97f47a89eb78d2f4ebaef4672f5606186", - "start": 602313, - "end": 603434, + "start": 603368, + "end": 604489, "origin": "crate-archive", "path": "LICENSE" } @@ -1204,16 +1226,82 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5", - "start": 588243, - "end": 589315, + "start": 589298, + "end": 590370, + "origin": "crate-archive", + "path": "LICENSE-MIT" + } + ] + }, + { + "name": "defmt", + "version": "1.1.1", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "license": "MIT OR Apache-2.0", + "members": [ + { + "sha256": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90", + "start": 428416, + "end": 439266, "origin": "crate-archive", + "path": "LICENSE-APACHE" + }, + { + "sha256": "2710a622a896bba67356913d4d0492cab5465f61b2ecce6d880aeb483834fb50", + "start": 148154, + "end": 149207, + "origin": "crate-archive", + "path": "LICENSE-MIT" + } + ] + }, + { + "name": "defmt-macros", + "version": "1.1.1", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "license": "MIT OR Apache-2.0", + "members": [ + { + "sha256": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90", + "start": 428416, + "end": 439266, + "origin": "crate-archive", + "path": "LICENSE-APACHE" + }, + { + "sha256": "2710a622a896bba67356913d4d0492cab5465f61b2ecce6d880aeb483834fb50", + "start": 148154, + "end": 149207, + "origin": "crate-archive", + "path": "LICENSE-MIT" + } + ] + }, + { + "name": "defmt-parser", + "version": "1.0.0", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "license": "MIT OR Apache-2.0", + "members": [ + { + "sha256": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90", + "start": 428416, + "end": 439266, + "origin": "committed-override", + "path": "LICENSE-APACHE" + }, + { + "sha256": "2710a622a896bba67356913d4d0492cab5465f61b2ecce6d880aeb483834fb50", + "start": 148154, + "end": 149207, + "origin": "committed-override", "path": "LICENSE-MIT" } ] @@ -1226,15 +1314,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "ad64fcb9589f162720f3cc5010ad76ca6ad3764e11861f9192c489df176bb71d", - "start": 582015, - "end": 583097, + "start": 583070, + "end": 584152, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1248,15 +1336,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a5c61b93b6ee1d104af9920cf020ff3c7efe818e31fe562c72261847a728f513", - "start": 533942, - "end": 535002, + "start": 534997, + "end": 536057, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1270,8 +1358,8 @@ "members": [ { "sha256": "edd65bdd88957a205c47d53fa499eed8865a70320f0f03f6391668cb304ea376", - "start": 726211, - "end": 737560, + "start": 727266, + "end": 738615, "origin": "crate-archive", "path": "LICENSE-Apache" }, @@ -1292,15 +1380,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "9e0dfd2dd4173a530e238cb6adb37aa78c34c6bc7444e0e10c1ab5d8881f63ba", - "start": 532245, - "end": 533302, + "start": 533300, + "end": 534357, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1314,8 +1402,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1343,8 +1431,8 @@ }, { "sha256": "aa893340d14b9844625be6a50ac644169a01b52f0211cbf81b09e1874c8cd81d", - "start": 570082, - "end": 571164, + "start": 571137, + "end": 572219, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1358,15 +1446,15 @@ "members": [ { "sha256": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90", - "start": 427361, - "end": 438211, + "start": 428416, + "end": 439266, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "fb252fecf98d9af8f1d9201c5860319a514f5a8a24700dc84fc6ea287a7a4958", - "start": 750463, - "end": 751536, + "start": 751518, + "end": 752591, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1380,15 +1468,15 @@ "members": [ { "sha256": "78779d420019e6b4630376af8e86b6b335ee8a2f89ede6e0411e0469a326aaa4", - "start": 407134, - "end": 417980, + "start": 408189, + "end": 419035, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "bdebaf9156a298f8fdab56dd26cb5144673de522d80f4c0d88e0039145f147f9", - "start": 607749, - "end": 608819, + "start": 608804, + "end": 609874, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1402,15 +1490,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "7576269ea71f767b99297934c0b2367532690f8c4badc695edf8e04ab6a1e545", - "start": 393732, - "end": 394775, + "start": 394787, + "end": 395830, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1424,15 +1512,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "d27687b51f2874822c1530976b7e837eac4f308d94bf3dd42047011b7d437b47", - "start": 679922, - "end": 680992, + "start": 680977, + "end": 682047, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1461,15 +1549,15 @@ "members": [ { "sha256": "41ba8a366e4129d0b7551f8b98211f59635b2e30c0a3c7845e828e2a7ce42064", - "start": 223394, - "end": 233109, + "start": 224449, + "end": 234164, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "2e3edd2716fb15616e867bd53f724f0906732242e9ae76bb1faad1d88f7eeebd", - "start": 177588, - "end": 178665, + "start": 178643, + "end": 179720, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1483,15 +1571,15 @@ "members": [ { "sha256": "68d7c3ae5b131ec533fb33a9fd63753eb82fac77d7597bb5058a5af07adf9f06", - "start": 344616, - "end": 354312, + "start": 345671, + "end": 355367, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "d13669f0eaff9b7015bff0d8637297213b53d9f239826636c07a15633acf7052", - "start": 677284, - "end": 678338, + "start": 678339, + "end": 679393, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1505,15 +1593,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "7365cc8878a1d7ce155a58c4ca09c3d7a6be413efa5334a80ea842912b669349", - "start": 380163, - "end": 381212, + "start": 381218, + "end": 382267, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1527,15 +1615,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "8764a597675778ddfd4e25f81b08a05dbcf089ac05662df7613fe67f150e3aa2", - "start": 460585, - "end": 461639, + "start": 461640, + "end": 462694, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1549,22 +1637,22 @@ "members": [ { "sha256": "ec82b96487e9e778ee610c7ab245162464782cfa1f555c2299333f8dbe5c036a", - "start": 724839, - "end": 725160, + "start": 725894, + "end": 726215, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "62065228e42caebca7e7d7db1204cbb867033de5982ca4009928915e4095f3a3", - "start": 329807, - "end": 330874, + "start": 330862, + "end": 331929, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1578,8 +1666,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1600,8 +1688,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1622,8 +1710,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1651,8 +1739,8 @@ }, { "sha256": "c77a4cf9da729987d0fe7ccd811e3bd27393914ddf3d23467c18cc22954513b3", - "start": 647102, - "end": 648138, + "start": 648157, + "end": 649193, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1666,15 +1754,15 @@ "members": [ { "sha256": "3708458dee7f359ac6c9c5558023ed481be87e5372c43ebd7f2ca7ad23c12026", - "start": 206225, - "end": 217073, + "start": 207280, + "end": 218128, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "8d0c1d1d4b2bebf5b9211f0e883d5a482b7808f3ed31320da14ddee95811f4ef", - "start": 499980, - "end": 501056, + "start": 501035, + "end": 502111, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1688,15 +1776,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397", - "start": 217928, - "end": 218985, + "start": 218983, + "end": 220040, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1710,8 +1798,8 @@ "members": [ { "sha256": "e339134e53732f093f68ef00bcec3687ebf964ef8c6c812f31e74099c07d3f49", - "start": 697251, - "end": 698332, + "start": 698306, + "end": 699387, "origin": "crate-archive", "path": "LICENSE" } @@ -1725,8 +1813,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1747,8 +1835,8 @@ "members": [ { "sha256": "40be1e77825d7e49485a2e43d89bed29dfff29f8f529e71d3c683656021f0d08", - "start": 221104, - "end": 222179, + "start": 222159, + "end": 223234, "origin": "crate-archive", "path": "LICENSE" } @@ -1762,8 +1850,8 @@ "members": [ { "sha256": "b1181a40b2a7b25cf66fd01481713bc1005df082c53ef73e851e55071b102744", - "start": 586314, - "end": 587170, + "start": 587369, + "end": 588225, "origin": "crate-archive", "path": "LICENSE" } @@ -1777,8 +1865,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1799,15 +1887,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1821,15 +1909,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1843,15 +1931,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1865,15 +1953,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1887,8 +1975,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -1901,8 +1989,8 @@ }, { "sha256": "6226d0632e2e1a80c23597e964da9812ae193c535fe058154afb034e94167aa5", - "start": 330875, - "end": 332724, + "start": 331930, + "end": 333779, "origin": "crate-archive", "path": "LICENSE-THIRD-PARTY" } @@ -1916,15 +2004,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1938,15 +2026,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1960,15 +2048,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -1982,15 +2070,15 @@ "members": [ { "sha256": "275c491d6d1160553c32fd6127061d7f9606c3ea25abfad6ca3f6ed088785427", - "start": 148154, - "end": 159028, + "start": 149209, + "end": 160083, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6652c868f35dfe5e8ef636810a4e576b9d663f3a17fb0f5613ad73583e1b88fd", - "start": 343521, - "end": 344615, + "start": 344576, + "end": 345670, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2004,8 +2092,8 @@ "members": [ { "sha256": "c09aae9d3c77b531f56351a9947bc7446511d6b025b3255312d3e3442a9a7583", - "start": 608820, - "end": 609927, + "start": 609875, + "end": 610982, "origin": "crate-archive", "path": "LICENSE" } @@ -2019,8 +2107,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE" } @@ -2034,15 +2122,15 @@ "members": [ { "sha256": "aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf", - "start": 571165, - "end": 582014, + "start": 572220, + "end": 583069, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "42fa16951ce7f24b5a467a40e5b449a1d41e662f97ca779864f053f39e097737", - "start": 235252, - "end": 236382, + "start": 236307, + "end": 237437, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2056,15 +2144,15 @@ "members": [ { "sha256": "aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf", - "start": 571165, - "end": 582014, + "start": 572220, + "end": 583069, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "29e9fe5074bd27e0e5d5d110394fbbcd841baee2651a3c4b4560a632702cede4", - "start": 172106, - "end": 173236, + "start": 173161, + "end": 174291, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2078,15 +2166,15 @@ "members": [ { "sha256": "aaff376532ea30a0cd5330b9502ad4a4c8bf769c539c87ffe78819d188a18ebf", - "start": 571165, - "end": 582014, + "start": 572220, + "end": 583069, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "523a42c25d245dde9c015f882cec7f4555aad883382a6cf19b4b7d9b2cd5419b", - "start": 283395, - "end": 284525, + "start": 284450, + "end": 285580, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2100,8 +2188,8 @@ "members": [ { "sha256": "8cf56d10131ce201cf69ab74b111d3ebac1acca3833d7efb39ae357224b70edb", - "start": 498955, - "end": 499979, + "start": 500010, + "end": 501034, "origin": "crate-archive", "path": "LICENSE" } @@ -2115,15 +2203,15 @@ "members": [ { "sha256": "dae402989de65164815b7e2b6bc2b9576285434c3785934c8b6ece0fa055960d", - "start": 686785, - "end": 687436, + "start": 687840, + "end": 688491, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "8cf56d10131ce201cf69ab74b111d3ebac1acca3833d7efb39ae357224b70edb", - "start": 498955, - "end": 499979, + "start": 500010, + "end": 501034, "origin": "crate-archive", "path": "LICENSE" } @@ -2137,15 +2225,15 @@ "members": [ { "sha256": "dae402989de65164815b7e2b6bc2b9576285434c3785934c8b6ece0fa055960d", - "start": 686785, - "end": 687436, + "start": 687840, + "end": 688491, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "8cf56d10131ce201cf69ab74b111d3ebac1acca3833d7efb39ae357224b70edb", - "start": 498955, - "end": 499979, + "start": 500010, + "end": 501034, "origin": "crate-archive", "path": "LICENSE" } @@ -2159,8 +2247,8 @@ "members": [ { "sha256": "8cf56d10131ce201cf69ab74b111d3ebac1acca3833d7efb39ae357224b70edb", - "start": 498955, - "end": 499979, + "start": 500010, + "end": 501034, "origin": "crate-archive", "path": "LICENSE" } @@ -2174,8 +2262,8 @@ "members": [ { "sha256": "8cf56d10131ce201cf69ab74b111d3ebac1acca3833d7efb39ae357224b70edb", - "start": 498955, - "end": 499979, + "start": 500010, + "end": 501034, "origin": "crate-archive", "path": "LICENSE" } @@ -2189,15 +2277,15 @@ "members": [ { "sha256": "7429802d3e67e3308471b91fbea341e484c4e0a23d0fb230a8636c38184cec79", - "start": 382282, - "end": 382897, + "start": 383337, + "end": 383952, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -2225,8 +2313,8 @@ }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -2269,15 +2357,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2", - "start": 752631, - "end": 753691, + "start": 753686, + "end": 754746, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2291,15 +2379,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "7b63ecd5f1902af1b63729947373683c32745c16a10e8e6292e2e2dcd7e90ae0", - "start": 421039, - "end": 422110, + "start": 422094, + "end": 423165, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2313,15 +2401,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "f7bdb3426d045cd50efd4953026e3eb5a83d0199f458a075602611b9344da5b9", - "start": 747341, - "end": 748466, + "start": 748396, + "end": 749521, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2335,15 +2423,15 @@ "members": [ { "sha256": "59013a5c8d3a19c26a457579105915a5d51bb0c09d579f8cdedf12e4203c3018", - "start": 288341, - "end": 299189, + "start": 289396, + "end": 300244, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "d288f9c9b4590446ec18c22ead8f8b5a12a3d4025b68f62dc9015063eb9cca69", - "start": 680993, - "end": 682101, + "start": 682048, + "end": 683156, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2357,15 +2445,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "9e0dfd2dd4173a530e238cb6adb37aa78c34c6bc7444e0e10c1ab5d8881f63ba", - "start": 532245, - "end": 533302, + "start": 533300, + "end": 534357, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2379,15 +2467,15 @@ "members": [ { "sha256": "8bb1b50b0e5c9399ae33bd35fab2769010fa6c14e8860c729a52295d84896b7a", - "start": 485980, - "end": 496815, + "start": 487035, + "end": 497870, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "dc91f8200e4b2a1f9261035d4c18c33c246911a6c0f7b543d75347e61b249cff", - "start": 689460, - "end": 690519, + "start": 690515, + "end": 691574, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2431,15 +2519,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "391a5396cec6230bfabd4ef4eb2350eb895bc5efce377a2218f5702ed020d3e3", - "start": 218986, - "end": 220049, + "start": 220041, + "end": 221104, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2453,15 +2541,15 @@ "members": [ { "sha256": "4d10fe5f3aa176b05b229a248866bad70b834c173f1252a814ff4748d8a13837", - "start": 256963, - "end": 267218, + "start": 258018, + "end": 268273, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "934887691e05d69d7c86ad3f2c360980fa30c15b035e351f3c9865e99da4debc", - "start": 503786, - "end": 504837, + "start": 504841, + "end": 505892, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2475,8 +2563,8 @@ "members": [ { "sha256": "2d01890414494742ba4a509fcec8efa40f6d8be22cbd72be7cff08d6fda4ec89", - "start": 175376, - "end": 176438, + "start": 176431, + "end": 177493, "origin": "crate-archive", "path": "LICENSE" } @@ -2490,8 +2578,8 @@ "members": [ { "sha256": "9e0a97848ea543aef745c98e84fde696a9a3e0735538f6daefdd3cb1942effc1", - "start": 531182, - "end": 532244, + "start": 532237, + "end": 533299, "origin": "crate-archive", "path": "LICENSE" } @@ -2505,15 +2593,15 @@ "members": [ { "sha256": "696759d65dfe558ff7d9f031c76db19ec5c0767470fb67c4e8d990820d1e99c9", - "start": 354313, - "end": 365145, + "start": 355368, + "end": 366200, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "da28ccc6b158fc2d8cccc74e99794b1cff1d29bd7bbeb019442fcf0c04c6cad9", - "start": 685725, - "end": 686784, + "start": 686780, + "end": 687839, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2527,8 +2615,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -2542,8 +2630,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -2557,8 +2645,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -2572,8 +2660,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -2587,8 +2675,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -2602,8 +2690,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -2617,8 +2705,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -2632,15 +2720,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5", - "start": 588243, - "end": 589315, + "start": 589298, + "end": 590370, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2654,15 +2742,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "8b43ce8accd61e9d370b5ca9e9c4f953279b5c239926c62315b40e24df51b726", - "start": 484917, - "end": 485979, + "start": 485972, + "end": 487034, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2676,8 +2764,8 @@ "members": [ { "sha256": "436637bd4909fde7e14c899e9ff2cdd440b5968df12d431f1651f11db19bc2ef", - "start": 236383, - "end": 237468, + "start": 237438, + "end": 238523, "origin": "crate-archive", "path": "LICENSE" } @@ -2691,15 +2779,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "ecc269ef87fd38a1d98e30bfac9ba964a9dbd9315c3770fed98d4d7cb5882055", - "start": 725161, - "end": 726210, + "start": 726216, + "end": 727265, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2713,15 +2801,15 @@ "members": [ { "sha256": "87d9feb9238c6bd8e0024fc4733b06cff036f89f36d93b7df1c8a0549bbb7a5b", - "start": 461640, - "end": 472992, + "start": 462695, + "end": 474047, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "47dc9ff29128ddfb4d6a0435383c9f89120bc374dbcc1dd00b933a0b28aa7865", - "start": 253740, - "end": 254802, + "start": 254795, + "end": 255857, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2735,8 +2823,8 @@ "members": [ { "sha256": "7377e48a67377f0baa9ccee6425e125eb7b96d5b8e706f4c99479ca4ffa21b77", - "start": 381213, - "end": 382281, + "start": 382268, + "end": 383336, "origin": "crate-archive", "path": "LICENSE" } @@ -2750,8 +2838,8 @@ "members": [ { "sha256": "7377e48a67377f0baa9ccee6425e125eb7b96d5b8e706f4c99479ca4ffa21b77", - "start": 381213, - "end": 382281, + "start": 382268, + "end": 383336, "origin": "crate-archive", "path": "LICENSE" } @@ -2765,15 +2853,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2787,15 +2875,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "7576269ea71f767b99297934c0b2367532690f8c4badc695edf8e04ab6a1e545", - "start": 393732, - "end": 394775, + "start": 394787, + "end": 395830, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2809,8 +2897,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -2823,6 +2911,50 @@ } ] }, + { + "name": "jiff", + "version": "0.2.37", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "license": "Unlicense OR MIT", + "members": [ + { + "sha256": "01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f", + "start": 15052, + "end": 15178, + "origin": "crate-archive", + "path": "COPYING" + }, + { + "sha256": "0f96a83840e146e43c0ec96a22ec1f392e0680e6c1226e6f3ba87e0740af850f", + "start": 93999, + "end": 95080, + "origin": "crate-archive", + "path": "LICENSE-MIT" + } + ] + }, + { + "name": "jiff-core", + "version": "0.1.1", + "source": "registry+https://github.com/rust-lang/crates.io-index", + "license": "Unlicense OR MIT", + "members": [ + { + "sha256": "01c266bced4a434da0051174d6bee16a4c82cf634e2679b6155d40d75012390f", + "start": 15052, + "end": 15178, + "origin": "crate-archive", + "path": "COPYING" + }, + { + "sha256": "0f96a83840e146e43c0ec96a22ec1f392e0680e6c1226e6f3ba87e0740af850f", + "start": 93999, + "end": 95080, + "origin": "crate-archive", + "path": "LICENSE-MIT" + } + ] + }, { "name": "jobserver", "version": "0.1.35", @@ -2831,15 +2963,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397", - "start": 217928, - "end": 218985, + "start": 218983, + "end": 220040, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2853,8 +2985,8 @@ "members": [ { "sha256": "7e12e5df4bae12cb21581ba157ced20e1986a0508dd10d0e8a4ab9a4cf94e85c", - "start": 423950, - "end": 425161, + "start": 425005, + "end": 426216, "origin": "committed-override", "path": "UNLICENSE" } @@ -2868,15 +3000,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -2890,8 +3022,8 @@ "members": [ { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -2912,8 +3044,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -2934,8 +3066,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -2956,43 +3088,43 @@ "members": [ { "sha256": "85b7daebe41ecc11f8cfd5fce1f654a73fdadec09f89fd61a9e0b2e3409865eb", - "start": 458433, - "end": 459918, + "start": 459488, + "end": 460973, "origin": "crate-archive", "path": "LICENSE" }, { "sha256": "c5d2b95c2538d2e41d8eedd9ecc750cd5fee085c7bb2bc3e2f95f4e59cc0b10d", - "start": 612787, - "end": 635741, + "start": 613842, + "end": 636796, "origin": "crate-archive", "path": "flac/COPYING.FDL" }, { "sha256": "8177f97513213526df2cf6184d8ff986c675afb514d4e68a404010521b880643", - "start": 438212, - "end": 456304, + "start": 439267, + "end": 457359, "origin": "crate-archive", "path": "flac/COPYING.GPL" }, { "sha256": "5df07007198989c622f5d41de8d703e7bef3d0e79d62e24332ee739a452af62a", - "start": 301214, - "end": 327650, + "start": 302269, + "end": 328705, "origin": "crate-archive", "path": "flac/COPYING.LGPL" }, { "sha256": "7866ee98760fc1f0156b4fe6bf530257e02be487ab3fd94e2b63799dd32d6b2c", - "start": 405624, - "end": 407133, + "start": 406679, + "end": 408188, "origin": "crate-archive", "path": "flac/COPYING.Xiph" }, { "sha256": "d2ab5758336489da61c12cc5bb757da5339c4ae9001f9bb0562b4370249af814", - "start": 682102, - "end": 683568, + "start": 683157, + "end": 684623, "origin": "crate-archive", "path": "ogg/COPYING" } @@ -3006,8 +3138,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3028,8 +3160,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3050,15 +3182,15 @@ "members": [ { "sha256": "3290ae0fbc9ddb77d2239121d710f0bb9d31b3b4744e6d97fe01e652b4c1870b", - "start": 192422, - "end": 193303, + "start": 193477, + "end": 194358, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3086,8 +3218,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -3101,15 +3233,15 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "7dc1552e88f49132cb358b1b962fc5e79fa42d70bcbb88c526d33e45b8e98036", - "start": 422887, - "end": 423949, + "start": 423942, + "end": 425004, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3123,15 +3255,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", - "start": 342449, - "end": 343520, + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3167,15 +3299,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "df9cfd06d8a44d9a671eadd39ffd97f166481da015a30f45dfd27886209c5922", - "start": 690520, - "end": 691578, + "start": 691575, + "end": 692633, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3189,8 +3321,8 @@ "members": [ { "sha256": "816000f9c28f7005d931c77636eb79fa7020071eb0f6e6a995515dfccd3559cb", - "start": 426255, - "end": 427360, + "start": 427310, + "end": 428415, "origin": "crate-archive", "path": "LICENSE" } @@ -3204,8 +3336,8 @@ "members": [ { "sha256": "8173d5c29b4f956d532781d2b86e4e30f83e6b7878dce18c919451d6ba707c90", - "start": 427361, - "end": 438211, + "start": 428416, + "end": 439266, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3218,8 +3350,8 @@ }, { "sha256": "dbe1fff0fb1314b6af94f161511406275cf01c5a32441fbf24528a57a051d599", - "start": 687456, - "end": 689459, + "start": 688511, + "end": 690514, "origin": "crate-archive", "path": "LICENSE.md" } @@ -3233,8 +3365,8 @@ "members": [ { "sha256": "4108245a1f2df9d4e94df8abed5b4ba0759bb2f9b40a6b939f1be141077ae50b", - "start": 222180, - "end": 223393, + "start": 223235, + "end": 224448, "origin": "crate-archive", "path": "LICENSE" }, @@ -3247,8 +3379,8 @@ }, { "sha256": "799e9ca9d179295ef372f25d3769cdda7d25bb2668add6a6a1e22d1e4c678b8d", - "start": 417981, - "end": 419193, + "start": 419036, + "end": 420248, "origin": "crate-archive", "path": "LICENSE-MIT.md" }, @@ -3284,8 +3416,8 @@ "members": [ { "sha256": "c524732311819f888ce57b1b56148feaa6e9b1705fcb158e7e5d71554ccf39ed", - "start": 611672, - "end": 612786, + "start": 612727, + "end": 613841, "origin": "crate-archive", "path": "LICENSE" } @@ -3299,8 +3431,8 @@ "members": [ { "sha256": "4dbda04344456f09a7a588140455413a9ac59b6b26a1ef7cdf9c800c012d87f0", - "start": 268291, - "end": 269356, + "start": 269346, + "end": 270411, "origin": "crate-archive", "path": "LICENSE" } @@ -3314,15 +3446,15 @@ "members": [ { "sha256": "b40930bbcf80744c86c46a12bc9da056641d722716c378f5659b9e555ef833e1", - "start": 589816, - "end": 601173, + "start": 590871, + "end": 602228, "origin": "crate-archive", "path": "LICENSE-Apache" }, { "sha256": "d848c165548bd3f33419b71c3c3bb7cacec620d93383483393410688cba68431", - "start": 684652, - "end": 685724, + "start": 685707, + "end": 686779, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3336,8 +3468,8 @@ "members": [ { "sha256": "284465860407420254e39be4e1bdcaaf2e7f2d18e06f9bab75bc75341a5d8501", - "start": 170948, - "end": 172105, + "start": 172003, + "end": 173160, "origin": "crate-archive", "path": "LICENSE" } @@ -3351,15 +3483,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", - "start": 342449, - "end": 343520, + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3380,8 +3512,8 @@ }, { "sha256": "e2e245f2b566d0bfafb0f6a04c16b82d710c4e6e7d799e39bb4ef6e541b85b98", - "start": 696200, - "end": 697250, + "start": 697255, + "end": 698305, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3395,15 +3527,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", - "start": 342449, - "end": 343520, + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3417,15 +3549,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", - "start": 342449, - "end": 343520, + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3439,15 +3571,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", - "start": 342449, - "end": 343520, + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3461,15 +3593,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb", - "start": 342449, - "end": 343520, + "start": 343504, + "end": 344575, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3483,15 +3615,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a5c61b93b6ee1d104af9920cf020ff3c7efe818e31fe562c72261847a728f513", - "start": 533942, - "end": 535002, + "start": 534997, + "end": 536057, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3505,8 +3637,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3527,8 +3659,8 @@ "members": [ { "sha256": "e63690624d604aa626c3c62b6ead1a9f4a916d2260ac8132022acbafe2556045", - "start": 720543, - "end": 721658, + "start": 721598, + "end": 722713, "origin": "crate-archive", "path": "LICENSE.md" } @@ -3542,8 +3674,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3564,8 +3696,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3586,8 +3718,8 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3608,8 +3740,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3622,8 +3754,8 @@ }, { "sha256": "9a6d7a3c1b8edcc706c4b6c37f8dae9a77f02c7f9051df603f975db136b55419", - "start": 517146, - "end": 517597, + "start": 518201, + "end": 518652, "origin": "crate-archive", "path": "LICENSE-THIRD-PARTY" } @@ -3637,8 +3769,8 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3659,8 +3791,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3681,8 +3813,8 @@ "members": [ { "sha256": "b7c76ff4466a3aeb6a7d903e81b651335e97d64ecb857e2ee9812a36c6fd1acf", - "start": 603435, - "end": 604520, + "start": 604490, + "end": 605575, "origin": "crate-archive", "path": "LICENSE.md" } @@ -3696,15 +3828,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5", - "start": 588243, - "end": 589315, + "start": 589298, + "end": 590370, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3718,8 +3850,8 @@ "members": [ { "sha256": "f71452d91682fdae0ca948b18cfed53a953d1237740dd80371c76a5c1c7bbe91", - "start": 746279, - "end": 747340, + "start": 747334, + "end": 748395, "origin": "crate-archive", "path": "LICENSE" } @@ -3755,8 +3887,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3777,15 +3909,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "ad64fcb9589f162720f3cc5010ad76ca6ad3764e11861f9192c489df176bb71d", - "start": 582015, - "end": 583097, + "start": 583070, + "end": 584152, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3799,15 +3931,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397", - "start": 217928, - "end": 218985, + "start": 218983, + "end": 220040, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3821,15 +3953,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "eaf40297c75da471f7cda1f3458e8d91b4b2ec866e609527a13acfa93b638652", - "start": 722732, - "end": 723780, + "start": 723787, + "end": 724835, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3843,8 +3975,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3865,8 +3997,8 @@ "members": [ { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3887,8 +4019,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -3931,8 +4063,8 @@ }, { "sha256": "4cada0bd02ea3692eee6f16400d86c6508bbd3bafb2b65fed0419f36d4f83e8f", - "start": 255886, - "end": 256962, + "start": 256941, + "end": 258017, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -3946,8 +4078,8 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3968,8 +4100,8 @@ "members": [ { "sha256": "8ada45cd9f843acf64e4722ae262c622a2b3b3007c7310ef36ac1061a30f6adb", - "start": 474056, - "end": 484916, + "start": 475111, + "end": 485971, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -3990,8 +4122,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4012,15 +4144,15 @@ "members": [ { "sha256": "7b25e06666d3797292dbb4b1c3f5ba509ebe02fce102e1dca7ca81dd3cbfbeb7", - "start": 419964, - "end": 421038, + "start": 421019, + "end": 422093, "origin": "crate-archive", "path": "LICENSE" }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" } @@ -4034,15 +4166,15 @@ "members": [ { "sha256": "f09adf500d35265ee63ef552f8e61487e09ee549da66eaf0ec7924e3ad7cf14b", - "start": 738293, - "end": 739367, + "start": 739348, + "end": 740422, "origin": "crate-archive", "path": "LICENSE" }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" } @@ -4056,8 +4188,8 @@ "members": [ { "sha256": "5b2c207dcf571267ebe0bbdd5bf321f561ddc22ff597e7b363e96f4539507a29", - "start": 299191, - "end": 300296, + "start": 300246, + "end": 301351, "origin": "crate-archive", "path": "LICENSE-MIT.md" } @@ -4071,8 +4203,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4093,15 +4225,15 @@ "members": [ { "sha256": "90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5", - "start": 502135, - "end": 502704, + "start": 503190, + "end": 503759, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "35242e7a83f69875e6edeff02291e688c97caafe2f8902e4e19b49d3e78b4cab", - "start": 195453, - "end": 205177, + "start": 196508, + "end": 206232, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4122,15 +4254,15 @@ "members": [ { "sha256": "90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5", - "start": 502135, - "end": 502704, + "start": 503190, + "end": 503759, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "35242e7a83f69875e6edeff02291e688c97caafe2f8902e4e19b49d3e78b4cab", - "start": 195453, - "end": 205177, + "start": 196508, + "end": 206232, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4151,15 +4283,15 @@ "members": [ { "sha256": "90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5", - "start": 502135, - "end": 502704, + "start": 503190, + "end": 503759, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "6df43f6f4b5d4587f3d8d71e45532c688fd168afa5fe89d571cb32fa09c4ef51", - "start": 366711, - "end": 376993, + "start": 367766, + "end": 378048, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4180,15 +4312,15 @@ "members": [ { "sha256": "90eb64f0279b0d9432accfa6023ff803bc4965212383697eee27a0f426d5f8d5", - "start": 502135, - "end": 502704, + "start": 503190, + "end": 503759, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "6df43f6f4b5d4587f3d8d71e45532c688fd168afa5fe89d571cb32fa09c4ef51", - "start": 366711, - "end": 376993, + "start": 367766, + "end": 378048, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4209,8 +4341,8 @@ "members": [ { "sha256": "2ff0e21d54b189664c884c142f7a608aae1515524b72e6b1ca251577760d44cf", - "start": 178666, - "end": 190336, + "start": 179721, + "end": 191391, "origin": "crate-archive", "path": "LICENSE" } @@ -4224,15 +4356,15 @@ "members": [ { "sha256": "751963a8b88c0e3a9f27e98933079fbcf09b9998b2c13ac49c2e4d58444520d6", - "start": 382898, - "end": 393731, + "start": 383953, + "end": 394786, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "47d4e1803702728e03d30f8a848ae2249ba274bbd9f8443e803f7924d83cd371", - "start": 252676, - "end": 253739, + "start": 253731, + "end": 254794, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4246,15 +4378,15 @@ "members": [ { "sha256": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9", - "start": 546915, - "end": 557088, + "start": 547970, + "end": 558143, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "f5d934dc281b44e0003ee461ac740b18b6629a454decd872c774d34e4ee0b21d", - "start": 745221, - "end": 746278, + "start": 746276, + "end": 747333, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4268,8 +4400,8 @@ "members": [ { "sha256": "457b464bc0fba8a3d67d2458569104f5611869f0c1563a1a12d9c51a0bca9261", - "start": 239720, - "end": 240783, + "start": 240775, + "end": 241838, "origin": "crate-archive", "path": "LICENSE" } @@ -4283,8 +4415,8 @@ "members": [ { "sha256": "b3d734001a94efff3579978d953391aa7115f877657d25eb54037a43875d078a", - "start": 589316, - "end": 589815, + "start": 590371, + "end": 590870, "origin": "crate-archive", "path": "LICENSE" }, @@ -4297,29 +4429,29 @@ }, { "sha256": "f025ccfb7dfb6bdfedc75ca0f67acc69e6fb4998143d834f7c2f38a29989680f", - "start": 737561, - "end": 738292, + "start": 738616, + "end": 739347, "origin": "crate-archive", "path": "LICENSE-other-bits" }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "src/polyfill/once_cell/LICENSE-APACHE" }, { "sha256": "6ee2ed6c77710de911761acd5fc1ad1da00f476beb1a7ef27e78c2d1858deafc", - "start": 376994, - "end": 378016, + "start": 378049, + "end": 379071, "origin": "crate-archive", "path": "src/polyfill/once_cell/LICENSE-MIT" }, { "sha256": "9eacbcb81be660840c714a560a9d65ba07913db98dd4baf969f78dd499fdd60f", - "start": 533303, - "end": 533941, + "start": 534358, + "end": 534996, "origin": "crate-archive", "path": "third_party/fiat/LICENSE" } @@ -4333,15 +4465,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "fffe218c1e349e1d482a05677f2ce850502f88298174d77f6ac7c04821db7899", - "start": 753692, - "end": 754775, + "start": 754747, + "end": 755830, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4355,15 +4487,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a5c61b93b6ee1d104af9920cf020ff3c7efe818e31fe562c72261847a728f513", - "start": 533942, - "end": 535002, + "start": 534997, + "end": 536057, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4377,15 +4509,15 @@ "members": [ { "sha256": "377c2e7c53250cc5905c0b0532d35973392af16ffb9596a41d99d202cf3617c9", - "start": 217074, - "end": 217927, + "start": 218129, + "end": 218982, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4413,22 +4545,22 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "7cfafc877eccc46c0e346ccbaa5c51bb6b894d2b818e617d970211e232785ad4", - "start": 422111, - "end": 422886, + "start": 423166, + "end": 423941, "origin": "crate-archive", "path": "LICENSE-ISC" }, { "sha256": "709e3175b4212f7b13aa93971c9f62ff8c69ec45ad8c6532a7e0c41d7a7d6f8c", - "start": 379080, - "end": 380162, + "start": 380135, + "end": 381217, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4442,15 +4574,15 @@ "members": [ { "sha256": "45fd05c4865e7c350b98ad7ac50e1b15462d49af4a91e9b0c9dd933dc9a69742", - "start": 241840, - "end": 252675, + "start": 242895, + "end": 253730, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "9117d922e667125508dde62b02c1f57ed22f5ad21eb536aa2e2d99e1c796e639", - "start": 502705, - "end": 503785, + "start": 503760, + "end": 504840, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4464,8 +4596,8 @@ "members": [ { "sha256": "5b698ca13897be3afdb7174256fa1574f8c6892b8bea1a66dd6469d3fe27885a", - "start": 300297, - "end": 301213, + "start": 301352, + "end": 302268, "origin": "crate-archive", "path": "LICENSE" } @@ -4479,15 +4611,15 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "c9bff75738922193e67fa726fa225535870d2aa1059f91452c411736284ad566", - "start": 651673, - "end": 653011, + "start": 652728, + "end": 654066, "origin": "crate-archive", "path": "LICENSE-BOOST" } @@ -4501,15 +4633,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "56340c5acb4a9359ab88df277780ef29b9388587ebdb43460ad19dc783f75a54", - "start": 285093, - "end": 286154, + "start": 286148, + "end": 287209, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4523,15 +4655,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "4a883ecc3bb1010faed542bf63d53e530fea5e5e12cf676aed588784298ba929", - "start": 254803, - "end": 255885, + "start": 255858, + "end": 256940, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4545,8 +4677,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4567,8 +4699,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4589,8 +4721,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4611,8 +4743,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4633,8 +4765,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4655,15 +4787,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4677,15 +4809,15 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b9eb266294324f672cbe945fe8f2e32f85024f0d61a1a7d14382cdde0ac44769", - "start": 605607, - "end": 606665, + "start": 606662, + "end": 607720, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4699,15 +4831,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b4eb00df6e2a4d22518fcaa6a2b4646f249b3a3c9814509b22bd2091f1392ff1", - "start": 601174, - "end": 602312, + "start": 602229, + "end": 603367, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4721,15 +4853,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b4eb00df6e2a4d22518fcaa6a2b4646f249b3a3c9814509b22bd2091f1392ff1", - "start": 601174, - "end": 602312, + "start": 602229, + "end": 603367, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4743,8 +4875,8 @@ "members": [ { "sha256": "eafbfa606bc005ed7fd2f623d65af17ffe4ef7c017221ac14405bf4140771ea9", - "start": 723781, - "end": 724838, + "start": 724836, + "end": 725893, "origin": "crate-archive", "path": "LICENSE" } @@ -4758,15 +4890,15 @@ "members": [ { "sha256": "553fffcd9b1cb158bc3e9edc35da85ca5c3b3d7d2e61c883ebcfa8a65814b583", - "start": 284526, - "end": 285092, + "start": 285581, + "end": 286147, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "4455bf75a91154108304cb283e0fea9948c14f13e20d60887cf2552449dea3b1", - "start": 238627, - "end": 239719, + "start": 239682, + "end": 240774, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4780,15 +4912,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "503558bfefe66ca15e4e3f7955b3cb0ec87fd52f29bf24b336af7bd00e946d5c", - "start": 270421, - "end": 271489, + "start": 271476, + "end": 272544, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4802,15 +4934,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b3470648aff02beb36d7a53240fc9260ed80ed93bd43bace6b67d7ef7336ee33", - "start": 587172, - "end": 588242, + "start": 588227, + "end": 589297, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4824,8 +4956,8 @@ "members": [ { "sha256": "42a35170233e83e18856792e748de4c1ce4a63b2afce9a370c89ef3fe23f9f2d", - "start": 234173, - "end": 235251, + "start": 235228, + "end": 236306, "origin": "crate-archive", "path": "LICENSE.md" } @@ -4839,8 +4971,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4861,8 +4993,8 @@ "members": [ { "sha256": "c962ee4d1d05ddc138b202b2540219ebc57893fcf97b364852094a9a94ce1365", - "start": 649236, - "end": 649517, + "start": 650291, + "end": 650572, "origin": "crate-archive", "path": "COPYING" } @@ -4876,8 +5008,8 @@ "members": [ { "sha256": "8ce0830173fdac609dfb4ea603fdc002c2f4af0dc9b1a005653f5da9cf534b18", - "start": 497899, - "end": 498954, + "start": 498954, + "end": 500009, "origin": "crate-archive", "path": "LICENSE" } @@ -4891,8 +5023,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -4913,15 +5045,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397", - "start": 217928, - "end": 218985, + "start": 218983, + "end": 220040, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4935,15 +5067,15 @@ "members": [ { "sha256": "a9040321c3712d8fd0b09cf52b17445de04a23a10165049ae187cd39e5c86be5", - "start": 559232, - "end": 570081, + "start": 560287, + "end": 571136, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "c995204cc6bad2ed67dd41f7d89bb9f1a9d48e0edd745732b30640d7912089a4", - "start": 649518, - "end": 650600, + "start": 650573, + "end": 651655, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -4957,8 +5089,8 @@ "members": [ { "sha256": "e14071c7b7a16d742419ad7f408700719bda2d1f99538f5c3da312d7e772cd22", - "start": 691579, - "end": 692770, + "start": 692634, + "end": 693825, "origin": "crate-archive", "path": "assets/mark_assets/NOTICE.md" } @@ -5002,15 +5134,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "5e05b024f653a5ce199e77cbbbd42fb5553562ec714b819421ed0c3e552a75d7", - "start": 327651, - "end": 328707, + "start": 328706, + "end": 329762, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5024,15 +5156,15 @@ "members": [ { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "ea084a2373ebc1f0902c09266e7bf25a05ab3814c1805bb017ffa7308f90c061", - "start": 721659, - "end": 722731, + "start": 722714, + "end": 723786, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5046,8 +5178,8 @@ "members": [ { "sha256": "3085885678bb161f6c472bbd331f66a2550b555eb76128f7f8247779128199c0", - "start": 190337, - "end": 191397, + "start": 191392, + "end": 192452, "origin": "crate-archive", "path": "LICENSE" } @@ -5076,8 +5208,8 @@ "members": [ { "sha256": "d1fc1bc0d155df60b2e7705b6b2ae02a05c96f948e1cec6e2fb86360b09f346b", - "start": 678339, - "end": 679921, + "start": 679394, + "end": 680976, "origin": "crate-archive", "path": "LICENSE" } @@ -5091,15 +5223,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "f3c9fe731c701ed77fd5fbaac573872af04dc5869385eb9bd5e3c73c42713814", - "start": 744159, - "end": 745220, + "start": 745214, + "end": 746275, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5113,8 +5245,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5165,8 +5297,8 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5202,8 +5334,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5224,8 +5356,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5246,8 +5378,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5268,8 +5400,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5290,15 +5422,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5", - "start": 650601, - "end": 651672, + "start": 651656, + "end": 652727, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5378,8 +5510,8 @@ "members": [ { "sha256": "6d41e05f1d54fe726997cb0334ec539f1dff50600b1d5d90462ec2b392770ced", - "start": 365146, - "end": 366710, + "start": 366201, + "end": 367765, "origin": "crate-archive", "path": "LICENSE" } @@ -5393,8 +5525,8 @@ "members": [ { "sha256": "6d41e05f1d54fe726997cb0334ec539f1dff50600b1d5d90462ec2b392770ced", - "start": 365146, - "end": 366710, + "start": 366201, + "end": 367765, "origin": "crate-archive", "path": "LICENSE" } @@ -5408,8 +5540,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -5453,15 +5585,15 @@ "members": [ { "sha256": "cc117d90b498b32b11a886f279b359da16a73c3b01efbb2f5cc004b20262334e", - "start": 654036, - "end": 664868, + "start": 655091, + "end": 665923, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "e20fa2b8e0a2565f24a792b94b4bf4b6c2b9d36f781d8a9516e218a036e6677a", - "start": 692771, - "end": 693827, + "start": 693826, + "end": 694882, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5475,8 +5607,8 @@ "members": [ { "sha256": "fdd55e2b2da854b0fbdc1e607df7c2ba1e1ebf91ecb77c515511ebeef972bc8f", - "start": 751537, - "end": 752630, + "start": 752592, + "end": 753685, "origin": "crate-archive", "path": "LICENSE" } @@ -5505,15 +5637,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5527,15 +5659,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5549,15 +5681,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5571,15 +5703,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5593,15 +5725,15 @@ "members": [ { "sha256": "c6596eb7be8581c18be736c846fb9173b69eccf6ef94c5135893ec56bd92ba08", - "start": 635743, - "end": 647101, + "start": 636798, + "end": 648156, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "6efb0476a1cc085077ed49357026d8c173bf33017278ef440f222fb9cbcb66e6", - "start": 378017, - "end": 379079, + "start": 379072, + "end": 380134, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5615,8 +5747,8 @@ "members": [ { "sha256": "4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482", - "start": 233110, - "end": 234172, + "start": 234165, + "end": 235227, "origin": "crate-archive", "path": "LICENSE" } @@ -5630,8 +5762,8 @@ "members": [ { "sha256": "5049cf464977eff4b4fcfa7988d84e74116956a3eb9d5f1d451b3f828f945233", - "start": 271490, - "end": 272557, + "start": 272545, + "end": 273612, "origin": "crate-archive", "path": "LICENSE" } @@ -5645,8 +5777,8 @@ "members": [ { "sha256": "4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482", - "start": 233110, - "end": 234172, + "start": 234165, + "end": 235227, "origin": "crate-archive", "path": "LICENSE" } @@ -5660,8 +5792,8 @@ "members": [ { "sha256": "4249c8e6c5ebb85f97c77e6457c6fafc1066406eb8f1ef61e796fbdc5ff18482", - "start": 233110, - "end": 234172, + "start": 234165, + "end": 235227, "origin": "crate-archive", "path": "LICENSE" } @@ -5675,8 +5807,8 @@ "members": [ { "sha256": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1", - "start": 472993, - "end": 474055, + "start": 474048, + "end": 475110, "origin": "crate-archive", "path": "LICENSE" } @@ -5690,8 +5822,8 @@ "members": [ { "sha256": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1", - "start": 472993, - "end": 474055, + "start": 474048, + "end": 475110, "origin": "crate-archive", "path": "LICENSE" } @@ -5705,15 +5837,15 @@ "members": [ { "sha256": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1", - "start": 472993, - "end": 474055, + "start": 474048, + "end": 475110, "origin": "crate-archive", "path": "LICENSE" }, { "sha256": "58545fed1565e42d687aecec6897d35c6d37ccb71479a137c0deb2203e125c79", - "start": 287255, - "end": 288340, + "start": 288310, + "end": 289395, "origin": "crate-archive", "path": "src/spin/LICENSE" } @@ -5727,8 +5859,8 @@ "members": [ { "sha256": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1", - "start": 472993, - "end": 474055, + "start": 474048, + "end": 475110, "origin": "crate-archive", "path": "LICENSE" } @@ -5742,8 +5874,8 @@ "members": [ { "sha256": "898b1ae9821e98daf8964c8d6c7f61641f5f5aa78ad500020771c0939ee0dea1", - "start": 472993, - "end": 474055, + "start": 474048, + "end": 475110, "origin": "crate-archive", "path": "LICENSE" } @@ -5757,8 +5889,8 @@ "members": [ { "sha256": "c816a0749cdc6bf062a5111c159723de51b2bfac66a1dac2655abd9e6b1583eb", - "start": 648139, - "end": 649235, + "start": 649194, + "end": 650290, "origin": "crate-archive", "path": "LICENSE" } @@ -5772,15 +5904,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "7fea0ee51a4ca5d5cea7464135fd55e8b09caf3a61da3d451ac8a22af95c033f", - "start": 425162, - "end": 426254, + "start": 426217, + "end": 427309, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5794,22 +5926,22 @@ "members": [ { "sha256": "db11fec9946737df39ca3898d9cd8c10ec6f6c3a884a6802b0ad0b81b4e8f23a", - "start": 687437, - "end": 687454, + "start": 688492, + "end": 688509, "origin": "crate-archive", "path": "LICENSE" }, { "sha256": "516b24e051bf5630880ebbd55c40a25ce9552ebaf8970a53e8976eb70e522406", - "start": 272558, - "end": 283393, + "start": 273613, + "end": 284448, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a825bd853ab71619a4923d7b4311221427848070ff44d990da39b0b274c1683f", - "start": 558148, - "end": 559231, + "start": 559203, + "end": 560286, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5823,15 +5955,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "4f6bd11a0f17fe5b085ace1daaedb7b002a08316850dd9577c246c6a68a68e8c", - "start": 269357, - "end": 270420, + "start": 270412, + "end": 271475, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5845,8 +5977,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5859,8 +5991,8 @@ }, { "sha256": "f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1", - "start": 748467, - "end": 750462, + "start": 749522, + "end": 751517, "origin": "crate-archive", "path": "LICENSE-UNICODE" } @@ -5874,8 +6006,8 @@ "members": [ { "sha256": "7abd9b6960dcf7d4d0a48606a5b71bfe37d472db68d70637f3a58a56785f1621", - "start": 419194, - "end": 419963, + "start": 420249, + "end": 421018, "origin": "crate-archive", "path": "LICENSE.txt" } @@ -5889,15 +6021,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b38f11f6096706e6de553dabe2a7ed142d59b6fa8c97e290c67496154745cdd5", - "start": 588243, - "end": 589315, + "start": 589298, + "end": 590370, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5911,15 +6043,15 @@ "members": [ { "sha256": "a6cba85bc92e0cff7a450b1d873c0eaa2e9fc96bf472df0247a26bec77bf3ff9", - "start": 546915, - "end": 557088, + "start": 547970, + "end": 558143, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "f5d934dc281b44e0003ee461ac740b18b6629a454decd872c774d34e4ee0b21d", - "start": 745221, - "end": 746278, + "start": 746276, + "end": 747333, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5933,8 +6065,8 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, @@ -5955,22 +6087,22 @@ "members": [ { "sha256": "c30152c94a6d75e021adbc52b3a52470366a46edb917e17deae3259251af244c", - "start": 609929, - "end": 611671, + "start": 610984, + "end": 612726, "origin": "crate-archive", "path": "COPYRIGHT" }, { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "3fa4ca83dcc9237839b1bdeb2e6d16bdfb5ec0c5ce42b24694d8bbf0dcbef72c", - "start": 220050, - "end": 221103, + "start": 221105, + "end": 222158, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -5984,15 +6116,15 @@ "members": [ { "sha256": "62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a", - "start": 332725, - "end": 342448, + "start": 333780, + "end": 343503, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "e4c9b06fa850cb9b540a5e400e9f6394cf15efcf4098144de477d1d3dae10150", - "start": 719490, - "end": 720542, + "start": 720545, + "end": 721597, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6006,15 +6138,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "436bc5a105d8e57dcd8778730f3754f7bf39c14d2f530e4cde4bd2d17a83ec3d", - "start": 237469, - "end": 238626, + "start": 238524, + "end": 239681, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6028,8 +6160,8 @@ "members": [ { "sha256": "cedfcc7ace1639adb054bd4a19b6f8585ccb2429a60b4bf51bfeb0601058c22c", - "start": 664869, - "end": 665924, + "start": 665924, + "end": 666979, "origin": "crate-archive", "path": "LICENSE" } @@ -6043,15 +6175,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "b7e650f3fce5c53249d1cdc608b54df156a97edd636cf9d23498d0cfe7aec63e", - "start": 604521, - "end": 605606, + "start": 605576, + "end": 606661, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6065,8 +6197,8 @@ "members": [ { "sha256": "a65f5d0a945d267751344c95665945b90c030ea107faf5c85d518929886187da", - "start": 545851, - "end": 546914, + "start": 546906, + "end": 547969, "origin": "crate-archive", "path": "LICENSE" } @@ -6117,8 +6249,8 @@ }, { "sha256": "f1a2b233e8a9a71c40f4aa885be08a0842ac85bb8588703c1dd7e6e6502e3124", - "start": 739368, - "end": 740870, + "start": 740423, + "end": 741925, "origin": "crate-archive", "path": "protocols/COPYING" } @@ -6162,8 +6294,8 @@ "members": [ { "sha256": "e271993808fec50ab29350b39539cdec611a9103f827e0aa26d61da70e2d33f8", - "start": 693828, - "end": 696199, + "start": 694883, + "end": 697254, "origin": "crate-archive", "path": "LICENSE" } @@ -6177,8 +6309,8 @@ "members": [ { "sha256": "cb5aedb296c5246d1f22e9099f925a65146f9f0d6b4eebba97fd27a6cdbbab2d", - "start": 653012, - "end": 654035, + "start": 654067, + "end": 655090, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6192,8 +6324,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -6207,15 +6339,15 @@ "members": [ { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a72561f47c1f665535930f606739d9098a6186802d5e2e8ec491faf00f4add5b", - "start": 557089, - "end": 558147, + "start": 558144, + "end": 559202, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6229,15 +6361,15 @@ "members": [ { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a72561f47c1f665535930f606739d9098a6186802d5e2e8ec491faf00f4add5b", - "start": 557089, - "end": 558147, + "start": 558144, + "end": 559202, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6251,15 +6383,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "a5c61b93b6ee1d104af9920cf020ff3c7efe818e31fe562c72261847a728f513", - "start": 533942, - "end": 535002, + "start": 534997, + "end": 536057, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6273,8 +6405,8 @@ "members": [ { "sha256": "2cdce1ff4ca8f455ef169691ea493407e23c32ecdea5fd9b3a6fc82be5b49b5a", - "start": 174293, - "end": 175375, + "start": 175348, + "end": 176430, "origin": "crate-archive", "path": "LICENSE" } @@ -6288,15 +6420,15 @@ "members": [ { "sha256": "a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2", - "start": 535003, - "end": 545850, + "start": 536058, + "end": 546905, "origin": "committed-override", "path": "LICENSE-APACHE" }, { "sha256": "2a7df90e60fd5512b8bca35d3ce90e068f21c52d962855053fd1d9e2e7ca0f16", - "start": 173237, - "end": 174292, + "start": 174292, + "end": 175347, "origin": "committed-override", "path": "LICENSE-MIT" } @@ -6310,8 +6442,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -6325,8 +6457,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -6385,15 +6517,15 @@ "members": [ { "sha256": "9d185ac6703c4b0453974c0d85e9eee43e6941009296bb1f5eb0b54e2329e9f3", - "start": 518720, - "end": 530070, + "start": 519775, + "end": 531125, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "83c1763356e822adde0a2cae748d938a73fdc263849ccff6b27776dff213bd32", - "start": 456305, - "end": 457580, + "start": 457360, + "end": 458635, "origin": "crate-archive", "path": "LICENSE-BSD" }, @@ -6414,8 +6546,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -6429,8 +6561,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -6444,15 +6576,15 @@ "members": [ { "sha256": "cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30", - "start": 665925, - "end": 677283, + "start": 666980, + "end": 678338, "origin": "crate-archive", "path": "LICENSE-APACHE" }, { "sha256": "8c7516d4b27b1e495be5e38b612298b63de48d05f49cdac94f70f3cd70f8864b", - "start": 496816, - "end": 497898, + "start": 497871, + "end": 498953, "origin": "crate-archive", "path": "LICENSE-MIT" } @@ -6466,8 +6598,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -6481,8 +6613,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" } @@ -6496,8 +6628,8 @@ "members": [ { "sha256": "f367c1b8e1aa262435251e442901da4607b4650e0e63a026f5044473ecfb90f2", - "start": 741963, - "end": 744158, + "start": 743018, + "end": 745213, "origin": "crate-archive", "path": "LICENSE" }