diff -pruN 3.4.1+20241227-3/Cargo.toml 3.4.2+20251114-1/Cargo.toml
--- 3.4.1+20241227-3/Cargo.toml	2024-12-27 06:52:24.000000000 +0000
+++ 3.4.2+20251114-1/Cargo.toml	2025-11-14 21:52:15.000000000 +0000
@@ -1,6 +1,6 @@
 [package]
 name = "lazy-regex"
-version = "3.4.1"
+version = "3.4.2"
 authors = ["Canop <cano.petrole@gmail.com>"]
 edition = "2021"
 description = "lazy static regular expressions checked at compile time"
@@ -18,7 +18,7 @@ regex-lite = {version = "0.1", optional
 
 [dependencies.lazy-regex-proc_macros]
 path = "src/proc_macros"
-version = "3.4.1"
+version = "3.4.2"
 
 [features]
 default = ["regex/default"]
diff -pruN 3.4.1+20241227-3/README.md 3.4.2+20251114-1/README.md
--- 3.4.1+20241227-3/README.md	2024-12-27 06:52:24.000000000 +0000
+++ 3.4.2+20251114-1/README.md	2025-11-14 21:52:15.000000000 +0000
@@ -15,6 +15,8 @@
 
 # lazy-regex
 
+<!-- cradoc start -->
+
 With lazy-regex macros, regular expressions
 
 * are checked at compile time, with clear error messages
@@ -22,89 +24,112 @@ With lazy-regex macros, regular expressi
 * can hold flags as suffix: `let case_insensitive_regex = regex!("ab*"i);`
 * are defined in a less verbose way
 
-The `regex!` macro returns references to normal instances of `regex::Regex` or `regex::bytes::Regex` so all the usual features are available.
+The [`regex!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex.html) macro returns references to normal instances of [`regex::Regex`](https://docs.rs/lazy-regex/latest/lazy_regex/struct.Regex.html) or [`regex::bytes::Regex`](https://docs.rs/lazy-regex/latest/lazy_regex/struct.BytesRegex.html) so all the usual features are available.
 
-Other macros are specialized for testing a match, replacing with concise closures, or capturing groups as substrings in some common situations:
+But most often, you won't even use the `regex!` macro but the other macros which are specialized for testing a match, replacing, or capturing groups in some common situations:
 
-* `regex_is_match!`
-* `regex_find!`
-* `regex_captures!`
-* `regex_replace!`
-* `regex_replace_all!`
-* `regex_switch!`
+* [Test a match](#test-a-match) with [`regex_is_match!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_is_match.html)
+* [Extract a value](#extract-a-value) with [`regex_find!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_find.html)
+* [Capture](#capture) with [`regex_captures!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_captures.html)
+* [Iter on captures](#iter-on-captures) with [`regex_captures_iter!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_captures_iter.html)
+* [Replace with captured groups](#replace-with-captured-groups) with [`regex_replace!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_replace.html) and [`regex_replace_all!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_replace_all.html)
+* [Switch over patterns](#switch-over-patterns) with [`regex_switch!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_switch.html)
 
 They support the `B` flag for the `regex::bytes::Regex` variant.
 
-All macros exist with a `bytes_` prefix for building `bytes::Regex`, so you also have `bytes_regex!`, `bytes_regex_is_match!`, `bytes_regex_find!`, `bytes_regex_captures!`, `bytes_regex_replace!`, `bytes_regex_replace_all!`, and `bytes_regex_switch!`.
+All macros exist with a `bytes_` prefix for building `bytes::Regex`, so you also have [`bytes_regex!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.bytes_regex.html), [`bytes_regex_is_match!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.bytes_regex_is_match.html), [`bytes_regex_find!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.bytes_regex_find.html), [`bytes_regex_captures!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.bytes_regex_captures.html), [`bytes_regex_replace!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.bytes_regex_replace.html), [`bytes_regex_replace_all!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.bytes_regex_replace_all.html), and [`bytes_regex_switch!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.bytes_regex_switch.html).
 
 Some structs of the regex crate are reexported to ease dependency managment.
-The regex crate itself is also reexported, to avoid the need to synchronize the versions/flavor (see [Features](#features_and_reexport) below)
 
 # Build Regexes
 
-```rust
-use lazy_regex::regex;
+Build a simple regex:
 
-// build a simple regex
+```rust
 let r = regex!("sa+$");
 assert_eq!(r.is_match("Saa"), false);
+```
+
+Build a regex with flag(s):
 
-// build a regex with flag(s)
+```rust
 let r = regex!("sa+$"i);
 assert_eq!(r.is_match("Saa"), true);
+```
+You can use a raw literal:
 
-// you can use a raw literal
+```rust
 let r = regex!(r#"^"+$"#);
 assert_eq!(r.is_match("\"\""), true);
+```
 
-// or a raw literal with flag(s)
+Or a raw literal with flag(s):
+```rust
 let r = regex!(r#"^\s*("[a-t]*"\s*)+$"#i);
 assert_eq!(r.is_match(r#" "Aristote" "Platon" "#), true);
+```
 
-// build a regex that operates on &[u8]
+Build a regex that operates on `&[u8](https://docs.rs/lazy-regex/latest/lazy_regex/https://doc.rust-lang.org/1.91.1/std/primitive.u8.html)`:
+```rust
 let r = regex!("(byte)?string$"B);
 assert_eq!(r.is_match(b"bytestring"), true);
+```
 
-// there's no problem using the multiline definition syntax
-let r = regex!(r#"(?x)
+There's no problem using the multiline definition syntax:
+```rust
+let r = regex!(r"(?x)
     (?P<name>\w+)
     -
     (?P<version>[0-9.]+)
-"#);
+");
 assert_eq!(r.find("This is lazy_regex-2.2!").unwrap().as_str(), "lazy_regex-2.2");
-// (look at the regex_captures! macro to easily extract the groups)
-
 ```
+
+(look at the `regex_captures!` macro to easily extract the groups)
+
+This line doesn't compile because the regex is invalid:
 ```compile_fail
-// this line doesn't compile because the regex is invalid:
 let r = regex!("(unclosed");
 
 ```
-Supported regex flags: `i`, `m`, `s`, `x`, `U`.
+Supported regex flags: [`i`, `m`, `s`, `x`, `U`]regex::RegexBuilder, and you may also use `B` to build a bytes regex.
+
+The following regexes are equivalent:
+* `bytes_regex!("^ab+$"i)`
+* `bytes_regex!("(?i)^ab+$")`
+* `regex!("^ab+$"iB)`
+* `regex!("(?i)^ab+$"B)`
+
+They're all case insensitive instances of `regex::bytes::Regex`.
 
-See [regex::RegexBuilder](https://docs.rs/regex/latest/regex/struct.RegexBuilder.html).
 
 # Test a match
 
 ```rust
-use lazy_regex::regex_is_match;
+use lazy_regex::*;
 
-let b = regex_is_match!("[ab]+", "car");
+let b = regex_is_match!("ab+", "car");
+assert_eq!(b, true);
+let b = bytes_regex_is_match!("ab+", b"car");
 assert_eq!(b, true);
 ```
 
+See [`regex_is_match!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_is_match.html)
+
 
 # Extract a value
 
 ```rust
 use lazy_regex::regex_find;
 
-let f_word = regex_find!(r#"\bf\w+\b"#, "The fox jumps.");
+let f_word = regex_find!(r"\bf\w+\b", "The fox jumps.");
 assert_eq!(f_word, Some("fox"));
-let f_word = regex_find!(r#"\bf\w+\b"#B, b"The forest is silent.");
-assert_eq!(f_word, Some(b"forest" as &[u8]));
+let f_word = regex_find!(r"\bf\w+\b"B, b"The forest is silent.");
+assert_eq!(f_word, Some(b"forest" as &[u8](https://docs.rs/lazy-regex/latest/lazy_regex/https://doc.rust-lang.org/1.91.1/std/primitive.u8.html)));
 ```
 
+See [`regex_find!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_find.html)
+
 # Capture
 
 ```rust
@@ -114,7 +139,7 @@ let (_, letter) = regex_captures!("([a-z
 assert_eq!(letter, "A");
 
 let (whole, name, version) = regex_captures!(
-    r#"(\w+)-([0-9.]+)"#, // a literal regex
+    r"(\w+)-([0-9.]+)", // a literal regex
     "This is lazy_regex-2.0!", // any expression
 ).unwrap();
 assert_eq!(whole, "lazy_regex-2.0");
@@ -127,9 +152,31 @@ It's checked at compile time to ensure y
 
 You receive `""` for optional groups with no value.
 
+See [`regex_captures!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_captures.html)
+
+# Iter on captures
+
+```rust
+use lazy_regex::regex_captures_iter;
+
+let hay = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+let mut movies = vec![];
+let iter = regex_captures_iter!(r"'([^']+)'\s+\(([0-9]{4})\)", hay);
+for (_, [title, year]) in iter.map(|c| c.extract()) {
+    movies.push((title, year.parse::<i64>().unwrap()));
+}
+assert_eq!(movies, vec![
+    ("Citizen Kane", 1941),
+    ("The Wizard of Oz", 1939),
+    ("M", 1931),
+]);
+```
+
+See [`regex_captures_iter!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_captures_iter.html)
+
 # Replace with captured groups
 
-The `regex_replace!` and `regex_replace_all!` macros bring once compilation and compilation time checks to the `replace` and `replace_all` functions.
+The [`regex_replace!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_replace.html) and [`regex_replace_all!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_replace_all.html) macros bring once compilation and compilation time checks to the `replace` and `replace_all` functions.
 
 ## Replace with a closure
 
@@ -138,7 +185,7 @@ use lazy_regex::regex_replace_all;
 
 let text = "Foo8 fuu3";
 let text = regex_replace_all!(
-    r#"\bf(\w+)(\d)"#i,
+    r"\bf(\w+)(\d)"i,
     text,
     |_, name, digit| format!("F<{}>{}", name, digit),
 );
@@ -146,7 +193,7 @@ assert_eq!(text, "F<oo>8 F<uu>3");
 ```
 The number of arguments given to the closure is checked at compilation time to match the number of groups in the regular expression.
 
-If it doesn't match you get, at compilation time, a clear error message.
+If it doesn't match you get a clear error message at compilation time.
 
 ## Replace with another kind of Replacer
 
@@ -157,49 +204,60 @@ let output = regex_replace_all!("U", tex
 assert_eq!(&output, "OwO");
 ```
 
-# Switch over regexes
+# Switch over patterns
 
-Execute the expression bound to the first matching regex, with named captured groups declared as varibles:
+Execute the expression bound to the first matching regex, with named captured groups declared as variables:
 
 ```rust
 use lazy_regex::regex_switch;
+#[derive(Debug, PartialEq)]
 pub enum ScrollCommand {
     Top,
     Bottom,
     Lines(i32),
     Pages(i32),
+    JumpTo(String),
 }
 impl std::str::FromStr for ScrollCommand {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Self, ()> {
+    type Err = &'static str;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
         regex_switch!(s,
             "^scroll-to-top$" => Self::Top,
             "^scroll-to-bottom$" => Self::Bottom,
-            r#"^scroll-lines?\((?<n>[+-]?\d{1,4})\)$"# => Self::Lines(n.parse().unwrap()),
-            r#"^scroll-pages?\((?<n>[+-]?\d{1,4})\)$"# => Self::Pages(n.parse().unwrap()),
-        ).ok_or(())
+            r"^scroll-lines?\((?<n>[+-]?\d{1,4})\)$" => Self::Lines(n.parse().unwrap()),
+            r"^scroll-pages?\((?<n>[+-]?\d{1,4})\)$" => Self::Pages(n.parse().unwrap()),
+            r"^jump-to\((?<name>\w+)\)$" => Self::JumpTo(name.to_string()),
+        ).ok_or("unknown command")
     }
 }
+assert_eq!("scroll-lines(42)".parse(), Ok(ScrollCommand::Lines(42)));
+assert_eq!("scroll-lines(XLII)".parse::<ScrollCommand>(), Err("unknown command"));
 ```
 
+See [`regex_switch!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex_switch.html)
+
 # Shared lazy static
 
 When a regular expression is used in several functions, you sometimes don't want
 to repeat it but have a shared static instance.
 
-The `regex!` macro, while being backed by a lazy static regex, returns a reference.
+The [`regex!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.regex.html) macro, while being backed by a lazy static regex, returns a reference.
 
-If you want to have a shared lazy static regex, use the `lazy_regex!` macro:
+If you want to have a shared lazy static regex, use the [`lazy_regex!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.lazy_regex.html) macro:
 
 ```rust
-use lazy_regex::*;
 
 pub static GLOBAL_REX: Lazy<Regex> = lazy_regex!("^ab+$"i);
 ```
 
 Like for the other macros, the regex is static, checked at compile time, and lazily built at first use.
 
-# Features and reexport
+See [`lazy_regex!`](https://docs.rs/lazy-regex/latest/lazy_regex/macro.lazy_regex.html)
+<!-- cradoc end -->
+
+
+
+# Features and Reexport
 
 With default features, `lazy-regex` use the `regex` crate with its default features, tailored for performances and complete Unicode support.
 
diff -pruN 3.4.1+20241227-3/debian/changelog 3.4.2+20251114-1/debian/changelog
--- 3.4.1+20241227-3/debian/changelog	2025-03-04 06:53:13.000000000 +0000
+++ 3.4.2+20251114-1/debian/changelog	2025-12-05 21:50:58.000000000 +0000
@@ -1,3 +1,17 @@
+rust-lazy-regex (3.4.2+20251114-1) unstable; urgency=medium
+
+  [ upstream ]
+  * new development snapshot
+
+  [ Jonas Smedegaard ]
+  * update watch file:
+    + use file format 5
+    + bump version prefix
+  * unfuzz patches
+  * bump project versions in virtual packages and autopkgtests
+
+ -- Jonas Smedegaard <dr@jones.dk>  Fri, 05 Dec 2025 22:50:58 +0100
+
 rust-lazy-regex (3.4.1+20241227-3) unstable; urgency=medium
 
   * mention crate lazy-regex-proc_macros in long description
diff -pruN 3.4.1+20241227-3/debian/control 3.4.2+20251114-1/debian/control
--- 3.4.1+20241227-3/debian/control	2025-03-04 06:53:00.000000000 +0000
+++ 3.4.2+20251114-1/debian/control	2025-12-05 21:50:58.000000000 +0000
@@ -62,10 +62,10 @@ Provides:
  librust-lazy-regex-3+unicode-script-dev (= ${binary:Version}),
  librust-lazy-regex-3+unicode-segment-dev (= ${binary:Version}),
  librust-lazy-regex-3-dev (= ${binary:Version}),
- librust-lazy-regex-3.4.1-dev (= ${binary:Version}),
+ librust-lazy-regex-3.4.2-dev (= ${binary:Version}),
  librust-lazy-regex-proc-macros-3+default-dev (= ${rust:Version:librust-lazy-regex-proc-macros-dev}),
  librust-lazy-regex-proc-macros-3-dev (= ${rust:Version:librust-lazy-regex-proc-macros-dev}),
- librust-lazy-regex-proc-macros-3.4.1-dev (= ${rust:Version:librust-lazy-regex-proc-macros-dev}),
+ librust-lazy-regex-proc-macros-3.4.2-dev (= ${rust:Version:librust-lazy-regex-proc-macros-dev}),
  librust-lazy-regex-proc-macros-dev (= ${rust:Version:librust-lazy-regex-proc-macros-dev}),
 Description: lazy static regexes checked at compile time - Rust source code
  Lazy-regex enables you to use the `regex!` macro to build regexes:
diff -pruN 3.4.1+20241227-3/debian/patches/1001_fence_features.patch 3.4.2+20251114-1/debian/patches/1001_fence_features.patch
--- 3.4.1+20241227-3/debian/patches/1001_fence_features.patch	2025-01-15 00:00:10.000000000 +0000
+++ 3.4.2+20251114-1/debian/patches/1001_fence_features.patch	2025-12-05 21:50:36.000000000 +0000
@@ -9,7 +9,7 @@ Last-Update: 2024-12-14
 This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
 --- a/src/lib.rs
 +++ b/src/lib.rs
-@@ -233,7 +233,7 @@
+@@ -271,7 +271,7 @@
      once_cell::sync::Lazy,
  };
  
diff -pruN 3.4.1+20241227-3/debian/tests/control 3.4.2+20251114-1/debian/tests/control
--- 3.4.1+20241227-3/debian/tests/control	2025-03-04 06:52:10.000000000 +0000
+++ 3.4.2+20251114-1/debian/tests/control	2025-12-05 21:50:58.000000000 +0000
@@ -1,6 +1,6 @@
 # check single-feature tests only on amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --all-features
 Features: test-name=rust-lazy-regex:@
 Depends:
@@ -8,7 +8,7 @@ Depends:
  librust-lazy-regex-3-dev,
 Restrictions: allow-stderr
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features
 Features: test-name=rust-lazy-regex:
 Depends:
@@ -16,7 +16,7 @@ Depends:
  librust-lazy-regex-3-dev,
 Restrictions: allow-stderr
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets
 Features: test-name=rust-lazy-regex:default
 Depends:
@@ -24,7 +24,7 @@ Depends:
  librust-lazy-regex-3+default-dev,
 Restrictions: allow-stderr
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features lite
 Features: test-name=rust-lazy-regex:lite
 Depends:
@@ -33,7 +33,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features perf
 Features: test-name=rust-lazy-regex:perf
 Depends:
@@ -42,7 +42,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features perf-cache
 Features: test-name=rust-lazy-regex:perf-cache
 Depends:
@@ -51,7 +51,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features perf-dfa
 Features: test-name=rust-lazy-regex:perf-dfa
 Depends:
@@ -60,7 +60,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features perf-inline
 Features: test-name=rust-lazy-regex:perf-inline
 Depends:
@@ -69,7 +69,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features perf-literal
 Features: test-name=rust-lazy-regex:perf-literal
 Depends:
@@ -78,7 +78,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features std
 Features: test-name=rust-lazy-regex:std
 Depends:
@@ -87,7 +87,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode
 Features: test-name=rust-lazy-regex:unicode
 Depends:
@@ -96,7 +96,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode-age
 Features: test-name=rust-lazy-regex:unicode-age
 Depends:
@@ -105,7 +105,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode-bool
 Features: test-name=rust-lazy-regex:unicode-bool
 Depends:
@@ -114,7 +114,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode-case
 Features: test-name=rust-lazy-regex:unicode-case
 Depends:
@@ -123,7 +123,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode-gencat
 Features: test-name=rust-lazy-regex:unicode-gencat
 Depends:
@@ -132,7 +132,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode-perl
 Features: test-name=rust-lazy-regex:unicode-perl
 Depends:
@@ -141,7 +141,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode-script
 Features: test-name=rust-lazy-regex:unicode-script
 Depends:
@@ -150,7 +150,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex 3.4.2
  --all-targets --no-default-features --features unicode-segment
 Features: test-name=rust-lazy-regex:unicode-segment
 Depends:
@@ -159,7 +159,7 @@ Depends:
 Restrictions: allow-stderr
 Architecture: amd64
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex-proc_macros 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex-proc_macros 3.4.2
  --all-targets --all-features
 Features: test-name=rust-lazy-regex-proc_macros:@
 Depends:
@@ -167,7 +167,7 @@ Depends:
  librust-lazy-regex-proc-macros-3-dev,
 Restrictions: allow-stderr
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex-proc_macros 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex-proc_macros 3.4.2
  --all-targets --no-default-features
 Features: test-name=rust-lazy-regex-proc_macros:
 Depends:
@@ -175,7 +175,7 @@ Depends:
  librust-lazy-regex-proc-macros-3-dev,
 Restrictions: allow-stderr
 
-Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex-proc_macros 3.4.1
+Test-Command: /usr/share/dh-rust/bin/cargo-auto-test lazy-regex-proc_macros 3.4.2
  --all-targets
 Features: test-name=rust-lazy-regex-proc_macros:default
 Depends:
diff -pruN 3.4.1+20241227-3/debian/watch 3.4.2+20251114-1/debian/watch
--- 3.4.1+20241227-3/debian/watch	2025-02-07 09:37:41.000000000 +0000
+++ 3.4.2+20251114-1/debian/watch	2025-12-05 21:49:48.000000000 +0000
@@ -1,10 +1,8 @@
-version=4
+version: 5
 # check: uscan --report
 # update: gbp import-orig --upstream-vcs-tag=vX.Y.Z --uscan
 
-opts=\
-filenamemangle=s/.*?@ANY_VERSION@(@ARCHIVE_EXT@)/@PACKAGE@_$1.orig$2/,\
-mode=git,pgpmode=none,pretty=3.4.1+%cd,\
-dversionmangle=auto \
-https://github.com/canop/lazy-regex \
-HEAD
+Source: https://github.com/canop/lazy-regex.git
+Matching-Pattern: HEAD
+Mode: git
+Pretty: 3.4.2+%cd
diff -pruN 3.4.1+20241227-3/src/lib.rs 3.4.2+20251114-1/src/lib.rs
--- 3.4.1+20241227-3/src/lib.rs	2024-12-27 06:52:24.000000000 +0000
+++ 3.4.2+20251114-1/src/lib.rs	2025-11-14 21:52:15.000000000 +0000
@@ -7,59 +7,77 @@ With lazy-regex macros, regular expressi
 * can hold flags as suffix: `let case_insensitive_regex = regex!("ab*"i);`
 * are defined in a less verbose way
 
-The [regex!] macro returns references to normal instances of [regex::Regex] or [regex::bytes::Regex] so all the usual features are available.
+The [`regex!`] macro returns references to normal instances of [`regex::Regex`] or [`regex::bytes::Regex`] so all the usual features are available.
 
 But most often, you won't even use the `regex!` macro but the other macros which are specialized for testing a match, replacing, or capturing groups in some common situations:
 
-* [Test a match](#test-a-match) with [regex_is_match!]
-* [Extract a value](#extract-a-value) with [regex_find!]
-* [Capture](#capture) with [regex_captures!] and [regex_captures_iter!]
-* [Replace with captured groups](#replace-with-captured-groups) with [regex_replace!] and [regex_replace_all!]
-* [Switch over patterns](#switch-over-patterns) with [regex_switch!]
+* [Test a match](#test-a-match) with [`regex_is_match!`]
+* [Extract a value](#extract-a-value) with [`regex_find!`]
+* [Capture](#capture) with [`regex_captures!`]
+* [Iter on captures](#iter-on-captures) with [`regex_captures_iter!`]
+* [Replace with captured groups](#replace-with-captured-groups) with [`regex_replace!`] and [`regex_replace_all!`]
+* [Switch over patterns](#switch-over-patterns) with [`regex_switch!`]
 
 They support the `B` flag for the `regex::bytes::Regex` variant.
 
-All macros exist with a `bytes_` prefix for building `bytes::Regex`, so you also have [bytes_regex!], [bytes_regex_is_match!], [bytes_regex_find!], [bytes_regex_captures!], [bytes_regex_replace!], [bytes_regex_replace_all!], and [bytes_regex_switch!].
+All macros exist with a `bytes_` prefix for building `bytes::Regex`, so you also have [`bytes_regex!`], [`bytes_regex_is_match!`], [`bytes_regex_find!`], [`bytes_regex_captures!`], [`bytes_regex_replace!`], [`bytes_regex_replace_all!`], and [`bytes_regex_switch!`].
 
 Some structs of the regex crate are reexported to ease dependency managment.
 
 # Build Regexes
 
-```rust
-use lazy_regex::regex;
+Build a simple regex:
 
-// build a simple regex
+```rust
+# use lazy_regex::regex;
 let r = regex!("sa+$");
 assert_eq!(r.is_match("Saa"), false);
+```
 
-// build a regex with flag(s)
+Build a regex with flag(s):
+
+```rust
+# use lazy_regex::regex;
 let r = regex!("sa+$"i);
 assert_eq!(r.is_match("Saa"), true);
+```
+You can use a raw literal:
 
-// you can use a raw literal
+```rust
+# use lazy_regex::regex;
 let r = regex!(r#"^"+$"#);
 assert_eq!(r.is_match("\"\""), true);
+```
 
-// or a raw literal with flag(s)
+Or a raw literal with flag(s):
+```rust
+# use lazy_regex::regex;
 let r = regex!(r#"^\s*("[a-t]*"\s*)+$"#i);
 assert_eq!(r.is_match(r#" "Aristote" "Platon" "#), true);
+```
 
-// build a regex that operates on &[u8]
+Build a regex that operates on `&[u8]`:
+```rust
+# use lazy_regex::regex;
 let r = regex!("(byte)?string$"B);
 assert_eq!(r.is_match(b"bytestring"), true);
+```
 
-// there's no problem using the multiline definition syntax
+There's no problem using the multiline definition syntax:
+```rust
+# use lazy_regex::regex;
 let r = regex!(r"(?x)
     (?P<name>\w+)
     -
     (?P<version>[0-9.]+)
 ");
 assert_eq!(r.find("This is lazy_regex-2.2!").unwrap().as_str(), "lazy_regex-2.2");
-// (look at the regex_captures! macro to easily extract the groups)
-
 ```
+
+(look at the `regex_captures!` macro to easily extract the groups)
+
+This line doesn't compile because the regex is invalid:
 ```compile_fail
-// this line doesn't compile because the regex is invalid:
 let r = regex!("(unclosed");
 
 ```
@@ -85,7 +103,7 @@ let b = bytes_regex_is_match!("[ab]+", b
 assert_eq!(b, true);
 ```
 
-doc: [regex_is_match!]
+See [`regex_is_match!`]
 
 
 # Extract a value
@@ -99,7 +117,7 @@ let f_word = regex_find!(r"\bf\w+\b"B, b
 assert_eq!(f_word, Some(b"forest" as &[u8]));
 ```
 
-doc: [regex_find!]
+See [`regex_find!`]
 
 # Capture
 
@@ -123,11 +141,31 @@ It's checked at compile time to ensure y
 
 You receive `""` for optional groups with no value.
 
-See [regex_captures!] and [regex_captures_iter!]
+See [`regex_captures!`]
+
+# Iter on captures
+
+```rust
+use lazy_regex::regex_captures_iter;
+
+let hay = "'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931).";
+let mut movies = vec![];
+let iter = regex_captures_iter!(r"'([^']+)'\s+\(([0-9]{4})\)", hay);
+for (_, [title, year]) in iter.map(|c| c.extract()) {
+    movies.push((title, year.parse::<i64>().unwrap()));
+}
+assert_eq!(movies, vec![
+    ("Citizen Kane", 1941),
+    ("The Wizard of Oz", 1939),
+    ("M", 1931),
+]);
+```
+
+See [`regex_captures_iter!`]
 
 # Replace with captured groups
 
-The [regex_replace!] and [regex_replace_all!] macros bring once compilation and compilation time checks to the `replace` and `replace_all` functions.
+The [`regex_replace!`] and [`regex_replace_all!`] macros bring once compilation and compilation time checks to the `replace` and `replace_all` functions.
 
 ## Replace with a closure
 
@@ -157,7 +195,7 @@ assert_eq!(&output, "OwO");
 
 # Switch over patterns
 
-Execute the expression bound to the first matching regex, with named captured groups declared as varibles:
+Execute the expression bound to the first matching regex, with named captured groups declared as variables:
 
 ```rust
 use lazy_regex::regex_switch;
@@ -185,26 +223,26 @@ assert_eq!("scroll-lines(42)".parse(), O
 assert_eq!("scroll-lines(XLII)".parse::<ScrollCommand>(), Err("unknown command"));
 ```
 
-doc: [regex_switch!]
+See [`regex_switch!`]
 
 # Shared lazy static
 
 When a regular expression is used in several functions, you sometimes don't want
 to repeat it but have a shared static instance.
 
-The [regex!] macro, while being backed by a lazy static regex, returns a reference.
+The [`regex!`] macro, while being backed by a lazy static regex, returns a reference.
 
-If you want to have a shared lazy static regex, use the [lazy_regex!] macro:
+If you want to have a shared lazy static regex, use the [`lazy_regex!`] macro:
 
 ```rust
-use lazy_regex::*;
+# use lazy_regex::*;
 
 pub static GLOBAL_REX: Lazy<Regex> = lazy_regex!("^ab+$"i);
 ```
 
 Like for the other macros, the regex is static, checked at compile time, and lazily built at first use.
 
-doc: [lazy_regex!]
+See [`lazy_regex!`]
 
 */
 
diff -pruN 3.4.1+20241227-3/src/proc_macros/Cargo.toml 3.4.2+20251114-1/src/proc_macros/Cargo.toml
--- 3.4.1+20241227-3/src/proc_macros/Cargo.toml	2024-12-27 06:52:24.000000000 +0000
+++ 3.4.2+20251114-1/src/proc_macros/Cargo.toml	2025-11-14 21:52:15.000000000 +0000
@@ -1,6 +1,6 @@
 [package]
 name = "lazy-regex-proc_macros"
-version = "3.4.1"
+version = "3.4.2"
 authors = ["Canop <cano.petrole@gmail.com>"]
 description = "proc macros for the lazy_regex crate"
 license = "MIT"
diff -pruN 3.4.1+20241227-3/src/proc_macros/args.rs 3.4.2+20251114-1/src/proc_macros/args.rs
--- 3.4.1+20241227-3/src/proc_macros/args.rs	2024-12-27 06:52:24.000000000 +0000
+++ 3.4.2+20251114-1/src/proc_macros/args.rs	2025-11-14 21:52:15.000000000 +0000
@@ -29,7 +29,7 @@ impl Parse for RexValArgs {
 }
 
 /// Wrapping of the three arguments given to the
-/// ``regex_replace` and regex_replace_all` macros
+/// `regex_replace` and `regex_replace_all` macros
 pub(crate) struct ReplaceArgs {
     pub regex_str: LitStr,
     pub value: Expr,
@@ -63,7 +63,7 @@ impl Parse for ReplaceArgs {
     }
 }
 
-/// Wrapping of the arguments given to a regex_if macro
+/// Wrapping of the arguments given to a `regex_if` macro
 pub(crate) struct RexIfArgs {
     pub regex_str: LitStr,
     pub value: Expr, // this expression is (or produces) the text to search or check
@@ -86,7 +86,7 @@ impl Parse for RexIfArgs {
     }
 }
 
-/// Wrapping of the arguments given to a regex_switch macro
+/// Wrapping of the arguments given to a `regex_switch` macro
 pub(crate) struct RexSwitchArgs {
     pub value: Expr, // this expression is (or produces) the text to search or check
     pub arms: Vec<RexSwitchArmArgs>,
diff -pruN 3.4.1+20241227-3/src/proc_macros/mod.rs 3.4.2+20251114-1/src/proc_macros/mod.rs
--- 3.4.1+20241227-3/src/proc_macros/mod.rs	2024-12-27 06:52:24.000000000 +0000
+++ 3.4.2+20251114-1/src/proc_macros/mod.rs	2025-11-14 21:52:15.000000000 +0000
@@ -41,8 +41,8 @@ where
 /// let case_insensitive_regex = regex!("^ab+$"i);
 /// ```
 ///
-/// The macro returns a reference to a [regex::Regex]
-/// or a [regex::bytes::Regex] instance,
+/// The macro returns a reference to a `regex::Regex`
+/// or a `regex::bytes::Regex` instance,
 /// differentiated by the `B` flag:
 /// ```
 /// let verbose = regex!(r#"_([\d\.]+)"#)
@@ -119,7 +119,7 @@ pub fn regex_is_match(input: TokenStream
 }
 
 /// Test whether an expression matches a lazy static
-/// bytes::Regex regular expression (the regex is checked
+/// `bytes::Regex` regular expression (the regex is checked
 /// at compile time)
 ///
 /// Example:
@@ -300,7 +300,7 @@ pub fn bytes_regex_captures_iter(input:
     })
 }
 
-/// common implementation of regex_replace and regex_replace_all
+/// common implementation of `regex_replace` and `regex_replace_all`
 fn replacen(input: TokenStream, limit: usize) -> TokenStream {
     let parsed = parse_macro_input!(input as ReplaceArgs);
     let ReplaceArgs { regex_str, value, replacer } = parsed;
@@ -342,7 +342,7 @@ fn replacen(input: TokenStream, limit: u
     stream.into()
 }
 
-/// common implementation of bytes_regex_replace and bytes_regex_replace_all
+/// common implementation of `bytes_regex_replace` and `bytes_regex_replace_all`
 fn bytes_replacen(input: TokenStream, limit: usize) -> TokenStream {
     let parsed = parse_macro_input!(input as ReplaceArgs);
     let ReplaceArgs { regex_str, value, replacer } = parsed;
@@ -477,7 +477,7 @@ pub fn bytes_regex_replace_all(input: To
     bytes_replacen(input, 0)
 }
 
-/// Return an Option<T>, with T being the type returned by the block or expression
+/// Return an `Option<T>`, with T being the type returned by the block or expression
 /// given as third argument.
 ///
 /// If the regex matches, executes the expression and return it as Some.
@@ -590,7 +590,7 @@ pub fn regex_switch(input: TokenStream)
         arms,
     } = parse_macro_input!(input as RexSwitchArgs);
     let mut q_arms = Vec::new();
-    for RexSwitchArmArgs { regex_str, then } in arms.into_iter() {
+    for RexSwitchArmArgs { regex_str, then } in arms {
         let regex_code = match RegexCode::from_lit_str(regex_str, false) {
             Ok(r) => r,
             Err(e) => {
@@ -660,7 +660,7 @@ pub fn bytes_regex_switch(input: TokenSt
         arms,
     } = parse_macro_input!(input as RexSwitchArgs);
     let mut q_arms = Vec::new();
-    for RexSwitchArmArgs { regex_str, then } in arms.into_iter() {
+    for RexSwitchArmArgs { regex_str, then } in arms {
         let regex_code = match RegexCode::from_lit_str(regex_str, true) {
             Ok(r) => r,
             Err(e) => {
diff -pruN 3.4.1+20241227-3/src/proc_macros/regex_code.rs 3.4.2+20251114-1/src/proc_macros/regex_code.rs
--- 3.4.1+20241227-3/src/proc_macros/regex_code.rs	2024-12-27 06:52:24.000000000 +0000
+++ 3.4.2+20251114-1/src/proc_macros/regex_code.rs	2025-11-14 21:52:15.000000000 +0000
@@ -42,10 +42,10 @@ impl RegexCode {
                     // subspan only works on nighlty
                     return Err(syn::Error::new(
                         lit.subspan(pos - 1..pos).unwrap_or_else(|| lit.span()),
-                        format!("unrecognized regex flag {:?}", ch),
+                        format!("unrecognized regex flag {ch:?}"),
                     ));
                 }
-            };
+            }
         }
 
         let regex = if is_bytes {